@atomic-ehr/codegen 0.0.1-canary.20251014085150.f19c2e1 → 0.0.1-canary.20251015064414.0fcee22

package/dist/index.d.ts

@@ -830,6 +830,9 @@ declare class APIBuilder {
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
     writeTypeSchemas(target: string): this;
+    private static isIdenticalTo;
+    private writeTypeSchemasToSeparateFiles;
+    private writeTypeSchemasToSingleFile;
     private tryWriteTypeSchema;
     generate(): Promise<GenerationResult>;
     /**

package/dist/index.js

@@ -2256,7 +2256,7 @@ var CodegenLogger = class _CodegenLogger {
    */
   error(message, error) {
     if (this.isSuppressed(3 /* ERROR */)) return;
-    console.error(this.formatMessage("", message, pc.red));
+    console.error(this.formatMessage("X", message, pc.red));
     if (error && this.options.verbose) {
       console.error(pc.red(`   ${error.message}`));
       if (error.stack) {
@@ -3012,6 +3012,23 @@ var uppercaseFirstLetter = (str) => {
 var uppercaseFirstLetterOfEach = (strings) => {
   return strings.map((str) => uppercaseFirstLetter(str));
 };
+function deepEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (obj1 === null || obj2 === null || typeof obj1 !== "object" || typeof obj2 !== "object") {
+    return false;
+  }
+  if (Array.isArray(obj1) && Array.isArray(obj2)) {
+    if (obj1.length !== obj2.length) return false;
+    return obj1.every((item, index) => deepEqual(item, obj2[index]));
+  }
+  if (Array.isArray(obj1) || Array.isArray(obj2)) {
+    return false;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  return keys1.every((key) => keys2.includes(key) && deepEqual(obj1[key], obj2[key]));
+}
 
 // src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
@@ -5724,7 +5741,7 @@ var writerToGenerator = (writerGen) => {
   };
 };
 var normalizeFileName = (str) => str.replace(/[^a-zA-Z0-9]/g, "");
-var APIBuilder = class {
+var APIBuilder = class _APIBuilder {
   schemas = [];
   options;
   generators = /* @__PURE__ */ new Map();
@@ -5852,33 +5869,53 @@ var APIBuilder = class {
     this.options.typeSchemaOutputDir = target;
     return this;
   }
+  static async isIdenticalTo(path, tsJSON) {
+    if (!await afs.exists(path)) return false;
+    const json = await afs.readFile(path);
+    const ts1 = JSON.parse(json.toString());
+    const ts2 = JSON.parse(tsJSON);
+    return deepEqual(ts1, ts2);
+  }
+  async writeTypeSchemasToSeparateFiles(typeSchemas, outputDir) {
+    if (this.options.cleanOutput) fs.rmSync(outputDir, { recursive: true, force: true });
+    await afs.mkdir(outputDir, { recursive: true });
+    const usedNames = {};
+    this.logger.info(`Writing TypeSchema files to ${outputDir}...`);
+    for (const ts of typeSchemas) {
+      const package_name = camelCase(ts.identifier.package.replaceAll("/", "-"));
+      const name = normalizeFileName(ts.identifier.name.toString());
+      const json = JSON.stringify(ts, null, 2);
+      const baseName = Path2.join(outputDir, 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`;
+      }
+      if (await _APIBuilder.isIdenticalTo(fullName, json)) continue;
+      await afs.mkdir(Path2.dirname(fullName), { recursive: true });
+      await afs.writeFile(fullName, json);
+    }
+  }
+  async writeTypeSchemasToSingleFile(typeSchemas, outputFile) {
+    if (this.options.cleanOutput && fs.existsSync(outputFile)) fs.rmSync(outputFile);
+    await afs.mkdir(Path2.dirname(outputFile), { recursive: true });
+    this.logger.info(`Writing TypeSchemas to one file ${outputFile}...`);
+    for (const ts of typeSchemas) {
+      const json = JSON.stringify(ts, null, 2);
+      await afs.appendFile(outputFile, json + "\n");
+    }
+  }
   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`);
+      this.logger.info(`Starting writing TypeSchema files.`);
+      if (Path2.extname(this.options.typeSchemaOutputDir) === ".ndjson")
+        await this.writeTypeSchemasToSingleFile(typeSchemas, this.options.typeSchemaOutputDir);
+      else await this.writeTypeSchemasToSeparateFiles(typeSchemas, this.options.typeSchemaOutputDir);
+      this.logger.info(`Finished writing TypeSchema files.`);
     } catch (error) {
       if (this.options.throwException) throw error;
       this.logger.error(