@atomic-ehr/codegen 0.0.1-canary.20250821160126.c552195 → 0.0.1-canary.20250822150706.c3b8669

package/dist/api/generators/types.js

@@ -0,0 +1,4 @@
+/**
+ * Common types used in generated code
+ */
+export {};

package/dist/api/generators/typescript.d.ts

@@ -5,9 +5,9 @@
  * Built using the BaseGenerator architecture with TypeMapper, TemplateEngine, and FileManager.
  */
 import type { TypeSchema } from "../../typeschema/type-schema.types";
-import { BaseGenerator } from "./base/BaseGenerator";
-import { type TypeScriptTypeMapperOptions } from "./base/TypeScriptTypeMapper";
-import type { BaseGeneratorOptions, GeneratedFile, TemplateContext, TypeMapper } from "./base/types";
+import { BaseGenerator } from "./base/BaseGenerator.js";
+import { type TypeScriptTypeMapperOptions } from "./base/TypeScriptTypeMapper.js";
+import type { BaseGeneratorOptions, GeneratedFile, TemplateContext, TypeMapper } from "./base/types.js";
 /**
  * TypeScript-specific generator options
  */

package/dist/api/generators/typescript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/api/generators/typescript.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/api/generators/typescript.ts"],"names":[],"mappings":"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"}

package/dist/api/generators/typescript.js

