@alt-stack/zod-openapi 1.1.3 → 1.3.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alt-stack/zod-openapi@1.1.3 build /home/runner/work/alt-stack/alt-stack/packages/zod-openapi
+> @alt-stack/zod-openapi@1.3.0 build /home/runner/work/alt-stack/alt-stack/packages/zod-openapi
 > tsup
 
 CLI Building entry: src/index.ts
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js     32.90 KB
-ESM dist/index.js.map 72.42 KB
-ESM ⚡️ Build success in 47ms
-CJS dist/index.cjs     34.44 KB
-CJS dist/index.cjs.map 73.28 KB
-CJS ⚡️ Build success in 47ms
+CJS dist/index.cjs     42.75 KB
+CJS dist/index.cjs.map 90.45 KB
+CJS ⚡️ Build success in 33ms
+ESM dist/index.js     41.13 KB
+ESM dist/index.js.map 89.49 KB
+ESM ⚡️ Build success in 33ms
 DTS Build start
-DTS ⚡️ Build success in 1504ms
-DTS dist/index.d.ts  4.83 KB
-DTS dist/index.d.cts 4.83 KB
+DTS ⚡️ Build success in 1429ms
+DTS dist/index.d.ts  6.06 KB
+DTS dist/index.d.cts 6.06 KB

package/dist/index.cjs

