toolcraft-openapi 0.0.122 → 0.0.124

package/node_modules/toolcraft-schema/dist/json-schema/utils.js

@@ -0,0 +1,171 @@
+export function isSchema(value) {
+    return typeof value === "boolean" || isObject(value);
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function dialectFor(schema, inherited) {
+    const dialect = schema.$schema;
+    if (typeof dialect !== "string") {
+        return inherited;
+    }
+    if (dialect.includes("draft-07")) {
+        return "draft7";
+    }
+    if (dialect.includes("2020-12")) {
+        return "draft2020-12";
+    }
+    return inherited;
+}
+export function resolveUri(reference, baseUri) {
+    try {
+        return new URL(reference, baseUri).href;
+    }
+    catch {
+        throw new Error(`Invalid schema URI: ${reference}`);
+    }
+}
+export function withoutFragment(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? uri : uri.slice(0, index);
+}
+export function fragmentOf(uri) {
+    const index = uri.indexOf("#");
+    return index === -1 ? "" : uri.slice(index + 1);
+}
+export function escapePointer(value) {
+    return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+export function decodePointer(value) {
+    return decodeURIComponent(value).replaceAll("~1", "/").replaceAll("~0", "~");
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (typeof left !== typeof right || left === null || right === null) {
+        return false;
+    }
+    if (Array.isArray(left)) {
+        return (Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => deepEqual(value, right[index])));
+    }
+    if (isObject(left) && isObject(right)) {
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        return (leftKeys.length === rightKeys.length &&
+            leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key])));
+    }
+    return false;
+}
+export 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;
+}
+export function issue(path, expected, value, message, keyword = keywordFor(expected)) {
+    return { path, expected, received: receivedType(value), message, keyword };
+}
+function keywordFor(expected) {
+    if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
+        return "type";
+    }
+    if (expected.startsWith("multiple of"))
+        return "multipleOf";
+    if (expected.startsWith("length <="))
+        return "maxLength";
+    if (expected.startsWith("length >="))
+        return "minLength";
+    if (expected.startsWith("pattern "))
+        return "pattern";
+    if (expected.startsWith("items <="))
+        return "maxItems";
+    if (expected.startsWith("items >="))
+        return "minItems";
+    if (expected === "unique items")
+        return "uniqueItems";
+    if (expected.startsWith("properties <="))
+        return "maxProperties";
+    if (expected.startsWith("properties >="))
+        return "minProperties";
+    if (expected.startsWith("<= "))
+        return "maximum";
+    if (expected.startsWith(">= "))
+        return "minimum";
+    if (expected.startsWith("< "))
+        return "exclusiveMaximum";
+    if (expected.startsWith("> "))
+        return "exclusiveMinimum";
+    if (expected === "valid schema")
+        return "false schema";
+    return expected;
+}
+export function validResult() {
+    return {
+        valid: true,
+        issues: [],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function invalidResult(problem) {
+    return {
+        valid: false,
+        issues: [problem],
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+export function mergeResults(results) {
+    const merged = validResult();
+    for (const result of results) {
+        merged.valid &&= result.valid;
+        merged.issues.push(...result.issues);
+        for (const key of result.evaluatedProperties) {
+            merged.evaluatedProperties.add(key);
+        }
+        for (const index of result.evaluatedItems) {
+            merged.evaluatedItems.add(index);
+        }
+    }
+    return merged;
+}
+export function typeMatches(type, value) {
+    switch (type) {
+        case "null":
+            return value === null;
+        case "boolean":
+            return typeof value === "boolean";
+        case "object":
+            return isObject(value);
+        case "array":
+            return Array.isArray(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "string":
+            return typeof value === "string";
+        default:
+            return true;
+    }
+}
+export function unicodeLength(value) {
+    return [...value].length;
+}
+export function isMultipleOf(value, divisor) {
+    if (divisor === 0) {
+        return false;
+    }
+    const quotient = value / divisor;
+    return (Math.abs(quotient - Math.round(quotient)) <=
+        Number.EPSILON * Math.max(1, Math.abs(quotient)) * 4);
+}

package/node_modules/toolcraft-schema/dist/json-schema-document.d.ts

@@ -0,0 +1,14 @@
+import type { JsonSchema } from "./index.js";
+export interface JsonSchemaDocumentOptions {
+    id?: string;
+    title?: string;
+    description?: string;
+    schema?: string;
+}
+export type JsonSchemaDocument = JsonSchema & {
+    $schema: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+};
+export declare function createJsonSchemaDocument(jsonSchema: JsonSchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;

package/node_modules/toolcraft-schema/dist/json-schema-document.js

@@ -0,0 +1,17 @@
+export function createJsonSchemaDocument(jsonSchema, options = {}) {
+    const { id, schema: schemaUri = "https://json-schema.org/draft/2020-12/schema", ...metadata } = options;
+    const document = {
+        $schema: schemaUri,
+        ...jsonSchema
+    };
+    if (id !== undefined) {
+        document.$id = id;
+    }
+    if (metadata.title !== undefined) {
+        document.title = metadata.title;
+    }
+    if (metadata.description !== undefined) {
+        document.description = metadata.description;
+    }
+    return document;
+}

package/node_modules/toolcraft-schema/dist/json.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/json.compile-check.js

@@ -0,0 +1,2 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Json();

package/node_modules/toolcraft-schema/dist/json.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaBase } from "./index.js";
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+export interface JsonValueSchema extends SchemaBase<"json", JsonValue> {
+    readonly kind: "json";
+}
+export declare function Json(): JsonValueSchema;
+export {};

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

@@ -0,0 +1,5 @@
+export function Json() {
+    return {
+        kind: "json",
+    };
+}

package/node_modules/toolcraft-schema/dist/oneof.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/oneof.compile-check.js

@@ -0,0 +1,12 @@
+import { S } from "./index.js";
+const ignoredSchema = S.OneOf({
+    discriminator: "kind",
+    branches: {
+        text: S.Object({
+            value: S.String(),
+        }),
+        count: S.Object({
+            value: S.Number(),
+        }),
+    },
+});

package/node_modules/toolcraft-schema/dist/oneof.d.ts

@@ -0,0 +1,15 @@
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type OneOfStatic<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string> = {
+    [TBranchName in keyof TBranches & string]: Omit<Static<TBranches[TBranchName]>, TDiscriminator> & {
+        [TFieldName in TDiscriminator]: TBranchName;
+    };
+}[keyof TBranches & string];
+export interface OneOfSchema<TBranches extends Record<string, ObjectSchema<any>>, TDiscriminator extends string = string> extends SchemaBase<"oneOf", OneOfStatic<TBranches, TDiscriminator>> {
+    readonly discriminator: TDiscriminator;
+    readonly branches: TBranches;
+}
+export declare function OneOf<TDiscriminator extends string, TBranches extends Record<string, ObjectSchema<any>>>(config: {
+    discriminator: TDiscriminator;
+    branches: TBranches;
+}): OneOfSchema<TBranches, TDiscriminator>;
+export {};

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

@@ -0,0 +1,18 @@
+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, config.discriminator);
+    return {
+        kind: "oneOf",
+        discriminator: config.discriminator,
+        branches: config.branches,
+    };
+}

package/node_modules/toolcraft-schema/dist/record.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/record.compile-check.js

@@ -0,0 +1,2 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Record(S.String());

package/node_modules/toolcraft-schema/dist/record.d.ts

@@ -0,0 +1,5 @@
+import type { AnySchema, SchemaBase, Static } from "./index.js";
+export interface RecordSchema<TValue extends AnySchema> extends SchemaBase<"record", Record<string, Static<TValue>>> {
+    readonly value: TValue;
+}
+export declare function Record<TValue extends AnySchema>(value: TValue): RecordSchema<TValue>;

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

@@ -0,0 +1,6 @@
+export function Record(value) {
+    return {
+        kind: "record",
+        value,
+    };
+}

package/node_modules/toolcraft-schema/dist/union.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/union.compile-check.js

@@ -0,0 +1,9 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Union([
+    S.Object({
+        email: S.String(),
+    }),
+    S.Object({
+        phone: S.String(),
+    }),
+]);

package/node_modules/toolcraft-schema/dist/union.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type UnionStatic<TBranches extends readonly ObjectSchema<any>[]> = Static<TBranches[number]>;
+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/node_modules/toolcraft-schema/dist/union.js

@@ -0,0 +1,45 @@
+function isOptionalSchema(schema) {
+    return schema.kind === "optional";
+}
+function getRequiredKeys(schema) {
+    return Object.keys(schema.shape)
+        .filter((key) => !isOptionalSchema(schema.shape[key]))
+        .sort();
+}
+export function getRequiredKeyFingerprint(schema) {
+    return getRequiredKeys(schema).join("+");
+}
+function assertUniqueRequiredKeyFingerprints(branches) {
+    const fingerprints = new Map();
+    branches.forEach((branch, index) => {
+        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 { display, indices } of fingerprints.values()) {
+        if (indices.length > 1) {
+            throw new Error(`Union branches [${indices.join(", ")}] share required-key fingerprint "${display}". 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");
+    }
+    assertUniqueRequiredKeyFingerprints(branches);
+}
+export function Union(branches) {
+    assertValidBranches(branches);
+    return {
+        kind: "union",
+        branches,
+    };
+}

package/node_modules/toolcraft-schema/dist/validate.d.ts

@@ -0,0 +1,17 @@
+import type { AnySchema, Static } from "./index.js";
+export type SchemaDescriptor = AnySchema;
+export type ValidationIssue = {
+    path: readonly string[];
+    expected: string;
+    received: string;
+    message: string;
+    keyword?: 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>>;