@omer-x/next-openapi-json-generator 2.0.3 → 2.1.0-rc.2

package/dist/index.cjs

@@ -36,6 +36,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/core/generateOpenApiSpec.ts
 var import_node_path4 = __toESM(require("path"), 1);
+var import_openapi_optimizer = require("@omer-x/openapi-optimizer");
 var import_package_metadata = __toESM(require("@omer-x/package-metadata"), 1);
 
 // src/utils/object.ts
@@ -281,54 +282,57 @@ function getRoutePathName(filePath, rootPath) {
   return "/" + import_node_path3.default.relative(rootPath, dirName).replaceAll("[", "{").replaceAll("]", "}").replaceAll("\\", "/");
 }
 
-// src/utils/deepEqual.ts
-function deepEqual(a, b) {
-  if (typeof a !== typeof b) return false;
-  switch (typeof a) {
-    case "object": {
-      if (!a || !b) return a === b;
-      if (Array.isArray(a) && Array.isArray(b)) {
-        return a.every((item, index) => deepEqual(item, b[index]));
-      }
-      if (Object.keys(a).length !== Object.keys(b).length) return false;
-      return Object.entries(a).every(([key, value]) => {
-        return deepEqual(value, b[key]);
-      });
+// src/core/route.ts
+function createRouteRecord(method, filePath, rootPath, apiData) {
+  return {
+    method: method.toLocaleLowerCase(),
+    path: getRoutePathName(filePath, rootPath),
+    apiData
+  };
+}
+function bundlePaths(source) {
+  source.sort((a, b) => a.path.localeCompare(b.path));
+  return source.reduce((collection, route) => ({
+    ...collection,
+    [route.path]: {
+      ...collection[route.path],
+      [route.method]: route.apiData
     }
-    case "function":
-    case "symbol":
-      return false;
-    default:
-      return a === b;
-  }
+  }), {});
 }
 
 // src/core/zod-to-openapi.ts
 var import_zod2 = require("zod");
+function alterSchema(schema, newShape) {
+  if (schema.description) {
+    newShape = newShape.describe(schema.description);
+  }
+  return newShape;
+}
 function fixSchema(schema) {
   if ("unwrap" in schema && typeof schema.unwrap === "function") {
     switch (schema._zod.def.type) {
       case "nullable":
-        return fixSchema(schema.unwrap()).nullable();
+        return alterSchema(schema, fixSchema(schema.unwrap()).nullable());
       case "optional":
-        return fixSchema(schema.unwrap()).optional();
+        return alterSchema(schema, fixSchema(schema.unwrap()).optional());
       case "readonly":
-        return fixSchema(schema.unwrap()).readonly();
+        return alterSchema(schema, fixSchema(schema.unwrap()).readonly());
       case "array":
-        return fixSchema(schema.unwrap()).array();
+        return alterSchema(schema, fixSchema(schema.unwrap()).array());
       default:
         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") {
-    return import_zod2.z.iso.datetime();
+    return alterSchema(schema, import_zod2.z.iso.datetime());
   }
   if (schema._zod.def.type === "object") {
     const { shape } = schema;
     const entries = Object.entries(shape);
     const alteredEntries = entries.map(([propName, prop]) => [propName, fixSchema(prop)]);
     const newShape = Object.fromEntries(alteredEntries);
-    return import_zod2.z.object(newShape);
+    return alterSchema(schema, import_zod2.z.object(newShape));
   }
   return schema;
 }
@@ -336,128 +340,12 @@ function convertToOpenAPI(schema, isArray) {
   return import_zod2.z.toJSONSchema(fixSchema(isArray ? schema.array() : schema));
 }
 
-// src/core/mask.ts
-function maskWithReference(schema, storedSchemas, self) {
-  if (self) {
-    for (const [schemaName, zodSchema] of Object.entries(storedSchemas)) {
-      if (deepEqual(schema, convertToOpenAPI(zodSchema, false))) {
-        return {
-          $ref: `#/components/schemas/${schemaName}`
-        };
-      }
-    }
-  }
-  if ("$ref" in schema) return schema;
-  if (schema.oneOf) {
-    return {
-      ...schema,
-      oneOf: schema.oneOf.map((i) => maskWithReference(i, storedSchemas, true))
-    };
-  }
-  if (schema.anyOf) {
-    return {
-      ...schema,
-      anyOf: schema.anyOf.map((i) => maskWithReference(i, storedSchemas, true))
-    };
-  }
-  switch (schema.type) {
-    case "object":
-      return {
-        ...schema,
-        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))
-        };
-      }
-      return {
-        ...schema,
-        items: maskWithReference(schema.items, storedSchemas, true)
-      };
-  }
-  return schema;
-}
-
-// src/core/operation-mask.ts
-function maskSchema(storedSchemas, schema) {
-  if (!schema) return schema;
-  return maskWithReference(schema, storedSchemas, true);
-}
-function maskParameterSchema(param, storedSchemas) {
-  if ("$ref" in param) return param;
-  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)
-    }
-  }), {});
-}
-function maskRequestBodySchema(storedSchemas, body) {
-  if (!body || "$ref" in body) return body;
-  return { ...body, content: maskContentSchema(storedSchemas, body.content) };
-}
-function maskResponseSchema(storedSchemas, response) {
-  if ("$ref" in response) return response;
-  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)
-  }), {});
-}
-function maskOperationSchemas(operation, storedSchemas) {
-  return {
-    ...operation,
-    parameters: operation.parameters?.map((p) => maskParameterSchema(p, storedSchemas)),
-    requestBody: maskRequestBodySchema(storedSchemas, operation.requestBody),
-    responses: maskSchemasInResponses(storedSchemas, operation.responses)
-  };
-}
-
-// src/core/route.ts
-function createRouteRecord(method, filePath, rootPath, apiData) {
-  return {
-    method: method.toLocaleLowerCase(),
-    path: getRoutePathName(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)
-    }
-  }), {});
-}
-
 // 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 entries = Object.entries(schemas).map(([schemaName, schema]) => {
