@alt-stack/zod-openapi 1.2.0 → 1.3.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alt-stack/zod-openapi@1.2.0 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     38.35 KB
-ESM dist/index.js.map 84.13 KB
-ESM ⚡️ Build success in 32ms
-CJS dist/index.cjs     39.98 KB
-CJS dist/index.cjs.map 85.09 KB
+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 1497ms
-DTS dist/index.d.ts  5.68 KB
-DTS dist/index.d.cts 5.68 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

@@ -267,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 }];
@@ -317,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) {
@@ -328,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) {
@@ -336,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();
 }
@@ -710,7 +728,37 @@ var validIdentifierRegex2 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 function quotePropertyName2(name) {
   return validIdentifierRegex2.test(name) ? name : `'${name}'`;
 }
-function schemaToTypeString(schema) {
+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(
@@ -728,56 +776,64 @@ function schemaToTypeString(schema) {
   let result = "unknown";
   if ("oneOf" in schema && Array.isArray(schema["oneOf"])) {
     const unionMembers = schema["oneOf"].map(
-      (s) => schemaToTypeString(s)
+      (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)
+      (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)
+      (s) => schemaToTypeString(s, options)
     );
     result = unionMembers.length > 1 ? `(${unionMembers.join(" | ")})` : unionMembers[0] ?? "unknown";
   } else {
     switch (schema["type"]) {
-      case "string":
-        if (schema["enum"] && Array.isArray(schema["enum"])) {
+      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":
-        if (schema["enum"] && Array.isArray(schema["enum"])) {
+      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 = "boolean";
+        result = getRegisteredOutputAlias(schema, options) ?? "boolean";
         break;
       case "null":
         result = "null";
         break;
       case "array":
         if (schema["items"]) {
-          const itemType = schemaToTypeString(schema["items"]);
+          const itemType = schemaToTypeString(schema["items"], options);
           result = `Array<${itemType}>`;
         } else {
           result = "unknown[]";
         }
         break;
       case "object":
-        result = objectSchemaToTypeString(schema);
+        result = objectSchemaToTypeString(schema, options);
         break;
       default:
         if (schema["properties"]) {
-          result = objectSchemaToTypeString(schema);
+          result = objectSchemaToTypeString(schema, options);
         } else if (schema["enum"] && Array.isArray(schema["enum"])) {
           result = schema["enum"].map((v) => JSON.stringify(v)).join(" | ");
         } else {
@@ -791,7 +847,7 @@ function schemaToTypeString(schema) {
   }
   return result;
 }
-function objectSchemaToTypeString(schema) {
+function objectSchemaToTypeString(schema, options) {
   const properties = schema["properties"];
   const required = new Set(schema["required"] ?? []);
   const additionalProperties = schema["additionalProperties"];
@@ -802,7 +858,7 @@ function objectSchemaToTypeString(schema) {
   if (properties) {
     for (const [propName, propSchema] of Object.entries(properties)) {
       const isRequired = required.has(propName);
-      const propType = schemaToTypeString(propSchema);
+      const propType = schemaToTypeString(propSchema, options);
       const quotedName = quotePropertyName2(propName);
       propertyStrings.push(
         `${quotedName}${isRequired ? "" : "?"}: ${propType}`
@@ -812,23 +868,23 @@ function objectSchemaToTypeString(schema) {
   if (additionalProperties === true) {
     propertyStrings.push("[key: string]: unknown");
   } else if (typeof additionalProperties === "object" && additionalProperties !== null) {
-    const additionalType = schemaToTypeString(additionalProperties);
+    const additionalType = schemaToTypeString(additionalProperties, options);
     propertyStrings.push(`[key: string]: ${additionalType}`);
   }
   return `{ ${propertyStrings.join("; ")} }`;
 }
-function generateInterface(name, schema) {
+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)};`;
+    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);
+      const propType = schemaToTypeString(propSchema, options);
       const quotedName = quotePropertyName2(propName);
       lines.push(`  ${quotedName}${isRequired ? "" : "?"}: ${propType};`);
     }
@@ -837,7 +893,7 @@ function generateInterface(name, schema) {
   if (additionalProperties === true) {
     lines.push("  [key: string]: unknown;");
   } else if (typeof additionalProperties === "object" && additionalProperties !== null) {
-    const additionalType = schemaToTypeString(additionalProperties);
+    const additionalType = schemaToTypeString(additionalProperties, options);
     lines.push(`  [key: string]: ${additionalType};`);
   }
   lines.push("}");
@@ -1163,20 +1219,31 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   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(generateInterface(typeName, schema));
-      lines.push(`export const ${schemaName}: z.ZodType<${typeName}> = ${zodExpr};`);
-      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"));