@alt-stack/zod-openapi 1.1.2 → 1.1.3

package/dist/index.js

@@ -108,6 +108,87 @@ function topologicalSortSchemas(schemas) {
   return sorted;
 }
 
+// src/schema-dedup.ts
+function sortObjectDeep(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(sortObjectDeep);
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = sortObjectDeep(obj[key]);
+  }
+  return sorted;
+}
+function getSchemaFingerprint(schema) {
+  return JSON.stringify(sortObjectDeep(schema));
+}
+function createSchemaRegistry() {
+  return {
+    fingerprintToName: /* @__PURE__ */ new Map(),
+    nameToFingerprint: /* @__PURE__ */ new Map()
+  };
+}
+function registerSchema(registry, name, schema) {
+  const fingerprint = getSchemaFingerprint(schema);
+  const existing = registry.fingerprintToName.get(fingerprint);
+  if (existing) {
+    return { isNew: false, canonicalName: existing };
+  }
+  registry.fingerprintToName.set(fingerprint, name);
+  registry.nameToFingerprint.set(name, fingerprint);
+  return { isNew: true, canonicalName: name };
+}
+function preRegisterSchema(registry, name, fingerprint) {
+  registry.fingerprintToName.set(fingerprint, name);
+  registry.nameToFingerprint.set(name, fingerprint);
+}
+function extractErrorCode(schema) {
+  const properties = schema?.["properties"];
+  const errorObj = properties?.["error"];
+  const errorProps = errorObj?.["properties"];
+  const codeSchema = errorProps?.["code"];
+  const codeEnum = codeSchema?.["enum"];
+  if (Array.isArray(codeEnum) && codeEnum.length === 1) {
+    return codeEnum[0];
+  }
+  return null;
+}
+function errorCodeToPascalCase(code) {
+  return code.split("_").map((part) => part.charAt(0) + part.slice(1).toLowerCase()).join("");
+}
+function generateCommonErrorSchemaName(errorCode) {
+  return `${errorCodeToPascalCase(errorCode)}ErrorSchema`;
+}
+function findCommonSchemas(schemas, minCount = 2) {
+  const fingerprints = /* @__PURE__ */ new Map();
+  for (const { name, schema } of schemas) {
+    const fingerprint = getSchemaFingerprint(schema);
+    const existing = fingerprints.get(fingerprint);
+    if (existing) {
+      existing.names.push(name);
+    } else {
+      fingerprints.set(fingerprint, {
+        schema,
+        names: [name],
+        errorCode: extractErrorCode(schema)
+      });
+    }
+  }
+  const commonSchemas = [];
+  for (const [fingerprint, data] of fingerprints) {
+    if (data.names.length >= minCount) {
+      const name = data.errorCode ? generateCommonErrorSchemaName(data.errorCode) : data.names[0];
+      commonSchemas.push({
+        name,
+        schema: data.schema,
+        fingerprint,
+        count: data.names.length
+      });
+    }
+  }
+  return commonSchemas.sort((a, b) => b.count - a.count);
+}
+
 // src/types/boolean.ts
 function convertOpenAPIBooleanToZod(_) {
   return "z.boolean()";
@@ -606,34 +687,64 @@ function generateRouteSchemaName2(path, method, suffix) {
   const parts = [methodPrefix, ...pathParts, suffix];
   return parts.join("");
 }
-function generateRouteSchemas(routes, convertSchema) {
-  const lines = [];
-  const schemaNames = /* @__PURE__ */ new Set();
+function generateRouteSchemas(routes, convertSchema, registry) {
+  const declarations = [];
+  const schemaNameToCanonical = /* @__PURE__ */ new Map();
+  const generatedNames = /* @__PURE__ */ new Set();
   for (const route of routes) {
     const names = generateRouteSchemaNames(route);
     const pathParams = route.parameters.filter((p) => p.in === "path");
     const queryParams = route.parameters.filter((p) => p.in === "query");
     const headerParams = route.parameters.filter((p) => p.in === "header");
     if (names.paramsSchemaName && pathParams.length > 0) {
-      if (!schemaNames.has(names.paramsSchemaName)) {
-        schemaNames.add(names.paramsSchemaName);
+      const paramsSchema = {
+        type: "object",
+        properties: Object.fromEntries(
+          pathParams.map((p) => [p.name, p.schema])
+        ),
+        required: pathParams.filter((p) => p.required).map((p) => p.name)
+      };
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.paramsSchemaName,
+        paramsSchema
+      );
+      schemaNameToCanonical.set(names.paramsSchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.paramsSchemaName)) {
+        generatedNames.add(names.paramsSchemaName);
         const properties = [];
-        const required = [];
         for (const param of pathParams) {
           const zodExpr = convertSchema(param.schema);
           properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
-          if (param.required) {
-            required.push(param.name);
-          }
         }
-        lines.push(
+        declarations.push(
           `export const ${names.paramsSchemaName} = z.object({ ${properties.join(", ")} });`
         );
+      } else if (!isNew && names.paramsSchemaName !== canonicalName) {
+        if (!generatedNames.has(names.paramsSchemaName)) {
+          generatedNames.add(names.paramsSchemaName);
+          declarations.push(
+            `export const ${names.paramsSchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     if (names.querySchemaName && queryParams.length > 0) {
-      if (!schemaNames.has(names.querySchemaName)) {
-        schemaNames.add(names.querySchemaName);
+      const querySchema = {
+        type: "object",
+        properties: Object.fromEntries(
+          queryParams.map((p) => [p.name, p.schema])
+        ),
+        required: queryParams.filter((p) => p.required).map((p) => p.name)
+      };
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.querySchemaName,
+        querySchema
+      );
+      schemaNameToCanonical.set(names.querySchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.querySchemaName)) {
+        generatedNames.add(names.querySchemaName);
         const properties = [];
         for (const param of queryParams) {
           let zodExpr = convertSchema(param.schema);
@@ -642,14 +753,34 @@ function generateRouteSchemas(routes, convertSchema) {
           }
           properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
         }
-        lines.push(
+        declarations.push(
           `export const ${names.querySchemaName} = z.object({ ${properties.join(", ")} });`
         );
+      } else if (!isNew && names.querySchemaName !== canonicalName) {
+        if (!generatedNames.has(names.querySchemaName)) {
+          generatedNames.add(names.querySchemaName);
+          declarations.push(
+            `export const ${names.querySchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     if (names.headersSchemaName && headerParams.length > 0) {
-      if (!schemaNames.has(names.headersSchemaName)) {
-        schemaNames.add(names.headersSchemaName);
+      const headersSchema = {
+        type: "object",
+        properties: Object.fromEntries(
+          headerParams.map((p) => [p.name, p.schema])
+        ),
+        required: headerParams.filter((p) => p.required).map((p) => p.name)
+      };
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.headersSchemaName,
+        headersSchema
+      );
+      schemaNameToCanonical.set(names.headersSchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.headersSchemaName)) {
+        generatedNames.add(names.headersSchemaName);
         const properties = [];
         for (const param of headerParams) {
           let zodExpr = convertSchema(param.schema);
@@ -658,16 +789,36 @@ function generateRouteSchemas(routes, convertSchema) {
           }
           properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
         }
-        lines.push(
+        declarations.push(
           `export const ${names.headersSchemaName} = z.object({ ${properties.join(", ")} });`
         );
+      } else if (!isNew && names.headersSchemaName !== canonicalName) {
+        if (!generatedNames.has(names.headersSchemaName)) {
+          generatedNames.add(names.headersSchemaName);
+          declarations.push(
+            `export const ${names.headersSchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     if (names.bodySchemaName && route.requestBody) {
-      if (!schemaNames.has(names.bodySchemaName)) {
-        schemaNames.add(names.bodySchemaName);
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.bodySchemaName,
+        route.requestBody
+      );
+      schemaNameToCanonical.set(names.bodySchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.bodySchemaName)) {
+        generatedNames.add(names.bodySchemaName);
         const zodExpr = convertSchema(route.requestBody);
-        lines.push(`export const ${names.bodySchemaName} = ${zodExpr};`);
+        declarations.push(`export const ${names.bodySchemaName} = ${zodExpr};`);
+      } else if (!isNew && names.bodySchemaName !== canonicalName) {
+        if (!generatedNames.has(names.bodySchemaName)) {
+          generatedNames.add(names.bodySchemaName);
+          declarations.push(
+            `export const ${names.bodySchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     for (const [statusCode, responseSchema] of Object.entries(
@@ -681,19 +832,35 @@ function generateRouteSchemas(routes, convertSchema) {
         route.method,
         suffix
       );
-      if (!schemaNames.has(responseSchemaName)) {
-        schemaNames.add(responseSchemaName);
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        responseSchemaName,
+        responseSchema
+      );
+      schemaNameToCanonical.set(responseSchemaName, canonicalName);
+      if (isNew && !generatedNames.has(responseSchemaName)) {
+        generatedNames.add(responseSchemaName);
         const zodExpr = convertSchema(responseSchema);
-        lines.push(`export const ${responseSchemaName} = ${zodExpr};`);
+        declarations.push(`export const ${responseSchemaName} = ${zodExpr};`);
+      } else if (!isNew && responseSchemaName !== canonicalName) {
+        if (!generatedNames.has(responseSchemaName)) {
+          generatedNames.add(responseSchemaName);
+          declarations.push(
+            `export const ${responseSchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
   }
-  return lines;
+  return { declarations, schemaNameToCanonical };
 }
-function generateRequestResponseObjects(routes) {
+function generateRequestResponseObjects(routes, schemaNameToCanonical) {
   const lines = [];
   const requestPaths = {};
   const responsePaths = {};
+  const resolveSchemaName = (name) => {
+    return schemaNameToCanonical.get(name) ?? name;
+  };
   for (const route of routes) {
     const names = generateRouteSchemaNames(route);
     const pathParams = route.parameters.filter((p) => p.in === "path");
@@ -708,16 +875,20 @@ function generateRequestResponseObjects(routes) {
     }
     const requestParts = [];
     if (names.paramsSchemaName && pathParams.length > 0) {
-      requestParts.push(`params: ${names.paramsSchemaName}`);
+      requestParts.push(
+        `params: ${resolveSchemaName(names.paramsSchemaName)}`
+      );
     }
     if (names.querySchemaName && queryParams.length > 0) {
-      requestParts.push(`query: ${names.querySchemaName}`);
+      requestParts.push(`query: ${resolveSchemaName(names.querySchemaName)}`);
     }
     if (names.headersSchemaName && headerParams.length > 0) {
-      requestParts.push(`headers: ${names.headersSchemaName}`);
+      requestParts.push(
+        `headers: ${resolveSchemaName(names.headersSchemaName)}`
+      );
     }
     if (names.bodySchemaName && route.requestBody) {
-      requestParts.push(`body: ${names.bodySchemaName}`);
+      requestParts.push(`body: ${resolveSchemaName(names.bodySchemaName)}`);
     }
     if (requestParts.length > 0) {
       requestMethodObj[route.method] = requestParts;
@@ -740,7 +911,7 @@ function generateRequestResponseObjects(routes) {
         route.method,
         suffix
       );
-      responseMethodObj[route.method][statusCode] = responseSchemaName;
+      responseMethodObj[route.method][statusCode] = resolveSchemaName(responseSchemaName);
     }
   }
   lines.push("export const Request = {");
@@ -780,6 +951,25 @@ function generateRequestResponseObjects(routes) {
   lines.push("} as const;");
   return lines;
 }
+function collectRouteSchemas(routes) {
+  const collected = [];
+  for (const route of routes) {
+    for (const [statusCode, responseSchema] of Object.entries(
+      route.responses
+    )) {
+      if (!responseSchema) continue;
+      const isSuccess = statusCode.startsWith("2");
+      const suffix = isSuccess ? `${statusCode}Response` : `${statusCode}ErrorResponse`;
+      const responseSchemaName = generateRouteSchemaName2(
+        route.path,
+        route.method,
+        suffix
+      );
+      collected.push({ name: responseSchemaName, schema: responseSchema });
+    }
+  }
+  return collected;
+}
 var openApiToZodTsCode = (openapi, customImportLines, options) => {
   const components = openapi["components"];
   const schemas = components?.["schemas"] ?? {};
@@ -792,6 +982,7 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   lines.push("import { z } from 'zod';");
   lines.push(...customImportLines ?? []);
   lines.push("");
+  const registry = createSchemaRegistry();
   const sortedSchemaNames = topologicalSortSchemas(schemas);
   for (const name of sortedSchemaNames) {
     const schema = schemas[name];
@@ -802,19 +993,37 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
       lines.push(`export const ${schemaName} = ${zodExpr};`);
       lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
       lines.push("");
+      const fingerprint = getSchemaFingerprint(schema);
+      preRegisterSchema(registry, schemaName, fingerprint);
     }
   }
   if (options?.includeRoutes) {
     const routes = parseOpenApiPaths(openapi);
     if (routes.length > 0) {
-      const routeSchemas = generateRouteSchemas(
+      const routeSchemaList = collectRouteSchemas(routes);
+      const commonSchemas = findCommonSchemas(routeSchemaList, 2);
+      if (commonSchemas.length > 0) {
+        lines.push("// Common Error Schemas (deduplicated)");
+        for (const common of commonSchemas) {
+          const zodExpr = convertSchemaToZodString(common.schema);
+          lines.push(`export const ${common.name} = ${zodExpr};`);
+          preRegisterSchema(registry, common.name, common.fingerprint);
+        }
+        lines.push("");
+      }
+      const { declarations, schemaNameToCanonical } = generateRouteSchemas(
         routes,
-        convertSchemaToZodString
+        convertSchemaToZodString,
+        registry
       );
-      if (routeSchemas.length > 0) {
-        lines.push(...routeSchemas);
+      if (declarations.length > 0) {
+        lines.push("// Route Schemas");
+        lines.push(...declarations);
         lines.push("");
-        const requestResponseObjs = generateRequestResponseObjects(routes);
+        const requestResponseObjs = generateRequestResponseObjects(
+          routes,
+          schemaNameToCanonical
+        );
         lines.push(...requestResponseObjs);
       }
     }