+    return [schemaName, convertToOpenAPI(schema, false)];
+  });
+  return Object.fromEntries(entries);
 }
 
 // src/core/generateOpenApiSpec.ts
@@ -495,13 +383,13 @@ async function generateOpenApiSpec(schemas, {
   }
   const metadata = (0, import_package_metadata.default)();
   const pathsAndComponents = {
-    paths: bundlePaths(validRoutes, schemas),
+    paths: bundlePaths(validRoutes),
     components: {
       schemas: bundleSchemas(schemas),
       securitySchemes
     }
   };
-  return JSON.parse(JSON.stringify({
+  const spec = JSON.parse(JSON.stringify({
     openapi: "3.1.0",
     info: {
       title: metadata.serviceName,
@@ -513,6 +401,7 @@ async function generateOpenApiSpec(schemas, {
     security,
     tags: []
   }));
+  return (0, import_openapi_optimizer.optimizeOpenApiSpec)(spec);
 }
 
 // src/index.ts

package/dist/index.js

@@ -7,6 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/core/generateOpenApiSpec.ts
 import path4 from "path";
+import { optimizeOpenApiSpec } from "@omer-x/openapi-optimizer";
 import getPackageMetadata from "@omer-x/package-metadata";
 
 // src/utils/object.ts
@@ -252,54 +253,57 @@ function getRoutePathName(filePath, rootPath) {
   return "/" + path3.relative(rootPath, dirName).replaceAll("[", "{").replaceAll("]", "}").replaceAll("\\", "/");
 }
 
-// src/utils/deepEqual.ts
-function deepEqual(a, b) {
-  if (typeof a !== typeof b) return false;
-  switch (typeof a) {
-    case "object": {
-      if (!a || !b) return a === b;
-      if (Array.isArray(a) && Array.isArray(b)) {
-        return a.every((item, index) => deepEqual(item, b[index]));
-      }
-      if (Object.keys(a).length !== Object.keys(b).length) return false;
-      return Object.entries(a).every(([key, value]) => {
-        return deepEqual(value, b[key]);
-      });
+// src/core/route.ts
+function createRouteRecord(method, filePath, rootPath, apiData) {
+  return {
+    method: method.toLocaleLowerCase(),
+    path: getRoutePathName(filePath, rootPath),
+    apiData
+  };
+}
+function bundlePaths(source) {
+  source.sort((a, b) => a.path.localeCompare(b.path));
+  return source.reduce((collection, route) => ({
+    ...collection,
+    [route.path]: {
+      ...collection[route.path],
+      [route.method]: route.apiData
     }
-    case "function":
-    case "symbol":
-      return false;
-    default:
-      return a === b;
-  }
+  }), {});
 }
 
 // src/core/zod-to-openapi.ts
 import { z as z2 } from "zod";
+function alterSchema(schema, newShape) {
+  if (schema.description) {
+    newShape = newShape.describe(schema.description);
+  }
+  return newShape;
+}
 function fixSchema(schema) {
   if ("unwrap" in schema && typeof schema.unwrap === "function") {
     switch (schema._zod.def.type) {
       case "nullable":
-        return fixSchema(schema.unwrap()).nullable();
+        return alterSchema(schema, fixSchema(schema.unwrap()).nullable());
       case "optional":
-        return fixSchema(schema.unwrap()).optional();
+        return alterSchema(schema, fixSchema(schema.unwrap()).optional());
       case "readonly":
-        return fixSchema(schema.unwrap()).readonly();
+        return alterSchema(schema, fixSchema(schema.unwrap()).readonly());
       case "array":
-        return fixSchema(schema.unwrap()).array();
+        return alterSchema(schema, fixSchema(schema.unwrap()).array());
       default:
         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") {
-    return z2.iso.datetime();
+    return alterSchema(schema, z2.iso.datetime());
   }
   if (schema._zod.def.type === "object") {
     const { shape } = schema;
     const entries = Object.entries(shape);
     const alteredEntries = entries.map(([propName, prop]) => [propName, fixSchema(prop)]);
     const newShape = Object.fromEntries(alteredEntries);
-    return z2.object(newShape);
+    return alterSchema(schema, z2.object(newShape));
   }
   return schema;
 }
@@ -307,128 +311,12 @@ function convertToOpenAPI(schema, isArray) {
   return z2.toJSONSchema(fixSchema(isArray ? schema.array() : schema));
 }
 
-// src/core/mask.ts
-function maskWithReference(schema, storedSchemas, self) {
-  if (self) {
-    for (const [schemaName, zodSchema] of Object.entries(storedSchemas)) {
-      if (deepEqual(schema, convertToOpenAPI(zodSchema, false))) {
-        return {
-          $ref: `#/components/schemas/${schemaName}`
-        };
-      }
-    }
-  }
-  if ("$ref" in schema) return schema;
-  if (schema.oneOf) {
-    return {
-      ...schema,
-      oneOf: schema.oneOf.map((i) => maskWithReference(i, storedSchemas, true))
-    };
-  }
-  if (schema.anyOf) {
-    return {
-      ...schema,
-      anyOf: schema.anyOf.map((i) => maskWithReference(i, storedSchemas, true))
-    };
-  }
-  switch (schema.type) {
-    case "object":
-      return {
-        ...schema,
-        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))
-        };
-      }
-      return {
-        ...schema,
-        items: maskWithReference(schema.items, storedSchemas, true)
-      };
-  }
-  return schema;
-}
-
-// src/core/operation-mask.ts
-function maskSchema(storedSchemas, schema) {
-  if (!schema) return schema;
-  return maskWithReference(schema, storedSchemas, true);
-}
-function maskParameterSchema(param, storedSchemas) {
-  if ("$ref" in param) return param;
-  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)
-    }
-  }), {});
-}
-function maskRequestBodySchema(storedSchemas, body) {
-  if (!body || "$ref" in body) return body;
-  return { ...body, content: maskContentSchema(storedSchemas, body.content) };
-}
-function maskResponseSchema(storedSchemas, response) {
-  if ("$ref" in response) return response;
-  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)
-  }), {});
-}
-function maskOperationSchemas(operation, storedSchemas) {
-  return {
-    ...operation,
-    parameters: operation.parameters?.map((p) => maskParameterSchema(p, storedSchemas)),
-    requestBody: maskRequestBodySchema(storedSchemas, operation.requestBody),
-    responses: maskSchemasInResponses(storedSchemas, operation.responses)
-  };
-}
-
-// src/core/route.ts
-function createRouteRecord(method, filePath, rootPath, apiData) {
-  return {
-    method: method.toLocaleLowerCase(),
-    path: getRoutePathName(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)
-    }
-  }), {});
-}
-
 // 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 entries = Object.entries(schemas).map(([schemaName, schema]) => {
