@atomic-ehr/codegen 0.0.1-canary.20251006092200.fdb4a88 → 0.0.1-canary.20251006094042.7f0be72

package/dist/api/generators/base/TypeMapper.js

@@ -1,153 +0,0 @@
-/**
- * Abstract base class for language-specific type mapping
- *
- * This provides the interface that all language generators must implement
- * to convert FHIR TypeSchema types into their target language types.
- */
-/**
- * Abstract type mapper for language-specific type conversion
- */
-export class TypeMapper {
-    options;
-    constructor(options = {}) {
-        this.options = {
-            generateNullable: true,
-            strictTypes: true,
-            customMappings: {},
-            preferArraySyntax: true,
-            namingConvention: "PascalCase",
-            ...options,
-        };
-    }
-    // ==========================================
-    // Concrete Methods - Shared functionality
-    // ==========================================
-    /**
-     * Main entry point for type mapping
-     * @param schemaType Type from TypeSchema
-     */
-    mapType(schemaType) {
-        // Handle primitive types
-        if (typeof schemaType === "string") {
-            return this.mapPrimitive(schemaType);
-        }
-        // Handle complex types
-        if (schemaType && typeof schemaType === "object") {
-            const kind = schemaType.kind || schemaType.type;
-            switch (kind) {
-                case "primitive-type":
-                    return this.mapPrimitive(schemaType.name);
-                case "reference":
-                    return this.mapReference(schemaType.targets || []);
-                case "array": {
-                    const elementType = this.mapType(schemaType.element);
-                    return this.mapArray(elementType);
-                }
-                case "enum":
-                case "coded":
-                    return this.mapEnum(schemaType.values || [], schemaType.name);
-                case "complex-type":
-                case "resource":
-                    return this.mapComplexType(schemaType);
-                default:
-                    return this.mapUnknownType(schemaType);
-            }
-        }
-        return this.mapUnknownType(schemaType);
-    }
-    /**
-     * Map a complex type (resource, complex-type)
-     * @param schemaType Complex type from schema
-     */
-    mapComplexType(schemaType) {
-        const typeName = this.formatTypeName(schemaType.name || "Unknown");
-        return {
-            name: typeName,
-            isPrimitive: false,
-            importPath: this.calculateImportPath(schemaType),
-            nullable: !schemaType.required && this.options.generateNullable,
-            metadata: {
-                kind: schemaType.kind,
-                package: schemaType.package,
-            },
-        };
-    }
-    /**
-     * Handle unknown/unmapped types
-     * @param schemaType Unknown type
-     */
-    mapUnknownType(schemaType) {
-        // console.warn(`Unknown type encountered:`, schemaType);
-        return {
-            name: "unknown",
-            isPrimitive: true,
-            nullable: true,
-            metadata: {
-                originalType: schemaType,
-                warning: "unmapped_type",
-            },
-        };
-    }
-    /**
-     * Calculate import path for a type
-     * @param schemaType Type to calculate import for
-     */
-    calculateImportPath(schemaType) {
-        if (!schemaType.name)
-            return undefined;
-        const fileName = this.formatFileName(schemaType.name);
-        return `./${fileName}`;
-    }
-    /**
-     * Apply naming convention to a string
-     * @param name Input name
-     */
-    applyNamingConvention(name) {
-        switch (this.options.namingConvention) {
-            case "camelCase":
-                return toCamelCase(name);
-            case "PascalCase":
-                return toPascalCase(name);
-            case "snake_case":
-                return toSnakeCase(name);
-            case "kebab-case":
-                return toKebabCase(name);
-            default:
-                return name;
-        }
-    }
-    /**
-     * Get custom mapping if available
-     * @param type Original type name
-     */
-    getCustomMapping(type) {
-        return this.options.customMappings[type];
-    }
-    /**
-     * Check if type should be nullable
-     * @param required Whether field is required
-     */
-    shouldBeNullable(required) {
-        return !required && this.options.generateNullable;
-    }
-}
-// ==========================================
-// Utility Functions
-// ==========================================
-function toCamelCase(str) {
-    return str.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() || "");
-}
-function toPascalCase(str) {
-    const camelCase = toCamelCase(str);
-    return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
-}
-function toSnakeCase(str) {
-    return str
-        .replace(/([A-Z])/g, "_$1")
-        .replace(/[-\s]+/g, "_")
-        .toLowerCase()
-        .replace(/^_/, "");
-}
-function toKebabCase(str) {
-    return toSnakeCase(str).replace(/_/g, "-");
-}

