@hydradb/sdk 0.0.3 → 2.0.1

package/dist/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectLikeUtils = getObjectLikeUtils;
+exports.withParsedProperties = withParsedProperties;
+const filterObject_js_1 = require("../../utils/filterObject.js");
+const getErrorMessageForIncorrectType_js_1 = require("../../utils/getErrorMessageForIncorrectType.js");
+const isPlainObject_js_1 = require("../../utils/isPlainObject.js");
+const index_js_1 = require("../schema-utils/index.js");
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const _hasOwn = Object.prototype.hasOwnProperty;
+function getObjectLikeUtils(schema) {
+    return {
+        withParsedProperties: (properties) => withParsedProperties(schema, properties),
+    };
+}
+/**
+ * object-like utils are defined in one file to resolve issues with circular imports
+ */
+function withParsedProperties(objectLike, properties) {
+    const objectSchema = {
+        parse: (raw, opts) => {
+            const parsedObject = objectLike.parse(raw, opts);
+            if (!parsedObject.ok) {
+                return parsedObject;
+            }
+            const additionalProperties = {};
+            for (const key in properties) {
+                if (_hasOwn.call(properties, key)) {
+                    const value = properties[key];
+                    additionalProperties[key] =
+                        typeof value === "function" ? value(parsedObject.value) : value;
+                }
+            }
+            return {
+                ok: true,
+                value: {
+                    ...parsedObject.value,
+                    ...additionalProperties,
+                },
+            };
+        },
+        json: (parsed, opts) => {
+            if (!(0, isPlainObject_js_1.isPlainObject)(parsed)) {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: opts?.breadcrumbsPrefix ?? [],
+                            message: (0, getErrorMessageForIncorrectType_js_1.getErrorMessageForIncorrectType)(parsed, "object"),
+                        },
+                    ],
+                };
+            }
+            // strip out added properties
+            const addedPropertyKeys = new Set(Object.keys(properties));
+            const parsedWithoutAddedProperties = (0, filterObject_js_1.filterObject)(parsed, Object.keys(parsed).filter((key) => !addedPropertyKeys.has(key)));
+            return objectLike.json(parsedWithoutAddedProperties, opts);
+        },
+        getType: () => objectLike.getType(),
+    };
+    return {
+        ...objectSchema,
+        ...(0, index_js_1.getSchemaUtils)(objectSchema),
+        ...getObjectLikeUtils(objectSchema),
+    };
+}

package/dist/core/schemas/builders/object-like/index.d.ts

@@ -0,0 +1,2 @@
+export { getObjectLikeUtils, withParsedProperties } from "./getObjectLikeUtils.js";
+export type { ObjectLikeSchema, ObjectLikeUtils } from "./types.js";

package/dist/core/schemas/builders/object-like/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withParsedProperties = exports.getObjectLikeUtils = void 0;
+var getObjectLikeUtils_js_1 = require("./getObjectLikeUtils.js");
+Object.defineProperty(exports, "getObjectLikeUtils", { enumerable: true, get: function () { return getObjectLikeUtils_js_1.getObjectLikeUtils; } });
+Object.defineProperty(exports, "withParsedProperties", { enumerable: true, get: function () { return getObjectLikeUtils_js_1.withParsedProperties; } });

package/dist/core/schemas/builders/object-like/types.d.ts

@@ -0,0 +1,7 @@
+import type { BaseSchema, Schema } from "../../Schema.js";
+export type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
+export interface ObjectLikeUtils<Raw, Parsed> {
+    withParsedProperties: <T extends Record<string, any>>(properties: {
+        [K in keyof T]: T[K] | ((parsed: Parsed) => T[K]);
+    }) => ObjectLikeSchema<Raw, Parsed & T>;
+}

package/dist/core/schemas/builders/primitives/any.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.js";
+export declare const any: () => Schema<any, any>;

