toolcraft-openapi 0.0.123 → 0.0.124

package/node_modules/toolcraft-schema/dist/validate.js

@@ -0,0 +1,379 @@
+import { getRequiredKeyFingerprint } from "./union.js";
+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 walkSchema(schema.inner, cloneDefault(defaultValue.value), path, state);
+        }
+        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.isFinite(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) {
+            setOwnValue(nextValue, key, result.value);
+        }
+    }
+    for (const [key, injectedValue] of Object.entries(injectedProperties)) {
+        if (Object.hasOwn(value, key)) {
+            setOwnValue(nextValue, key, value[key]);
+        }
+        else {
+            setOwnValue(nextValue, key, injectedValue);
+        }
+    }
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (allowedKeys.has(key)) {
+            continue;
+        }
+        if (schema.additionalProperties === true) {
+            setOwnValue(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];
+    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)) {
+        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, {
+        [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({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
+        }
+    }
+    if (matches.length === 1) {
+        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 };
+    }
+    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) {
+    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) {
+            setOwnValue(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, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return typeof value !== "number" || Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        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)) {
+        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":
+            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: 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(".");
+}
+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);
+}
+function formatReceivedDiscriminator(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    return receivedValue(value);
+}

package/node_modules/toolcraft-schema/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "toolcraft-schema",
+  "version": "0.0.124",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "cd ../.. && vitest run packages/toolcraft-schema/src",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src",
+    "lint": "cd ../.. && eslint packages/toolcraft-schema/src --ext ts && tsc -p packages/toolcraft-schema/tsconfig.json --noEmit"
+  },
+  "files": [
+    "LICENSE",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/toolcraft-schema"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.123",
+  "version": "0.0.124",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -19,8 +19,8 @@
     "build": "rm -rf dist && tsc",
     "test": "cd ../.. && vitest run packages/toolcraft-openapi/src",
     "test:unit": "cd ../.. && vitest run packages/toolcraft-openapi/src",
-    "prepack": "node ../../scripts/set-bin-executable.mjs && node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-design @poe-code/frontmatter auth-store fast-string-width fast-wrap-ansi sisteransi yaml",
-    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter auth-store fast-string-width fast-wrap-ansi sisteransi yaml"
+    "prepack": "node ../../scripts/set-bin-executable.mjs && node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema toolcraft-design @poe-code/frontmatter auth-store fast-string-width fast-wrap-ansi sisteransi yaml",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema toolcraft-design @poe-code/frontmatter auth-store fast-string-width fast-wrap-ansi sisteransi yaml"
   },
   "files": [
     "LICENSE",
@@ -30,7 +30,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.123",
+    "toolcraft": "0.0.124",
     "auth-store": "^0.0.1",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",
@@ -46,10 +46,12 @@
     "directory": "packages/toolcraft-openapi"
   },
   "optionalDependencies": {
+    "toolcraft-schema": "0.0.124",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*"
   },
   "bundleDependencies": [
+    "toolcraft-schema",
     "toolcraft-design",
     "@poe-code/frontmatter",
     "auth-store",