package/dist/api/generators/base/TypeScriptTypeMapper.d.ts

@@ -1,51 +0,0 @@
-/**
- * TypeScript-specific type mapper implementation
- */
-import type { Identifier } from "@typeschema/types";
-import { type LanguageType, TypeMapper, type TypeMapperOptions } from "./TypeMapper";
-/**
- * TypeScript-specific options
- */
-export interface TypeScriptTypeMapperOptions extends TypeMapperOptions {
-    /** Whether to use 'unknown' or 'any' for unmapped types */
-    preferUnknown?: boolean;
-    /** Whether to generate branded types for primitives */
-    useBrandedTypes?: boolean;
-    /** Whether to use 'undefined' or 'null' for optional types */
-    preferUndefined?: boolean;
-    /** Module format for imports */
-    moduleFormat?: "esm" | "commonjs";
-}
-/**
- * TypeScript type mapper
- */
-export declare class TypeScriptTypeMapper extends TypeMapper {
-    private readonly tsOptions;
-    constructor(options?: TypeScriptTypeMapperOptions);
-    getLanguageName(): string;
-    mapPrimitive(fhirType: string): LanguageType;
-    mapReference(targets: Identifier[]): LanguageType;
-    mapArray(elementType: LanguageType): LanguageType;
-    mapOptional(type: LanguageType, required: boolean): LanguageType;
-    mapEnum(values: string[], name?: string): LanguageType;
-    formatTypeName(name: string): string;
-    formatFieldName(name: string): string;
-    formatFileName(name: string): string;
-    /**
-     * Generate TypeScript interface field
-     * @param fieldName Field name
-     * @param fieldType Field type
-     * @param required Whether field is required
-     */
-    generateInterfaceField(fieldName: string, fieldType: LanguageType, required: boolean): string;
-    /**
-     * Generate import statement for a type
-     * @param type Language type with import info
-     */
-    generateImportStatement(type: LanguageType): string | undefined;
-    /**
-     * Get all required imports for a set of types
-     * @param types Array of language types
-     */
-    getRequiredImports(types: LanguageType[]): string[];
-}

package/dist/api/generators/base/TypeScriptTypeMapper.js

