@signe/schema-to-zod 2.8.3 → 2.9.0

package/dist/index.d.ts

@@ -2,8 +2,14 @@ import { ZodType } from 'zod';
 import { JSONSchema7, JSONSchema7Definition } from 'json-schema';
 
 /**
- * Converts a JSON Schema to a Zod schema
+ * Converts a JSON Schema to a full Zod schema.
+ * This export should be preferred when the schema uses allOf or if/then/else.
+ */
+declare function jsonSchemaToZodSchema(schema: JSONSchema7 | JSONSchema7Definition[]): ZodType<unknown>;
+/**
+ * Converts a JSON Schema to a Zod shape.
+ * This is kept for compatibility with the previous API.
  */
 declare function jsonSchemaToZod(schema: JSONSchema7 | JSONSchema7Definition[]): Record<string, ZodType<unknown>>;
 
-export { jsonSchemaToZod };
+export { jsonSchemaToZod, jsonSchemaToZodSchema };

package/dist/index.js

@@ -4075,6 +4075,48 @@ function isJSONSchema7(schema) {
   return typeof schema !== "boolean";
 }
 __name(isJSONSchema7, "isJSONSchema7");
+function asExtendedJSONSchema7(schema) {
+  return schema;
+}
+__name(asExtendedJSONSchema7, "asExtendedJSONSchema7");
+function unwrapSchemaDefinition(schema) {
+  if (typeof schema === "boolean") {
+    return schema;
+  }
+  if (!schema || typeof schema !== "object") {
+    return null;
+  }
+  if ("schema" in schema) {
+    return unwrapSchemaDefinition(schema.schema);
+  }
+  return schema;
+}
+__name(unwrapSchemaDefinition, "unwrapSchemaDefinition");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function areValuesEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    return left.every((item, index) => areValuesEqual(item, right[index]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+      return false;
+    }
+    return leftKeys.every((key) => areValuesEqual(left[key], right[key]));
+  }
+  return false;
+}
+__name(areValuesEqual, "areValuesEqual");
 var percent = z.number().min(0).max(100);
 var formatMap = {
   "date": /* @__PURE__ */ __name(() => z.string().regex(/^\d{4}-\d{2}-\d{2}$/), "date"),
@@ -4094,45 +4136,32 @@ var formatMap = {
   "code": /* @__PURE__ */ __name(() => z.string(), "code"),
   "percent": /* @__PURE__ */ __name(() => percent, "percent")
 };
-var typeMap = {
-  "string": /* @__PURE__ */ __name((schema) => {
-    if (schema.format && formatMap[schema.format]) {
-      return formatMap[schema.format](schema);
-    }
-    return z.string();
-  }, "string"),
-  "number": /* @__PURE__ */ __name((schema) => {
-    if (schema.format === "percent") {
-      return percent;
-    }
-    return z.number();
-  }, "number"),
-  "integer": /* @__PURE__ */ __name(() => z.number().int(), "integer"),
-  "boolean": /* @__PURE__ */ __name(() => z.boolean(), "boolean"),
-  "null": /* @__PURE__ */ __name(() => z.null(), "null"),
-  "array": /* @__PURE__ */ __name((schema) => {
-    if (!schema.items || Array.isArray(schema.items)) {
-      throw new Error("Invalid array items");
-    }
-    if (!isJSONSchema7(schema.items)) {
-      throw new Error("Boolean schema is not supported for array items");
-    }
-    if (schema.items.type === "object") {
-      return z.array(z.object(jsonSchemaToZod(schema.items)));
-    }
-    const itemType = schema.items.type;
-    if (!itemType || !isValidSchemaType(itemType)) {
-      throw new Error(`Unsupported array item type: ${itemType}`);
-    }
-    return z.array(typeMap[itemType](schema.items));
-  }, "array"),
-  "object": /* @__PURE__ */ __name((schema) => {
-    if (!schema.properties) {
-      throw new Error("Invalid object schema: missing properties");
-    }
-    return z.object(jsonSchemaToZod(schema));
-  }, "object")
-};
+function createRequiredUnknownSchema() {
+  return z.custom((value) => value !== void 0);
+}
+__name(createRequiredUnknownSchema, "createRequiredUnknownSchema");
+function inferSchemaType(schema) {
+  if (schema.type !== void 0 && !isValidSchemaType(schema.type)) {
+    throw new Error(`Unsupported type: ${schema.type}`);
+  }
+  if (schema.type && isValidSchemaType(schema.type)) {
+    return schema.type;
+  }
+  if (schema.properties || schema.required || schema.if || schema.then || schema.else || schema.allOf) {
+    return "object";
+  }
+  if (schema.items) {
+    return "array";
+  }
+  if (schema.pattern || schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.format && schema.format !== "percent") {
+    return "string";
+  }
+  if (schema.minimum !== void 0 || schema.maximum !== void 0 || schema.format === "percent") {
+    return "number";
+  }
+  return null;
+}
+__name(inferSchemaType, "inferSchemaType");
 function applyValidators(zodType, schema, required) {
   let zodTypeWithValidators = zodType;
   if (schema.type === "string" && required) {
@@ -4160,40 +4189,277 @@ function applyValidators(zodType, schema, required) {
       zodTypeWithValidators = zodTypeWithValidators.max(schema.maximum);
     }
   }
-  if (schema.enum) {
-    zodTypeWithValidators = zodTypeWithValidators.refine((value) => schema.enum.includes(value), {
-      message: `Must be one of: ${schema.enum.join(", ")}`
-    });
-  }
   if (schema.pattern) {
     zodTypeWithValidators = zodTypeWithValidators.regex(new RegExp(schema.pattern));
   }
+  if (schema.const !== void 0) {
+    zodTypeWithValidators = zodTypeWithValidators.refine((value) => areValuesEqual(value, schema.const), {
+      message: `Must be equal to: ${JSON.stringify(schema.const)}`
+    });
+  }
+  if (schema.enum) {
+    zodTypeWithValidators = zodTypeWithValidators.refine((value) => schema.enum.some((enumValue) => areValuesEqual(value, enumValue)), {
+      message: `Must be one of: ${schema.enum.map((value) => JSON.stringify(value)).join(", ")}`
+    });
+  }
   return zodTypeWithValidators;
 }
 __name(applyValidators, "applyValidators");
-function getTypeFunction(schema) {
-  if (!schema.type || !isValidSchemaType(schema.type)) {
-    throw new Error(`Unsupported type: ${schema.type}`);
+function applyLogicalCompositionValidators(zodType, schema) {
+  let composedType = zodType;
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    composedType = composedType.superRefine((value, context) => {
+      const matchesAnySchema = schema.anyOf.some((subSchema) => matchesSchemaDefinition(subSchema, value));
+      if (!matchesAnySchema) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Must match at least one schema in anyOf"
+        });
+      }
+    });
+  }
+  if (schema.not !== void 0) {
+    composedType = composedType.superRefine((value, context) => {
+      if (matchesSchemaDefinition(schema.not, value)) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Must not match schema in not"
+        });
+      }
+    });
   }
