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

package/dist/typeschema/parser.d.ts

@@ -1,79 +0,0 @@
-/**
- * TypeSchema Parser
- *
- * Parser for reading and manipulating TypeSchema documents from various formats.
- * Supports both NDJSON and JSON formats with automatic format detection.
- */
-import type { Identifier, TypeSchema, TypeschemaParserOptions } from "@typeschema/types";
-/**
- * TypeSchema Parser class
- *
- * Provides functionality to read, parse, and manipulate TypeSchema documents
- * from files or strings in various formats.
- */
-export declare class TypeSchemaParser {
-    private options;
-    constructor(options?: TypeschemaParserOptions);
-    /**
-     * Parse TypeSchema from file
-     */
-    parseFromFile(filePath: string): Promise<TypeSchema[]>;
-    /**
-     * Parse TypeSchema from string content
-     */
-    parseFromString(content: string, format?: "ndjson" | "json"): Promise<TypeSchema[]>;
-    /**
-     * Parse multiple TypeSchema files
-     */
-    parseFromFiles(filePaths: string[]): Promise<TypeSchema[]>;
-    /**
-     * Parse a single TypeSchema object
-     */
-    parseSchema(schemaData: any): TypeSchema;
-    /**
-     * Find schemas by identifier
-     */
-    findByIdentifier(schemas: TypeSchema[], identifier: Partial<Identifier>): TypeSchema[];
-    /**
-     * Find schema by URL
-     */
-    findByUrl(schemas: TypeSchema[], url: string): TypeSchema | undefined;
-    /**
-     * Find schemas by kind
-     */
-    findByKind(schemas: TypeSchema[], kind: Identifier["kind"]): TypeSchema[];
-    /**
-     * Find schemas by package
-     */
-    findByPackage(schemas: TypeSchema[], packageName: string): TypeSchema[];
-    /**
-     * Get all dependencies from a schema
-     */
-    /**
-     * Resolve schema dependencies
-     */
-    /**
-     * Detect format from content or filename
-     */
-    private detectFormat;
-    /**
-     * Parse NDJSON format
-     */
-    private parseNDJSON;
-    /**
-     * Parse JSON format
-     */
-    private parseJSON;
-    /**
-     * Validate schemas
-     */
-    private validateSchemas;
-    /**
-     * Validate identifier structure
-     */
-    private isValidIdentifier;
-    /**
-     * Check if identifier matches criteria
-     */
-    private matchesIdentifier;
-}

package/dist/typeschema/parser.js

