adorn-api 1.0.16 → 1.0.18

package/dist/cli.js

@@ -8,7 +8,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/cli.ts
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, rmSync, existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "fs";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve3, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
 
 // src/compiler/runner/createProgram.ts
 import ts from "typescript";
@@ -977,7 +978,7 @@ function handleMetalOrmWrapper(type, ctx) {
         required: ["id"]
       };
       if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
-        wrapperRel.pivot = typeArgs[1];
+        wrapperRel.pivot = ctx.checker.typeToString(typeArgs[1]);
       }
       return {
         type: "array",
@@ -987,7 +988,7 @@ function handleMetalOrmWrapper(type, ctx) {
     }
     const items = targetType ? typeToJsonSchema(targetType, ctx) : {};
     if (wrapperName === "ManyToManyCollection" && typeArgs?.[1]) {
-      wrapperRel.pivot = typeArgs[1];
+      wrapperRel.pivot = ctx.checker.typeToString(typeArgs[1]);
     }
     return {
       type: "array",
@@ -1573,7 +1574,12 @@ function generateOpenAPI(controllers, checker, options = {}) {
     mode: "response"
   };
   const paths = {};
-  for (const controller of controllers) {
+  const { onProgress } = options;
+  for (let i = 0; i < controllers.length; i++) {
+    const controller = controllers[i];
+    if (onProgress) {
+      onProgress(`Processing controller ${controller.className}`, i + 1, controllers.length);
+    }
     for (const operation of controller.operations) {
       const fullPath = convertToOpenApiPath(controller.basePath, operation.path);
       if (!paths[fullPath]) {
@@ -1584,6 +1590,9 @@ function generateOpenAPI(controllers, checker, options = {}) {
     }
   }
   const schemas = Object.fromEntries(components);
+  if (onProgress) {
+    onProgress("Generating and cleaning schemas", controllers.length, controllers.length);
+  }
   cleanupMetalOrmWrappers(schemas, paths);
   return {
     openapi: "3.1.0",
@@ -2372,7 +2381,7 @@ var ProgressTracker = class {
     }
     if (!this.quiet) {
       const elapsed = phase ? this.formatElapsed(phase.startTime, phase.endTime) : "";
-      const status = this.verbose ? `\u2713 ${message || name} ${elapsed}` : `\u2713 ${message || name}`;
+      const status = this.verbose ? `\u2713 ${message || name} ${elapsed}` : `\u2713 ${message || name} ${elapsed}`;
       this.log(status);
     }
   }
@@ -2444,7 +2453,6 @@ var ProgressTracker = class {
    */
   printSummary(stats) {
     if (this.quiet) return;
-    const totalTime = this.getTotalElapsed();
     this.log("");
     this.log("Build Summary:");
     this.log(`  Controllers:     ${stats.controllers}`);
@@ -2481,6 +2489,9 @@ var Spinner = class {
   frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u28B0", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   interval;
   message;
+  current = 0;
+  total = 0;
+  customStatus;
   constructor(message = "") {
     this.message = message;
   }
@@ -2491,10 +2502,45 @@ var Spinner = class {
     let frameIndex = 0;
     this.interval = setInterval(() => {
       const frame = this.frames[frameIndex];
-      process.stdout.write(`\r${frame} ${this.message}`);
+      let output;
+      if (this.customStatus) {
+        output = `\r${frame} ${this.customStatus}`;
+      } else if (this.total > 0) {
+        output = `\r${frame} ${this.message} (${this.current}/${this.total})`;
+      } else {
+        output = `\r${frame} ${this.message}`;
+      }
+      process.stdout.write(output);
+      if (process.stdout.writable) {
+        process.stdout.write("");
+      }
       frameIndex = (frameIndex + 1) % this.frames.length;
     }, 80);
   }
+  /**
+   * Set progress counters.
+   */
+  setProgress(current, total) {
+    this.current = current;
+    this.total = total;
+  }
+  /**
+   * Set a custom status message (overrides counters).
+   */
+  setStatus(status) {
+    this.customStatus = status;
+    const frame = this.frames[this.current];
+    process.stdout.write(`\r${frame} ${status}`);
+    if (process.stdout.writable) {
+      process.stdout.write("");
+    }
+  }
+  /**
+   * Clear the custom status message.
+   */
+  clearStatus() {
+    this.customStatus = void 0;
+  }
   /**
    * Stop the spinner with a completion message.
    */
@@ -2503,10 +2549,13 @@ var Spinner = class {
       clearInterval(this.interval);
       this.interval = void 0;
     }
-    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    process.stdout.write("\r" + " ".repeat(60) + "\r");
     if (completedMessage) {
       process.stdout.write(completedMessage + "\n");
     }
+    if (process.stdout.writable) {
+      process.stdout.write("");
+    }
   }
   /**
    * Stop the spinner with a failure message.
@@ -2901,12 +2950,17 @@ function generateModularOpenAPI(openapi, partitioning, config) {
     outputDir,
     schemasDir = "schemas",
     createIndexFile = true,
-    prettyPrint = true
+    prettyPrint = true,
+    onProgress
   } = config;
   const indent = prettyPrint ? 2 : 0;
   let totalSize = 0;
   const schemaFiles = [];
+  mkdirSync(outputDir, { recursive: true });
   if (!partitioning.shouldSplit || partitioning.groups.length === 1) {
+    if (onProgress) {
+      onProgress("Writing single OpenAPI file", 1, 1);
+    }
     const mainPath2 = resolve2(outputDir, "openapi.json");
     writeFileSync(mainPath2, JSON.stringify(openapi, null, indent));
     totalSize = Buffer.byteLength(JSON.stringify(openapi));
@@ -2919,9 +2973,16 @@ function generateModularOpenAPI(openapi, partitioning, config) {
   }
   const schemasPath = resolve2(outputDir, schemasDir);
   mkdirSync(schemasPath, { recursive: true });
+  if (onProgress) {
+    onProgress("Creating schemas directory", 0, partitioning.groups.length + 2);
+  }
   const schemaMap = collectAllSchemas(partitioning.groups);
   const schemaToFile = /* @__PURE__ */ new Map();
-  for (const group of partitioning.groups) {
+  for (let i = 0; i < partitioning.groups.length; i++) {
+    const group = partitioning.groups[i];
+    if (onProgress) {
+      onProgress(`Writing schema group ${group.name} (${group.schemas.size} schemas)`, i + 1, partitioning.groups.length + 2);
+    }
     const filename = getSchemaFilename(group);
     const filePath = resolve2(outputDir, filename);
     const content = generateSchemaFileContent(group, schemaMap);
@@ -2934,12 +2995,18 @@ function generateModularOpenAPI(openapi, partitioning, config) {
   }
   let indexFile;
   if (createIndexFile) {
+    if (onProgress) {
+      onProgress("Generating index file", partitioning.groups.length + 1, partitioning.groups.length + 2);
+    }
     const indexPath = resolve2(outputDir, "schemas/index.json");
     const indexContent = generateSchemaIndex(partitioning.groups, schemaMap);
     writeFileSync(indexPath, JSON.stringify(indexContent, null, indent));
     totalSize += Buffer.byteLength(JSON.stringify(indexContent));
     indexFile = indexPath;
   }
+  if (onProgress) {
+    onProgress("Generating main OpenAPI spec", partitioning.groups.length + 2, partitioning.groups.length + 2);
+  }
   const mainSpec = generateMainSpec(openapi, schemaMap, schemaToFile);
   const mainPath = resolve2(outputDir, "openapi.json");
   writeFileSync(mainPath, JSON.stringify(mainSpec, null, indent));
@@ -3270,7 +3337,27 @@ var SchemaGraph = class {
 // src/cli.ts
 import ts13 from "typescript";
 import process2 from "process";
-var ADORN_VERSION = "0.1.0";
+var ADORN_VERSION = (() => {
+  const tryReadPackageJson = (filePath) => {
+    try {
+      const pkg = JSON.parse(readFileSync3(filePath, "utf-8"));
+      return pkg.version ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const cliDir = dirname3(fileURLToPath(import.meta.url));
+  const bundledPkgPath = resolve3(cliDir, "..", "package.json");
+  const bundledVersion = tryReadPackageJson(bundledPkgPath);
+  if (bundledVersion) return bundledVersion;
+  const localPkgPath = resolve3(process2.cwd(), "package.json");
+  const localVersion = tryReadPackageJson(localPkgPath);
+  if (localVersion) return localVersion;
+  const nodeModulesPath = resolve3(cliDir, "..", "package.json");
+  const nodeModulesVersion = tryReadPackageJson(nodeModulesPath);
+  if (nodeModulesVersion) return nodeModulesVersion;
+  return "0.0.0";
+})();
 function log(msg, options) {
   if (options?.indent) {
     process2.stdout.write("  " + msg + "\n");
@@ -3463,10 +3550,21 @@ async function buildCommand(args) {
     }
   }
   progress.startPhase("openapi", "Generating OpenAPI schema");
-  if (verbose) {
-    progress.verboseLog("Processing schemas from type definitions");
+  const openapiSpinner = new Spinner("Processing schemas");
+  if (!quiet) openapiSpinner.start();
+  const openapi = generateOpenAPI(controllers, checker, {
+    title: "API",
+    version: "1.0.0",
+    onProgress: (message, current, total) => {
+      if (!quiet) {
+        openapiSpinner.setStatus(`${message} (${current}/${total})`);
+      }
+    }
+  });
+  if (!quiet) {
+    openapiSpinner.setStatus(`Processed ${controllers.length} controllers, ${totalOperations} operations`);
   }
-  const openapi = generateOpenAPI(controllers, checker, { title: "API", version: "1.0.0" });
+  if (!quiet) openapiSpinner.stop();
   const schemaCount = Object.keys(openapi.components?.schemas || {}).length;
   let splitEnabled = false;
   if (!noSplit && schemaCount >= splitThreshold) {
@@ -3484,14 +3582,24 @@ async function buildCommand(args) {
     if (splitEnabled) {
       progress.verboseLog(`Partitioning result: ${partitioning.strategy} strategy`);
       progress.verboseLog(`Recommendation: ${partitioning.recommendation}`);
+      if (!quiet) {
+        log(`  Auto-split enabled: ${partitioning.strategy} strategy`);
+      }
+      const splitSpinner = new Spinner("Writing split schema files");
+      if (!quiet) splitSpinner.start();
       generateModularOpenAPI(openapi, partitioning, {
         outputDir: outputPath,
         schemasDir: "schemas",
         createIndexFile: true,
-        prettyPrint: true
+        prettyPrint: true,
+        onProgress: (step, index, total) => {
+          if (!quiet) {
+            progress.logSub(`${step} (${index}/${total})`);
+          }
+        }
       });
+      if (!quiet) splitSpinner.stop();
       if (!quiet) {
-        log(`  Auto-split enabled: ${partitioning.strategy} strategy`);
         log(`  Schema groups: ${partitioning.groups.length}`);
       }
     } else {