@atomic-ehr/codegen 0.0.2-canary.20251121141554.c9f1e0b → 0.0.2-canary.20251121164115.c134ba7

package/dist/index.js

@@ -44,51 +44,71 @@ var typeSchemaInfo = (schema) => {
 var FileSystemWriter = class {
   opts;
   currentDir;
-  currentFileDescriptor;
-  writtenFilesSet = /* @__PURE__ */ new Set();
+  currentFile;
+  writtenFilesBuffer = {};
   constructor(opts) {
     this.opts = opts;
-    this.currentDir = opts.outputDir;
+  }
+  setOutputDir(path) {
+    if (this.currentDir) throw new Error("Can't change output dir while writing");
+    this.opts.outputDir = path;
   }
   logger() {
     return this.opts.logger;
   }
+  onDiskMkDir(path) {
+    if (this.opts.inMemoryOnly) return;
+    if (!fs.existsSync(path)) {
+      fs.mkdirSync(path, { recursive: true });
+    }
+  }
+  onDiskOpenFile(relPath) {
+    if (this.opts.inMemoryOnly) return -1;
+    return fs.openSync(relPath, "w");
+  }
+  onDiskCloseFile(descriptor) {
+    if (this.opts.inMemoryOnly) return;
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+  }
+  onDiskWrite(descriptor, token) {
+    if (this.opts.inMemoryOnly) return;
+    fs.writeSync(descriptor, token);
+  }
   cd(path, gen) {
     const prev = this.currentDir;
-    this.currentDir = path.startsWith("/") ? Path4.join(this.opts.outputDir, path) : Path4.join(this.currentDir, path);
-    if (!fs.existsSync(this.currentDir)) {
-      fs.mkdirSync(this.currentDir, { recursive: true });
-    }
+    this.currentDir = path.startsWith("/") ? Path4.join(this.opts.outputDir, path) : Path4.join(this.currentDir ?? this.opts.outputDir, path);
+    this.onDiskMkDir(this.currentDir);
     this.logger()?.debug(`cd '${this.currentDir}'`);
     gen();
     this.currentDir = prev;
   }
   cat(fn, gen) {
-    if (this.currentFileDescriptor) throw new Error("Can't open file in file");
+    if (this.currentFile) throw new Error("Can't open file when another file is open");
     if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
-    const fullFn = `${this.currentDir}/${fn}`;
+    const relPath = Path4.normalize(`${this.currentDir}/${fn}`);
     try {
-      this.currentFileDescriptor = fs.openSync(fullFn, "w");
-      this.writtenFilesSet.add(fn);
-      this.logger()?.debug(`cat > '${fullFn}'`);
+      const descriptor = this.onDiskOpenFile(relPath);
+      this.logger()?.debug(`cat > '${relPath}'`);
+      this.currentFile = { descriptor, relPath };
+      this.writtenFilesBuffer[this.currentFile.relPath] = { relPath, absPath: Path4.resolve(relPath), tokens: [] };
       gen();
     } finally {
-      if (this.currentFileDescriptor) {
-        fs.fsyncSync(this.currentFileDescriptor);
-        fs.closeSync(this.currentFileDescriptor);
-      }
-      this.currentFileDescriptor = void 0;
+      if (this.currentFile) this.onDiskCloseFile(this.currentFile.descriptor);
+      this.currentFile = void 0;
     }
   }
   write(str) {
-    if (!this.currentFileDescriptor) throw new Error("No file opened");
-    fs.writeSync(this.currentFileDescriptor, str);
-  }
-  async generate(_tsIndex) {
-    throw new Error("Not implemented");
+    if (!this.currentFile) throw new Error("No file opened");
+    this.onDiskWrite(this.currentFile.descriptor, str);
+    const buf = this.writtenFilesBuffer[this.currentFile.relPath];
+    if (!buf) throw new Error("No buffer found");
+    buf.tokens.push(str);
   }
   writtenFiles() {
-    return Array.from(this.writtenFilesSet);
+    return Object.values(this.writtenFilesBuffer).map(({ relPath, absPath, tokens }) => {
+      return { relPath, absPath, content: tokens.join() };
+    }).sort((a, b) => a.relPath.localeCompare(b.relPath));
   }
 };
 var Writer = class extends FileSystemWriter {
@@ -1360,7 +1380,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     append(schema);
   }
   const relations = resourceRelatives(schemas);
-  const resolve2 = (id) => index[id.url]?.[id.package];
+  const resolve3 = (id) => index[id.url]?.[id.package];
   const resolveByUrl = (pkgName, url) => index[url]?.[pkgName];
   const resourceChildren = (id) => {
     return relations.filter((relative) => relative.parent.name === id.name).map((relative) => relative.child);
@@ -1372,7 +1392,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
       res.push(cur);
       const base = cur.base;
       if (base === void 0) break;
-      const resolved = resolve2(base);
+      const resolved = resolve3(base);
       if (!resolved) {
         logger?.warn(
           `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
@@ -1398,7 +1418,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     return nonConstraintSchema;
   };
   const findLastSpecializationByIdentifier = (id) => {
-    const schema = resolve2(id);
+    const schema = resolve3(id);
     if (!schema) return id;
     return findLastSpecialization(schema).identifier;
   };
@@ -1470,7 +1490,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     collectResources: () => schemas.filter(isResourceTypeSchema),
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
-    resolve: resolve2,
+    resolve: resolve3,
     resolveByUrl,
     resourceChildren,
     tryHierarchy,
@@ -2054,25 +2074,6 @@ var TypeScript = class extends Writer {
 };
 
 // src/api/builder.ts
-var writerToGenerator = (writerGen) => {
-  const getGeneratedFiles = () => {
-    return writerGen.writtenFiles().map((fn) => {
-      return {
-        path: Path4.normalize(Path4.join(writerGen.opts.outputDir, fn)),
-        filename: fn.replace(/^.*[\\/]/, ""),
-        timestamp: /* @__PURE__ */ new Date()
-      };
-    });
-  };
-  return {
-    generate: async ({ index: tsIndex }) => {
-      await writerGen.generate(tsIndex);
-      return getGeneratedFiles();
-    },
-    setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
-    build: async (_input) => getGeneratedFiles()
-  };
-};
 var normalizeFileName = (str) => {
   const res = str.replace(/[^a-zA-Z0-9\-_.@#()]/g, "");
   if (res.length === 0) return "unknown";
@@ -2217,25 +2218,23 @@ var APIBuilder = class {
       ...defaultTsOpts,
       ...Object.fromEntries(Object.entries(userOpts).filter(([_, v]) => v !== void 0))
     };
-    const generator = writerToGenerator(new TypeScript(opts));
+    const generator = new TypeScript(opts);
     this.generators.set("typescript", generator);
     this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
   csharp(namespace, staticSourceDir) {
-    const generator = writerToGenerator(
-      new CSharp({
-        outputDir: Path4.join(this.options.outputDir, "/types"),
-        staticSourceDir: staticSourceDir ?? void 0,
-        targetNamespace: namespace,
-        logger: new CodegenLogger({
-          prefix: "C#",
-          timestamp: true,
-          verbose: true,
-          suppressLoggingLevel: []
-        })
+    const generator = new CSharp({
+      outputDir: Path4.join(this.options.outputDir, "/types"),
+      staticSourceDir: staticSourceDir ?? void 0,
+      targetNamespace: namespace,
+      logger: new CodegenLogger({
+        prefix: "C#",
+        timestamp: true,
+        verbose: true,
+        suppressLoggingLevel: []
       })
-    );
+    });
     this.generators.set("C#", generator);
     this.logger.debug(`Configured C# generator`);
     return this;
@@ -2254,9 +2253,7 @@ var APIBuilder = class {
     this.logger.debug(`Setting output directory: ${directory}`);
     this.options.outputDir = directory;
     for (const generator of this.generators.values()) {
-      if (generator.setOutputDir) {
-        generator.setOutputDir(directory);
-      }
+      generator.setOutputDir(directory);
     }
     return this;
   }
@@ -2315,10 +2312,7 @@ var APIBuilder = class {
       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, tsIndex);
       this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
       this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
@@ -2333,18 +2327,6 @@ var APIBuilder = class {
       duration: performance.now() - startTime
     };
   }
-  /**
-   * Generate and return the results without writing to files
-   */
-  async build() {
-    const results = {};
-    for (const [type, generator] of this.generators.entries()) {
-      if (generator.build) {
-        results[type] = await generator.build(this.schemas);
-      }
-    }
-    return results;
-  }
   /**
    * Clear all configuration and start fresh
    */
@@ -2366,12 +2348,13 @@ var APIBuilder = class {
   getGenerators() {
     return Array.from(this.generators.keys());
   }
-  async executeGenerators(result, input) {
+  async executeGenerators(result, tsIndex) {
     for (const [type, generator] of this.generators.entries()) {
       this.logger.info(`Generating ${type}...`);
       try {
-        const files = await generator.generate(input);
-        result.filesGenerated.push(...files.map((f) => f.path || f.filename));
+        await generator.generate(tsIndex);
+        const fileBuffer = generator.writtenFiles();
+        result.filesGenerated.push(...fileBuffer.map((e) => e.absPath));
         this.logger.info(`Generating ${type} finished successfully`);
       } catch (error) {
         result.errors.push(