package/dist/core/schemas/builders/primitives/any.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.any = void 0;
+const Schema_js_1 = require("../../Schema.js");
+const createIdentitySchemaCreator_js_1 = require("../../utils/createIdentitySchemaCreator.js");
+exports.any = (0, createIdentitySchemaCreator_js_1.createIdentitySchemaCreator)(Schema_js_1.SchemaType.ANY, (value) => ({
+    ok: true,
+    value,
+}));

package/dist/core/schemas/builders/primitives/boolean.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.js";
+export declare const boolean: () => Schema<boolean, boolean>;

package/dist/core/schemas/builders/primitives/boolean.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const Schema_js_1 = require("../../Schema.js");
+const createIdentitySchemaCreator_js_1 = require("../../utils/createIdentitySchemaCreator.js");
+const getErrorMessageForIncorrectType_js_1 = require("../../utils/getErrorMessageForIncorrectType.js");
+exports.boolean = (0, createIdentitySchemaCreator_js_1.createIdentitySchemaCreator)(Schema_js_1.SchemaType.BOOLEAN, (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "boolean") {
+        return {
+            ok: true,
+            value,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_js_1.getErrorMessageForIncorrectType)(value, "boolean"),
+                },
+            ],
+        };
+    }
+});

package/dist/core/schemas/builders/primitives/index.d.ts

@@ -0,0 +1,6 @@
+export { any } from "./any.js";
+export { boolean } from "./boolean.js";
+export { never } from "./never.js";
+export { number } from "./number.js";
+export { string } from "./string.js";
+export { unknown } from "./unknown.js";

package/dist/core/schemas/builders/primitives/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unknown = exports.string = exports.number = exports.never = exports.boolean = exports.any = void 0;
+var any_js_1 = require("./any.js");
+Object.defineProperty(exports, "any", { enumerable: true, get: function () { return any_js_1.any; } });
+var boolean_js_1 = require("./boolean.js");
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return boolean_js_1.boolean; } });
+var never_js_1 = require("./never.js");
+Object.defineProperty(exports, "never", { enumerable: true, get: function () { return never_js_1.never; } });
+var number_js_1 = require("./number.js");
+Object.defineProperty(exports, "number", { enumerable: true, get: function () { return number_js_1.number; } });
+var string_js_1 = require("./string.js");
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return string_js_1.string; } });
+var unknown_js_1 = require("./unknown.js");
+Object.defineProperty(exports, "unknown", { enumerable: true, get: function () { return unknown_js_1.unknown; } });

package/dist/core/schemas/builders/primitives/never.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.js";
+export declare const never: () => Schema<never, never>;

package/dist/core/schemas/builders/primitives/never.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.never = void 0;
+const Schema_js_1 = require("../../Schema.js");
+const createIdentitySchemaCreator_js_1 = require("../../utils/createIdentitySchemaCreator.js");
+exports.never = (0, createIdentitySchemaCreator_js_1.createIdentitySchemaCreator)(Schema_js_1.SchemaType.NEVER, (_value, { breadcrumbsPrefix = [] } = {}) => ({
+    ok: false,
+    errors: [
+        {
+            path: breadcrumbsPrefix,
+            message: "Expected never",
+        },
+    ],
+}));

package/dist/core/schemas/builders/primitives/number.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.js";
+export declare const number: () => Schema<number, number>;

package/dist/core/schemas/builders/primitives/number.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.number = void 0;
+const Schema_js_1 = require("../../Schema.js");
+const createIdentitySchemaCreator_js_1 = require("../../utils/createIdentitySchemaCreator.js");
+const getErrorMessageForIncorrectType_js_1 = require("../../utils/getErrorMessageForIncorrectType.js");
+exports.number = (0, createIdentitySchemaCreator_js_1.createIdentitySchemaCreator)(Schema_js_1.SchemaType.NUMBER, (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "number") {
+        return {
+            ok: true,
+            value,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_js_1.getErrorMessageForIncorrectType)(value, "number"),
+                },
+            ],
+        };
+    }
+});

package/dist/core/schemas/builders/primitives/string.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.js";
+export declare const string: () => Schema<string, string>;

