toolcraft 0.0.100 → 0.0.102

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

@@ -0,0 +1,294 @@
+import { Json } from "./json.js";
+import { createJsonSchemaDocument } from "./json-schema-document.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;
+    }
+    if (schema.default !== undefined) {
+        jsonSchema.default = schema.default;
+    }
+    if (schema.nullable === true) {
+        jsonSchema.nullable = true;
+    }
+    return jsonSchema;
+}
+function withStringMetadata(schema, jsonSchema) {
+    if (schema.minLength !== undefined) {
+        jsonSchema.minLength = schema.minLength;
+    }
+    if (schema.maxLength !== undefined) {
+        jsonSchema.maxLength = schema.maxLength;
+    }
+    if (schema.pattern !== undefined) {
+        jsonSchema.pattern = schema.pattern;
+    }
+    if (schema.format !== undefined) {
+        jsonSchema.format = schema.format;
+    }
+    return withMetadata(schema, jsonSchema);
+}
+function withNumberMetadata(schema, jsonSchema) {
+    if (schema.minimum !== undefined) {
+        jsonSchema.minimum = schema.minimum;
+    }
+    if (schema.maximum !== undefined) {
+        jsonSchema.maximum = schema.maximum;
+    }
+    return withMetadata(schema, jsonSchema);
+}
+function withArrayMetadata(schema, jsonSchema) {
+    if (schema.minItems !== undefined) {
+        jsonSchema.minItems = schema.minItems;
+    }
+    if (schema.maxItems !== undefined) {
+        jsonSchema.maxItems = schema.maxItems;
+    }
+    return withMetadata(schema, jsonSchema);
+}
+function withObjectMetadata(schema, jsonSchema) {
+    jsonSchema.additionalProperties = schema.additionalProperties ?? false;
+    return withMetadata(schema, jsonSchema);
+}
+function getEnumJsonType(values) {
+    const [firstValue] = values;
+    if (firstValue === undefined) {
+        return undefined;
+    }
+    const firstType = typeof firstValue;
+    const isSinglePrimitiveType = values.every((value) => typeof value === firstType);
+    if (!isSinglePrimitiveType) {
+        return undefined;
+    }
+    if (firstType === "string" || firstType === "number" || firstType === "boolean") {
+        return firstType;
+    }
+    return undefined;
+}
+function isOptionalSchema(schema) {
+    return schema.kind === "optional";
+}
+function assertValidEnumValues(values) {
+    if (values.length === 0) {
+        throw new Error("Enum schema requires at least one value");
+    }
+    const uniqueValues = new Set(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 assertMinMaxOrder(minimum, maximum, minimumName, maximumName) {
+    if (minimum !== undefined && maximum !== undefined && minimum > maximum) {
+        throw new Error(`${minimumName} must be less than or equal to ${maximumName}`);
+    }
+}
+function assertValidDefault(schema) {
+    if (schema.default === undefined) {
+        return;
+    }
+    const result = validate(schema, schema.default);
+    if (!result.ok) {
+        throw new Error(`default must satisfy schema: ${result.issues[0]?.message ?? "invalid default"}`);
+    }
+}
+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)) {
+        return unwrapOptional(schema.inner);
+    }
+    return schema;
+}
+function withInjectedDiscriminator(schema, discriminator, branchName) {
+    const branchJsonSchema = toJsonSchema(schema);
+    const properties = {
+        ...(branchJsonSchema.properties ?? {}),
+        [discriminator]: {
+            type: "string",
+            enum: [branchName]
+        }
+    };
+    const required = [...new Set([...(branchJsonSchema.required ?? []), discriminator])];
+    return {
+        ...branchJsonSchema,
+        type: "object",
+        properties,
+        required
+    };
+}
+export const S = {
+    String(options = {}) {
+        assertNonNegativeInteger(options.minLength, "minLength");
+        assertNonNegativeInteger(options.maxLength, "maxLength");
+        assertMinMaxOrder(options.minLength, options.maxLength, "minLength", "maxLength");
+        assertPattern(options.pattern);
+        const schema = {
+            kind: "string",
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Number(options = {}) {
+        assertFiniteNumber(options.minimum, "minimum");
+        assertFiniteNumber(options.maximum, "maximum");
+        assertMinMaxOrder(options.minimum, options.maximum, "minimum", "maximum");
+        assertFiniteNumber(options.default, "default");
+        if (options.jsonType === "integer" &&
+            options.default !== undefined &&
+            !Number.isInteger(options.default)) {
+            throw new Error("default must be an integer");
+        }
+        const schema = {
+            kind: "number",
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Boolean(options = {}) {
+        const schema = {
+            kind: "boolean",
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    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");
+        }
+        const schema = {
+            kind: "enum",
+            values,
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Array(item, options = {}) {
+        assertNonNegativeInteger(options.minItems, "minItems");
+        assertNonNegativeInteger(options.maxItems, "maxItems");
+        assertMinMaxOrder(options.minItems, options.maxItems, "minItems", "maxItems");
+        const schema = {
+            kind: "array",
+            item,
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Object(shape, options = {}) {
+        const schema = {
+            kind: "object",
+            shape,
+            ...options
+        };
+        assertValidDefault(schema);
+        return schema;
+    },
+    Optional(inner) {
+        return {
+            kind: "optional",
+            inner
+        };
+    },
+    OneOf,
+    Union,
+    Record: RecordBuilder,
+    Json
+};
+export function toJsonSchema(schema) {
+    const unwrappedSchema = unwrapOptional(schema);
+    switch (unwrappedSchema.kind) {
+        case "string":
+            return withStringMetadata(unwrappedSchema, { type: "string" });
+        case "number":
+            return withNumberMetadata(unwrappedSchema, { type: unwrappedSchema.jsonType ?? "number" });
+        case "boolean":
+            return withMetadata(unwrappedSchema, { type: "boolean" });
+        case "enum": {
+            const jsonSchema = {
+                enum: unwrappedSchema.nullable === true
+                    ? [...unwrappedSchema.values, null]
+                    : [...unwrappedSchema.values]
+            };
+            const enumType = unwrappedSchema.jsonType ?? getEnumJsonType(unwrappedSchema.values);
+            if (enumType !== undefined) {
+                jsonSchema.type = enumType;
+            }
+            return withMetadata(unwrappedSchema, jsonSchema);
+        }
+        case "array":
+            return withArrayMetadata(unwrappedSchema, {
+                type: "array",
+                items: toJsonSchema(unwrappedSchema.item)
+            });
+        case "object": {
+            const properties = {};
+            const required = [];
+            for (const [key, propertySchema] of Object.entries(unwrappedSchema.shape)) {
+                Object.defineProperty(properties, key, {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: toJsonSchema(propertySchema)
+                });
+                if (!isOptionalSchema(propertySchema)) {
+                    required.push(key);
+                }
+            }
+            return withObjectMetadata(unwrappedSchema, {
+                type: "object",
+                properties,
+                required
+            });
+        }
+        case "oneOf":
+            return withMetadata(unwrappedSchema, {
+                oneOf: Object.entries(unwrappedSchema.branches).map(([branchName, branchSchema]) => withInjectedDiscriminator(branchSchema, unwrappedSchema.discriminator, branchName))
+            });
+        case "union":
+            return withMetadata(unwrappedSchema, {
+                oneOf: unwrappedSchema.branches.map((branchSchema) => toJsonSchema(branchSchema))
+            });
+        case "record":
+            return withMetadata(unwrappedSchema, {
+                type: "object",
+                additionalProperties: toJsonSchema(unwrappedSchema.value)
+            });
+        case "json":
+            return withMetadata(unwrappedSchema, {});
+    }
+}
+export function toJsonSchemaDocument(schema, options = {}) {
+    return createJsonSchemaDocument(toJsonSchema(schema), options);
+}
+export { Json, OneOf, RecordBuilder as Record, Union, validate };

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,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>>;