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

package/dist/typeschema/parser.js

@@ -0,0 +1,310 @@
+// @ts-nocheck
+/**
+ * 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) {
+        const dependencies = [];
+        // 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);
+                }
+            }
+        }
+        // Add nested type dependencies
+        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;
+            dependencies.push(bindingSchema.valueset);
+            if (bindingSchema.type) {
+                dependencies.push(bindingSchema.type);
+            }
+        }
+        // Remove duplicates
+        return this.deduplicateDependencies(dependencies);
+    }
+    /**
+     * Resolve schema dependencies
+     */
+    resolveDependencies(schemas, targetSchema) {
+        const dependencies = this.getDependencies(targetSchema);
+        const resolved = [];
+        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));
+    }
+    /**
+     * Remove duplicate dependencies
+     */
+    deduplicateDependencies(deps) {
+        const seen = new Set();
+        const unique = [];
+        for (const dep of deps) {
+            if (!seen.has(dep.url)) {
+                seen.add(dep.url);
+                unique.push(dep);
+            }
+        }
+        return unique.sort((a, b) => a.name.localeCompare(b.name));
+    }
+}
+/**
+ * Convenience function to parse TypeSchema from file
+ */
+export async function parseTypeSchemaFromFile(filePath, options) {
+    const parser = new TypeSchemaParser(options);
+    return await parser.parseFromFile(filePath);
+}
+/**
+ * Convenience function to parse TypeSchema from string
+ */
+export async function parseTypeSchemaFromString(content, format, options) {
+    const parser = new TypeSchemaParser(options);
+    return await parser.parseFromString(content, format);
+}
+/**
+ * Convenience function to parse TypeSchema from multiple files
+ */
+export async function parseTypeSchemaFromFiles(filePaths, options) {
+    const parser = new TypeSchemaParser(options);
+    return await parser.parseFromFiles(filePaths);
+}

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

@@ -6,7 +6,7 @@
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
 import type { FHIRSchema } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaForProfile } from "../types";
+import type { PackageInfo, TypeSchemaForProfile } from "../types.js";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources

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

@@ -1 +1 @@
-{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../../src/typeschema/profile/processor.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAIzD,OAAO,KAAK,EACX,WAAW,EAIX,oBAAoB,EAEpB,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,CAAC,CAwF/B"}
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../../src/typeschema/profile/processor.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAIzD,OAAO,KAAK,EACX,WAAW,EAIX,oBAAoB,EAEpB,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,wBAAsB,gBAAgB,CACrC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EAC5C,WAAW,CAAC,EAAE,WAAW,GACvB,OAAO,CAAC,oBAAoB,CAAC,CAwF/B"}

package/dist/typeschema/profile/processor.js

@@ -0,0 +1,268 @@
+// @ts-nocheck
+/**
+ * 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 { buildSchemaIdentifier } from "../core/identifier.js";
+import { transformElements } from "../core/transformer.js";
+/**
+ * Transform a FHIR profile to TypeSchema format
+ * Profiles are treated as specialized resources that extend base resources
+ */
+export async function transformProfile(fhirSchema, manager, packageInfo) {
+    // Build profile identifier
+    const identifier = buildSchemaIdentifier(fhirSchema, packageInfo);
+    // 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, manager);
+        // 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"
+                : packageInfo?.name || fhirSchema.package_name || "undefined",
+            version: isStandardFhir
+                ? "4.0.1"
+                : packageInfo?.version || fhirSchema.package_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, packageInfo);
+    if (Object.keys(metadata).length > 0) {
+        profileSchema.metadata = metadata;
+    }
+    // Process profile fields from differential elements
+    if (fhirSchema.elements) {
+        const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, packageInfo);
+        if (Object.keys(fields).length > 0) {
+            profileSchema.fields = fields;
+        }
+    }
+    // Process profile constraints
+    const constraints = await processProfileConstraints(fhirSchema, manager);
+    if (Object.keys(constraints).length > 0) {
+        profileSchema.constraints = constraints;
+    }
+    // Process extensions
+    const extensions = await processProfileExtensions(fhirSchema, manager);
+    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, manager) {
+    try {
+        // Try to resolve the base schema
+        const baseSchema = await manager.resolve(baseUrl);
+        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, packageInfo) {
+    const metadata = {};
+    // 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_name) {
+        // @ts-ignore
+        metadata.package = fhirSchema.package_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;
+}