package/dist/core/schemas/builders/primitives/string.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = void 0;
+const Schema_js_1 = require("../../Schema.js");
+const createIdentitySchemaCreator_js_1 = require("../../utils/createIdentitySchemaCreator.js");
+const getErrorMessageForIncorrectType_js_1 = require("../../utils/getErrorMessageForIncorrectType.js");
+exports.string = (0, createIdentitySchemaCreator_js_1.createIdentitySchemaCreator)(Schema_js_1.SchemaType.STRING, (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "string") {
+        return {
+            ok: true,
+            value,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_js_1.getErrorMessageForIncorrectType)(value, "string"),
+                },
+            ],
+        };
+    }
+});

package/dist/core/schemas/builders/primitives/unknown.d.ts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.js";
+export declare const unknown: () => Schema<unknown, unknown>;

package/dist/core/schemas/builders/primitives/unknown.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unknown = void 0;
+const Schema_js_1 = require("../../Schema.js");
+const createIdentitySchemaCreator_js_1 = require("../../utils/createIdentitySchemaCreator.js");
+exports.unknown = (0, createIdentitySchemaCreator_js_1.createIdentitySchemaCreator)(Schema_js_1.SchemaType.UNKNOWN, (value) => ({ ok: true, value }));

package/dist/core/schemas/builders/record/index.d.ts

@@ -0,0 +1,2 @@
+export { partialRecord, record } from "./record.js";
+export type { BasePartialRecordSchema, BaseRecordSchema, PartialRecordSchema, RecordSchema } from "./types.js";

package/dist/core/schemas/builders/record/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = exports.partialRecord = void 0;
+var record_js_1 = require("./record.js");
+Object.defineProperty(exports, "partialRecord", { enumerable: true, get: function () { return record_js_1.partialRecord; } });
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return record_js_1.record; } });

package/dist/core/schemas/builders/record/record.d.ts

