toolcraft-schema 0.0.10 → 0.0.12

package/dist/index.d.ts

@@ -2,10 +2,12 @@ import { Json } from "./json.js";
 import { OneOf } from "./oneof.js";
 import { Record as RecordBuilder } from "./record.js";
 import { Union } from "./union.js";
+import { validate } from "./validate.js";
 import type { JsonValue, JsonValueSchema } from "./json.js";
 import type { OneOfSchema } from "./oneof.js";
 import type { RecordSchema } from "./record.js";
 import type { UnionSchema } from "./union.js";
+import type { ValidationIssue, ValidationResult } from "./validate.js";
 type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
 type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
 type EnumValue = string | number | boolean;
@@ -134,5 +136,5 @@ export declare const S: {
     readonly Json: typeof Json;
 };
 export declare function toJsonSchema(schema: AnySchema): JsonSchema;
-export { Json, OneOf, RecordBuilder as Record, Union };
-export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema };
+export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationResult, };

package/dist/index.js

@@ -2,6 +2,7 @@ import { Json } from "./json.js";
 import { OneOf } from "./oneof.js";
 import { Record as RecordBuilder } from "./record.js";
 import { Union } from "./union.js";
+import { validate } from "./validate.js";
 function withMetadata(schema, jsonSchema) {
     if (schema.description !== undefined) {
         jsonSchema.description = schema.description;
@@ -213,4 +214,4 @@ export function toJsonSchema(schema) {
             return withMetadata(unwrappedSchema, {});
     }
 }
-export { Json, OneOf, RecordBuilder as Record, Union };
+export { Json, OneOf, RecordBuilder as Record, Union, validate };

package/dist/validate.d.ts

@@ -0,0 +1,16 @@
+import type { AnySchema, Static } from "./index.js";
+export type SchemaDescriptor = AnySchema;
+export type ValidationIssue = {
+    path: readonly string[];
+    expected: string;
+    received: string;
+    message: string;
+};
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: readonly ValidationIssue[];
+};
+export declare function validate<S extends SchemaDescriptor>(schema: S, value: unknown): ValidationResult<Static<S>>;

package/dist/validate.js

