@spikers/next-openapi-json-generator 2.0.4 → 2.1.0

package/dist/index.js

@@ -6,12 +6,14 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/core/generateOpenApiSpec.ts
-import path4 from "path";
 import getPackageMetadata from "@omer-x/package-metadata";
+import path4 from "path";
 
 // src/utils/object.ts
 function omit(object, ...keys) {
-  return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+  return Object.fromEntries(
+    Object.entries(object).filter(([key]) => !keys.includes(key))
+  );
 }
 
 // src/core/clearUnusedSchemas.ts
@@ -24,17 +26,21 @@ function clearUnusedSchemas({
 }) {
   if (!components.schemas) return { paths, components };
   const stringifiedPaths = JSON.stringify(paths);
-  const stringifiedSchemas = Object.fromEntries(Object.entries(components.schemas).map(([schemaName, schema]) => {
-    return [schemaName, JSON.stringify(schema)];
-  }));
+  const stringifiedSchemas = Object.fromEntries(
+    Object.entries(components.schemas).map(([schemaName, schema]) => {
+      return [schemaName, JSON.stringify(schema)];
+    })
+  );
   return {
     paths,
     components: {
       ...components,
-      schemas: Object.fromEntries(Object.entries(components.schemas).filter(([schemaName]) => {
-        const otherSchemas = omit(stringifiedSchemas, schemaName);
-        return countReferences(schemaName, stringifiedPaths) > 0 || countReferences(schemaName, Object.values(otherSchemas).join("")) > 0;
-      }))
+      schemas: Object.fromEntries(
+        Object.entries(components.schemas).filter(([schemaName]) => {
+          const otherSchemas = omit(stringifiedSchemas, schemaName);
+          return countReferences(schemaName, stringifiedPaths) > 0 || countReferences(schemaName, Object.values(otherSchemas).join("")) > 0;
+        })
+      )
     }
   };
 }