@@ -0,0 +1,537 @@
+/**
+ * Modern TypeScript Generator built on BaseGenerator
+ *
+ * This is the new, clean implementation that replaces the monolithic typescript.ts generator.
+ * Built using the BaseGenerator architecture with TypeMapper, TemplateEngine, and FileManager.
+ */
+import { BaseGenerator } from "./base/BaseGenerator.js";
+import { TypeScriptTypeMapper, } from "./base/TypeScriptTypeMapper.js";
+/**
+ * Modern TypeScript Generator
+ *
+ * Generates clean, type-safe TypeScript interfaces from FHIR TypeSchema documents.
+ * Uses the new BaseGenerator architecture for maintainability and extensibility.
+ */
+export class TypeScriptGenerator extends BaseGenerator {
+    profilesByPackage = new Map();
+    resourceTypes = new Set();
+    get tsOptions() {
+        return this.options;
+    }
+    getLanguageName() {
+        return "TypeScript";
+    }
+    getFileExtension() {
+        return ".ts";
+    }
+    createTypeMapper() {
+        const options = this.options;
+        return new TypeScriptTypeMapper({
+            namingConvention: (options.namingConvention ?? "PascalCase") === "PascalCase"
+                ? "PascalCase"
+                : "camelCase",
+            moduleFormat: options.moduleFormat === "cjs" ? "commonjs" : "esm",
+            preferUndefined: true,
+            ...options.typeMapperOptions,
+        });
+    }
+    async generateSchemaContent(schema, context) {
+        // Skip unsupported schema types
+        if (this.shouldSkipSchema(schema)) {
+            return "";
+        }
+        // Collect resource types for Reference generic
+        if (schema.identifier.kind === "resource") {
+            this.resourceTypes.add(this.typeMapper.formatTypeName(schema.identifier.name));
+        }
+        // Update filename for profiles to include proper directory structure
+        // if (false) {
+        // 	// Profile support removed - not in core schema
+        // 	const sanitizedPackage = this.sanitizePackageName(
+        // 		schema.identifier.package || "unknown",
+        // 	);
+        // 	const profileFileName = this.typeMapper.formatFileName(
+        // 		schema.identifier.name,
+        // 	);
+        // 	context.filename = `profiles/${sanitizedPackage}/${profileFileName}`;
+        // 	// Track profile for index generation
+        // 	if (!this.profilesByPackage.has(schema.identifier.package || "unknown")) {
+        // 		this.profilesByPackage.set(schema.identifier.package || "unknown", []);
+        // 	}
+        // 	this.profilesByPackage.get(schema.identifier.package || "unknown")?.push({
+        // 		filename: profileFileName,
+        // 		interfaceName: this.typeMapper.formatTypeName(schema.identifier.name),
+        // 	});
+        // }
+        // Handle Reference type specially
+        if (schema.identifier.name === "Reference") {
+            return this.generateReferenceInterface(schema);
+        }
+        // Generate TypeScript content directly (no templates for simplicity)
+        const mainInterface = this.generateTypeScriptInterface(schema);
+        // Generate nested types if present
+        let nestedInterfaces = "";
+        if ("nested" in schema && schema.nested && Array.isArray(schema.nested)) {
+            const nestedInterfaceStrings = schema.nested.map((nestedType) => this.generateNestedTypeInterface(schema.identifier.name, nestedType));
+            nestedInterfaces = nestedInterfaceStrings.join("\n\n");
+        }
+        // Combine main interface with nested interfaces
+        if (nestedInterfaces) {
+            return `${mainInterface}\n\n${nestedInterfaces}`;
+        }
+        return mainInterface;
+    }
+    filterAndSortSchemas(schemas) {
+        return schemas.filter((schema) => !this.shouldSkipSchema(schema));
+    }
+    async validateContent(content, context) {
+        const hasValidExport = /export\s+(interface|class|type|enum)\s+\w+/.test(content);
+        const hasValidSyntax = content.includes("{") && content.includes("}");
+        if (!hasValidExport) {
+            throw new Error(`Generated content for ${context.schema.identifier.name} does not contain valid export statements`);
+        }
+        if (!hasValidSyntax) {
+            throw new Error(`Generated content for ${context.schema.identifier.name} has invalid syntax (missing braces)`);
+        }
+    }
+    /**
+     * Transform multiple schemas into TypeScript
+     */
+    async transformSchemas(schemas) {
+        const results = [];
+        for (const schema of schemas) {
+            const result = await this.transformSchema(schema);
+            if (result) {
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    /**
+     * Transform a single schema into TypeScript
+     */
+    async transformSchema(schema) {
+        if (this.shouldSkipSchema(schema)) {
+            return undefined;
+        }
+        // Create template context
+        const context = {
+            schema,
+            typeMapper: this.typeMapper,
+            filename: this.getFilenameForSchema(schema),
+            language: "TypeScript",
+            timestamp: new Date().toISOString(),
+        };
+        // Generate content using template engine
+        const content = await this.generateSchemaContent(schema, context);
+        if (!content.trim()) {
+            return undefined;
+        }
+        // Extract imports and exports from generated content
+        const imports = this.extractImportsFromContent(content, schema);
+        const exports = this.extractExportsFromContent(content, schema);
+        const filename = this.getFilenameForSchema(schema);
+        return {
+            content,
+            imports,
+            exports: Array.from(exports),
+            filename,
+        };
+    }
+    shouldSkipSchema(schema) {
+        if (schema.identifier.kind === "value-set" ||
+            schema.identifier.kind === "binding" ||
+            schema.identifier.kind === "primitive-type") {
+            return true;
+        }
+        // Profile support removed - not in core schema specification
+        if (schema.identifier.url?.includes("/extension/") &&
+            !this.tsOptions.includeExtensions) {
+            return true;
+        }
+        return false;
+    }
+    getFilenameForSchema(schema) {
+        const baseName = this.typeMapper.formatFileName(schema.identifier.name);
+        return `${baseName}${this.getFileExtension()}`;
+    }
+    extractImportsFromContent(content, _schema) {
+        const imports = new Map();
+        const importRegex = /import\s+(?:type\s+)?{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"];?/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const symbolsStr = match[1];
+            const path = match[2];
+            if (!symbolsStr || !path)
+                continue;
+            const symbols = symbolsStr.split(",").map((s) => s.trim());
+            for (const symbol of symbols) {
+                imports.set(symbol, path);
+            }
+        }
+        return imports;
+    }
+    extractExportsFromContent(content, schema) {
+        const exports = new Set();
+        const exportRegex = /export\s+(?:interface|class|enum|type)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+        let match;
+        while ((match = exportRegex.exec(content)) !== null) {
+            if (match[1])
+                exports.add(match[1]);
+        }
+        exports.add(this.typeMapper.formatTypeName(schema.identifier.name));
+        return exports;
+    }
+    sanitizePackageName(packageName) {
+        return packageName.replace(/[^a-zA-Z0-9-_.]/g, "-");
+    }
+    /**
+     * Generate special Reference interface with generics
+     */
+    generateReferenceInterface(schema) {
+        const lines = [];
+        const imports = new Set();
+        if ("fields" in schema && schema.fields) {
+            for (const [, field] of Object.entries(schema.fields)) {
+                const importDeps = this.collectFieldImports(field);
+                importDeps.forEach((imp) => imports.add(imp));
+            }
+        }
+        lines.push("import type { ResourceType } from './utilities.js';");
+        if (imports.size > 0) {
+            const sortedImports = Array.from(imports).sort();
+            for (const importName of sortedImports) {
+                lines.push(`import type { ${importName} } from './${importName}.js';`);
+            }
+        }
+        lines.push(""); // Add blank line after imports
+        // Add JSDoc comment
+        if (this.tsOptions.includeDocuments && schema.description) {
+            lines.push("/**");
+            lines.push(` * ${schema.description}`);
+            if (schema.identifier.url) {
+                lines.push(` * @see ${schema.identifier.url}`);
+            }
+            if (schema.identifier.package) {
+                lines.push(` * @package ${schema.identifier.package}`);
+            }
+            lines.push(" * @template T - The resource type being referenced");
+            lines.push(" */");
+        }
+        // Generate generic interface declaration
+        lines.push("export interface Reference<T extends ResourceType = ResourceType> {");
+        if ("fields" in schema && schema.fields) {
+            for (const [fieldName, field] of Object.entries(schema.fields)) {
+                if (fieldName === "type") {
+                    // Special handling for the type field to use the generic parameter
+                    lines.push("  type?: T;");
+                }
+                else {
+                    const fieldLine = this.generateFieldLine(fieldName, field);
+                    if (fieldLine) {
+                        lines.push(`  ${fieldLine}`);
+                    }
+                }
+            }
+        }
+        lines.push("}");
+        return lines.join("\n");
+    }
+    /**
+     * Generate TypeScript interface directly without templates
+     */
+    generateTypeScriptInterface(schema) {
+        const lines = [];
+        const interfaceName = this.typeMapper.formatTypeName(schema.identifier.name);
+        const imports = new Set();
+        if ("fields" in schema && schema.fields) {
+            for (const [, field] of Object.entries(schema.fields)) {
+                const importDeps = this.collectFieldImports(field);
+                importDeps.forEach((imp) => imports.add(imp));
+            }
+        }
+        // Collect imports from nested types
+        if ("nested" in schema && schema.nested && Array.isArray(schema.nested)) {
+            for (const nestedType of schema.nested) {
+                if (nestedType.fields) {
+                    for (const [, field] of Object.entries(nestedType.fields)) {
+                        const importDeps = this.collectFieldImports(field);
+                        importDeps.forEach((imp) => imports.add(imp));
+                    }
+                }
+            }
+        }
+        // Generate import statements
+        if (imports.size > 0) {
+            const sortedImports = Array.from(imports).sort();
+            for (const importName of sortedImports) {
+                lines.push(`import type { ${importName} } from './${importName}.js';`);
+            }
+            lines.push(""); // Add blank line after imports
+        }
+        // Add JSDoc comment if enabled
+        if (this.tsOptions.includeDocuments && schema.description) {
+            lines.push("/**");
+            lines.push(` * ${schema.description}`);
+            if (schema.identifier.url) {
+                lines.push(` * @see ${schema.identifier.url}`);
+            }
+            if (schema.identifier.package) {
+                lines.push(` * @package ${schema.identifier.package}`);
+            }
+            lines.push(" */");
+        }
+        // Generate interface declaration
+        lines.push(`export interface ${interfaceName} {`);
+        // Add resourceType for FHIR resources
+        if (schema.identifier.kind === "resource") {
+            lines.push(`  resourceType: '${interfaceName}';`);
+        }
+        // Generate fields (if any)
+        if ("fields" in schema && schema.fields) {
+            for (const [fieldName, field] of Object.entries(schema.fields)) {
+                const fieldLine = this.generateFieldLine(fieldName, field);
+                if (fieldLine) {
+                    lines.push(`  ${fieldLine}`);
+                }
+            }
+        }
+        lines.push("}");
+        return lines.join("\n");
+    }
+    /**
+     * Collect import dependencies from a field
+     */
+    collectFieldImports(field) {
+        const imports = [];
+        if ("type" in field && field.type) {
+            // Handle nested types - they don't need imports as they're in the same file
+            if (field.type.kind === "nested") {
+                // Nested types are generated in the same file, no import needed
+                return imports;
+            }
+            const languageType = this.typeMapper.mapType(field.type);
+            // Only import non-primitive types that are not built-in
+            if (!languageType.isPrimitive && languageType.name !== "any") {
+                const builtInTypes = [
+                    "string",
+                    "number",
+                    "boolean",
+                    "Date",
+                    "object",
+                    "unknown",
+                    "any",
+                ];
+                if (!builtInTypes.includes(languageType.name)) {
+                    imports.push(languageType.name);
+                }
+            }
+        }
+        return imports;
+    }
+    /**
+     * Extract resource types from reference field constraints
+     */
+    extractReferenceTypes(referenceConstraints) {
+        const resourceTypes = [];
+        if (!Array.isArray(referenceConstraints)) {
+            return resourceTypes;
+        }
+        for (const constraint of referenceConstraints) {
+            if (!constraint || typeof constraint !== "object") {
+                continue;
+            }
+            if (constraint.kind === "resource" && constraint.name) {
+                const resourceType = this.typeMapper.formatTypeName(constraint.name);
+                resourceTypes.push(resourceType);
+            }
+        }
+        return [...new Set(resourceTypes)]; // Remove duplicates
+    }
+    /**
+     * Generate nested type interface
+     */
+    generateNestedTypeInterface(parentTypeName, nestedType) {
+        const lines = [];
+        const nestedTypeName = this.typeMapper.formatTypeName(`${parentTypeName}${this.capitalizeFirst(nestedType.identifier.name)}`);
+        // Add JSDoc comment if enabled
+        if (this.tsOptions.includeDocuments && nestedType.description) {
+            lines.push("/**");
+            lines.push(` * ${nestedType.description}`);
+            if (nestedType.identifier.url) {
+                lines.push(` * @see ${nestedType.identifier.url}`);
+            }
+            lines.push(" */");
+        }
+        // Generate interface declaration
+        lines.push(`export interface ${nestedTypeName} {`);
+        // Generate fields
+        if (nestedType.fields) {
+            for (const [fieldName, field] of Object.entries(nestedType.fields)) {
+                const fieldLine = this.generateFieldLine(fieldName, field);
+                if (fieldLine) {
+                    lines.push(`  ${fieldLine}`);
+                }
+            }
+        }
+        lines.push("}");
+        return lines.join("\n");
+    }
+    /**
+     * Capitalize first letter of string
+     */
+    capitalizeFirst(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    /**
+     * Generate a single field line
+     */
+    generateFieldLine(fieldName, field) {
+        let typeString = "any";
+        let required = false;
+        let isArray = false;
+        if ("type" in field && field.type) {
+            const languageType = this.typeMapper.mapType(field.type);
+            typeString = languageType.name;
+            // Handle nested types specially
+            if (field.type.kind === "nested") {
+                // Extract parent name from URL like "http://hl7.org/fhir/StructureDefinition/Patient#contact"
+                const urlParts = field.type.url?.split("#") || [];
+                if (urlParts.length === 2) {
+                    const parentName = urlParts[0].split("/").pop() || "";
+                    const nestedName = field.type.name;
+                    typeString = this.typeMapper.formatTypeName(`${parentName}${this.capitalizeFirst(nestedName)}`);
+                }
+                else {
+                    typeString = this.typeMapper.formatTypeName(field.type.name);
+                }
+            }
+            else if (typeString === "Reference" &&
+                field.reference &&
+                Array.isArray(field.reference)) {
+                const referenceTypes = this.extractReferenceTypes(field.reference);
+                if (referenceTypes.length > 0) {
+                    referenceTypes.forEach((type) => this.resourceTypes.add(type));
+                    const unionType = referenceTypes
+                        .map((type) => `'${type}'`)
+                        .join(" | ");
+                    typeString = `Reference<${unionType}>`;
+                }
+            }
+        }
+        if ("required" in field) {
+            required = field.required;
+        }
+        if ("array" in field) {
+            isArray = field.array;
+        }
+        const optional = required ? "" : "?";
+        const arrayType = isArray ? "[]" : "";
+        return `${fieldName}${optional}: ${typeString}${arrayType};`;
+    }
+    // ==========================================
+    /**
+     * Extract exported symbols from TypeScript content
+     */
+    extractExports(content) {
+        const exports = [];
+        const exportListPattern = /export\s*\{\s*([^}]+)\s*\}/g;
+        let match;
+        while ((match = exportListPattern.exec(content)) !== null) {
+            if (match[1]) {
+                const names = match[1]
+                    .split(",")
+                    .map((name) => name.trim())
+                    .filter(Boolean);
+                exports.push(...names);
+            }
+        }
+        const directExportPatterns = [
+            /export\s+interface\s+(\w+)/g, // export interface Name
+            /export\s+type\s+(\w+)/g, // export type Name
+            /export\s+class\s+(\w+)/g, // export class Name
+            /export\s+enum\s+(\w+)/g, // export enum Name
+            /export\s+const\s+(\w+)/g, // export const name
+            /export\s+function\s+(\w+)/g, // export function name
+        ];
+        for (const pattern of directExportPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                if (match[1]) {
+                    exports.push(match[1]);
+                }
+            }
+        }
+        return [...new Set(exports)];
+    }
+    /**
+     * Set output directory for compatibility with API builder
+     */
+    setOutputDir(directory) {
+        this.options.outputDir = directory;
+    }
+    /**
+     * Update generator options for compatibility with API builder
+     */
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    /**
+     * Get current options for compatibility with API builder
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+    /**
+     * Run post-generation hooks - generate utility files
+     */
+    async runPostGenerationHooks() {
+        await super.runPostGenerationHooks();
+        await this.generateUtilitiesFile();
+    }
+    /**
+     * Generate utilities.ts file with ResourceType union
+     */
+    async generateUtilitiesFile() {
+        if (this.resourceTypes.size === 0) {
+            this.logger.warn("No resource types found, skipping utilities.ts generation");
+            return;
+        }
+        const lines = [];
+        // Add file header comment
+        lines.push("/**");
+        lines.push(" * FHIR Resource Type Utilities");
+        lines.push(" * This file contains utility types for FHIR resources.");
+        lines.push(" * ");
+        lines.push(" * @generated This file is auto-generated. Do not edit manually.");
+        lines.push(" */");
+        lines.push("");
+        // Generate ResourceType union
+        const sortedResourceTypes = Array.from(this.resourceTypes).sort();
+        lines.push("/**");
+        lines.push(" * Union of all FHIR resource types in this package");
+        lines.push(" */");
+        lines.push("export type ResourceType =");
+        for (let i = 0; i < sortedResourceTypes.length; i++) {
+            const isLast = i === sortedResourceTypes.length - 1;
+            const separator = isLast ? ";" : "";
+            lines.push(`  | '${sortedResourceTypes[i]}'${separator}`);
+        }
+        lines.push("");
+        // Generate helper type for Resource references
+        lines.push("/**");
+        lines.push(" * Helper type for creating typed References");
+        lines.push(" * @example Reference<'Patient' | 'Practitioner'> - Reference that can point to Patient or Practitioner");
+        lines.push(" */");
+        lines.push("export type TypedReference<T extends ResourceType> = {");
+        lines.push("  reference?: string;");
+        lines.push("  type?: T;");
+        lines.push("  identifier?: any; // Simplified for utility");
+        lines.push("  display?: string;");
+        lines.push("};");
+        const content = lines.join("\n");
+        // Write the utilities file
+        await this.fileManager.writeFile("utilities.ts", content);
+        this.logger.info(`Generated utilities.ts with ${this.resourceTypes.size} resource types`);
+    }
+}