@@ -0,0 +1,323 @@
+const missingValue = Symbol("missingValue");
+export function validate(schema, value) {
+    const state = { issues: [] };
+    const result = walkSchema(schema, value, [], state);
+    if (state.issues.length > 0) {
+        return { ok: false, issues: state.issues };
+    }
+    return { ok: true, value: (result.present ? result.value : undefined) };
+}
+function walkSchema(schema, value, path, state) {
+    if (schema.kind === "optional") {
+        return walkOptional(schema, value, path, state);
+    }
+    if (value === missingValue) {
+        addIssue(state, path, expectedFor(schema), "missing", `Expected ${expectedFor(schema)} at ${formatPath(path)}`);
+        return { present: false };
+    }
+    if (value === null && schema.nullable === true) {
+        return { present: true, value };
+    }
+    switch (schema.kind) {
+        case "string":
+            return walkString(schema, value, path, state);
+        case "number":
+            return walkNumber(schema, value, path, state);
+        case "boolean":
+            return walkBoolean(value, path, state);
+        case "enum":
+            return walkEnum(schema, value, path, state);
+        case "array":
+            return walkArray(schema, value, path, state);
+        case "object":
+            return walkObject(schema, value, path, state);
+        case "oneOf":
+            return walkOneOf(schema, value, path, state);
+        case "union":
+            return walkUnion(schema, value, path, state);
+        case "record":
+            return walkRecord(schema, value, path, state);
+        case "json":
+            return walkJson(value, path, state);
+    }
+}
+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 { present: false };
+    }
+    return walkSchema(schema.inner, value, path, state);
+}
+function walkString(schema, value, path, state) {
+    if (typeof value !== "string") {
+        addExpectedIssue(state, path, "string", value);
+        return { present: true, value };
+    }
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        const expected = `string with length at least ${schema.minLength}`;
+        addIssue(state, path, expected, `string with length ${value.length}`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        const expected = `string with length at most ${schema.maxLength}`;
+        addIssue(state, path, expected, `string with length ${value.length}`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.pattern !== undefined) {
+        const pattern = compilePattern(schema.pattern);
+        if (pattern === undefined || !pattern.test(value)) {
+            const expected = `string matching pattern ${schema.pattern}`;
+            addIssue(state, path, expected, value, `Expected ${expected} at ${formatPath(path)}`);
+        }
+    }
+    return { present: true, value };
+}
+function walkNumber(schema, value, path, state) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        addExpectedIssue(state, path, schema.jsonType === "integer" ? "integer" : "number", value);
+        return { present: true, value };
+    }
+    if (schema.jsonType === "integer" && !Number.isInteger(value)) {
+        addExpectedIssue(state, path, "integer", value);
+    }
+    if (schema.minimum !== undefined && value < schema.minimum) {
+        const expected = `number greater than or equal to ${schema.minimum}`;
+        addIssue(state, path, expected, String(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+        const expected = `number less than or equal to ${schema.maximum}`;
+        addIssue(state, path, expected, String(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    return { present: true, value };
+}
+function walkBoolean(value, path, state) {
+    if (typeof value !== "boolean") {
+        addExpectedIssue(state, path, "boolean", value);
+    }
+    return { present: true, value };
+}
+function walkEnum(schema, value, path, state) {
+    if (!schema.values.includes(value)) {
+        const expected = `one of ${schema.values.join(", ")}`;
+        addIssue(state, path, expected, receivedValue(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    return { present: true, value };
+}
+function walkArray(schema, value, path, state) {
+    if (!Array.isArray(value)) {
+        addExpectedIssue(state, path, "array", value);
+        return { present: true, value };
+    }
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        const expected = `array with at least ${schema.minItems} items`;
+        addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        const expected = `array with at most ${schema.maxItems} items`;
+        addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    const nextValue = value.map((item, index) => {
+        const result = walkSchema(schema.item, item, [...path, String(index)], state);
+        return result.present ? result.value : item;
+    });
+    return { present: true, value: nextValue };
+}
+function walkObject(schema, value, path, state, injectedProperties = {}) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const nextValue = {};
+    const allowedKeys = new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
+    for (const [key, propertySchema] of Object.entries(schema.shape)) {
+        const propertyValue = Object.hasOwn(value, key) ? value[key] : missingValue;
+        const result = walkSchema(propertySchema, propertyValue, [...path, key], state);
+        if (result.present) {
+            nextValue[key] = result.value;
+        }
+    }
+    for (const [key, injectedValue] of Object.entries(injectedProperties)) {
+        if (Object.hasOwn(value, key)) {
+            nextValue[key] = value[key];
+        }
+        else {
+            nextValue[key] = injectedValue;
+        }
+    }
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (allowedKeys.has(key)) {
+            continue;
+        }
+        if (schema.additionalProperties === true) {
+            nextValue[key] = propertyValue;
+        }
+        else {
+            addUnexpectedPropertyIssue(state, [...path, key]);
+        }
+    }
+    return { present: true, value: nextValue };
+}
+function walkOneOf(schema, value, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const discriminatorValue = value[schema.discriminator];
+    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)}`);
+        return { present: true, value };
+    }
+    return walkObject(schema.branches[discriminatorValue], value, path, state, {
+        [schema.discriminator]: discriminatorValue
+    });
+}
+function walkUnion(schema, value, path, state) {
+    if (isPlainRecord(value)) {
+        const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+        if (candidateBranches.length === 1) {
+            return walkObject(candidateBranches[0], value, path, state);
+        }
+    }
+    const matches = [];
+    for (const branch of schema.branches) {
+        const branchState = { issues: [] };
+        const result = walkObject(branch, value, path, branchState);
+        if (branchState.issues.length === 0 && result.present) {
+            matches.push(result.value);
+        }
+    }
+    if (matches.length === 1) {
+        return { present: true, value: matches[0] };
+    }
+    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)}`);
+    return { present: true, value };
+}
+function hasRequiredKeys(schema, value) {
+    for (const [key, propertySchema] of Object.entries(schema.shape)) {
+        if (propertySchema.kind !== "optional" && !Object.hasOwn(value, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function walkRecord(schema, value, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const nextValue = {};
+    for (const [key, propertyValue] of Object.entries(value)) {
+        const result = walkSchema(schema.value, propertyValue, [...path, key], state);
+        if (result.present) {
+            nextValue[key] = result.value;
+        }
+    }
+    return { present: true, value: nextValue };
+}
+function walkJson(value, path, state) {
+    if (isJsonValue(value)) {
+        return { present: true, value };
+    }
+    addExpectedIssue(state, path, "JSON value", value);
+    return { present: true, value };
+}
+function getDefault(schema) {
+    if (schema.default !== undefined) {
+        return { present: true, value: schema.default };
+    }
+    if (schema.kind === "optional") {
+        return getDefault(schema.inner);
+    }
+    return { present: false };
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return typeof value !== "number" || Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonValue(item));
+    }
+    if (isPlainRecord(value)) {
+        return Object.values(value).every((item) => isJsonValue(item));
+    }
+    return false;
+}
+function expectedFor(schema) {
+    switch (schema.kind) {
+        case "string":
+            return "string";
+        case "number":
+            return schema.jsonType === "integer" ? "integer" : "number";
+        case "boolean":
+            return "boolean";
+        case "enum":
+            return `one of ${schema.values.join(", ")}`;
+        case "array":
+            return "array";
+        case "object":
+        case "oneOf":
+        case "record":
+            return "object";
+        case "union":
+            return "exactly one union branch";
+        case "json":
+            return "JSON value";
+        case "optional":
+            return expectedFor(schema.inner);
+    }
+}
+function addExpectedIssue(state, path, expected, value) {
+    addIssue(state, path, expected, receivedType(value), `Expected ${expected} at ${formatPath(path)}`);
+}
+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 formatPath(path) {
+    return path.length === 0 ? "value" : path.join(".");
+}
+function compilePattern(pattern) {
+    try {
+        return new RegExp(pattern);
+    }
+    catch {
+        return undefined;
+    }
+}
+function receivedType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return "integer";
+    }
+    return typeof value;
+}
+function receivedValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "undefined";
+    }
+    return String(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,8 +12,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "test": "cd ../.. && vitest run packages/toolcraft-schema/src/index.test.ts",
-    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src/index.test.ts",
+    "test": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src/*.test.ts",
     "lint": "cd ../.. && eslint packages/toolcraft-schema/src --ext ts && tsc -p packages/toolcraft-schema/tsconfig.json --noEmit"
   },
   "files": [