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

package/dist/index.cjs

@@ -35,12 +35,14 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/core/generateOpenApiSpec.ts
-var import_node_path4 = __toESM(require("path"), 1);
 var import_package_metadata = __toESM(require("@omer-x/package-metadata"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 
 // 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
@@ -53,17 +55,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;
+        })
+      )
     }
   };
 }
@@ -71,8 +77,8 @@ function clearUnusedSchemas({
 // src/core/dir.ts
 var import_fs = require("fs");
 var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
+var import_node_path = __toESM(require("path"), 1);
 async function directoryExists(dirPath) {
   try {
     await import_promises.default.access(dirPath, import_fs.constants.F_OK);
@@ -101,8 +107,12 @@ function filterDirectoryItems(rootPath, items, include, exclude) {
   const excludedPatterns = exclude.map((pattern) => new import_minimatch.Minimatch(pattern));
   return items.filter((item) => {
     const relativePath = import_node_path.default.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;
   });
 }
@@ -123,9 +133,9 @@ async function isDocumentedRoute(routePath) {
 }
 
 // src/core/next.ts
+var import_next_openapi_route_handler = require("@spikers/next-openapi-route-handler");
 var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var import_next_openapi_route_handler = require("@spikers/next-openapi-route-handler");
 var import_zod = require("zod");
 
 // src/utils/generateRandomString.ts
@@ -136,14 +146,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) {
@@ -155,7 +168,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);
 }
 
@@ -224,7 +243,9 @@ async function safeEval(code, routePath) {
     fn(exports2, module2, require2);
     return module2.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;
   }
 }
@@ -244,7 +265,12 @@ async function getModuleTranspiler() {
 async function getRouteExports(routePath, routeDefinerName, schemas) {
   const rawCode = await import_promises3.default.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] = import_next_openapi_route_handler.defineRoute;
   global.z = import_zod.z;
@@ -321,7 +347,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") {
@@ -330,14 +358,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 import_zod2.z.object(newShape);
   }
   return schema;
 }
 function convertToOpenAPI(schema, isArray) {
-  return import_zod2.z.toJSONSchema(fixSchema(isArray ? schema.array() : schema));
+  return import_zod2.z.toJSONSchema(
+    fixSchema(isArray ? schema.array() : schema)
+  );
 }
 
 // src/core/mask.ts
@@ -368,16 +401,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 {
@@ -395,37 +433,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)
   };
@@ -441,27 +496,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
@@ -481,20 +545,33 @@ async function generateOpenApiSpec(schemas, {
   if (!appFolderPath) throw new Error("This is not a Next.js application!");
   const rootPath = additionalRootPath ? import_node_path4.default.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 = (0, import_package_metadata.default)();
@@ -505,18 +582,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