@atomic-ehr/codegen 0.0.1-canary.20251110083633.71e5f87 → 0.0.1-canary.20251110140511.b3e2283

package/dist/index.d.ts

@@ -757,6 +757,10 @@ declare class TypeSchemaParser {
     private matchesIdentifier;
 }
 
+type TypeSchemaShakeRule = {
+    ignoreFields?: string[];
+};
+type TreeShake = Record<string, Record<string, TypeSchemaShakeRule>>;
 interface TypeRelation {
     parent: Identifier;
     child: Identifier;
@@ -770,6 +774,7 @@ type TypeSchemaIndex = {
     collectLogicalModels: () => RegularTypeSchema[];
     collectProfiles: () => ProfileTypeSchema[];
     resolve: (id: Identifier) => TypeSchema | undefined;
+    resolveByUrl: (pkgName: PackageName, url: CanonicalUrl) => TypeSchema | undefined;
     resourceChildren: (id: Identifier) => Identifier[];
     tryHierarchy: (schema: TypeSchema) => TypeSchema[] | undefined;
     hierarchy: (schema: TypeSchema) => TypeSchema[];
@@ -811,6 +816,7 @@ interface APIBuilderOptions {
     typeSchemaOutputDir?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
     throwException?: boolean;
     exportTypeTree?: string;
+    treeShake?: TreeShake;
 }
 /**
  * Progress callback for long-running operations
@@ -875,10 +881,12 @@ declare class APIBuilder {
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
     writeTypeTree(filename: string): this;
+    treeShake(tree: TreeShake): this;
     writeTypeSchemas(target: string): this;
     private writeTypeSchemasToSeparateFiles;
     private writeTypeSchemasToSingleFile;
     private tryWriteTypeSchema;
+    cleanup(): Promise<void>;
     generate(): Promise<GenerationResult>;
     /**
      * Generate and return the results without writing to files

package/dist/index.js

@@ -1447,6 +1447,9 @@ var isComplexTypeTypeSchema = (schema) => {
 var isResourceTypeSchema = (schema) => {
   return schema?.identifier.kind === "resource";
 };
+var isPrimitiveTypeSchema = (schema) => {
+  return schema?.identifier.kind === "primitive-type";
+};
 var isLogicalTypeSchema = (schema) => {
   return schema?.identifier.kind === "logical";
 };
@@ -1456,6 +1459,9 @@ var isProfileTypeSchema = (schema) => {
 function isBindingSchema(schema) {
   return schema?.identifier.kind === "binding";
 }
+function isValueSetTypeSchema(schema) {
+  return schema?.identifier.kind === "value-set";
+}
 var isNotChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices === void 0;
@@ -3488,6 +3494,57 @@ var groupByPackages = (typeSchemas) => {
   }
   return grouped;
 };
+var treeShakeTypeSchema = (schema, rule, _logger) => {
+  schema = structuredClone(schema);
+  if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema)) return schema;
+  for (const fieldName of rule.ignoreFields ?? []) {
+    if (schema.fields && !schema.fields[fieldName]) throw new Error(`Field ${fieldName} not found`);
+    if (schema.fields) {
+      delete schema.fields[fieldName];
+    }
+  }
+  schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
+  return schema;
+};
+var treeShake = (tsIndex, treeShake2, logger) => {
+  const focusedSchemas = [];
+  for (const [pkgId, requires] of Object.entries(treeShake2)) {
+    for (const [url, rule] of Object.entries(requires)) {
+      const schema = tsIndex.resolveByUrl(pkgId, url);
+      if (!schema) throw new Error(`Schema not found for ${pkgId} ${url}`);
+      const shaked2 = treeShakeTypeSchema(schema, rule);
+      focusedSchemas.push(shaked2);
+    }
+  }
+  const collectDeps = (schemas, acc) => {
+    if (schemas.length === 0) return Object.values(acc);
+    for (const schema of schemas) {
+      acc[JSON.stringify(schema.identifier)] = schema;
+    }
+    const newSchemas = [];
+    for (const schema of schemas) {
+      if (isSpecializationTypeSchema(schema)) {
+        if (!schema.dependencies) continue;
+        schema.dependencies.forEach((dep) => {
+          const depSchema = tsIndex.resolve(dep);
+          if (!depSchema) throw new Error(`Schema not found for ${dep}`);
+          const id = JSON.stringify(depSchema.identifier);
+          if (!acc[id]) newSchemas.push(depSchema);
+        });
+        if (schema.nested) {
+          for (const nest of schema.nested) {
+            if (isNestedIdentifier(nest.identifier)) continue;
+            const id = JSON.stringify(nest.identifier);
+            if (!acc[id]) newSchemas.push(nest);
+          }
+        }
+      }
+    }
+    return collectDeps(newSchemas, acc);
+  };
+  const shaked = collectDeps(focusedSchemas, {});
+  return mkTypeSchemaIndex(shaked, logger);
+};
 var resourceRelatives = (schemas) => {
   const regularSchemas = schemas.filter(isResourceTypeSchema);
   const directPairs = [];
@@ -3534,6 +3591,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
   }
   const relations = resourceRelatives(schemas);
   const resolve2 = (id) => index[id.url]?.[id.package];
+  const resolveByUrl = (pkgName, url) => index[url]?.[pkgName];
   const resourceChildren = (id) => {
     return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
   };
@@ -3546,6 +3604,9 @@ var mkTypeSchemaIndex = (schemas, logger) => {
       if (base === void 0) break;
       const resolved = resolve2(base);
       if (!resolved) {
+        logger?.warn(
+          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
+        );
         return void 0;
       }
       cur = resolved;
@@ -3640,6 +3701,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
     resolve: resolve2,
+    resolveByUrl,
     resourceChildren,
     tryHierarchy,
     hierarchy,
@@ -6115,7 +6177,8 @@ var APIBuilder = class {
       manager: options.manager || null,
       throwException: options.throwException || false,
       typeSchemaOutputDir: options.typeSchemaOutputDir,
-      exportTypeTree: options.exportTypeTree
+      exportTypeTree: options.exportTypeTree,
+      treeShake: options.treeShake
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
@@ -6235,6 +6298,10 @@ var APIBuilder = class {
     this.options.exportTypeTree = filename;
     return this;
   }
+  treeShake(tree) {
+    this.options.treeShake = tree;
+    return this;
+  }
   writeTypeSchemas(target) {
     this.options.typeSchemaOutputDir = target;
     return this;
@@ -6244,7 +6311,10 @@ var APIBuilder = class {
     this.logger.info(`Writing TypeSchema files to ${outputDir}/...`);
     const files = {};
     for (const ts of typeSchemas) {
-      const pkg = { name: ts.identifier.package, version: ts.identifier.version };
+      const pkg = {
+        name: ts.identifier.package,
+        version: ts.identifier.version
+      };
       const pkgPath = normalizeFileName(packageMetaToFhir(pkg));
       const name = normalizeFileName(`${ts.identifier.name}(${extractNameFromCanonical(ts.identifier.url)})`);
       const json = JSON.stringify(ts, null, 2);
@@ -6297,6 +6367,31 @@ var APIBuilder = class {
       if (this.options.throwException) throw error;
     }
   }
+  async cleanup() {
+    this.logger.info(`Cleaning outputs...`);
+    try {
+      this.logger.info(`Clean ${this.options.outputDir}`);
+      fs.rmSync(this.options.outputDir, { recursive: true, force: true });
+      if (this.options.typeSchemaOutputDir) {
+        this.logger.info(`Clean ${this.options.typeSchemaOutputDir}`);
+        fs.rmSync(this.options.typeSchemaOutputDir, {
+          recursive: true,
+          force: true
+        });
+      }
+      if (this.options.exportTypeTree) {
+        this.logger.info(`Clean ${this.options.exportTypeTree}`);
+        fs.rmSync(this.options.exportTypeTree, {
+          recursive: true,
+          force: true
+        });
+      }
+    } catch (error) {
+      this.logger.warn(
+        `Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   async generate() {
     const startTime = performance.now();
     const result = {
@@ -6308,26 +6403,8 @@ var APIBuilder = class {
       duration: 0
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
-    if (this.options.cleanOutput) {
-      this.logger.info(`Cleaning outputs...`);
-      try {
-        this.logger.info(`Clean ${this.options.outputDir}`);
-        fs.rmSync(this.options.outputDir, { recursive: true, force: true });
-        if (this.options.typeSchemaOutputDir) {
-          this.logger.info(`Clean ${this.options.typeSchemaOutputDir}`);
-          fs.rmSync(this.options.typeSchemaOutputDir, { recursive: true, force: true });
-        }
-        if (this.options.exportTypeTree) {
-          this.logger.info(`Clean ${this.options.exportTypeTree}`);
-          fs.rmSync(this.options.exportTypeTree, { recursive: true, force: true });
-        }
-      } catch (error) {
-        this.logger.warn(
-          `Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
     try {
+      if (this.options.cleanOutput) this.cleanup();
       this.logger.info("Initialize Canonical Manager");
       const manager = CanonicalManager({
         packages: this.packages,
@@ -6340,16 +6417,21 @@ var APIBuilder = class {
       });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
       await this.tryWriteTypeSchema(typeSchemas);
-      const tsIndex = mkTypeSchemaIndex(typeSchemas);
+      let tsIndex = mkTypeSchemaIndex(typeSchemas, this.logger);
+      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake, this.logger);
       if (this.options.exportTypeTree) await tsIndex.exportTree(this.options.exportTypeTree);
       this.logger.debug(`Executing ${this.generators.size} generators`);
-      await this.executeGenerators(result, { schemas: typeSchemas, index: tsIndex });
+      await this.executeGenerators(result, {
+        schemas: typeSchemas,
+        index: tsIndex
+      });
       this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
       this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
     } catch (error) {
       this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)));
       result.errors.push(error instanceof Error ? error.message : String(error));
+      if (this.options.throwException) throw error;
     }
     return {
       ...result,