@atomic-ehr/codegen 0.0.1-canary.20251006070905.fb6ed98 → 0.0.1-canary.20251006094042.7f0be72

package/dist/api/generators/base/builders/FileBuilder.js

@@ -1,406 +0,0 @@
-/**
- * Fluent file builder with lifecycle hooks and validation
- *
- * This provides a clean, chainable API for building files with imports,
- * exports, content generation, and lifecycle hooks for customization.
- */
-import { FileOperationError, TemplateError } from "../errors";
-/**
- * Fluent builder for creating files with lifecycle hooks
- *
- * Features:
- * - Fluent API for content building
- * - Template integration
- * - Import/export management
- * - Lifecycle hooks (before/after save, error handling)
- * - Content validation
- * - Automatic import path resolution
- */
-export class FileBuilder {
-    config;
-    content = "";
-    imports = new Map();
-    exports = new Set();
-    metadata = new Map();
-    // Lifecycle hooks
-    beforeSaveHooks = [];
-    afterSaveHooks = [];
-    errorHooks = [];
-    // Options
-    options = {
-        template: undefined,
-        importStrategy: "auto",
-        validation: "strict",
-        prettify: true,
-        formatting: {
-            indentSize: 2,
-            useTabs: false,
-            maxLineLength: 100,
-        },
-        encoding: "utf-8",
-    };
-    constructor(config) {
-        this.config = config;
-    }
-    // ==========================================
-    // Content Building Methods
-    // ==========================================
-    /**
-     * Set content directly
-     * @param content File content
-     */
-    withContent(content) {
-        this.content = typeof content === "string" ? content : content();
-        return this;
-    }
-    /**
-     * Generate content from template
-     * @param templateName Template to use
-     * @param context Template context
-     */
-    withTemplate(templateName, context) {
-        if (!this.config.templateEngine) {
-            throw new TemplateError(`Template engine is required for template rendering. Template: '${templateName}'`, templateName, context);
-        }
-        this.options.template = templateName;
-        try {
-            this.content = this.config.templateEngine.render(templateName, {
-                ...context,
-                imports: this.imports,
-                exports: this.exports,
-                filename: this.config.filename,
-            });
-        }
-        catch (_error) {
-            throw new TemplateError(`Failed to render template '${templateName}'`, templateName, context, {
-                availableTemplates: this.config.templateEngine.getAvailableTemplates?.() || [],
-            });
-        }
-        return this;
-    }
-    /**
-     * Append content to existing content
-     * @param content Content to append
-     */
-    appendContent(content) {
-        this.content += content;
-        return this;
-    }
-    /**
-     * Prepend content to existing content
-     * @param content Content to prepend
-     */
-    prependContent(content) {
-        this.content = content + this.content;
-        return this;
-    }
-    // ==========================================
-    // Import/Export Management
-    // ==========================================
-    /**
-     * Set all imports at once
-     * @param imports Map of symbol name to import path
-     */
-    withImports(imports) {
-        this.imports.clear();
-        for (const [symbol, path] of imports) {
-            this.imports.set(symbol, path);
-        }
-        return this;
-    }
-    /**
-     * Add a single import
-     * @param symbol Symbol to import
-     * @param from Import path
-     */
-    addImport(symbol, from) {
-        this.imports.set(symbol, from);
-        return this;
-    }
-    /**
-     * Add multiple imports from the same path
-     * @param symbols Symbols to import
-     * @param from Import path
-     */
-    addImports(symbols, from) {
-        for (const symbol of symbols) {
-            this.imports.set(symbol, from);
-        }
-        return this;
-    }
-    /**
-     * Set all exports at once
-     * @param exports Array of export names
-     */
-    withExports(exports) {
-        this.exports.clear();
-        for (const exp of exports) {
-            this.exports.add(exp);
-        }
-        return this;
-    }
-    /**
-     * Add a single export
-     * @param name Export name
-     */
-    addExport(name) {
-        this.exports.add(name);
-        return this;
-    }
-    /**
-     * Add multiple exports
-     * @param names Export names
-     */
-    addExports(names) {
-        for (const name of names) {
-            this.exports.add(name);
-        }
-        return this;
-    }
-    // ==========================================
-    // Metadata and Options
-    // ==========================================
-    /**
-     * Set metadata for the file
-     * @param key Metadata key
-     * @param value Metadata value
-     */
-    withMetadata(key, value) {
-        this.metadata.set(key, value);
-        return this;
-    }
-    /**
-     * Set file builder options
-     * @param options Options to set
-     */
-    withOptions(options) {
-        this.options = { ...this.options, ...options };
-        return this;
-    }
-    // ==========================================
-    // Lifecycle Hooks
-    // ==========================================
-    /**
-     * Add hook to run before saving
-     * @param hook Hook function
-     */
-    onBeforeSave(hook) {
-        this.beforeSaveHooks.push(hook);
-        return this;
-    }
-    /**
-     * Add hook to run after successful save
-     * @param hook Hook function
-     */
-    onAfterSave(hook) {
-        this.afterSaveHooks.push(hook);
-        return this;
-    }
-    /**
-     * Add hook to run when error occurs
-     * @param hook Hook function
-     */
-    onError(hook) {
-        this.errorHooks.push(hook);
-        return this;
-    }
-    // ==========================================
-    // Execution Methods
-    // ==========================================
-    /**
-     * Build final content without saving
-     * @returns File context with final content
-     */
-    build() {
-        const finalContent = this.buildFinalContent();
-        return {
-            filename: this.config.filename,
-            content: finalContent,
-            imports: new Map(this.imports),
-            exports: new Set(this.exports),
-            metadata: Object.fromEntries(this.metadata),
-            templateName: this.options.template,
-        };
-    }
-    /**
-     * Save the file
-     * @returns Promise resolving to file path
-     */
-    async save() {
-        const context = this.build();
-        try {
-            // Run before-save hooks
-            for (const hook of this.beforeSaveHooks) {
-                await hook(context);
-            }
-            // Validate content if enabled
-            if (this.options.validation !== "none") {
-                await this.validateContent(context.content);
-            }
-            // Write file
-            const result = await this.config.fileManager.writeFile(this.config.filename, context.content, {
-                encoding: this.options.encoding,
-            });
-            const stats = {
-                size: result.size,
-                generationTime: 0, // Set by caller if needed
-                writeTime: result.writeTime,
-            };
-            // Run after-save hooks
-            for (const hook of this.afterSaveHooks) {
-                await hook(result.path, stats);
-            }
-            this.config.logger.debug(`Saved ${this.config.filename} successfully`);
-            return result.path;
-        }
-        catch (error) {
-            // Run error hooks
-            for (const hook of this.errorHooks) {
-                try {
-                    await hook(error instanceof Error ? error : new Error(String(error)), context);
-                }
-                catch (hookError) {
-                    this.config.logger.warn(`Error hook failed: ${hookError instanceof Error ? hookError.message : String(hookError)}`);
-                }
-            }
-            throw error;
-        }
-    }
-    // ==========================================
-    // Private Helper Methods
-    // ==========================================
-    /**
-     * Build final content with imports and exports
-     */
-    buildFinalContent() {
-        const parts = [];
-        // Add imports
-        if (this.imports.size > 0 && this.options.importStrategy !== "none") {
-            parts.push(this.generateImportStatements());
-            parts.push(""); // Empty line after imports
-        }
-        // Add main content
-        if (this.content) {
-            parts.push(this.content);
-        }
-        // Add exports if not already in content
-        if (this.exports.size > 0 && !this.content.includes("export")) {
-            parts.push(""); // Empty line before exports
-            parts.push(this.generateExportStatements());
-        }
-        let finalContent = parts.join("\n");
-        // Prettify if enabled
-        if (this.options.prettify) {
-            finalContent = this.prettifyContent(finalContent);
-        }
-        return finalContent;
-    }
-    /**
-     * Generate import statements
-     */
-    generateImportStatements() {
-        const lines = [];
-        // Group imports by path
-        const importsByPath = new Map();
-        for (const [symbol, path] of this.imports) {
-            const resolvedPath = this.options.importStrategy === "auto"
-                ? this.config.fileManager.getRelativeImportPath(this.config.filename, path)
-                : path;
-            if (!importsByPath.has(resolvedPath)) {
-                importsByPath.set(resolvedPath, []);
-            }
-            importsByPath.get(resolvedPath)?.push(symbol);
-        }
-        // Generate import statements
-        for (const [path, symbols] of importsByPath) {
-            if (symbols.length === 1) {
-                lines.push(`import type { ${symbols[0]} } from '${path}';`);
-            }
-            else {
-                const sortedSymbols = symbols.sort();
-                if (sortedSymbols.length <= 3) {
-                    lines.push(`import type { ${sortedSymbols.join(", ")} } from '${path}';`);
-                }
-                else {
-                    lines.push(`import type {`);
-                    const indent = "\t";
-                    sortedSymbols.forEach((symbol, index) => {
-                        const isLast = index === sortedSymbols.length - 1;
-                        lines.push(`${indent}${symbol}${isLast ? "" : ","}`);
-                    });
-                    lines.push(`} from '${path}';`);
-                }
-            }
-        }
-        return lines.join("\n");
-    }
-    /**
-     * Generate export statements
-     */
-    generateExportStatements() {
-        const exports = Array.from(this.exports).sort();
-        return exports.map((exp) => `export { ${exp} };`).join("\n");
-    }
-    /**
-     * Prettify content (basic implementation)
-     */
-    prettifyContent(content) {
-        // Basic prettification
-        return content
-            .replace(/\n{3,}/g, "\n\n") // Max 2 consecutive newlines
-            .replace(/\t/g, this.options.formatting?.useTabs ? "\t" : " ".repeat(this.options.formatting?.indentSize || 2))
-            .trim();
-    }
-    /**
-     * Validate generated content
-     */
-    async validateContent(content) {
-        if (this.options.validation === "none")
-            return;
-        // Basic validation - check for syntax errors
-        const issues = [];
-        // Check for unmatched braces
-        const openBraces = (content.match(/\{/g) || []).length;
-        const closeBraces = (content.match(/\}/g) || []).length;
-        if (openBraces !== closeBraces) {
-            issues.push(`Unmatched braces: ${openBraces} open, ${closeBraces} close`);
-        }
-        // Check for unmatched parentheses
-        const openParens = (content.match(/\(/g) || []).length;
-        const closeParens = (content.match(/\)/g) || []).length;
-        if (openParens !== closeParens) {
-            issues.push(`Unmatched parentheses: ${openParens} open, ${closeParens} close`);
-        }
-        // Check for basic TypeScript syntax issues
-        if (this.config.filename.endsWith(".ts") || this.config.filename.endsWith(".tsx")) {
-            if (content.includes("interface") && !content.match(/interface\s+\w+\s*\{/)) {
-                issues.push("Invalid interface syntax detected");
-            }
-        }
-        if (issues.length > 0 && this.options.validation === "strict") {
-            throw new FileOperationError(`Content validation failed for ${this.config.filename}: ${issues.join(", ")}`, "write", this.config.filename);
-        }
-        else if (issues.length > 0) {
-            // Just warn for non-strict validation
-            this.config.logger.warn(`Validation issues in ${this.config.filename}: ${issues.join(", ")}`);
-        }
-    }
-    /**
-     * Get current content (for testing/debugging)
-     */
-    getContent() {
-        return this.content;
-    }
-    /**
-     * Get current imports (for testing/debugging)
-     */
-    getImports() {
-        return new Map(this.imports);
-    }
-    /**
-     * Get current exports (for testing/debugging)
-     */
-    getExports() {
-        return new Set(this.exports);
-    }
-}

package/dist/api/generators/base/builders/IndexBuilder.d.ts

@@ -1,126 +0,0 @@
-/**
- * Index file builder for automated exports
- *
- * Automatically generates index files that export all types and functions
- * from a directory, with support for grouping and namespaces.
- */
-import type { CodegenLogger } from "../../../../utils/codegen-logger";
-import type { FileManager } from "../FileManager";
-import type { TemplateEngine } from "../types";
-export interface IndexBuilderConfig {
-    directory: string;
-    fileManager: FileManager;
-    templateEngine?: TemplateEngine;
-    logger: CodegenLogger;
-}
-/**
- * Builder for index files with intelligent export management
- *
- * Features:
- * - Automatic export detection
- * - Namespace support
- * - Export grouping
- * - Custom headers
- * - Template support
- */
-export declare class IndexBuilder {
-    private readonly config;
-    private readonly exports;
-    private readonly namespaces;
-    private readonly reExports;
-    private header;
-    private footer;
-    private groupingFunction?;
-    private sortFunction?;
-    constructor(config: IndexBuilderConfig);
-    /**
-     * Add exports from a specific file
-     * @param exportNames Export names
-     * @param fromPath Path to file (without extension)
-     */
-    withExports(exportNames: string[], fromPath: string): IndexBuilder;
-    /**
-     * Add a single export
-     * @param exportName Export name
-     * @param fromPath Path to file
-     */
-    withExport(exportName: string, fromPath: string): IndexBuilder;
-    /**
-     * Add namespace exports
-     * @param namespaces Map of namespace to path
-     */
-    withNamespaces(namespaces: Record<string, string>): IndexBuilder;
-    /**
-     * Add namespace export
-     * @param namespace Namespace name
-     * @param path Path to export as namespace
-     */
-    withNamespace(namespace: string, path: string): IndexBuilder;
-    /**
-     * Re-export all from paths
-     * @param paths Paths to re-export all from
-     */
-    withReExports(paths: string[]): IndexBuilder;
-    /**
-     * Add re-export
-     * @param path Path to re-export all from
-     */
-    withReExport(path: string): IndexBuilder;
-    /**
-     * Set header content
-     * @param header Header content
-     */
-    withHeader(header: string): IndexBuilder;
-    /**
-     * Set footer content
-     * @param footer Footer content
-     */
-    withFooter(footer: string): IndexBuilder;
-    /**
-     * Group exports by function
-     * @param fn Function that returns group name for export
-     */
-    groupBy(fn: (exportName: string) => string): IndexBuilder;
-    /**
-     * Sort exports by function
-     * @param fn Sort function for [exportName, fromPath] tuples
-     */
-    sortBy(fn: (a: [string, string], b: [string, string]) => number): IndexBuilder;
-    /**
-     * Auto-discover exports from directory
-     * @param filePattern Pattern to match files (e.g., "*.ts")
-     */
-    autoDiscover(_filePattern?: string): Promise<IndexBuilder>;
-    /**
-     * Save the index file
-     */
-    save(): Promise<string>;
-    /**
-     * Build content without saving (for preview)
-     */
-    build(): string;
-    /**
-     * Generate the index file content
-     */
-    private generateContent;
-    /**
-     * Generate simple exports without grouping
-     */
-    private generateSimpleExports;
-    /**
-     * Generate grouped exports
-     */
-    private generateGroupedExports;
-    /**
-     * Get current exports (for testing/debugging)
-     */
-    getExports(): Map<string, string>;
-    /**
-     * Get current namespaces (for testing/debugging)
-     */
-    getNamespaces(): Map<string, string>;
-    /**
-     * Get current re-exports (for testing/debugging)
-     */
-    getReExports(): Map<string, string>;
-}