@alt-stack/zod-openapi 1.1.3 → 1.2.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.2.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
+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 ⚡️ 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 1497ms
+DTS dist/index.d.ts  5.68 KB
+DTS dist/index.d.cts 5.68 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);
 
@@ -703,11 +705,150 @@ 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 schemaToTypeString(schema) {
+  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)
+    );
+    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)
+    );
+    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)
+    );
+    result = unionMembers.length > 1 ? `(${unionMembers.join(" | ")})` : unionMembers[0] ?? "unknown";
+  } else {
+    switch (schema["type"]) {
+      case "string":
+        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"])) {
+          result = schema["enum"].map((v) => String(v)).join(" | ");
+        } else {
+          result = "number";
+        }
+        break;
+      case "boolean":
+        result = "boolean";
+        break;
+      case "null":
+        result = "null";
+        break;
+      case "array":
+        if (schema["items"]) {
+          const itemType = schemaToTypeString(schema["items"]);
+          result = `Array<${itemType}>`;
+        } else {
+          result = "unknown[]";
+        }
+        break;
+      case "object":
+        result = objectSchemaToTypeString(schema);
+        break;
+      default:
+        if (schema["properties"]) {
+          result = objectSchemaToTypeString(schema);
+        } 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) {
+  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);
+      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);
+    propertyStrings.push(`[key: string]: ${additionalType}`);
+  }
+  return `{ ${propertyStrings.join("; ")} }`;
+}
+function generateInterface(name, schema) {
+  const properties = schema["properties"];
+  const required = new Set(schema["required"] ?? []);
+  if (schema["type"] !== "object" && !properties) {
+    return `export type ${name} = ${schemaToTypeString(schema)};`;
+  }
+  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 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);
+    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 +890,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 +926,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 +962,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 +1157,31 @@ 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 = [];
   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(generateInterface(typeName, schema));
+      lines.push(`export const ${schemaName}: z.ZodType<${typeName}> = ${zodExpr};`);
       lines.push("");
+      typeAssertions.push(`type _Assert${typeName} = _AssertEqual<${typeName}, z.infer<typeof ${schemaName}>>;`);
       const fingerprint = getSchemaFingerprint(schema);
       preRegisterSchema(registry, schemaName, fingerprint);
     }
   }
+  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 +1220,13 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   SUPPORTED_STRING_FORMATS,
   clearZodSchemaToOpenApiSchemaRegistry,
   convertSchemaToZodString,
+  generateInterface,
   generateRouteSchemaNames,
   getSchemaExportedVariableNameForStringFormat,
   openApiToZodTsCode,
   parseOpenApiPaths,
   registerZodSchemaToOpenApiSchema,
-  schemaRegistry
+  schemaRegistry,
+  schemaToTypeString
 });
 //# sourceMappingURL=index.cjs.map