toolcraft-schema 0.0.16 → 0.0.18

package/dist/index.d.ts

@@ -21,10 +21,12 @@ type StringMetadata = {
     maxLength?: number;
     minLength?: number;
     pattern?: string;
+    secret?: boolean;
 };
 type NumberMetadata = {
     maximum?: number;
     minimum?: number;
+    secret?: boolean;
 };
 type ArrayMetadata = {
     maxItems?: number;

package/dist/union.d.ts

@@ -3,5 +3,6 @@ type UnionStatic<TBranches extends readonly ObjectSchema<any>[]> = Static<TBranc
 export interface UnionSchema<TBranches extends readonly ObjectSchema<any>[]> extends SchemaBase<"union", UnionStatic<TBranches>> {
     readonly branches: TBranches;
 }
+export declare function getRequiredKeyFingerprint(schema: ObjectSchema<any>): string;
 export declare function Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): UnionSchema<TBranches>;
 export {};

package/dist/union.js

@@ -1,24 +1,33 @@
 function isOptionalSchema(schema) {
     return schema.kind === "optional";
 }
-function getRequiredKeyFingerprint(schema) {
-    const requiredKeys = Object.keys(schema.shape)
+function getRequiredKeys(schema) {
+    return Object.keys(schema.shape)
         .filter((key) => !isOptionalSchema(schema.shape[key]))
         .sort();
-    return JSON.stringify(requiredKeys);
+}
+export function getRequiredKeyFingerprint(schema) {
+    return getRequiredKeys(schema).join("+");
+}
+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);
+    });
+    for (const [fingerprint, indices] of fingerprints) {
+        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.`);
+        }
+    }
 }
 function assertValidBranches(branches) {
     if (branches.length === 0) {
         throw new Error("Union schema requires at least one branch");
     }
-    const fingerprints = new Set();
-    for (const branch of branches) {
-        const fingerprint = getRequiredKeyFingerprint(branch);
-        if (fingerprints.has(fingerprint)) {
-            throw new Error("Union schema branches must have unique required-key fingerprints");
-        }
-        fingerprints.add(fingerprint);
-    }
+    assertUniqueRequiredKeyFingerprints(branches);
 }
 export function Union(branches) {
     assertValidBranches(branches);

package/dist/validate.js

@@ -1,3 +1,4 @@
+import { getRequiredKeyFingerprint } from "./union.js";
 const missingValue = Symbol("missingValue");
 export function validate(schema, value) {
     const state = { issues: [] };
@@ -164,11 +165,16 @@ function walkOneOf(schema, value, path, state) {
         return { present: true, value };
     }
     const discriminatorValue = value[schema.discriminator];
+    const discriminatorPath = [...path, schema.discriminator];
+    const branchValues = Object.keys(schema.branches);
+    const expected = `one of ${branchValues.join(", ")}`;
+    if (!Object.hasOwn(value, schema.discriminator)) {
+        addIssueWithMessage(state, discriminatorPath, expected, "missing", `Missing discriminator "${schema.discriminator}" at ${formatPath(path)}. Expected one of: ${branchValues.join(", ")}.`);
+        return { present: true, value };
+    }
     if (typeof discriminatorValue !== "string" ||
         !Object.hasOwn(schema.branches, discriminatorValue)) {
-        const discriminatorPath = [...path, schema.discriminator];
-        const expected = `one of ${Object.keys(schema.branches).join(", ")}`;
-        addIssue(state, discriminatorPath, expected, receivedValue(discriminatorValue), `Expected ${expected} at ${formatPath(discriminatorPath)}`);
+        addIssueWithMessage(state, discriminatorPath, expected, receivedValue(discriminatorValue), `Expected ${expected} at ${formatPath(discriminatorPath)}, got ${formatReceivedDiscriminator(discriminatorValue)}`);
         return { present: true, value };
     }
     return walkObject(schema.branches[discriminatorValue], value, path, state, {
@@ -187,13 +193,18 @@ function walkUnion(schema, value, path, state) {
         const branchState = { issues: [] };
         const result = walkObject(branch, value, path, branchState);
         if (branchState.issues.length === 0 && result.present) {
-            matches.push(result.value);
+            matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
         }
     }
     if (matches.length === 1) {
-        return { present: true, value: matches[0] };
+        return { present: true, value: matches[0].value };
+    }
+    if (matches.length === 0) {
+        const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
+        addIssueWithMessage(state, path, "exactly one union branch", "0 matching branches", `No union branch matched at ${formatPath(path)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`);
+        return { present: true, value };
     }
-    addIssue(state, path, "exactly one union branch", matches.length === 0 ? "no matching branches" : `${matches.length} matching branches`, `Expected exactly one union branch at ${formatPath(path)}`);
+    addIssueWithMessage(state, path, "exactly one union branch", `${matches.length} matching branches`, `Expected exactly one union branch at ${formatPath(path)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`);
     return { present: true, value };
 }
 function hasRequiredKeys(schema, value) {
@@ -286,8 +297,24 @@ function addExpectedIssue(state, path, expected, value) {
 function addUnexpectedPropertyIssue(state, path) {
     addIssue(state, path, "no additional properties", "unknown property", `Unexpected property ${formatPath(path)}`);
 }
-function addIssue(state, path, expected, received, message) {
-    state.issues.push({ path, expected, received, message });
+function addIssue(state, path, expected, received, _message) {
+    state.issues.push({
+        path,
+        expected,
+        received,
+        message: formatIssueMessage(expected, path, received)
+    });
+}
+function addIssueWithMessage(state, path, expected, received, message) {
+    state.issues.push({
+        path,
+        expected,
+        received,
+        message
+    });
+}
+function formatIssueMessage(expected, path, received) {
+    return `Expected ${expected} at ${formatPath(path)}, got ${received}`;
 }
 function formatPath(path) {
     return path.length === 0 ? "value" : path.join(".");
@@ -321,3 +348,9 @@ function receivedValue(value) {
     }
     return String(value);
 }
+function formatReceivedDiscriminator(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    return receivedValue(value);
+}

package/package.json

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