toolcraft-schema 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -1,5 +1,13 @@
+import { Json } from "./json.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.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";
 type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
-type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional";
+type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
 type EnumValue = string | number | boolean;
 type JsonSchemaEnumValue = EnumValue | null;
 type NumberJsonType = "number" | "integer";
@@ -41,7 +49,7 @@ type SchemaOptions<TDefault> = {
     short?: string;
     scope?: readonly SchemaScope[];
 };
-interface SchemaBase<TKind extends SchemaKind, TStatic> {
+export interface SchemaBase<TKind extends SchemaKind, TStatic> {
     readonly kind: TKind;
     readonly description?: string;
     readonly default?: TStatic;
@@ -52,7 +60,7 @@ interface SchemaBase<TKind extends SchemaKind, TStatic> {
     readonly __static?: TStatic;
 }
 export interface JsonSchema {
-    additionalProperties?: boolean;
+    additionalProperties?: boolean | JsonSchema;
     type?: JsonSchemaType;
     description?: string;
     default?: unknown;
@@ -66,6 +74,7 @@ export interface JsonSchema {
     minimum?: number;
     minLength?: number;
     nullable?: boolean;
+    oneOf?: JsonSchema[];
     pattern?: string;
     properties?: Record<string, JsonSchema>;
     required?: string[];
@@ -97,7 +106,7 @@ export interface ObjectSchema<TShape extends ObjectShape> extends SchemaBase<"ob
 export interface OptionalSchema<TInner extends AnySchema> extends SchemaBase<"optional", Static<TInner> | undefined> {
     readonly inner: TInner;
 }
-export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | ArraySchema<AnySchema> | ObjectSchema<ObjectShape> | OptionalSchema<AnySchema>;
+export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | ArraySchema<AnySchema> | ObjectSchema<ObjectShape> | OptionalSchema<AnySchema> | OneOfSchema<Record<string, ObjectSchema<any>>, string> | UnionSchema<readonly ObjectSchema<any>[]> | RecordSchema<AnySchema> | JsonValueSchema;
 export type Static<TSchema extends AnySchema> = TSchema extends SchemaBase<any, infer TStatic> ? TStatic : never;
 export declare const S: {
     readonly String: (options?: SchemaOptions<string> & StringMetadata) => StringSchema;
@@ -119,6 +128,11 @@ export declare const S: {
     readonly Array: <TItem extends AnySchema>(item: TItem, options?: SchemaOptions<Array<Static<TItem>>> & ArrayMetadata) => ArraySchema<TItem>;
     readonly Object: <const TShape extends ObjectShape>(shape: TShape, options?: SchemaOptions<InferObject<TShape>> & ObjectMetadata) => ObjectSchema<TShape>;
     readonly Optional: <TInner extends AnySchema>(inner: TInner) => OptionalSchema<TInner>;
+    readonly OneOf: typeof OneOf;
+    readonly Union: typeof Union;
+    readonly Record: typeof RecordBuilder;
+    readonly Json: typeof Json;
 };
 export declare function toJsonSchema(schema: AnySchema): JsonSchema;
-export {};
+export { Json, OneOf, RecordBuilder as Record, Union };
+export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema };

package/dist/index.js

@@ -1,3 +1,7 @@
+import { Json } from "./json.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.js";
 function withMetadata(schema, jsonSchema) {
     if (schema.description !== undefined) {
         jsonSchema.description = schema.description;
@@ -82,6 +86,23 @@ function unwrapOptional(schema) {
     }
     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 = {}) {
         return {
@@ -129,6 +150,10 @@ export const S = {
             inner,
         };
     },
+    OneOf,
+    Union,
+    Record: RecordBuilder,
+    Json,
 };
 export function toJsonSchema(schema) {
     const unwrappedSchema = unwrapOptional(schema);
@@ -171,5 +196,21 @@ export function toJsonSchema(schema) {
                 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 { Json, OneOf, RecordBuilder as Record, Union };

package/dist/json.compile-check.d.ts

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

package/dist/json.compile-check.js

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

package/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/dist/json.js

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

package/dist/oneof.compile-check.d.ts

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

package/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/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/dist/oneof.js

@@ -0,0 +1,13 @@
+function assertValidBranches(branches) {
+    if (Object.keys(branches).length === 0) {
+        throw new Error("OneOf schema requires at least one branch");
+    }
+}
+export function OneOf(config) {
+    assertValidBranches(config.branches);
+    return {
+        kind: "oneOf",
+        discriminator: config.discriminator,
+        branches: config.branches,
+    };
+}

package/dist/record.compile-check.d.ts

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

package/dist/record.compile-check.js

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

package/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/dist/record.js

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

package/dist/union.compile-check.d.ts

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

package/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/dist/union.d.ts

@@ -0,0 +1,7 @@
+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 Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): UnionSchema<TBranches>;
+export {};

package/dist/union.js

@@ -0,0 +1,29 @@
+function isOptionalSchema(schema) {
+    return schema.kind === "optional";
+}
+function getRequiredKeyFingerprint(schema) {
+    const requiredKeys = Object.keys(schema.shape)
+        .filter((key) => !isOptionalSchema(schema.shape[key]))
+        .sort();
+    return JSON.stringify(requiredKeys);
+}
+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);
+    }
+}
+export function Union(branches) {
+    assertValidBranches(branches);
+    return {
+        kind: "union",
+        branches,
+    };
+}

package/package.json

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