+    return [schemaName, convertToOpenAPI(schema, false)];
+  });
+  return Object.fromEntries(entries);
 }
 
 // src/core/generateOpenApiSpec.ts
@@ -466,13 +354,13 @@ async function generateOpenApiSpec(schemas, {
   }
   const metadata = getPackageMetadata();
   const pathsAndComponents = {
-    paths: bundlePaths(validRoutes, schemas),
+    paths: bundlePaths(validRoutes),
     components: {
       schemas: bundleSchemas(schemas),
       securitySchemes
     }
   };
-  return JSON.parse(JSON.stringify({
+  const spec = JSON.parse(JSON.stringify({
     openapi: "3.1.0",
     info: {
       title: metadata.serviceName,
@@ -484,6 +372,7 @@ async function generateOpenApiSpec(schemas, {
     security,
     tags: []
   }));
+  return optimizeOpenApiSpec(spec);
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omer-x/next-openapi-json-generator",
-  "version": "2.0.3",
+  "version": "2.1.0-rc.2",
   "description": "a Next.js plugin to generate OpenAPI documentation from route handlers",
   "keywords": [
     "next.js",
@@ -40,6 +40,8 @@
     }
   },
   "scripts": {
+    "lint": "eslint --flag unstable_native_nodejs_ts_config",
+    "lint:fix": "eslint --fix --flag unstable_native_nodejs_ts_config",
     "test": "vitest run --coverage",
     "test:watch": "vitest --coverage",
     "dev": "tsup --watch",
@@ -48,20 +50,21 @@
   "peerDependencies": {
     "@omer-x/next-openapi-route-handler": "^2",
     "@omer-x/openapi-types": "^1",
-    "zod": "^4",
-    "typescript": "^5"
+    "typescript": "^5",
+    "zod": "^4"
   },
   "dependencies": {
+    "@omer-x/openapi-optimizer": "alpha",
     "@omer-x/package-metadata": "^1.0.2",
     "minimatch": "^10.1.1"
   },
   "devDependencies": {
     "@omer-x/eslint-config": "^2.2.6",
-    "@types/node": "^25.0.1",
-    "@vitest/coverage-v8": "^4.0.15",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
     "eslint": "^9.39.2",
     "semantic-release": "^25.0.2",
     "tsup": "^8.5.1",
-    "vitest": "^4.0.15"
+    "vitest": "^4.0.16"
   }
 }