-  return typeMap[schema.type](schema);
+  return composedType;
 }
-__name(getTypeFunction, "getTypeFunction");
+__name(applyLogicalCompositionValidators, "applyLogicalCompositionValidators");
+function matchesSchemaDefinition(schema, value) {
+  if (!isJSONSchema7(schema)) {
+    return schema;
+  }
+  return jsonSchemaDefinitionToZod(schema).safeParse(value).success;
+}
+__name(matchesSchemaDefinition, "matchesSchemaDefinition");
+function addSchemaIssues(schema, value, context) {
+  if (!isJSONSchema7(schema)) {
+    if (!schema) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Schema condition rejected the current value"
+      });
+    }
+    return;
+  }
+  const result = jsonSchemaDefinitionToZod(schema).safeParse(value);
+  if (result.success) {
+    return;
+  }
+  for (const issue of result.error.issues) {
+    context.addIssue(issue);
+  }
+}
+__name(addSchemaIssues, "addSchemaIssues");
+function collectComposablePropertyKeys(schema) {
+  const extendedSchema = asExtendedJSONSchema7(schema);
+  const keys = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((definition) => {
+    if (!definition || !isJSONSchema7(definition)) {
+      return;
+    }
+    const extendedDefinition = asExtendedJSONSchema7(definition);
+    if (extendedDefinition.properties) {
+      for (const key of Object.keys(extendedDefinition.properties)) {
+        keys.add(key);
+      }
+    }
+    if (extendedDefinition.required) {
+      for (const key of extendedDefinition.required) {
+        keys.add(key);
+      }
+    }
+    if (extendedDefinition.dependentRequired) {
+      for (const [key, requiredKeys] of Object.entries(extendedDefinition.dependentRequired)) {
+        keys.add(key);
+        for (const requiredKey of requiredKeys) {
+          keys.add(requiredKey);
+        }
+      }
+    }
+    if (extendedDefinition.dependentSchemas) {
+      for (const [key, dependentSchema] of Object.entries(extendedDefinition.dependentSchemas)) {
+        keys.add(key);
+        visit(dependentSchema);
+      }
+    }
+    if (extendedDefinition.anyOf) {
+      for (const item of extendedDefinition.anyOf) {
+        visit(item);
+      }
+    }
+    if (extendedDefinition.allOf) {
+      for (const item of extendedDefinition.allOf) {
+        visit(item);
+      }
+    }
+    visit(extendedDefinition.not);
+    visit(extendedDefinition.if);
+    visit(extendedDefinition.then);
+    visit(extendedDefinition.else);
+  }, "visit");
+  visit(extendedSchema);
+  return keys;
+}
+__name(collectComposablePropertyKeys, "collectComposablePropertyKeys");
+function hasComposableValidation(schema) {
+  const extendedSchema = asExtendedJSONSchema7(schema);
+  return Boolean(extendedSchema.dependentRequired || extendedSchema.dependentSchemas || extendedSchema.if || extendedSchema.then || extendedSchema.else || Array.isArray(extendedSchema.allOf) && extendedSchema.allOf.length > 0);
+}
+__name(hasComposableValidation, "hasComposableValidation");
+function createPrimitiveType(schema, type) {
+  switch (type) {
+    case "string":
+      if (schema.format && formatMap[schema.format]) {
+        return formatMap[schema.format](schema);
+      }
+      return z.string();
+    case "number":
+      if (schema.format === "percent") {
+        return percent;
+      }
+      return z.number();
+    case "integer":
+      return z.number().int();
+    case "boolean":
+      return z.boolean();
+    case "null":
+      return z.null();
+  }
+}
+__name(createPrimitiveType, "createPrimitiveType");
+function buildObjectSchema(schema) {
+  const extendedSchema = asExtendedJSONSchema7(schema);
+  const shape = {};
+  if (extendedSchema.properties) {
+    for (const [key, propertySchema] of Object.entries(extendedSchema.properties)) {
+      if (!isJSONSchema7(propertySchema)) {
+        continue;
+      }
+      shape[key] = convertPropertyToZod(propertySchema, key, extendedSchema);
+    }
+  }
+  if (extendedSchema.required) {
+    for (const key of extendedSchema.required) {
+      if (!shape[key]) {
+        shape[key] = createRequiredUnknownSchema();
+      }
+    }
+  }
+  for (const key of collectComposablePropertyKeys(extendedSchema)) {
+    if (!shape[key]) {
+      shape[key] = z.unknown().optional();
+    }
+  }
+  const baseObject = z.object(shape);
+  if (!hasComposableValidation(extendedSchema)) {
+    return baseObject;
+  }
+  return baseObject.superRefine((value, context) => {
+    if (extendedSchema.dependentRequired) {
+      for (const [triggerKey, requiredKeys] of Object.entries(extendedSchema.dependentRequired)) {
+        if (!Object.prototype.hasOwnProperty.call(value, triggerKey)) {
+          continue;
+        }
+        for (const requiredKey of requiredKeys) {
+          if (!Object.prototype.hasOwnProperty.call(value, requiredKey)) {
+            context.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `Property "${requiredKey}" is required when "${triggerKey}" is present`,
+              path: [
+                requiredKey
+              ]
+            });
+          }
+        }
+      }
+    }
+    if (extendedSchema.dependentSchemas) {
+      for (const [triggerKey, dependentSchema] of Object.entries(extendedSchema.dependentSchemas)) {
+        if (!Object.prototype.hasOwnProperty.call(value, triggerKey)) {
+          continue;
+        }
+        addSchemaIssues(dependentSchema, value, context);
+      }
+    }
+    if (extendedSchema.if) {
+      const matches = matchesSchemaDefinition(extendedSchema.if, value);
+      if (matches && extendedSchema.then) {
+        addSchemaIssues(extendedSchema.then, value, context);
+      }
+      if (!matches && extendedSchema.else) {
+        addSchemaIssues(extendedSchema.else, value, context);
+      }
+    }
+    if (extendedSchema.allOf) {
+      for (const item of extendedSchema.allOf) {
+        addSchemaIssues(item, value, context);
+      }
+    }
+  });
+}
+__name(buildObjectSchema, "buildObjectSchema");
+function buildArraySchema(schema) {
+  if (!schema.items || Array.isArray(schema.items)) {
+    throw new Error("Invalid array items");
+  }
+  return applyValidators(z.array(jsonSchemaDefinitionToZod(schema.items, true)), schema, true);
+}
+__name(buildArraySchema, "buildArraySchema");
+function jsonSchemaDefinitionToZod(schema, required = true) {
+  if (!isJSONSchema7(schema)) {
+    return schema ? z.any() : z.never();
+  }
+  const inferredType = inferSchemaType(schema);
+  let zodType;
+  if (inferredType === "object") {
+    zodType = buildObjectSchema(schema);
+    return applyLogicalCompositionValidators(zodType, schema);
+  }
+  if (inferredType === "array") {
+    zodType = buildArraySchema(schema);
+    return applyLogicalCompositionValidators(zodType, schema);
+  }
+  if (inferredType) {
+    zodType = applyValidators(createPrimitiveType(schema, inferredType), schema, required);
+    return applyLogicalCompositionValidators(zodType, schema);
+  }
+  zodType = applyValidators(z.any(), schema, required);
+  return applyLogicalCompositionValidators(zodType, schema);
+}
+__name(jsonSchemaDefinitionToZod, "jsonSchemaDefinitionToZod");
 function convertPropertyToZod(schema, key, parentSchema) {
   const required = Array.isArray(parentSchema.required) && parentSchema.required.includes(key);
-  if (schema.type === "object") {
-    const objectSchema = z.object(jsonSchemaToZod(schema));
-    return required ? objectSchema : objectSchema.optional();
-  }
-  const typeValidator = applyValidators(getTypeFunction(schema), schema, required);
-  return required ? typeValidator : typeValidator.optional();
+  const propertySchema = jsonSchemaDefinitionToZod(schema, required);
+  return required ? propertySchema : propertySchema.optional();
 }
 __name(convertPropertyToZod, "convertPropertyToZod");