@@ -1,232 +0,0 @@
-/**
- * TypeScript-specific type mapper implementation
- */
-import { TypeMapper } from "./TypeMapper";
-/**
- * TypeScript type mapper
- */
-export class TypeScriptTypeMapper extends TypeMapper {
-    tsOptions;
-    constructor(options = {}) {
-        super(options);
-        this.tsOptions = {
-            ...this.options,
-            preferUnknown: true,
-            useBrandedTypes: false,
-            preferUndefined: true,
-            moduleFormat: "esm",
-            ...options,
-        };
-    }
-    getLanguageName() {
-        return "TypeScript";
-    }
-    mapPrimitive(fhirType) {
-        const customMapping = this.getCustomMapping(fhirType);
-        if (customMapping) {
-            return {
-                name: customMapping,
-                isPrimitive: true,
-                nullable: false,
-            };
-        }
-        const primitiveMap = {
-            string: "string",
-            integer: "number",
-            decimal: "number",
-            boolean: "boolean",
-            dateTime: "string",
-            date: "string",
-            time: "string",
-            instant: "string",
-            uri: "string",
-            url: "string",
-            canonical: "string",
-            oid: "string",
-            uuid: "string",
-            base64Binary: "string",
-            code: "string",
-            id: "string",
-            markdown: "string",
-            unsignedInt: "number",
-            positiveInt: "number",
-            xhtml: "string",
-            json: "unknown",
-        };
-        const mappedType = primitiveMap[fhirType];
-        if (!mappedType) {
-            console.warn(`Unknown FHIR primitive type: ${fhirType}`);
-            return {
-                name: this.tsOptions.preferUnknown ? "unknown" : "any",
-                isPrimitive: true,
-                nullable: false,
-                metadata: { warning: "unmapped_primitive", originalType: fhirType },
-            };
-        }
-        if (this.tsOptions.useBrandedTypes && fhirType !== mappedType) {
-            return {
-                name: `${mappedType} & { readonly __brand: '${fhirType}' }`,
-                isPrimitive: false,
-                importPath: "./brands",
-                nullable: false,
-                metadata: { isBranded: true, originalFhirType: fhirType },
-            };
-        }
-        return {
-            name: mappedType,
-            isPrimitive: true,
-            nullable: false,
-        };
-    }
-    mapReference(targets) {
-        if (!targets || targets.length === 0) {
-            return {
-                name: "Reference",
-                isPrimitive: false,
-                importPath: "./Reference",
-                generics: ["unknown"],
-                nullable: false,
-            };
-        }
-        if (targets.length === 1) {
-            const targetName = targets[0]?.name || "unknown";
-            const targetStringLiteral = targetName === "unknown" ? "unknown" : `'${targetName}'`;
-            return {
-                name: "Reference",
-                isPrimitive: false,
-                importPath: "./Reference",
-                generics: [targetStringLiteral],
-                nullable: false,
-                metadata: {
-                    referencedType: targetName,
-                    referencedSchema: targets[0],
-                },
-            };
-        }
-        const targetStringLiterals = targets.map((t) => {
-            const targetName = t.name || "unknown";
-            return targetName === "unknown" ? "unknown" : `'${targetName}'`;
-        });
-        return {
-            name: "Reference",
-            isPrimitive: false,
-            importPath: "./Reference",
-            generics: [targetStringLiterals.join(" | ")],
-            nullable: false,
-            metadata: {
-                referencedTypes: targets.map((t) => t.name || "unknown"),
-                referencedSchemas: targets,
-            },
-        };
-    }
-    mapArray(elementType) {
-        if (this.options.preferArraySyntax) {
-            return {
-                name: `${elementType.name}[]`,
-                isPrimitive: elementType.isPrimitive,
-                importPath: elementType.importPath,
-                isArray: true,
-                nullable: false,
-                metadata: {
-                    elementType: elementType,
-                    arrayStyle: "suffix",
-                },
-            };
-        }
-        else {
-            return {
-                name: "Array",
-                isPrimitive: false,
-                generics: [elementType.name],
-                isArray: true,
-                nullable: false,
-                metadata: {
-                    elementType: elementType,
-                    arrayStyle: "generic",
-                },
-            };
-        }
-    }
-    mapOptional(type, required) {
-        if (required || !this.shouldBeNullable(required)) {
-            return type;
-        }
-        const nullType = this.tsOptions.preferUndefined ? "undefined" : "null";
-        return {
-            ...type,
-            name: `${type.name} | ${nullType}`,
-            nullable: true,
-            metadata: {
-                ...type.metadata,
-                nullabilityType: nullType,
-                wasOptional: true,
-            },
-        };
-    }
-    mapEnum(values, name) {
-        const enumName = name ? this.formatTypeName(name) : "CodedValue";
-        const unionType = values.map((v) => `'${v}'`).join(" | ");
-        return {
-            name: unionType,
-            isPrimitive: false,
-            nullable: false,
-            metadata: {
-                enumName,
-                values,
-                isUnionType: true,
-            },
-        };
-    }
-    formatTypeName(name) {
-        return this.applyNamingConvention(name);
-    }
-    formatFieldName(name) {
-        return toCamelCase(name);
-    }
-    formatFileName(name) {
-        return this.applyNamingConvention(name);
-    }
-    /**
-     * Generate TypeScript interface field
-     * @param fieldName Field name
-     * @param fieldType Field type
-     * @param required Whether field is required
-     */
-    generateInterfaceField(fieldName, fieldType, required) {
-        const formattedName = this.formatFieldName(fieldName);
-        const optionalMarker = required ? "" : "?";
-        return `${formattedName}${optionalMarker}: ${fieldType.name};`;
-    }
-    /**
-     * Generate import statement for a type
-     * @param type Language type with import info
-     */
-    generateImportStatement(type) {
-        if (!type.importPath || type.isPrimitive) {
-            return undefined;
-        }
-        if (this.tsOptions.moduleFormat === "esm") {
-            return `import type { ${type.name} } from '${type.importPath}';`;
-        }
-        else {
-            return `const { ${type.name} } = require('${type.importPath}');`;
-        }
-    }
-    /**
-     * Get all required imports for a set of types
-     * @param types Array of language types
-     */
-    getRequiredImports(types) {
-        const imports = new Set();
-        for (const type of types) {
-            const importStatement = this.generateImportStatement(type);
-            if (importStatement) {
-                imports.add(importStatement);
-            }
-        }
-        return Array.from(imports).sort();
-    }
-}
-function toCamelCase(str) {
-    return str.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() || "");
-}

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