@@ -42,8 +48,8 @@ function clearUnusedSchemas({
 // src/core/dir.ts
 import { constants } from "fs";
 import fs from "fs/promises";
-import path from "path";
 import { Minimatch } from "minimatch";
+import path from "path";
 async function directoryExists(dirPath) {
   try {
     await fs.access(dirPath, constants.F_OK);
@@ -72,8 +78,12 @@ function filterDirectoryItems(rootPath, items, include, exclude) {
   const excludedPatterns = exclude.map((pattern) => new Minimatch(pattern));
   return items.filter((item) => {
     const relativePath = path.relative(rootPath, item);
-    const isIncluded = includedPatterns.some((pattern) => pattern.match(relativePath));
-    const isExcluded = excludedPatterns.some((pattern) => pattern.match(relativePath));
+    const isIncluded = includedPatterns.some(
+      (pattern) => pattern.match(relativePath)
+    );
+    const isExcluded = excludedPatterns.some(
+      (pattern) => pattern.match(relativePath)
+    );
     return (isIncluded || !include.length) && !isExcluded;
   });
 }
@@ -94,9 +104,9 @@ async function isDocumentedRoute(routePath) {
 }
 
 // src/core/next.ts
+import { defineRoute } from "@spikers/next-openapi-route-handler";
 import fs3 from "fs/promises";
 import path2 from "path";
-import { defineRoute } from "@spikers/next-openapi-route-handler";
 import { z } from "zod";
 
 // src/utils/generateRandomString.ts
@@ -107,14 +117,17 @@ function generateRandomString(length) {
 // src/utils/string-preservation.ts
 function preserveStrings(code) {
   let replacements = {};
-  const output = code.replace(/(['"`])((?:\\.|(?!\1).)*)\1/g, (match, quote, content) => {
-    const replacementId = generateRandomString(32);
-    replacements = {
-      ...replacements,
-      [replacementId]: `${quote}${content}${quote}`
-    };
-    return `<@~${replacementId}~@>`;
-  });
+  const output = code.replace(
+    /(['"`])((?:\\.|(?!\1).)*)\1/g,
+    (match, quote, content) => {
+      const replacementId = generateRandomString(32);
+      replacements = {
+        ...replacements,
+        [replacementId]: `${quote}${content}${quote}`
+      };
+      return `<@~${replacementId}~@>`;
+    }
+  );
   return { output, replacements };
 }
 function restoreStrings(code, replacements) {
@@ -126,7 +139,13 @@ function restoreStrings(code, replacements) {
 // src/core/injectSchemas.ts
 function injectSchemas(code, refName) {
   const { output: preservedCode, replacements } = preserveStrings(code);
-  const preservedCodeWithSchemasInjected = preservedCode.replace(new RegExp(`\\b${refName}\\.`, "g"), `global.schemas[${refName}].`).replace(new RegExp(`\\b${refName}\\b`, "g"), `"${refName}"`).replace(new RegExp(`queryParams:\\s*['"\`]${refName}['"\`]`, "g"), `queryParams: global.schemas["${refName}"]`).replace(new RegExp(`pathParams:\\s*['"\`]${refName}['"\`]`, "g"), `pathParams: global.schemas["${refName}"]`);
+  const preservedCodeWithSchemasInjected = preservedCode.replace(new RegExp(`\\b${refName}\\.`, "g"), `global.schemas[${refName}].`).replace(new RegExp(`\\b${refName}\\b`, "g"), `"${refName}"`).replace(
+    new RegExp(`queryParams:\\s*['"\`]${refName}['"\`]`, "g"),
+    `queryParams: global.schemas["${refName}"]`
+  ).replace(
+    new RegExp(`pathParams:\\s*['"\`]${refName}['"\`]`, "g"),
+    `pathParams: global.schemas["${refName}"]`
+  );
   return restoreStrings(preservedCodeWithSchemasInjected, replacements);
 }
 
@@ -195,7 +214,9 @@ async function safeEval(code, routePath) {
     fn(exports2, module, require2);
     return module.exports;
   } catch (error) {
-    console.log(`An error occured while evaluating the route exports from "${routePath}"`);
+    console.log(
+      `An error occured while evaluating the route exports from "${routePath}"`
+    );
     throw error;
   }
 }
@@ -215,7 +236,12 @@ async function getModuleTranspiler() {
 async function getRouteExports(routePath, routeDefinerName, schemas) {
   const rawCode = await fs3.readFile(routePath, "utf-8");
   const middlewareName = detectMiddlewareName(rawCode);
-  const code = transpile(true, rawCode, middlewareName, await getModuleTranspiler());
+  const code = transpile(
+    true,
+    rawCode,
+    middlewareName,
+    await getModuleTranspiler()
+  );
   const fixedCode = Object.keys(schemas).reduce(injectSchemas, code);
   global[routeDefinerName] = defineRoute;
   global.z = z;
@@ -251,7 +277,7 @@ function verifyOptions(include, exclude) {
 import path3 from "path";
 function getRoutePathName(filePath, rootPath) {
   const dirName = path3.dirname(filePath);
-  return "/" + path3.relative(rootPath, dirName).replaceAll("[", "{").replaceAll("]", "}").replaceAll("\\", "/").replaceAll(/\([^)]*\)\//g, "/");
+  return "/" + path3.relative(rootPath, dirName).replaceAll("[", "{").replaceAll("]", "}").replaceAll("\\", "/").replaceAll(/\([^)]*\)\//g, "");
 }
 
 // src/utils/deepEqual.ts
@@ -292,7 +318,9 @@ function fixSchema(schema) {
       case "nonoptional":
         return fixSchema(schema.unwrap());
       default:
-        throw new Error(`${schema._zod.def.type} type is not covered in fixSchema (@omer-x/next-openapi-json-generator")`);
+        throw new Error(
+          `${schema._zod.def.type} type is not covered in fixSchema (@omer-x/next-openapi-json-generator")`
+        );
     }
   }
   if (schema._zod.def.type === "date") {
@@ -301,14 +329,19 @@ function fixSchema(schema) {
   if (schema._zod.def.type === "object") {
     const { shape } = schema;
     const entries = Object.entries(shape);
-    const alteredEntries = entries.map(([propName, prop]) => [propName, fixSchema(prop)]);
+    const alteredEntries = entries.map(([propName, prop]) => [
+      propName,
+      fixSchema(prop)
+    ]);
     const newShape = Object.fromEntries(alteredEntries);
     return z2.object(newShape);
   }
   return schema;
 }
 function convertToOpenAPI(schema, isArray) {
-  return z2.toJSONSchema(fixSchema(isArray ? schema.array() : schema));
+  return z2.toJSONSchema(
+    fixSchema(isArray ? schema.array() : schema)
+  );
 }
 
 // src/core/mask.ts
@@ -339,16 +372,21 @@ function maskWithReference(schema, storedSchemas, self) {
     case "object":
       return {
         ...schema,
-        properties: Object.entries(schema.properties ?? {}).reduce((props, [propName, prop]) => ({
-          ...props,
-          [propName]: maskWithReference(prop, storedSchemas, true)
-        }), {})
+        properties: Object.entries(schema.properties ?? {}).reduce(
+          (props, [propName, prop]) => ({
+            ...props,
+            [propName]: maskWithReference(prop, storedSchemas, true)
+          }),
+          {}
+        )
       };
     case "array":
       if (Array.isArray(schema.items)) {
         return {
           ...schema,
-          items: schema.items.map((i) => maskWithReference(i, storedSchemas, true))
+          items: schema.items.map(
+            (i) => maskWithReference(i, storedSchemas, true)
+          )
         };
       }
       return {
@@ -366,37 +404,54 @@ function maskSchema(storedSchemas, schema) {
 }
 function maskParameterSchema(param, storedSchemas) {
   if ("$ref" in param) return param;
-  return { ...param, schema: maskSchema(storedSchemas, param.schema) };
+  return {
+    ...param,
+    schema: maskSchema(storedSchemas, param.schema)
+  };
 }
 function maskContentSchema(storedSchemas, bodyContent) {
   if (!bodyContent) return bodyContent;
-  return Object.entries(bodyContent).reduce((collection, [contentType, content]) => ({
-    ...collection,
-    [contentType]: {
-      ...content,
-      schema: maskSchema(storedSchemas, content.schema)
-    }
-  }), {});
+  return Object.entries(bodyContent).reduce(
+    (collection, [contentType, content]) => ({
+      ...collection,
+      [contentType]: {
+        ...content,
+        schema: maskSchema(storedSchemas, content.schema)
+      }
+    }),
+    {}
+  );
 }
 function maskRequestBodySchema(storedSchemas, body) {
   if (!body || "$ref" in body) return body;
-  return { ...body, content: maskContentSchema(storedSchemas, body.content) };
+  return {
+    ...body,
+    content: maskContentSchema(storedSchemas, body.content)
+  };
 }
 function maskResponseSchema(storedSchemas, response) {
   if ("$ref" in response) return response;
-  return { ...response, content: maskContentSchema(storedSchemas, response.content) };
+  return {
+    ...response,
+    content: maskContentSchema(storedSchemas, response.content)
+  };
 }
 function maskSchemasInResponses(storedSchemas, responses) {
   if (!responses) return responses;
-  return Object.entries(responses).reduce((collection, [key, response]) => ({
-    ...collection,
-    [key]: maskResponseSchema(storedSchemas, response)
-  }), {});
+  return Object.entries(responses).reduce(
+    (collection, [key, response]) => ({
+      ...collection,
+      [key]: maskResponseSchema(storedSchemas, response)
+    }),
+    {}
+  );
 }
 function maskOperationSchemas(operation, storedSchemas) {
   return {
     ...operation,
-    parameters: operation.parameters?.map((p) => maskParameterSchema(p, storedSchemas)),
+    parameters: operation.parameters?.map(
+      (p) => maskParameterSchema(p, storedSchemas)
+    ),
     requestBody: maskRequestBodySchema(storedSchemas, operation.requestBody),
     responses: maskSchemasInResponses(storedSchemas, operation.responses)
   };
@@ -412,27 +467,36 @@ function createRouteRecord(method, filePath, rootPath, apiData) {
 }
 function bundlePaths(source, storedSchemas) {
   source.sort((a, b) => a.path.localeCompare(b.path));
-  return source.reduce((collection, route) => ({
-    ...collection,
-    [route.path]: {
-      ...collection[route.path],
-      [route.method]: maskOperationSchemas(route.apiData, storedSchemas)
-    }
-  }), {});
+  return source.reduce(
+    (collection, route) => ({
+      ...collection,
+      [route.path]: {
+        ...collection[route.path],
+        [route.method]: maskOperationSchemas(route.apiData, storedSchemas)
+      }
+    }),
+    {}
+  );
 }
 
 // src/core/schema.ts
 function bundleSchemas(schemas) {
-  const bundledSchemas = Object.keys(schemas).reduce((collection, schemaName) => {
-    return {
-      ...collection,
-      [schemaName]: convertToOpenAPI(schemas[schemaName], false)
-    };
-  }, {});
-  return Object.entries(bundledSchemas).reduce((bundle, [schemaName, schema]) => ({
-    ...bundle,
-    [schemaName]: maskWithReference(schema, schemas, false)
-  }), {});
+  const bundledSchemas = Object.keys(schemas).reduce(
+    (collection, schemaName) => {
+      return {
+        ...collection,
+        [schemaName]: convertToOpenAPI(schemas[schemaName], false)
+      };
+    },
+    {}
+  );
+  return Object.entries(bundledSchemas).reduce(
+    (bundle, [schemaName, schema]) => ({
+      ...bundle,
+      [schemaName]: maskWithReference(schema, schemas, false)
+    }),
+    {}
+  );
 }
 
 // src/core/generateOpenApiSpec.ts
@@ -452,20 +516,33 @@ async function generateOpenApiSpec(schemas, {
   if (!appFolderPath) throw new Error("This is not a Next.js application!");
   const rootPath = additionalRootPath ? path4.resolve(appFolderPath, "./" + additionalRootPath) : appFolderPath;
   const routes = await getDirectoryItems(rootPath, "route.ts");
-  const verifiedRoutes = filterDirectoryItems(rootPath, routes, verifiedOptions.include, verifiedOptions.exclude);
+  const verifiedRoutes = filterDirectoryItems(
+    rootPath,
+    routes,
+    verifiedOptions.include,
+    verifiedOptions.exclude
+  );
   const validRoutes = [];
   for (const route of verifiedRoutes) {
     const isDocumented = await isDocumentedRoute(route);
     if (!isDocumented) continue;
-    const exportedRouteHandlers = await getRouteExports(route, routeDefinerName, schemas);
-    for (const [method, routeHandler] of Object.entries(exportedRouteHandlers)) {
+    const exportedRouteHandlers = await getRouteExports(
+      route,
+      routeDefinerName,
+      schemas
+    );
+    for (const [method, routeHandler] of Object.entries(
+      exportedRouteHandlers
+    )) {
       if (!routeHandler || !routeHandler.apiData) continue;
-      validRoutes.push(createRouteRecord(
-        method.toLocaleLowerCase(),
-        route,
-        rootPath,
-        routeHandler.apiData
-      ));
+      validRoutes.push(
+        createRouteRecord(
+          method.toLocaleLowerCase(),
+          route,
+          rootPath,
+          routeHandler.apiData
+        )
+      );
     }
   }
   const metadata = getPackageMetadata();
@@ -476,18 +553,20 @@ async function generateOpenApiSpec(schemas, {
       securitySchemes
     }
   };
-  return JSON.parse(JSON.stringify({
-    openapi: "3.1.0",
-    info: {
-      title: metadata.serviceName,
-      version: metadata.version,
-      ...info ?? {}
-    },
-    servers,
-    ...clearUnusedSchemasOption ? clearUnusedSchemas(pathsAndComponents) : pathsAndComponents,
-    security,
-    tags: []
-  }));
+  return JSON.parse(
+    JSON.stringify({
+      openapi: "3.1.0",
+      info: {
+        title: metadata.serviceName,
+        version: metadata.version,
+        ...info ?? {}
+      },
+      servers,
+      ...clearUnusedSchemasOption ? clearUnusedSchemas(pathsAndComponents) : pathsAndComponents,
+      security,
+      tags: []
+    })
+  );
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spikers/next-openapi-json-generator",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "a Next.js plugin to generate OpenAPI documentation from route handlers",
   "keywords": [
     "next.js",
@@ -35,32 +35,32 @@
     }
   },
   "scripts": {
-    "lint": "eslint --flag unstable_native_nodejs_ts_config",
-    "lint:fix": "eslint --fix --flag unstable_native_nodejs_ts_config",
+    "lint": "prettier --check './src/**/*.{js,jsx,mjs,cjs,ts,tsx,json}' --plugin=prettier-plugin-organize-imports",
+    "lint:fix": "prettier --write './src/**/*.{js,jsx,mjs,cjs,ts,tsx,json}' --plugin=prettier-plugin-organize-imports",
     "test": "vitest run --coverage",
     "test:watch": "vitest --coverage",
     "dev": "tsup --watch",
     "build": "tsup"
   },
   "peerDependencies": {
-    "@omer-x/json-schema-types": "^1",
-    "@spikers/next-openapi-route-handler": "^2",
-    "@omer-x/openapi-types": "^1",
-    "typescript": "^5",
-    "zod": "^4"
+    "@omer-x/json-schema-types": "^1.0.4",
+    "@spikers/next-openapi-route-handler": "^2.0.1",
+    "@omer-x/openapi-types": "^1.3.0",
+    "typescript": "^5.9.3",
+    "zod": "^4.2.1"
   },
   "dependencies": {
     "@omer-x/openapi-optimizer": "alpha",
     "@omer-x/package-metadata": "^1.0.2",
-    "minimatch": "^10.1.1"
+    "minimatch": "^10.2.2"
   },
   "devDependencies": {
-    "@omer-x/eslint-config": "^2.2.6",
-    "@types/node": "^25.0.3",
-    "@vitest/coverage-v8": "^4.0.16",
-    "eslint": "^9.39.2",
-    "semantic-release": "^25.0.2",
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "prettier": "^3.8.1",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "semantic-release": "^25.0.3",
     "tsup": "^8.5.1",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   }
 }