@@ -0,0 +1,4 @@
+import { type Schema } from "../../Schema.js";
+import type { PartialRecordSchema, RecordSchema } from "./types.js";
+export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;
+export declare function partialRecord<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): PartialRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/dist/core/schemas/builders/record/record.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = record;
+exports.partialRecord = partialRecord;
+const Schema_js_1 = require("../../Schema.js");
+const getErrorMessageForIncorrectType_js_1 = require("../../utils/getErrorMessageForIncorrectType.js");
+const isPlainObject_js_1 = require("../../utils/isPlainObject.js");
+const maybeSkipValidation_js_1 = require("../../utils/maybeSkipValidation.js");
+const index_js_1 = require("../schema-utils/index.js");
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const _hasOwn = Object.prototype.hasOwnProperty;
+function record(keySchema, valueSchema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            return validateAndTransformRecord({
+                value: raw,
+                isKeyNumeric: keySchema.getType() === Schema_js_1.SchemaType.NUMBER,
+                transformKey: (key) => keySchema.parse(key, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key} (key)`],
+                }),
+                transformValue: (value, key) => valueSchema.parse(value, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key}`],
+                }),
+                breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+            });
+        },
+        json: (parsed, opts) => {
+            return validateAndTransformRecord({
+                value: parsed,
+                isKeyNumeric: keySchema.getType() === Schema_js_1.SchemaType.NUMBER,
+                transformKey: (key) => keySchema.json(key, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key} (key)`],
+                }),
+                transformValue: (value, key) => valueSchema.json(value, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key}`],
+                }),
+                breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+            });
+        },
+        getType: () => Schema_js_1.SchemaType.RECORD,
+    };
+    return {
+        ...(0, maybeSkipValidation_js_1.maybeSkipValidation)(baseSchema),
+        ...(0, index_js_1.getSchemaUtils)(baseSchema),
+    };
+}
+function partialRecord(keySchema, valueSchema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            return validateAndTransformRecord({
+                value: raw,
+                isKeyNumeric: keySchema.getType() === Schema_js_1.SchemaType.NUMBER,
+                transformKey: (key) => keySchema.parse(key, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key} (key)`],
+                }),
+                transformValue: (value, key) => valueSchema.parse(value, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key}`],
+                }),
+                breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+            });
+        },
+        json: (parsed, opts) => {
+            return validateAndTransformRecord({
+                value: parsed,
+                isKeyNumeric: keySchema.getType() === Schema_js_1.SchemaType.NUMBER,
+                transformKey: (key) => keySchema.json(key, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key} (key)`],
+                }),
+                transformValue: (value, key) => valueSchema.json(value, {
+                    ...opts,
+                    breadcrumbsPrefix: [...(opts?.breadcrumbsPrefix ?? []), `${key}`],
+                }),
+                breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+            });
+        },
+        getType: () => Schema_js_1.SchemaType.RECORD,
+    };
+    return {
+        ...(0, maybeSkipValidation_js_1.maybeSkipValidation)(baseSchema),
+        ...(0, index_js_1.getSchemaUtils)(baseSchema),
+    };
+}
+function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
+    if (!(0, isPlainObject_js_1.isPlainObject)(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_js_1.getErrorMessageForIncorrectType)(value, "object"),
+                },
+            ],
+        };
+    }
+    const result = {};
+    const errors = [];
+    for (const stringKey in value) {
+        if (!_hasOwn.call(value, stringKey)) {
+            continue;
+        }
+        const entryValue = value[stringKey];
+        if (entryValue === undefined) {
+            continue;
+        }
+        let key = stringKey;
+        if (isKeyNumeric) {
+            const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+            if (!Number.isNaN(numberKey)) {
+                key = numberKey;
+            }
+        }
+        const transformedKey = transformKey(key);
+        const transformedValue = transformValue(entryValue, key);
+        if (transformedKey.ok && transformedValue.ok) {
+            result[transformedKey.value] = transformedValue.value;
+        }
+        else {
+            if (!transformedKey.ok) {
+                errors.push(...transformedKey.errors);
+            }
+            if (!transformedValue.ok) {
+                errors.push(...transformedValue.errors);
+            }
+        }
+    }
+    if (errors.length === 0) {
+        return { ok: true, value: result };
+    }
+    return { ok: false, errors };
+}

package/dist/core/schemas/builders/record/types.d.ts

@@ -0,0 +1,6 @@
+import type { BaseSchema } from "../../Schema.js";
+import type { SchemaUtils } from "../schema-utils/index.js";
+export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type PartialRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BasePartialRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Partial<Record<ParsedKey, ParsedValue>>>;
+export type BasePartialRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Partial<Record<ParsedKey, ParsedValue>>>;

package/dist/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationError } from "../../Schema.js";
+export declare class JsonError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

package/dist/core/schemas/builders/schema-utils/JsonError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonError = void 0;
+const stringifyValidationErrors_js_1 = require("./stringifyValidationErrors.js");
+class JsonError extends Error {
+    constructor(errors) {
+        super(errors.map(stringifyValidationErrors_js_1.stringifyValidationError).join("; "));
+        this.errors = errors;
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = this.constructor.name;
+    }
+}
+exports.JsonError = JsonError;

package/dist/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationError } from "../../Schema.js";
+export declare class ParseError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

package/dist/core/schemas/builders/schema-utils/ParseError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = void 0;
+const stringifyValidationErrors_js_1 = require("./stringifyValidationErrors.js");
+class ParseError extends Error {
+    constructor(errors) {
+        super(errors.map(stringifyValidationErrors_js_1.stringifyValidationError).join("; "));
+        this.errors = errors;
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = this.constructor.name;
+    }
+}
+exports.ParseError = ParseError;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -0,0 +1,21 @@
+import { type BaseSchema, type Schema, type SchemaOptions } from "../../Schema.js";
+export interface SchemaUtils<Raw, Parsed> {
+    nullable: () => Schema<Raw | null, Parsed | null>;
+    optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
+    optionalNullable: () => Schema<Raw | null | undefined, Parsed | null | undefined>;
+    transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
+    parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
+    jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Raw;
+}
+export interface SchemaTransformer<Parsed, Transformed> {
+    transform: (parsed: Parsed) => Transformed;
+    untransform: (transformed: any) => Parsed;
+}
+export declare function getSchemaUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): SchemaUtils<Raw, Parsed>;
+/**
+ * schema utils are defined in one file to resolve issues with circular imports
+ */
+export declare function nullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null, Parsed | null>;
+export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | undefined>;
+export declare function optionalNullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | null | undefined>;
+export declare function transform<Raw, Parsed, Transformed>(schema: BaseSchema<Raw, Parsed>, transformer: SchemaTransformer<Parsed, Transformed>): Schema<Raw, Transformed>;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaUtils = getSchemaUtils;
+exports.nullable = nullable;
+exports.optional = optional;
+exports.optionalNullable = optionalNullable;
+exports.transform = transform;
+const Schema_js_1 = require("../../Schema.js");
+const JsonError_js_1 = require("./JsonError.js");
+const ParseError_js_1 = require("./ParseError.js");
+function getSchemaUtils(schema) {
+    return {
+        nullable: () => nullable(schema),
+        optional: () => optional(schema),
+        optionalNullable: () => optionalNullable(schema),
+        transform: (transformer) => transform(schema, transformer),
+        parseOrThrow: (raw, opts) => {
+            const parsed = schema.parse(raw, opts);
+            if (parsed.ok) {
+                return parsed.value;
+            }
+            throw new ParseError_js_1.ParseError(parsed.errors);
+        },
+        jsonOrThrow: (parsed, opts) => {
+            const raw = schema.json(parsed, opts);
+            if (raw.ok) {
+                return raw.value;
+            }
+            throw new JsonError_js_1.JsonError(raw.errors);
+        },
+    };
+}
+/**
+ * schema utils are defined in one file to resolve issues with circular imports
+ */
+function nullable(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (parsed == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_js_1.SchemaType.NULLABLE,
+    };
+    return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+    };
+}
+function optional(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw == null) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (opts?.omitUndefined && parsed === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (parsed == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_js_1.SchemaType.OPTIONAL,
+    };
+    return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+    };
+}
+function optionalNullable(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (raw === null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (parsed === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (parsed === null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_js_1.SchemaType.OPTIONAL_NULLABLE,
+    };
+    return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+    };
+}
+function transform(schema, transformer) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            const parsed = schema.parse(raw, opts);
+            if (!parsed.ok) {
+                return parsed;
+            }
+            return {
+                ok: true,
+                value: transformer.transform(parsed.value),
+            };
+        },
+        json: (transformed, opts) => {
+            const parsed = transformer.untransform(transformed);
+            return schema.json(parsed, opts);
+        },
+        getType: () => schema.getType(),
+    };
+    return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+    };
+}

package/dist/core/schemas/builders/schema-utils/index.d.ts

@@ -0,0 +1,4 @@
+export type { SchemaUtils } from "./getSchemaUtils.js";
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils.js";
+export { JsonError } from "./JsonError.js";
+export { ParseError } from "./ParseError.js";

package/dist/core/schemas/builders/schema-utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = exports.JsonError = exports.transform = exports.optional = exports.getSchemaUtils = void 0;
+var getSchemaUtils_js_1 = require("./getSchemaUtils.js");
+Object.defineProperty(exports, "getSchemaUtils", { enumerable: true, get: function () { return getSchemaUtils_js_1.getSchemaUtils; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return getSchemaUtils_js_1.optional; } });
+Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return getSchemaUtils_js_1.transform; } });
+var JsonError_js_1 = require("./JsonError.js");
+Object.defineProperty(exports, "JsonError", { enumerable: true, get: function () { return JsonError_js_1.JsonError; } });
+var ParseError_js_1 = require("./ParseError.js");
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return ParseError_js_1.ParseError; } });