@firesystem/memory/src/providers/MemoryWorkspaceProvider.ts

In-memory implementation of Virtual File System

import type {
  IReactiveFileSystem,
  IFileSystemCapabilities,
} from "@firesystem/core";
// Import type-only para evitar dependência em runtime
import type { SourceProvider } from "@workspace-fs/core";
import { MemoryFileSystem } from "../MemoryFileSystem";

/**
 * Provider para MemoryFileSystem no workspace
 * Implementa o padrão de providers do VSCode
 */
export class MemoryWorkspaceProvider implements SourceProvider {
  readonly scheme = "memory";
  readonly displayName = "In-Memory File System";

  /**
   * Cria uma nova instância do MemoryFileSystem
   */
  async createFileSystem(config: any): Promise<IReactiveFileSystem> {
    const fs = new MemoryFileSystem();

    // Se tem dados iniciais, carrega eles
    if (config?.initialData) {
      await this.loadInitialData(fs, config.initialData);
    }

    // Inicializa o FS (emite eventos de inicialização)
    if (fs.initialize) {
      await fs.initialize();
    }

    return fs;
  }

  /**
   * Valida configuração do Memory provider
   */
  async validateConfiguration(
    config: any,
  ): Promise<{ valid: boolean; errors?: string[] }> {
    const errors: string[] = [];

    if (config) {
      // Valida initialData se fornecido
      if (config.initialData && typeof config.initialData !== "object") {
        errors.push("initialData must be an object");
      }

      // Valida limites se fornecidos
      if (config.maxSize !== undefined) {
        if (typeof config.maxSize !== "number") {
          errors.push("maxSize must be a number");
        } else if (config.maxSize <= 0) {
          errors.push("maxSize must be greater than 0");
        }
      }
    }

    return {
      valid: errors.length === 0,
      errors: errors.length > 0 ? errors : undefined,
    };
  }

  /**
   * Retorna as capacidades do Memory FS
   */
  getCapabilities(): IFileSystemCapabilities {
    return {
      readonly: false,
      caseSensitive: true,
      atomicRename: true,
      supportsWatch: true,
      supportsMetadata: true,
      supportsGlob: true,
      maxFileSize: 50 * 1024 * 1024, // 50MB
      maxPathLength: 1024,
      description: "High-performance in-memory file system. Data is volatile.",
    };
  }

  /**
   * Limpa e destrói o file system
   */
  async dispose(fs: IReactiveFileSystem): Promise<void> {
    // Limpa todos os arquivos
    if ("clear" in fs) {
      await fs.clear();
    }

    // Remove todos os event listeners
    if (fs.events && "removeAllListeners" in fs.events) {
      fs.events.removeAllListeners();
    }
  }

  /**
   * Carrega dados iniciais no file system
   */
  private async loadInitialData(
    fs: IReactiveFileSystem,
    initialData: any,
  ): Promise<void> {
    // Primeiro, ordenar paths para garantir que diretórios sejam criados antes dos arquivos
    const paths = Object.keys(initialData).sort();

    for (const path of paths) {
      const data = initialData[path];

      // Criar diretório pai se necessário
      const parentDir = path.substring(0, path.lastIndexOf("/"));
      if (parentDir && parentDir !== "/" && !(await fs.exists(parentDir))) {
        await fs.mkdir(parentDir, true);
      }

      if (data && typeof data === "object" && "content" in data) {
        // Formato completo: { content, metadata }
        const fileData = data as any;
        await fs.writeFile(path, fileData.content, fileData.metadata);
      } else {
        // Formato simples: conteúdo direto
        await fs.writeFile(path, data);
      }
    }
  }
}

// Exporta uma instância singleton para conveniência
export const memoryProvider = new MemoryWorkspaceProvider();