@atomic-ehr/codegen 0.0.1-canary.20251010131311.9439f74 → 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(/^_/, "");
@@ -4890,7 +4918,7 @@ ${nestedInterfaces}`;
     }
     const optional = required ? "" : "?";
     const arrayType = isArray ? "[]" : "";
-    return `${fieldName.replace("-", "_")}${optional}: ${typeString}${arrayType};`;
+    return `${fieldName}${optional}: ${typeString}${arrayType};`;
   }
   // ==========================================
   /**
@@ -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;
@@ -5319,12 +5325,20 @@ var tsResourceName = (id) => {
   }
   return normalizeTsName(id.name);
 };
-var tsFieldName = (n) => normalizeTsName(n);
+var tsKeywords = /* @__PURE__ */ new Set(["class", "function", "return", "if", "for", "while", "const", "let", "var", "import", "export", "interface"]);
+var tsFieldName = (n) => {
+  if (tsKeywords.has(n)) return `"${n}"`;
+  if (n.includes(" ") || n.includes("-")) return `"${n}"`;
+  return n;
+};
 var normalizeTsName = (n) => {
-  const tsKeywords = /* @__PURE__ */ new Set(["abstract", "any", "as", "async", "await", "boolean", "bigint", "break", "case", "catch", "class", "const", "constructor", "continue", "debugger", "declare", "default", "delete", "do", "else", "enum", "export", "extends", "extern", "false", "finally", "for", "function", "from", "get", "goto", "if", "implements", "import", "in", "infer", "instanceof", "interface", "keyof", "let", "module", "namespace", "never", "new", "null", "number", "object", "of", "override", "private", "protected", "public", "readonly", "return", "satisfies", "set", "static", "string", "super", "switch", "this", "throw", "true", "try", "type", "typeof", "unknown", "var", "void", "while"]);
   if (tsKeywords.has(n)) n = `${n}_`;
   return n.replace(/[- ]/g, "_");
 };
+var tsGet = (object, tsFieldName2) => {
+  if (tsFieldName2.startsWith('"')) return `${object}[${tsFieldName2}]`;
+  return `${object}.${tsFieldName2}`;
+};
 var TypeScript = class extends Writer {
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
@@ -5388,7 +5402,8 @@ var TypeScript = class extends Writer {
   }
   addFieldExtension(fieldName, field) {
     if (field.type.kind === "primitive-type") {
-      this.lineSM(`_${tsFieldName(fieldName)}?: Element`);
+      const extFieldName = tsFieldName(`_${fieldName}`);
+      this.lineSM(`${extFieldName}?: Element`);
     }
   }
   generateType(tsIndex, schema) {
@@ -5513,7 +5528,7 @@ var TypeScript = class extends Writer {
             this.line(`profile: ['${flatProfile.identifier.url}']`);
           }, [","]);
           profileFields.forEach((fieldName) => {
-            this.line(`${fieldName}:`, `profile.${fieldName},`);
+            this.line(`${fieldName}: ${tsGet("profile", fieldName)},`);
           });
         });
       }
@@ -5544,7 +5559,7 @@ var TypeScript = class extends Writer {
           if (!isNotChoiceDeclarationField(pField) || !isNotChoiceDeclarationField(rField)) return;
           if (pField.required && !rField.required) {
             this.curlyBlock(
-              [`if (resource.${tsField} === undefined)`],
+              [`if (${tsGet("resource", tsField)} === undefined)`],
               () => this.lineSM(
                 `throw new Error("'${tsField}' is required for ${flatProfile.identifier.url}")`
               )
@@ -5563,11 +5578,11 @@ var TypeScript = class extends Writer {
                 this.line(";");
               });
             });
-            let cond = !pField?.required ? `!resource.${tsField} || ` : "";
+            let cond = !pField?.required ? `!${tsGet("resource", tsField)} || ` : "";
             if (pField.array) {
-              cond += `resource.${tsField}.every( (ref) => ${predName}(ref) )`;
+              cond += `${tsGet("resource", tsField)}.every( (ref) => ${predName}(ref) )`;
             } else {
-              cond += `!${predName}(resource.${tsField})`;
+              cond += `!${predName}(${tsGet("resource", tsField)})`;
             }
             this.curlyBlock(["if (", cond, ")"], () => {
               this.lineSM(
@@ -5583,9 +5598,12 @@ var TypeScript = class extends Writer {
           profileFields.forEach((fieldName) => {
             const tsField = tsFieldName(fieldName);
             if (shouldCast[fieldName]) {
-              this.line(`${tsField}:`, `resource.${tsField} as ${tsProfileName}['${tsField}'],`);
+              this.line(
+                `${tsField}:`,
+                `${tsGet("resource", tsField)} as ${tsProfileName}['${tsField}'],`
+              );
             } else {
-              this.line(`${tsField}:`, `resource.${tsField},`);
+              this.line(`${tsField}:`, `${tsGet("resource", tsField)},`);
             }
           });
         });
@@ -5657,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;
@@ -5677,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({
@@ -5780,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 = {
@@ -5811,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");