toolcraft-openapi 0.0.57 → 0.0.58

package/dist/bin/generate.d.ts

@@ -38,6 +38,7 @@ interface GenerateCliOptions {
     diff: boolean;
     input: string;
     inspect: boolean;
+    lockPath: string;
     outputFormat: OutputFormat;
     outputDir: string;
 }

package/dist/bin/generate.js

@@ -19,6 +19,7 @@ const DEFAULT_OPTIONS = {
     diff: false,
     input: "openapi.json",
     inspect: false,
+    lockPath: "openapi.lock",
     outputFormat: "terminal",
     outputDir: "src/generated"
 };
@@ -27,6 +28,7 @@ const HELP_TEXT = `Usage: toolcraft-openapi-generate [options]
 Options:
   --input <path-or-url>  OpenAPI document to read (default: openapi.json)
   --output <dir>         Directory for generated command files (default: src/generated)
+  --lock <path>          Lock file path (default: openapi.lock)
   --check                Exit non-zero if generated output would change
   --diff                 Print a diff of generated changes without writing files
   --inspect              Inspect route compatibility without writing files
@@ -113,18 +115,27 @@ export async function syncGeneratedClient(options, services) {
     const effectiveConfig = hasErrorDiagnostics(diagnostics) ? undefined : configResult.config;
     const generatedFiles = generate(document, { specSha, config: effectiveConfig });
     const outputDir = path.resolve(services.cwd, options.outputDir);
+    const lockPath = path.resolve(services.cwd, options.lockPath);
+    const currentLockContents = await readOpenApiLockText(services.fs, lockPath);
+    const desiredLockContents = stringifyOpenApiLock({ specSha });
     const currentFiles = await readGeneratedFiles(services.fs, outputDir);
     const desiredFiles = new Map([
         ...generatedFiles.map((file) => [path.resolve(outputDir, file.path), file.contents]),
         ...createDownloadedSpecFiles(options.input, sourceText).map((file) => [path.resolve(outputDir, file.path), file.contents])
     ]);
     const updatedFiles = collectUpdatedFiles(currentFiles, desiredFiles);
+    const updatedLockFile = currentLockContents === desiredLockContents
+        ? undefined
+        : { path: lockPath, contents: desiredLockContents, previousContents: currentLockContents };
     const deletedFiles = collectDeletedFiles(currentFiles, desiredFiles);
-    const drifted = updatedFiles.length > 0 || deletedFiles.length > 0;
+    const drifted = updatedFiles.length > 0 || updatedLockFile !== undefined || deletedFiles.length > 0;
     if (!options.check && !options.diff && drifted && !hasErrorDiagnostics(diagnostics)) {
         try {
             await writeGeneratedFiles(services.fs, outputDir, updatedFiles);
             await deleteGeneratedFiles(services.fs, outputDir, deletedFiles);
+            if (updatedLockFile !== undefined) {
+                await writeOpenApiLock(services.fs, lockPath, { specSha });
+            }
         }
         catch (error) {
             await restoreGeneratedFiles(services.fs, outputDir, currentFiles, updatedFiles, deletedFiles);
@@ -137,8 +148,8 @@ export async function syncGeneratedClient(options, services) {
         diagnostics,
         drifted,
         specSha,
-        updatedFiles,
-        updatedFileCount: updatedFiles.length
+        updatedFiles: updatedLockFile === undefined ? updatedFiles : [...updatedFiles, updatedLockFile],
+        updatedFileCount: updatedFiles.length + (updatedLockFile === undefined ? 0 : 1)
     };
 }
 async function readAdjacentToolcraftConfig(input, services) {
@@ -243,7 +254,10 @@ function parseGenerateCliArgs(argv) {
             options.inspect = true;
             continue;
         }
-        if (argument === "--input" || argument === "--output" || argument === "--output-format") {
+        if (argument === "--input" ||
+            argument === "--output" ||
+            argument === "--lock" ||
+            argument === "--output-format") {
             const value = argv[index + 1];
             if (value === undefined) {
                 throw new UserError(`Missing value for ${JSON.stringify(argument)}.`);
@@ -260,6 +274,10 @@ function parseGenerateCliArgs(argv) {
             assignOptionValue(options, "--output", argument.slice("--output=".length));
             continue;
         }
+        if (argument.startsWith("--lock=")) {
+            assignOptionValue(options, "--lock", argument.slice("--lock=".length));
+            continue;
+        }
         if (argument.startsWith("--output-format=")) {
             assignOptionValue(options, "--output-format", argument.slice("--output-format=".length));
             continue;
@@ -283,8 +301,57 @@ function assignOptionValue(options, argument, value) {
         options.outputFormat = value;
         return;
     }
+    if (argument === "--lock") {
+        options.lockPath = value;
+        return;
+    }
     options.outputDir = value;
 }
+async function readOpenApiLockText(fs, lockPath) {
+    try {
+        const contents = await fs.readFile(lockPath, "utf8");
+        parseOpenApiLock(contents, lockPath);
+        return contents;
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function parseOpenApiLock(contents, lockPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new UserError(`Lock file ${JSON.stringify(lockPath)} is not valid JSON: ${getErrorMessage(error)}.`, { cause: error });
+    }
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !("version" in parsed) ||
+        parsed.version !== 1 ||
+        !("specSha" in parsed) ||
+        typeof parsed.specSha !== "string" ||
+        parsed.specSha.length === 0) {
+        return null;
+    }
+    return { specSha: parsed.specSha };
+}
+function stringifyOpenApiLock(lock) {
+    return `${JSON.stringify({ version: 1, specSha: lock.specSha }, null, 2)}\n`;
+}
+async function writeOpenApiLock(fs, lockPath, lock) {
+    await fs.mkdir(path.dirname(lockPath), { recursive: true });
+    try {
+        await fs.writeFile(lockPath, stringifyOpenApiLock(lock), "utf8");
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        throw new UserError(`Failed to write lock file ${JSON.stringify(lockPath)}${code === undefined ? "" : ` (${code})`}: ${getErrorMessage(error)}`, { cause: error });
+    }
+}
 function createSpecSha(sourceText) {
     return `sha256:${createHash("sha256").update(sourceText).digest("hex")}`;
 }
@@ -446,6 +513,15 @@ function isNotFoundError(error) {
 function isAlreadyExistsError(error) {
     return hasOwnErrorCode(error, "EEXIST");
 }
+function getErrorCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error)) {
+        return undefined;
+    }
+    return typeof error.code === "string" ? error.code : undefined;
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function isDirectExecution(moduleUrl, argv) {
     const entryPoint = argv[1];
     if (entryPoint === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.57",
+  "version": "0.0.58",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.57",
+    "toolcraft": "0.0.58",
     "auth-store": "^0.0.1",
     "yaml": "^2.8.2"
   },