+function jsonSchemaToZodSchema(schema) {
+  if (Array.isArray(schema)) {
+    const definitions = schema.map(unwrapSchemaDefinition).filter((definition) => definition !== null);
+    return jsonSchemaDefinitionToZod({
+      type: "object",
+      allOf: definitions
+    });
+  }
+  return jsonSchemaDefinitionToZod(schema);
+}
+__name(jsonSchemaToZodSchema, "jsonSchemaToZodSchema");
 function jsonSchemaToZod(schema) {
   const zodSchema = {};
   if (Array.isArray(schema)) {
     for (const item of schema) {
-      if (!isJSONSchema7(item)) continue;
-      Object.assign(zodSchema, jsonSchemaToZod(item));
+      const definition = unwrapSchemaDefinition(item);
+      if (!definition || !isJSONSchema7(definition)) {
+        continue;
+      }
+      Object.assign(zodSchema, jsonSchemaToZod(definition));
     }
   } else if (schema.type === "object" && schema.properties) {
     for (const [key, prop] of Object.entries(schema.properties)) {
@@ -4205,6 +4471,7 @@ function jsonSchemaToZod(schema) {
 }
 __name(jsonSchemaToZod, "jsonSchemaToZod");
 export {
-  jsonSchemaToZod
+  jsonSchemaToZod,
+  jsonSchemaToZodSchema
 };
 //# sourceMappingURL=index.js.map