toolcraft-schema 0.0.23 → 0.0.25

package/dist/index.js

@@ -80,6 +80,30 @@ function assertValidEnumValues(values) {
     if (uniqueValues.size !== values.length) {
         throw new Error("Enum schema values must be unique");
     }
+    if (values.some((value) => typeof value === "number" && !Number.isFinite(value))) {
+        throw new Error("Enum schema numeric values must be finite");
+    }
+}
+function assertNonNegativeInteger(value, name) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+}
+function assertFiniteNumber(value, name) {
+    if (value !== undefined && !Number.isFinite(value)) {
+        throw new Error(`${name} must be finite`);
+    }
+}
+function assertPattern(pattern) {
+    if (pattern === undefined) {
+        return;
+    }
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        throw new Error("pattern must be a valid regular expression");
+    }
 }
 function unwrapOptional(schema) {
     if (isOptionalSchema(schema)) {
@@ -106,12 +130,21 @@ function withInjectedDiscriminator(schema, discriminator, branchName) {
 }
 export const S = {
     String(options = {}) {
+        assertNonNegativeInteger(options.minLength, "minLength");
+        assertNonNegativeInteger(options.maxLength, "maxLength");
+        assertPattern(options.pattern);
         return {
             kind: "string",
             ...options,
         };
     },
     Number(options = {}) {
+        assertFiniteNumber(options.minimum, "minimum");
+        assertFiniteNumber(options.maximum, "maximum");
+        assertFiniteNumber(options.default, "default");
+        if (options.jsonType === "integer" && options.default !== undefined && !Number.isInteger(options.default)) {
+            throw new Error("default must be an integer");
+        }
         return {
             kind: "number",
             ...options,
@@ -125,6 +158,9 @@ export const S = {
     },
     Enum(values, options = {}) {
         assertValidEnumValues(values);
+        if (options.jsonType === "integer" && values.some((value) => typeof value !== "number" || !Number.isInteger(value))) {
+            throw new Error("Integer enum values must be integers");
+        }
         return {
             kind: "enum",
             values,
@@ -132,6 +168,8 @@ export const S = {
         };
     },
     Array(item, options = {}) {
+        assertNonNegativeInteger(options.minItems, "minItems");
+        assertNonNegativeInteger(options.maxItems, "maxItems");
         return {
             kind: "array",
             item,
@@ -186,7 +224,12 @@ export function toJsonSchema(schema) {
             const properties = {};
             const required = [];
             for (const [key, propertySchema] of Object.entries(unwrappedSchema.shape)) {
-                properties[key] = toJsonSchema(propertySchema);
+                Object.defineProperty(properties, key, {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: toJsonSchema(propertySchema)
+                });
                 if (!isOptionalSchema(propertySchema)) {
                     required.push(key);
                 }

package/dist/oneof.js

@@ -1,10 +1,15 @@
-function assertValidBranches(branches) {
+function assertValidBranches(branches, discriminator) {
     if (Object.keys(branches).length === 0) {
         throw new Error("OneOf schema requires at least one branch");
     }
+    for (const [branchName, branch] of Object.entries(branches)) {
+        if (Object.prototype.hasOwnProperty.call(branch.shape, discriminator)) {
+            throw new Error(`OneOf branch "${branchName}" must not declare discriminator field "${discriminator}".`);
+        }
+    }
 }
 export function OneOf(config) {
-    assertValidBranches(config.branches);
+    assertValidBranches(config.branches, config.discriminator);
     return {
         kind: "oneOf",
         discriminator: config.discriminator,

package/dist/union.js

@@ -12,14 +12,21 @@ export function getRequiredKeyFingerprint(schema) {
 function assertUniqueRequiredKeyFingerprints(branches) {
     const fingerprints = new Map();
     branches.forEach((branch, index) => {
-        const fingerprint = getRequiredKeyFingerprint(branch);
-        const indices = fingerprints.get(fingerprint) ?? [];
-        indices.push(index);
-        fingerprints.set(fingerprint, indices);
+        const requiredKeys = getRequiredKeys(branch);
+        const fingerprint = JSON.stringify(requiredKeys);
+        const existing = fingerprints.get(fingerprint);
+        if (existing === undefined) {
+            fingerprints.set(fingerprint, {
+                display: requiredKeys.join("+"),
+                indices: [index],
+            });
+            return;
+        }
+        existing.indices.push(index);
     });
-    for (const [fingerprint, indices] of fingerprints) {
+    for (const { display, indices } of fingerprints.values()) {
         if (indices.length > 1) {
-            throw new Error(`Union branches [${indices.join(", ")}] share required-key fingerprint "${fingerprint}". Each branch must require a distinct set of keys.`);
+            throw new Error(`Union branches [${indices.join(", ")}] share required-key fingerprint "${display}". Each branch must require a distinct set of keys.`);
         }
     }
 }

package/dist/validate.js

@@ -46,7 +46,7 @@ function walkOptional(schema, value, path, state) {
     if (value === missingValue || value === undefined) {
         const defaultValue = getDefault(schema.inner);
         if (defaultValue.present) {
-            return { present: true, value: defaultValue.value };
+            return walkSchema(schema.inner, cloneDefault(defaultValue.value), path, state);
         }
         return { present: false };
     }
@@ -75,7 +75,7 @@ function walkString(schema, value, path, state) {
     return { present: true, value };
 }
 function walkNumber(schema, value, path, state) {
-    if (typeof value !== "number" || Number.isNaN(value)) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
         addExpectedIssue(state, path, schema.jsonType === "integer" ? "integer" : "number", value);
         return { present: true, value };
     }
@@ -135,15 +135,15 @@ function walkObject(schema, value, path, state, injectedProperties = {}) {
         const propertyValue = Object.hasOwn(value, key) ? value[key] : missingValue;
         const result = walkSchema(propertySchema, propertyValue, [...path, key], state);
         if (result.present) {
-            nextValue[key] = result.value;
+            setOwnValue(nextValue, key, result.value);
         }
     }
     for (const [key, injectedValue] of Object.entries(injectedProperties)) {
         if (Object.hasOwn(value, key)) {
-            nextValue[key] = value[key];
+            setOwnValue(nextValue, key, value[key]);
         }
         else {
-            nextValue[key] = injectedValue;
+            setOwnValue(nextValue, key, injectedValue);
         }
     }
     for (const [key, propertyValue] of Object.entries(value)) {
@@ -151,7 +151,7 @@ function walkObject(schema, value, path, state, injectedProperties = {}) {
             continue;
         }
         if (schema.additionalProperties === true) {
-            nextValue[key] = propertyValue;
+            setOwnValue(nextValue, key, propertyValue);
         }
         else {
             addUnexpectedPropertyIssue(state, [...path, key]);
@@ -224,7 +224,7 @@ function walkRecord(schema, value, path, state) {
     for (const [key, propertyValue] of Object.entries(value)) {
         const result = walkSchema(schema.value, propertyValue, [...path, key], state);
         if (result.present) {
-            nextValue[key] = result.value;
+            setOwnValue(nextValue, key, result.value);
         }
     }
     return { present: true, value: nextValue };
@@ -252,7 +252,7 @@ function isPlainRecord(value) {
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 }
-function isJsonValue(value) {
+function isJsonValue(value, ancestors = new Set()) {
     if (value === null ||
         typeof value === "string" ||
         typeof value === "number" ||
@@ -260,13 +260,36 @@ function isJsonValue(value) {
         return typeof value !== "number" || Number.isFinite(value);
     }
     if (Array.isArray(value)) {
-        return value.every((item) => isJsonValue(item));
+        if (ancestors.has(value)) {
+            return false;
+        }
+        ancestors.add(value);
+        const result = value.every((item) => isJsonValue(item, ancestors));
+        ancestors.delete(value);
+        return result;
     }
     if (isPlainRecord(value)) {
-        return Object.values(value).every((item) => isJsonValue(item));
+        if (ancestors.has(value)) {
+            return false;
+        }
+        ancestors.add(value);
+        const result = Object.values(value).every((item) => isJsonValue(item, ancestors));
+        ancestors.delete(value);
+        return result;
     }
     return false;
 }
+function cloneDefault(value) {
+    return structuredClone(value);
+}
+function setOwnValue(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value
+    });
+}
 function expectedFor(schema) {
     switch (schema.kind) {
         case "string":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",