@@ -1,274 +0,0 @@
-/**
- * TypeSchema Parser
- *
- * Parser for reading and manipulating TypeSchema documents from various formats.
- * Supports both NDJSON and JSON formats with automatic format detection.
- */
-import { readFile } from "node:fs/promises";
-/**
- * TypeSchema Parser class
- *
- * Provides functionality to read, parse, and manipulate TypeSchema documents
- * from files or strings in various formats.
- */
-export class TypeSchemaParser {
-    options;
-    constructor(options = {}) {
-        this.options = {
-            format: "auto",
-            validate: true,
-            strict: false,
-            ...options,
-        };
-    }
-    /**
-     * Parse TypeSchema from file
-     */
-    async parseFromFile(filePath) {
-        const content = await readFile(filePath, "utf-8");
-        const format = this.options.format === "auto" ? this.detectFormat(content, filePath) : this.options.format;
-        return this.parseFromString(content, format);
-    }
-    /**
-     * Parse TypeSchema from string content
-     */
-    async parseFromString(content, format) {
-        const actualFormat = format || this.detectFormat(content);
-        let schemas;
-        if (actualFormat === "ndjson") {
-            schemas = this.parseNDJSON(content);
-        }
-        else {
-            schemas = this.parseJSON(content);
-        }
-        if (this.options.validate) {
-            this.validateSchemas(schemas);
-        }
-        return schemas;
-    }
-    /**
-     * Parse multiple TypeSchema files
-     */
-    async parseFromFiles(filePaths) {
-        const allSchemas = [];
-        for (const filePath of filePaths) {
-            const schemas = await this.parseFromFile(filePath);
-            allSchemas.push(...schemas);
-        }
-        return allSchemas;
-    }
-    /**
-     * Parse a single TypeSchema object
-     */
-    parseSchema(schemaData) {
-        // Basic validation of required fields
-        if (!schemaData.identifier) {
-            throw new Error("TypeSchema must have an identifier");
-        }
-        if (!this.isValidIdentifier(schemaData.identifier)) {
-            throw new Error("TypeSchema identifier is invalid");
-        }
-        // Return the schema (assuming it's already in correct format)
-        // Additional validation would be performed by the validator
-        return schemaData;
-    }
-    /**
-     * Find schemas by identifier
-     */
-    findByIdentifier(schemas, identifier) {
-        return schemas.filter((schema) => this.matchesIdentifier(schema.identifier, identifier));
-    }
-    /**
-     * Find schema by URL
-     */
-    findByUrl(schemas, url) {
-        return schemas.find((schema) => schema.identifier.url === url);
-    }
-    /**
-     * Find schemas by kind
-     */
-    findByKind(schemas, kind) {
-        return schemas.filter((schema) => schema.identifier.kind === kind);
-    }
-    /**
-     * Find schemas by package
-     */
-    findByPackage(schemas, packageName) {
-        return schemas.filter((schema) => schema.identifier.package === packageName);
-    }
-    /**
-     * Get all dependencies from a schema
-     */
-    // getDependencies(schema: TypeSchema): Identifier[] {
-    //   const dependencies: Identifier[] = [];
-    //   // Add base dependency
-    //   if ("base" in schema && schema.base) {
-    //     dependencies.push(schema.base);
-    //   }
-    //   // Add explicit dependencies
-    //   if ("dependencies" in schema && schema.dependencies) {
-    //     dependencies.push(...schema.dependencies);
-    //   }
-    //   // Add field type dependencies
-    //   if ("fields" in schema && schema.fields) {
-    //     for (const field of Object.values(schema.fields)) {
-    //       if ("type" in field && field.type) {
-    //         dependencies.push(field.type);
-    //       }
-    //       if ("binding" in field && field.binding) {
-    //         dependencies.push(field.binding);
-    //       }
-    //       if ("reference" in field && field.reference) {
-    //         dependencies.push(...field.reference);
-    //       }
-    //     }
-    //   }
-    //   if ("nested" in schema && schema.nested) {
-    //     for (const nested of schema.nested) {
-    //       dependencies.push(nested.identifier);
-    //       dependencies.push(nested.base);
-    //       for (const field of Object.values(nested.fields)) {
-    //         if ("type" in field && field.type) {
-    //           dependencies.push(field.type);
-    //         }
-    //         if ("binding" in field && field.binding) {
-    //           dependencies.push(field.binding);
-    //         }
-    //         if ("reference" in field && field.reference) {
-    //           dependencies.push(...field.reference);
-    //         }
-    //       }
-    //     }
-    //   }
-    //   // Add binding dependencies
-    //   if ("valueset" in schema) {
-    //     const bindingSchema = schema as any;
-    //     dependencies.push(bindingSchema.valueset);
-    //     if (bindingSchema.type) {
-    //       dependencies.push(bindingSchema.type);
-    //     }
-    //   }
-    //   // Remove duplicates
-    //   return this.deduplicateDependencies(dependencies);
-    // }
-    /**
-     * Resolve schema dependencies
-     */
-    // resolveDependencies(
-    //   schemas: TypeSchema[],
-    //   targetSchema: TypeSchema,
-    // ): TypeSchema[] {
-    //   const dependencies = this.getDependencies(targetSchema);
-    //   const resolved: TypeSchema[] = [];
-    //   for (const dep of dependencies) {
-    //     const depSchema = this.findByUrl(schemas, dep.url);
-    //     if (depSchema) {
-    //       resolved.push(depSchema);
-    //     }
-    //   }
-    //   return resolved;
-    // }
-    /**
-     * Detect format from content or filename
-     */
-    detectFormat(content, filename) {
-        // Check file extension first
-        if (filename) {
-            if (filename.endsWith(".ndjson"))
-                return "ndjson";
-            if (filename.endsWith(".json"))
-                return "json";
-        }
-        // Check content format
-        const trimmed = content.trim();
-        // NDJSON typically has multiple lines with JSON objects
-        if (trimmed.includes("\n")) {
-            const lines = trimmed.split("\n").filter((line) => line.trim());
-            if (lines.length > 1) {
-                try {
-                    if (lines[0]) {
-                        JSON.parse(lines[0]);
-                    }
-                    return "ndjson";
-                }
-                catch {
-                    // Fall through to JSON detection
-                }
-            }
-        }
-        // Default to JSON for single objects or arrays
-        return "json";
-    }
-    /**
-     * Parse NDJSON format
-     */
-    parseNDJSON(content) {
-        const schemas = [];
-        const lines = content.split("\n").filter((line) => line.trim());
-        for (const line of lines) {
-            try {
-                const parsed = JSON.parse(line);
-                schemas.push(this.parseSchema(parsed));
-            }
-            catch (error) {
-                if (this.options.strict) {
-                    throw new Error(`Failed to parse NDJSON line: ${error}`);
-                }
-                // Skip invalid lines in non-strict mode
-            }
-        }
-        return schemas;
-    }
-    /**
-     * Parse JSON format
-     */
-    parseJSON(content) {
-        try {
-            const parsed = JSON.parse(content);
-            if (Array.isArray(parsed)) {
-                return parsed.map((item) => this.parseSchema(item));
-            }
-            else {
-                return [this.parseSchema(parsed)];
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to parse JSON: ${error}`);
-        }
-    }
-    /**
-     * Validate schemas
-     */
-    validateSchemas(schemas) {
-        for (const schema of schemas) {
-            if (!schema.identifier) {
-                throw new Error("Schema missing identifier");
-            }
-            if (!this.isValidIdentifier(schema.identifier)) {
-                throw new Error(`Invalid identifier in schema: ${JSON.stringify(schema.identifier)}`);
-            }
-        }
-    }
-    /**
-     * Validate identifier structure
-     */
-    isValidIdentifier(identifier) {
-        return (typeof identifier === "object" &&
-            identifier !== null &&
-            typeof identifier.kind === "string" &&
-            typeof identifier.package === "string" &&
-            typeof identifier.version === "string" &&
-            typeof identifier.name === "string" &&
-            typeof identifier.url === "string");
-    }
-    /**
-     * Check if identifier matches criteria
-     */
-    matchesIdentifier(identifier, criteria) {
-        return ((!criteria.kind || identifier.kind === criteria.kind) &&
-            (!criteria.package || identifier.package === criteria.package) &&
-            (!criteria.version || identifier.version === criteria.version) &&
-            (!criteria.name || identifier.name === criteria.name) &&
-            (!criteria.url || identifier.url === criteria.url));
-    }
-}

package/dist/typeschema/profile/processor.d.ts

@@ -1,14 +0,0 @@
-/**
- * Profile Processor (DEPRECATED - Profiles not in core TypeSchema spec)
- *
- * Handles transformation of FHIR profiles to TypeSchema format
- * This file is deprecated as profiles are not part of the core TypeSchema specification
- */
-import type { Register } from "@root/typeschema/register";
-import type { RichFHIRSchema } from "@typeschema/types";
-import type { ProfileTypeSchema } from "../types";
-/**
- * Transform a FHIR profile to TypeSchema format
- * Profiles are treated as specialized resources that extend base resources
- */
-export declare function transformProfile(register: Register, fhirSchema: RichFHIRSchema): Promise<ProfileTypeSchema>;

package/dist/typeschema/profile/processor.js

@@ -1,262 +0,0 @@
-/**
- * Profile Processor (DEPRECATED - Profiles not in core TypeSchema spec)
- *
- * Handles transformation of FHIR profiles to TypeSchema format
- * This file is deprecated as profiles are not part of the core TypeSchema specification
- */
-import { mkIdentifier } from "../core/identifier";
-import { mkFields } from "../core/transformer";
-/**
- * Transform a FHIR profile to TypeSchema format
- * Profiles are treated as specialized resources that extend base resources
- */
-export async function transformProfile(register, fhirSchema) {
-    // Build profile identifier
-    const identifier = mkIdentifier(fhirSchema);
-    const _packageInfo = fhirSchema.package_meta;
-    // Ensure this is recognized as a profile
-    if (identifier.kind !== "profile") {
-        throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
-    }
-    // Build base identifier - profiles always have a base
-    let base;
-    if (fhirSchema.base) {
-        const baseUrl = fhirSchema.base.includes("/")
-            ? fhirSchema.base
-            : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
-        const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
-        // Determine base kind - could be another profile or a base resource
-        const baseKind = await determineBaseKind(baseUrl, register);
-        // For standard FHIR types, use the standard package
-        const isStandardFhir = baseUrl.startsWith("http://hl7.org/fhir/");
-        base = {
-            kind: baseKind,
-            package: isStandardFhir ? "hl7.fhir.r4.core" : fhirSchema.package_meta.name || "undefined",
-            version: isStandardFhir ? "4.0.1" : fhirSchema.package_meta.version || "undefined",
-            name: baseName,
-            url: baseUrl,
-        };
-    }
-    // Initialize the profile schema
-    const profileSchema = {
-        identifier,
-        base: base,
-        dependencies: base ? [base] : [],
-    };
-    // Add description if present
-    if (fhirSchema.description) {
-        profileSchema.description = fhirSchema.description;
-    }
-    // Add profile-specific metadata
-    const metadata = extractProfileMetadata(fhirSchema);
-    if (Object.keys(metadata).length > 0) {
-        profileSchema.metadata = metadata;
-    }
-    // Process profile fields from differential elements
-    if (fhirSchema.elements) {
-        const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
-        if (fields && Object.keys(fields).length > 0) {
-            profileSchema.fields = fields;
-        }
-    }
-    // Process profile constraints
-    const constraints = await processProfileConstraints(fhirSchema, register);
-    if (Object.keys(constraints).length > 0) {
-        profileSchema.constraints = constraints;
-    }
-    // Process extensions
-    const extensions = await processProfileExtensions(fhirSchema, register);
-    if (extensions.length > 0) {
-        profileSchema.extensions = extensions;
-    }
-    // Add validation rules
-    const validationRules = extractValidationRules(fhirSchema);
-    if (validationRules.length > 0) {
-        profileSchema.validation = validationRules;
-    }
-    return profileSchema;
-}
-/**
- * Determine the kind of the base type for a profile
- */
-async function determineBaseKind(baseUrl, register) {
-    try {
-        // Try to resolve the base schema
-        const baseSchema = register.resolveFs(baseUrl);
-        if (!baseSchema)
-            return "resource";
-        if (baseSchema) {
-            // If it's also a constraint, it's likely another profile
-            if (baseSchema.derivation === "constraint") {
-                return "profile";
-            }
-            // Otherwise, use the base schema's kind
-            if (baseSchema.kind === "resource")
-                return "resource";
-            if (baseSchema.kind === "complex-type")
-                return "complex-type";
-        }
-    }
-    catch (error) {
-        // If we can't resolve, make a reasonable guess
-        console.warn(`Could not resolve base schema ${baseUrl}:`, error);
-    }
-    // Check if the URL suggests it's a profile from any implementation guide
-    // Non-standard FHIR StructureDefinition URLs (not from base FHIR) are likely profiles
-    // Check if it's any other profile URL pattern
-    if (baseUrl.includes("StructureDefinition/") && !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
-        // Non-standard FHIR StructureDefinition URLs are likely profiles
-        return "profile";
-    }
-    // Default to resource for profiles
-    return "resource";
-}
-/**
- * Extract profile metadata from FHIR schema
- */
-function extractProfileMetadata(fhirSchema) {
-    const metadata = {};
-    const packageInfo = fhirSchema.package_meta;
-    // Add profile-specific metadata
-    // @ts-ignore
-    if (fhirSchema.publisher)
-        metadata.publisher = fhirSchema.publisher;
-    // @ts-ignore
-    if (fhirSchema.contact)
-        metadata.contact = fhirSchema.contact;
-    // @ts-ignore
-    if (fhirSchema.copyright)
-        metadata.copyright = fhirSchema.copyright;
-    // @ts-ignore
-    if (fhirSchema.purpose)
-        metadata.purpose = fhirSchema.purpose;
-    // @ts-ignore
-    if (fhirSchema.experimental !== undefined) {
-        // @ts-ignore
-        metadata.experimental = fhirSchema.experimental;
-    }
-    // @ts-ignore
-    if (fhirSchema.date)
-        metadata.date = fhirSchema.date;
-    // @ts-ignore
-    if (fhirSchema.jurisdiction)
-        metadata.jurisdiction = fhirSchema.jurisdiction;
-    // Add package-specific metadata from packageInfo or schema
-    // @ts-ignore
-    if (packageInfo?.name) {
-        metadata.package = packageInfo.name;
-        // @ts-ignore
-    }
-    else if (fhirSchema.package_meta.name) {
-        // @ts-ignore
-        metadata.package = fhirSchema.package_meta.name;
-    }
-    return metadata;
-}
-/**
- * Process profile constraints from FHIR schema elements
- */
-async function processProfileConstraints(fhirSchema, _manager) {
-    const constraints = {};
-    if (!fhirSchema.elements)
-        return constraints;
-    // Process each element for constraints
-    for (const [path, element] of Object.entries(fhirSchema.elements)) {
-        const elementConstraints = {};
-        // Cardinality constraints
-        if (element.min !== undefined)
-            elementConstraints.min = element.min;
-        if (element.max !== undefined)
-            elementConstraints.max = String(element.max);
-        // Must Support elements
-        if (element.mustSupport)
-            elementConstraints.mustSupport = true;
-        // Fixed values
-        // @ts-ignore
-        if (element.fixedValue !== undefined)
-            // @ts-ignore
-            elementConstraints.fixedValue = element.fixedValue;
-        // @ts-ignore
-        if (element.patternValue !== undefined)
-            // @ts-ignore
-            elementConstraints.patternValue = element.patternValue;
-        // Value set bindings
-        if (element.binding) {
-            elementConstraints.binding = {
-                strength: element.binding.strength,
-                valueSet: element.binding.valueSet ?? "",
-            };
-        }
-        // Type constraints
-        if (element.type && Array.isArray(element.type) && element.type.length > 0) {
-            elementConstraints.types = element.type.map((t) => {
-                const typeConstraint = { code: t.code };
-                if (t.profile)
-                    typeConstraint.profile = t.profile;
-                if (t.targetProfile)
-                    typeConstraint.targetProfile = t.targetProfile;
-                return typeConstraint;
-            });
-        }
-        // Slicing information
-        if (element.slicing) {
-            elementConstraints.slicing = {
-                discriminator: element.slicing.discriminator ?? [],
-                rules: String(element.slicing),
-                ordered: element.slicing.ordered,
-            };
-        }
-        if (Object.keys(elementConstraints).length > 0) {
-            constraints[path] = elementConstraints;
-        }
-    }
-    return constraints;
-}
-/**
- * Process profile extensions
- */
-async function processProfileExtensions(fhirSchema, _manager) {
-    const extensions = [];
-    if (!fhirSchema.elements)
-        return extensions;
-    // Look for extension elements
-    for (const [path, element] of Object.entries(fhirSchema.elements)) {
-        if (path.includes("extension") && element.type && Array.isArray(element.type)) {
-            for (const type of element.type) {
-                if (type.code === "Extension" && type.profile) {
-                    extensions.push({
-                        path,
-                        profile: type.profile,
-                        min: element.min,
-                        max: String(element.max),
-                        mustSupport: element.mustSupport,
-                    });
-                }
-            }
-        }
-    }
-    return extensions;
-}
-/**
- * Extract validation rules from profile
- */
-function extractValidationRules(fhirSchema) {
-    const rules = [];
-    if (!fhirSchema.elements)
-        return rules;
-    // Extract invariants and constraints
-    for (const [path, element] of Object.entries(fhirSchema.elements)) {
-        if (element.constraint && Array.isArray(element.constraint)) {
-            for (const constraint of element.constraint) {
-                rules.push({
-                    path,
-                    key: constraint.key,
-                    severity: constraint.severity,
-                    human: constraint.human,
-                    expression: constraint.expression,
-                });
-            }
-        }
-    }
-    return rules;
-}

package/dist/typeschema/register.d.ts

@@ -1,21 +0,0 @@
-import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { FHIRSchema, FHIRSchemaElement, StructureDefinition } from "@atomic-ehr/fhirschema";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
-import type { CanonicalUrl, Name, PackageMeta, RichFHIRSchema, RichValueSet } from "@typeschema/types";
-export type Register = {
-    appendFs(fs: FHIRSchema): void;
-    ensureCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
-    resolveSd(canonicalUrl: CanonicalUrl): StructureDefinition | undefined;
-    resolveFs(canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
-    resolveFsGenealogy(canonicalUrl: CanonicalUrl): RichFHIRSchema[];
-    allSd(): StructureDefinition[];
-    allFs(): RichFHIRSchema[];
-    allVs(): RichValueSet[];
-    resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
-    complexTypeDict(): Record<string, RichFHIRSchema>;
-    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
-} & ReturnType<typeof CanonicalManager>;
-export declare const registerFromManager: (manager: ReturnType<typeof CanonicalManager>, logger?: CodegenLogger, packageInfo?: PackageMeta) => Promise<Register>;
-export declare const registerFromPackageMetas: (packageMetas: PackageMeta[], logger?: CodegenLogger) => Promise<Register>;
-export declare const resolveFsElementGenealogy: (genealogy: RichFHIRSchema[], path: string[]) => FHIRSchemaElement[];
-export declare function fsElementSnapshot(genealogy: FHIRSchemaElement[]): FHIRSchemaElement;