@@ -1,99 +0,0 @@
-/**
- * Directory builder for batch file operations
- *
- * Provides a fluent API for managing entire directories of files,
- * including subdirectories, index files, and batch operations.
- */
-import type { CodegenLogger } from "../../../../utils/codegen-logger";
-import type { FileManager } from "../FileManager";
-import type { FileBuilder } from "./FileBuilder";
-import type { IndexBuilder } from "./IndexBuilder";
-export interface DirectoryBuilderConfig {
-    path: string;
-    fileManager: FileManager;
-    logger: CodegenLogger;
-}
-/**
- * Fluent builder for directory operations
- *
- * Features:
- * - Subdirectory management
- * - Batch file operations
- * - Index file generation
- * - Directory cleaning
- * - File listing for preview
- */
-export declare class DirectoryBuilder {
-    private readonly config;
-    private readonly files;
-    private readonly subdirectories;
-    private indexBuilder?;
-    private shouldClean;
-    constructor(config: DirectoryBuilderConfig);
-    /**
-     * Add a subdirectory
-     * @param name Subdirectory name
-     */
-    withSubdirectory(name: string): DirectoryBuilder;
-    /**
-     * Add files to this directory
-     * @param files Map of filename to FileBuilder
-     */
-    withFiles(files: Record<string, FileBuilder>): DirectoryBuilder;
-    /**
-     * Add a single file
-     * @param filename File name
-     * @param builder File builder
-     */
-    withFile(filename: string, builder: FileBuilder): DirectoryBuilder;
-    /**
-     * Set index builder for this directory
-     * @param builder Index builder
-     */
-    withIndex(builder: IndexBuilder): DirectoryBuilder;
-    /**
-     * Clean directory before creating files
-     */
-    clean(): DirectoryBuilder;
-    /**
-     * Ensure directory exists
-     */
-    ensure(): Promise<DirectoryBuilder>;
-    /**
-     * Save all files in this directory
-     */
-    save(): Promise<string[]>;
-    /**
-     * Get all files that would be generated (for preview)
-     */
-    getFileList(): string[];
-    /**
-     * Get statistics about this directory
-     */
-    getStats(): {
-        fileCount: number;
-        subdirectoryCount: number;
-        hasIndex: boolean;
-        totalFiles: number;
-    };
-    /**
-     * Check if directory would overwrite existing files
-     */
-    wouldOverwrite(): Promise<string[]>;
-    /**
-     * Get the path of this directory
-     */
-    getPath(): string;
-    /**
-     * Get all file builders (for testing/debugging)
-     */
-    getFiles(): Map<string, FileBuilder>;
-    /**
-     * Get all subdirectories (for testing/debugging)
-     */
-    getSubdirectories(): Map<string, DirectoryBuilder>;
-    /**
-     * Get index builder (for testing/debugging)
-     */
-    getIndexBuilder(): IndexBuilder | undefined;
-}