typedapi-client-helpers 0.3.5 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typedapi-client-helpers",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Reusable typed OpenAPI client helpers.",
   "license": "MIT",
   "keywords": [

package/scripts/generate-api-minimal.mjs

@@ -2,7 +2,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { generateApi } from "./openapi-generator/index.mjs";
+import {
+  cleanupGenerationArtifacts,
+  generateApi,
+} from "./openapi-generator/index.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -93,6 +96,28 @@ const apiRoot = path.resolve(
   ),
 );
 
+let terminationSignalHandled = false;
+
+function handleTerminationSignal(signal) {
+  if (terminationSignalHandled) return;
+
+  terminationSignalHandled = true;
+
+  try {
+    cleanupGenerationArtifacts(apiRoot);
+  } catch (error) {
+    console.error(
+      `Failed to clean TypedApi temporary files after ${signal}:`,
+      error,
+    );
+  }
+
+  process.exit(signal === "SIGINT" ? 130 : 143);
+}
+
+process.once("SIGINT", () => handleTerminationSignal("SIGINT"));
+process.once("SIGTERM", () => handleTerminationSignal("SIGTERM"));
+
 const methodsDir = path.join(apiRoot, "methods");
 
 const defaultFunctionsPathSetting = getStringSetting(
@@ -222,7 +247,8 @@ function getMethodNameStyle(...values) {
   const normalized = value.replace(/[\s_-]/g, "").toLowerCase();
 
   if (["operationid", "operation"].includes(normalized)) return "operationId";
-  if (["action", "actionname", "controllermethod"].includes(normalized)) return "action";
+  if (["action", "actionname", "controllermethod"].includes(normalized))
+    return "action";
 
   throw new Error(
     `Invalid typedApiMethodNameStyle ${JSON.stringify(value)}. Use "operationId" or "action".`,
@@ -284,7 +310,12 @@ function copySwaggerBackupFromFile(filePath) {
 async function downloadSwaggerBackupFromUrl(url) {
   const controller = new AbortController();
   const timeout = setTimeout(
-    () => controller.abort(new Error(`Swagger download timed out after ${swaggerDownloadTimeoutMs}ms.`)),
+    () =>
+      controller.abort(
+        new Error(
+          `Swagger download timed out after ${swaggerDownloadTimeoutMs}ms.`,
+        ),
+      ),
     swaggerDownloadTimeoutMs,
   );
   let response;
@@ -323,7 +354,9 @@ function useBackupSwaggerInput(reason) {
 async function resolveSwaggerInput() {
   if (offlineMode) {
     if (!fileExists(swaggerBackupPath)) {
-      throw new Error(`Offline mode requires an existing Swagger backup: ${swaggerBackupPath}`);
+      throw new Error(
+        `Offline mode requires an existing Swagger backup: ${swaggerBackupPath}`,
+      );
     }
     return { input: swaggerBackupPath, label: swaggerBackupPath };
   }
@@ -342,7 +375,9 @@ async function resolveSwaggerInput() {
 
     const backupInput = strictMode
       ? undefined
-      : useBackupSwaggerInput(`Swagger file was not found: ${swaggerFilePath}.`);
+      : useBackupSwaggerInput(
+          `Swagger file was not found: ${swaggerFilePath}.`,
+        );
 
     if (backupInput) return backupInput;
 
@@ -452,7 +487,6 @@ export const ${defaultErrorMessageName} = "An unknown error occurred.";
   return resolvedFilePath;
 }
 
-
 function addDefaultErrorMessageIfMissing(filePath) {
   const source = fs.readFileSync(filePath, "utf8");
   if (fileExportsName(source, defaultErrorMessageName)) return;
@@ -527,10 +561,13 @@ function resolveDefaultHandlers() {
     ? defaultFunctionsFilePath
     : `${defaultFunctionsFilePath}.ts`;
   if (checkMode && !fs.existsSync(candidatePath)) {
-    if (verboseMode) console.log("Skipping missing default handler file in check mode.");
+    if (verboseMode)
+      console.log("Skipping missing default handler file in check mode.");
     return undefined;
   }
-  const defaultFunctionsFile = createDefaultFunctionsFileIfMissing(defaultFunctionsFilePath);
+  const defaultFunctionsFile = createDefaultFunctionsFileIfMissing(
+    defaultFunctionsFilePath,
+  );
   const source = fs.readFileSync(defaultFunctionsFile, "utf8");
   const hasSuccessHandler = fileExportsName(source, defaultSuccessHandlerName);
   const hasErrorHandler = fileExportsName(source, defaultErrorHandlerName);
@@ -562,6 +599,8 @@ function resolveDefaultHandlers() {
 }
 
 async function main() {
+  cleanupGenerationArtifacts(apiRoot);
+
   const swaggerInput = await resolveSwaggerInput();
 
   console.log(`Generating API from: ${swaggerInput.label}`);
@@ -588,7 +627,9 @@ async function main() {
     );
   }
 
-  console.log(checkMode ? "Generated API is up to date." : "API generation completed.");
+  console.log(
+    checkMode ? "Generated API is up to date." : "API generation completed.",
+  );
 }
 
 main().catch((error) => {

package/scripts/openapi-generator/index.mjs

@@ -1,7 +1,10 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { collectOperations, validateOpenApiDocument } from "./openapi-utils.mjs";
+import {
+  collectOperations,
+  validateOpenApiDocument,
+} from "./openapi-utils.mjs";
 import { generateDataContracts } from "./schema.mjs";
 import { generateHttpClient } from "./http-client-template.mjs";
 import {
@@ -54,13 +57,18 @@ export async function generateApi(options) {
 
   const controllers = new Map();
   for (const operationInfo of operations) {
-    const controllerName = controllerNameForOperation(operationInfo, normalizedOptions);
+    const controllerName = controllerNameForOperation(
+      operationInfo,
+      normalizedOptions,
+    );
     const controllerOperations = controllers.get(controllerName) ?? [];
     controllerOperations.push(operationInfo);
     controllers.set(controllerName, controllerOperations);
   }
 
-  const controllerNames = [...controllers.keys()].sort((a, b) => a.localeCompare(b));
+  const controllerNames = [...controllers.keys()].sort((a, b) =>
+    a.localeCompare(b),
+  );
   for (const controllerName of controllerNames) {
     files.set(
       `methods/${methodFileNameForController(controllerName)}`,
@@ -73,7 +81,6 @@ export async function generateApi(options) {
     );
   }
 
-
   const changes = compareOutput(output, files);
   if (options.check) {
     if (changes.length > 0) {
@@ -81,7 +88,10 @@ export async function generateApi(options) {
         `Generated API is out of date:\n${changes.map((item) => `- ${item}`).join("\n")}`,
       );
     }
-    return { files: [...files.keys()].map((file) => path.join(output, file)), changed: false };
+    return {
+      files: [...files.keys()].map((file) => path.join(output, file)),
+      changed: false,
+    };
   }
 
   const writeStrategy = writeOutputTransactionally(
@@ -105,7 +115,8 @@ function compareOutput(output, files) {
       changes.push(`${relativePath} is missing`);
       continue;
     }
-    if (fs.readFileSync(target, "utf8") !== expected) changes.push(`${relativePath} differs`);
+    if (fs.readFileSync(target, "utf8") !== expected)
+      changes.push(`${relativePath} differs`);
   }
 
   for (const relativePath of listManagedFiles(output)) {
@@ -123,7 +134,9 @@ function listManagedFiles(output) {
       result.push(topLevel);
       continue;
     }
-    walk(target, (file) => result.push(path.relative(output, file).replaceAll(path.sep, "/")));
+    walk(target, (file) =>
+      result.push(path.relative(output, file).replaceAll(path.sep, "/")),
+    );
   }
   return result;
 }
@@ -142,6 +155,61 @@ function removeManagedOutput(root) {
   }
 }
 
+export function cleanupGenerationArtifacts(output) {
+  const resolvedOutput = path.resolve(output);
+  const parent = path.dirname(resolvedOutput);
+
+  if (!fs.existsSync(parent)) return;
+
+  const outputName = path.basename(resolvedOutput);
+  const stagingPrefix = `.${outputName}.typedapi-staging-`;
+  const backupPrefix = `.${outputName}.typedapi-backup-`;
+  const managedBackupPrefix = `.${outputName}.typedapi-managed-backup-`;
+  const backups = [];
+
+  for (const entry of fs.readdirSync(parent, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+
+    const entryPath = path.join(parent, entry.name);
+
+    if (
+      entry.name.startsWith(stagingPrefix) ||
+      entry.name.startsWith(managedBackupPrefix)
+    ) {
+      removePathWithRetry(entryPath);
+      continue;
+    }
+
+    if (entry.name.startsWith(backupPrefix)) {
+      backups.push(entryPath);
+    }
+  }
+
+  if (backups.length === 0) return;
+
+  if (!fs.existsSync(resolvedOutput)) {
+    backups.sort(
+      (left, right) => fs.statSync(right).mtimeMs - fs.statSync(left).mtimeMs,
+    );
+
+    const [backupToRestore, ...staleBackups] = backups;
+
+    retryFileSystemOperation(() =>
+      fs.renameSync(backupToRestore, resolvedOutput),
+    );
+
+    for (const backup of staleBackups) {
+      removePathWithRetry(backup);
+    }
+
+    return;
+  }
+
+  for (const backup of backups) {
+    removePathWithRetry(backup);
+  }
+}
+
 const RETRYABLE_FS_ERROR_CODES = new Set([
   "EACCES",
   "EBUSY",
@@ -151,14 +219,25 @@ const RETRYABLE_FS_ERROR_CODES = new Set([
   "EPERM",
 ]);
 
-function writeOutputTransactionally(output, files, cleanOutput, forceInPlaceOutput = false) {
+function writeOutputTransactionally(
+  output,
+  files,
+  cleanOutput,
+  forceInPlaceOutput = false,
+) {
   const parent = path.dirname(output);
   fs.mkdirSync(parent, { recursive: true });
-  const staging = fs.mkdtempSync(path.join(parent, `.${path.basename(output)}.typedapi-staging-`));
-  const backup = path.join(parent, `.${path.basename(output)}.typedapi-backup-${process.pid}-${Date.now()}`);
+  const staging = fs.mkdtempSync(
+    path.join(parent, `.${path.basename(output)}.typedapi-staging-`),
+  );
+  const backup = path.join(
+    parent,
+    `.${path.basename(output)}.typedapi-backup-${process.pid}-${Date.now()}`,
+  );
 
   try {
-    if (fs.existsSync(output)) fs.cpSync(output, staging, { recursive: true, force: true });
+    if (fs.existsSync(output))
+      fs.cpSync(output, staging, { recursive: true, force: true });
     if (cleanOutput) removeManagedOutput(staging);
 
     for (const [relativePath, content] of files) {
@@ -212,7 +291,8 @@ function writeOutputTransactionally(output, files, cleanOutput, forceInPlaceOutp
     return "directory-swap";
   } finally {
     removePathWithRetry(staging);
-    if (fs.existsSync(backup) && fs.existsSync(output)) removePathWithRetry(backup);
+    if (fs.existsSync(backup) && fs.existsSync(output))
+      removePathWithRetry(backup);
   }
 }
 
@@ -272,7 +352,8 @@ function syncPath(source, target) {
       syncPath(path.join(source, entry), path.join(target, entry));
     }
     for (const entry of fs.readdirSync(target)) {
-      if (!sourceEntries.has(entry)) removePathWithRetry(path.join(target, entry));
+      if (!sourceEntries.has(entry))
+        removePathWithRetry(path.join(target, entry));
     }
     return;
   }
@@ -312,7 +393,8 @@ function retryFileSystemOperation(operation, attempts = 12) {
       return operation();
     } catch (error) {
       lastError = error;
-      if (!isRetryableFileSystemError(error) || attempt === attempts - 1) throw error;
+      if (!isRetryableFileSystemError(error) || attempt === attempts - 1)
+        throw error;
       sleepSynchronously(Math.min(25 * 2 ** attempt, 250));
     }
   }
@@ -320,7 +402,11 @@ function retryFileSystemOperation(operation, attempts = 12) {
 }
 
 function isRetryableFileSystemError(error) {
-  return Boolean(error && typeof error === "object" && RETRYABLE_FS_ERROR_CODES.has(error.code));
+  return Boolean(
+    error &&
+    typeof error === "object" &&
+    RETRYABLE_FS_ERROR_CODES.has(error.code),
+  );
 }
 
 function sleepSynchronously(milliseconds) {