@atomic-ehr/codegen 0.0.1-canary.20251010140912.b42d372 → 0.0.1-canary.20251013100511.ff2ef29

package/dist/index.d.ts

@@ -757,6 +757,7 @@ interface APIBuilderOptions {
     typeSchemaConfig?: TypeSchemaConfig;
     logger?: CodegenLogger;
     manager?: ReturnType<typeof CanonicalManager> | null;
+    typeSchemaOutputDir?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
     throwException?: boolean;
 }
 /**
@@ -826,6 +827,8 @@ declare class APIBuilder {
     verbose(enabled?: boolean): APIBuilder;
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
+    writeTypeSchemas(target: string): this;
+    private tryWriteTypeSchema;
     generate(): Promise<GenerationResult>;
     /**
      * Generate and return the results without writing to files

package/dist/index.js

@@ -2,6 +2,7 @@ import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as fhirschema from '@atomic-ehr/fhirschema';
 import * as fs from 'fs';
 import { existsSync, mkdirSync } from 'fs';
+import * as afs from 'fs/promises';
 import { readdir, stat, unlink, readFile, writeFile, access, mkdir, rm } from 'fs/promises';
 import * as Path2 from 'path';
 import { join, resolve, dirname, relative } from 'path';
@@ -2945,6 +2946,33 @@ var generateTypeSchemas = async (register, logger) => {
   return fhirSchemas;
 };
 
+// src/api/writer-generator/utils.ts
+var words = (s) => {
+  return s.split(/(?<=[a-z])(?=[A-Z])|[-_.\s]/).filter(Boolean);
+};
+var kebabCase = (s) => {
+  return words(s).map((s2) => s2.toLowerCase()).join("-");
+};
+var capitalCase = (s) => {
+  if (s.length === 0) throw new Error("Empty string");
+  return s[0]?.toUpperCase() + s.substring(1).toLowerCase();
+};
+var camelCase = (s) => {
+  if (s.length === 0) throw new Error("Empty string");
+  const [first, ...rest] = words(s);
+  return [first?.toLowerCase(), ...rest.map(capitalCase)].join("");
+};
+var pascalCase = (s) => {
+  return words(s).map(capitalCase).join("");
+};
+var uppercaseFirstLetter = (str) => {
+  if (!str || str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var uppercaseFirstLetterOfEach = (strings) => {
+  return strings.map((str) => uppercaseFirstLetter(str));
+};
+
 // src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
   const grouped = {};
@@ -4162,8 +4190,8 @@ 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);
+  const camelCase2 = toCamelCase(str);
+  return camelCase2.charAt(0).toUpperCase() + camelCase2.slice(1);
 }
 function toSnakeCase(str) {
   return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").toLowerCase().replace(/^_/, "");
@@ -5112,28 +5140,6 @@ ${nestedInterfaces}`;
     );
   }
 };
-
-// src/api/writer-generator/utils.ts
-var words = (s) => {
-  return s.split(/(?<=[a-z])(?=[A-Z])|[-_.\s]/).filter(Boolean);
-};
-var kebabCase = (s) => {
-  return words(s).map((s2) => s2.toLowerCase()).join("-");
-};
-var capitalCase = (s) => {
-  if (s.length === 0) throw new Error("Empty string");
-  return s[0]?.toUpperCase() + s.substring(1).toLowerCase();
-};
-var pascalCase = (s) => {
-  return words(s).map(capitalCase).join("");
-};
-var uppercaseFirstLetter = (str) => {
-  if (!str || str.length === 0) return str;
-  return str.charAt(0).toUpperCase() + str.slice(1);
-};
-var uppercaseFirstLetterOfEach = (strings) => {
-  return strings.map((str) => uppercaseFirstLetter(str));
-};
 var FileSystemWriter = class {
   opts;
   currentDir;
@@ -5669,6 +5675,7 @@ var writerToGenerator = (writerGen) => {
     build: async (_schemas) => getGeneratedFiles()
   };
 };
+var normalizeFileName = (str) => str.replace(/[^a-zA-Z0-9]/g, "");
 var APIBuilder = class {
   schemas = [];
   options;
@@ -5689,7 +5696,8 @@ var APIBuilder = class {
       cleanOutput: options.cleanOutput ?? true,
       typeSchemaConfig: options.typeSchemaConfig,
       manager: options.manager || null,
-      throwException: options.throwException || false
+      throwException: options.throwException || false,
+      typeSchemaOutputDir: options.typeSchemaOutputDir
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
@@ -5792,6 +5800,45 @@ var APIBuilder = class {
     this.options.cleanOutput = enabled;
     return this;
   }
+  writeTypeSchemas(target) {
+    this.options.typeSchemaOutputDir = target;
+    return this;
+  }
+  async tryWriteTypeSchema(typeSchemas) {
+    if (!this.options.typeSchemaOutputDir) return;
+    try {
+      if (this.options.cleanOutput) fs.rmSync(this.options.typeSchemaOutputDir, { recursive: true, force: true });
+      await afs.mkdir(this.options.typeSchemaOutputDir, { recursive: true });
+      let writtenCount = 0;
+      let overrideCount = 0;
+      const usedNames = {};
+      this.logger.info(`Writing TypeSchema files to ${this.options.typeSchemaOutputDir}...`);
+      for (const ts of typeSchemas) {
+        const package_name = camelCase(ts.identifier.package.replaceAll("/", "-"));
+        const name = normalizeFileName(ts.identifier.name.toString());
+        const baseName = Path2.join(this.options.typeSchemaOutputDir, package_name, name);
+        let fullName;
+        if (usedNames[baseName] !== void 0) {
+          usedNames[baseName]++;
+          fullName = `${baseName}-${usedNames[baseName]}.typeschema.json`;
+        } else {
+          usedNames[baseName] = 0;
+          fullName = `${baseName}.typeschema.json`;
+        }
+        await afs.mkdir(Path2.dirname(fullName), { recursive: true });
+        afs.writeFile(fullName, JSON.stringify(ts, null, 2));
+        if (await afs.exists(fullName)) overrideCount++;
+        else writtenCount++;
+      }
+      this.logger.info(`Created ${writtenCount} new TypeSchema files, overrode ${overrideCount} files`);
+    } catch (error) {
+      if (this.options.throwException) throw error;
+      this.logger.error(
+        "Failed to write TypeSchema output",
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
   async generate() {
     const startTime = performance.now();
     const result = {
@@ -5823,6 +5870,7 @@ var APIBuilder = class {
       await manager.init();
       const register = await registerFromManager(manager, this.logger);
       const typeSchemas = await generateTypeSchemas(register, this.logger);
+      await this.tryWriteTypeSchema(typeSchemas);
       this.logger.debug(`Executing ${this.generators.size} generators`);
       await this.executeGenerators(result, typeSchemas);
       this.logger.info("Generation completed successfully");