@@ -23,12 +23,14 @@ __export(index_exports, {
   SUPPORTED_STRING_FORMATS: () => SUPPORTED_STRING_FORMATS,
   clearZodSchemaToOpenApiSchemaRegistry: () => clearZodSchemaToOpenApiSchemaRegistry,
   convertSchemaToZodString: () => convertSchemaToZodString,
+  generateInterface: () => generateInterface,
   generateRouteSchemaNames: () => generateRouteSchemaNames,
   getSchemaExportedVariableNameForStringFormat: () => getSchemaExportedVariableNameForStringFormat,
   openApiToZodTsCode: () => openApiToZodTsCode,
   parseOpenApiPaths: () => parseOpenApiPaths,
   registerZodSchemaToOpenApiSchema: () => registerZodSchemaToOpenApiSchema,
-  schemaRegistry: () => schemaRegistry
+  schemaRegistry: () => schemaRegistry,
+  schemaToTypeString: () => schemaToTypeString
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -265,6 +267,9 @@ function isStringRegistration(reg) {
 function isStringsRegistration(reg) {
   return reg.type === "string" && "formats" in reg;
 }
+function isSupportedStringFormat(format) {
+  return Object.prototype.hasOwnProperty.call(SUPPORTED_STRING_FORMATS_MAP, format);
+}
 function getTypeFormatPairs(reg) {
   if (isStringRegistration(reg)) {
     return [{ type: "string", format: reg.format }];
@@ -315,6 +320,7 @@ var ZodSchemaRegistry = class {
    * Reverse-lookup helper: given a string format, return the registered schema's exported variable name
    */
   getSchemaExportedVariableNameForStringFormat(format) {
+    if (!isSupportedStringFormat(format)) return void 0;
     for (const registration of this.map.values()) {
       if (registration.type !== "string") continue;
       if (isStringRegistration(registration) && registration.format === format) {
@@ -326,6 +332,17 @@ var ZodSchemaRegistry = class {
     }
     return void 0;
   }
+  /**
+   * Reverse-lookup helper: given a primitive type, return the registered schema's exported variable name
+   */
+  getSchemaExportedVariableNameForPrimitiveType(type) {
+    for (const registration of this.map.values()) {
+      if (registration.type === type) {
+        return registration.schemaExportedVariableName;
+      }
+    }
+    return void 0;
+  }
 };
 var schemaRegistry = new ZodSchemaRegistry();
 function registerZodSchemaToOpenApiSchema(schema, openApiSchema) {
@@ -334,6 +351,9 @@ function registerZodSchemaToOpenApiSchema(schema, openApiSchema) {
 function getSchemaExportedVariableNameForStringFormat(format) {
   return schemaRegistry.getSchemaExportedVariableNameForStringFormat(format);
 }
+function getSchemaExportedVariableNameForPrimitiveType(type) {
+  return schemaRegistry.getSchemaExportedVariableNameForPrimitiveType(type);
+}
 function clearZodSchemaToOpenApiSchemaRegistry() {
   schemaRegistry.clear();
 }
@@ -703,11 +723,188 @@ function generateRouteSchemaNames(route) {
   return result;
 }
 
-// src/to-typescript.ts
+// src/interface-generator.ts
 var validIdentifierRegex2 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 function quotePropertyName2(name) {
   return validIdentifierRegex2.test(name) ? name : `'${name}'`;
 }
+function toPascalCase2(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9]/g, " ").split(" ").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function schemaExportNameToOutputAlias(name) {
+  return `${toPascalCase2(name)}Output`;
+}
+function registerOutputSchemaName(schemaName, options) {
+  options?.outputSchemaNames?.add(schemaName);
+  return schemaExportNameToOutputAlias(schemaName);
+}
+function getRegisteredOutputAlias(schema, options) {
+  if (!schema || typeof schema !== "object") return void 0;
+  if (schema["type"] === "string" && typeof schema["format"] === "string") {
+    const customSchemaName = getSchemaExportedVariableNameForStringFormat(
+      schema["format"]
+    );
+    if (customSchemaName) {
+      return registerOutputSchemaName(customSchemaName, options);
+    }
+  }
+  if (schema["type"] === "number" || schema["type"] === "integer" || schema["type"] === "boolean") {
+    const customSchemaName = getSchemaExportedVariableNameForPrimitiveType(
+      schema["type"]
+    );
+    if (customSchemaName) {
+      return registerOutputSchemaName(customSchemaName, options);
+    }
+  }
+  return void 0;
+}
+function schemaToTypeString(schema, options) {
+  if (!schema || typeof schema !== "object") return "unknown";
+  if (schema["$ref"] && typeof schema["$ref"] === "string") {
+    const match = schema["$ref"].match(
+      /#\/components\/schemas\/(.+)/
+    );
+    let result2 = "unknown";
+    if (match && match[1]) {
+      result2 = decodeURIComponent(match[1]);
+    }
+    if (schema["nullable"] === true) {
+      result2 = `(${result2} | null)`;
+    }
+    return result2;
+  }
+  let result = "unknown";
+  if ("oneOf" in schema && Array.isArray(schema["oneOf"])) {
+    const unionMembers = schema["oneOf"].map(
+      (s) => schemaToTypeString(s, options)
+    );
+    result = unionMembers.length > 1 ? `(${unionMembers.join(" | ")})` : unionMembers[0] ?? "unknown";
+  } else if ("allOf" in schema && Array.isArray(schema["allOf"])) {
+    const intersectionMembers = schema["allOf"].map(
+      (s) => schemaToTypeString(s, options)
+    );
+    result = intersectionMembers.length > 1 ? `(${intersectionMembers.join(" & ")})` : intersectionMembers[0] ?? "unknown";
+  } else if ("anyOf" in schema && Array.isArray(schema["anyOf"])) {
+    const unionMembers = schema["anyOf"].map(
+      (s) => schemaToTypeString(s, options)
+    );
+    result = unionMembers.length > 1 ? `(${unionMembers.join(" | ")})` : unionMembers[0] ?? "unknown";
+  } else {
+    switch (schema["type"]) {
+      case "string": {
+        const registeredAlias = getRegisteredOutputAlias(schema, options);
+        if (registeredAlias) {
+          result = registeredAlias;
+        } else if (schema["enum"] && Array.isArray(schema["enum"])) {
+          result = schema["enum"].map((v) => JSON.stringify(v)).join(" | ");
+        } else {
+          result = "string";
+        }
+        break;
+      }
+      case "number":
+      case "integer": {
+        const registeredAlias = getRegisteredOutputAlias(schema, options);
+        if (registeredAlias) {
+          result = registeredAlias;
+        } else if (schema["enum"] && Array.isArray(schema["enum"])) {
+          result = schema["enum"].map((v) => String(v)).join(" | ");
+        } else {
+          result = "number";
+        }
+        break;
+      }
+      case "boolean":
+        result = getRegisteredOutputAlias(schema, options) ?? "boolean";
+        break;
+      case "null":
+        result = "null";
+        break;
+      case "array":
+        if (schema["items"]) {
+          const itemType = schemaToTypeString(schema["items"], options);
+          result = `Array<${itemType}>`;
+        } else {
+          result = "unknown[]";
+        }
+        break;
+      case "object":
+        result = objectSchemaToTypeString(schema, options);
+        break;
+      default:
+        if (schema["properties"]) {
+          result = objectSchemaToTypeString(schema, options);
+        } else if (schema["enum"] && Array.isArray(schema["enum"])) {
+          result = schema["enum"].map((v) => JSON.stringify(v)).join(" | ");
+        } else {
+          result = "unknown";
+        }
+        break;
+    }
+  }
+  if (schema["nullable"] === true) {
+    result = `(${result} | null)`;
+  }
+  return result;
+}
+function objectSchemaToTypeString(schema, options) {
+  const properties = schema["properties"];
+  const required = new Set(schema["required"] ?? []);
+  const additionalProperties = schema["additionalProperties"];
+  if (!properties && !additionalProperties) {
+    return "Record<string, unknown>";
+  }
+  const propertyStrings = [];
+  if (properties) {
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.has(propName);
+      const propType = schemaToTypeString(propSchema, options);
+      const quotedName = quotePropertyName2(propName);
+      propertyStrings.push(
+        `${quotedName}${isRequired ? "" : "?"}: ${propType}`
+      );
+    }
+  }
+  if (additionalProperties === true) {
+    propertyStrings.push("[key: string]: unknown");
+  } else if (typeof additionalProperties === "object" && additionalProperties !== null) {
+    const additionalType = schemaToTypeString(additionalProperties, options);
+    propertyStrings.push(`[key: string]: ${additionalType}`);
+  }
+  return `{ ${propertyStrings.join("; ")} }`;
+}
+function generateInterface(name, schema, options) {
+  const properties = schema["properties"];
+  const required = new Set(schema["required"] ?? []);
+  if (schema["type"] !== "object" && !properties) {
+    return `export type ${name} = ${schemaToTypeString(schema, options)};`;
+  }
+  const lines = [];
+  lines.push(`export interface ${name} {`);
+  if (properties) {
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.has(propName);
+      const propType = schemaToTypeString(propSchema, options);
+      const quotedName = quotePropertyName2(propName);
+      lines.push(`  ${quotedName}${isRequired ? "" : "?"}: ${propType};`);
+    }
+  }
+  const additionalProperties = schema["additionalProperties"];
+  if (additionalProperties === true) {
+    lines.push("  [key: string]: unknown;");
+  } else if (typeof additionalProperties === "object" && additionalProperties !== null) {
+    const additionalType = schemaToTypeString(additionalProperties, options);
+    lines.push(`  [key: string]: ${additionalType};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/to-typescript.ts
+var validIdentifierRegex3 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function quotePropertyName3(name) {
+  return validIdentifierRegex3.test(name) ? name : `'${name}'`;
+}
 function generateRouteSchemaName2(path, method, suffix) {
   const pathParts = path.split("/").filter((p) => p).map((p) => {
     if (p.startsWith("{") && p.endsWith("}")) {
@@ -749,7 +946,7 @@ function generateRouteSchemas(routes, convertSchema, registry) {
         const properties = [];
         for (const param of pathParams) {
           const zodExpr = convertSchema(param.schema);
-          properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
+          properties.push(`${quotePropertyName3(param.name)}: ${zodExpr}`);
         }
         declarations.push(
           `export const ${names.paramsSchemaName} = z.object({ ${properties.join(", ")} });`
@@ -785,7 +982,7 @@ function generateRouteSchemas(routes, convertSchema, registry) {
           if (!param.required) {
             zodExpr += ".optional()";
           }
-          properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
+          properties.push(`${quotePropertyName3(param.name)}: ${zodExpr}`);
         }
         declarations.push(
           `export const ${names.querySchemaName} = z.object({ ${properties.join(", ")} });`
@@ -821,7 +1018,7 @@ function generateRouteSchemas(routes, convertSchema, registry) {
           if (!param.required) {
             zodExpr += ".optional()";
           }
-          properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
+          properties.push(`${quotePropertyName3(param.name)}: ${zodExpr}`);
         }
         declarations.push(
           `export const ${names.headersSchemaName} = z.object({ ${properties.join(", ")} });`
@@ -1016,21 +1213,42 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   lines.push("import { z } from 'zod';");
   lines.push(...customImportLines ?? []);
   lines.push("");
+  lines.push("// Type assertion helper - verifies interface matches schema at compile time");
+  lines.push("type _AssertEqual<T, U> = [T] extends [U] ? ([U] extends [T] ? true : never) : never;");
+  lines.push("");
   const registry = createSchemaRegistry();
   const sortedSchemaNames = topologicalSortSchemas(schemas);
+  const typeAssertions = [];
+  const outputSchemaNames = /* @__PURE__ */ new Set();
+  const schemaBlocks = [];
   for (const name of sortedSchemaNames) {
     const schema = schemas[name];
     if (schema) {
       const zodExpr = convertSchemaToZodString(schema);
       const schemaName = `${name}Schema`;
       const typeName = name;
-      lines.push(`export const ${schemaName} = ${zodExpr};`);
-      lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
-      lines.push("");
+      schemaBlocks.push(generateInterface(typeName, schema, { outputSchemaNames }));
+      schemaBlocks.push(`export const ${schemaName}: z.ZodType<${typeName}> = ${zodExpr};`);
+      schemaBlocks.push("");
+      typeAssertions.push(`type _Assert${typeName} = _AssertEqual<${typeName}, z.infer<typeof ${schemaName}>>;`);
       const fingerprint = getSchemaFingerprint(schema);
       preRegisterSchema(registry, schemaName, fingerprint);
     }
   }
+  if (outputSchemaNames.size > 0) {
+    lines.push("// Zod output aliases for registered schemas");
+    for (const schemaName of outputSchemaNames) {
+      const aliasName = schemaExportNameToOutputAlias(schemaName);
+      lines.push(`type ${aliasName} = z.output<typeof ${schemaName}>;`);
+    }
+    lines.push("");
+  }
+  lines.push(...schemaBlocks);
+  if (typeAssertions.length > 0) {
+    lines.push("// Compile-time type assertions - ensure interfaces match schemas");
+    lines.push(typeAssertions.join("\n"));
+    lines.push("");
+  }
   if (options?.includeRoutes) {
     const routes = parseOpenApiPaths(openapi);
     if (routes.length > 0) {
@@ -1069,11 +1287,13 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   SUPPORTED_STRING_FORMATS,
   clearZodSchemaToOpenApiSchemaRegistry,
   convertSchemaToZodString,
+  generateInterface,
   generateRouteSchemaNames,
   getSchemaExportedVariableNameForStringFormat,
   openApiToZodTsCode,
   parseOpenApiPaths,
   registerZodSchemaToOpenApiSchema,
-  schemaRegistry
+  schemaRegistry,
+  schemaToTypeString
 });
 //# sourceMappingURL=index.cjs.map