@livon/schema 0.27.0-rc.1

package/dist/string.spec.cjs

@@ -0,0 +1,158 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_string_cjs_namespaceObject = require("./string.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+external_vitest_namespaceObject.vi.mock('./typeGuards.js', ()=>({
+        isString: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isStringMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isString);
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)();
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('string()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isStringMock.mockReset();
+        isStringMock.mockReturnValue(true);
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        isStringMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isStringMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when string schema is created', ()=>{
+            const result = (0, external_string_cjs_namespaceObject.string)();
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('string');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('string');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'string',
+                name: 'string'
+            });
+            (0, external_vitest_namespaceObject.expect)(Object.keys(factoryInput.chain)).toEqual([
+                'min',
+                'max',
+                'email',
+                'regex'
+            ]);
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'string doc'
+            };
+            (0, external_string_cjs_namespaceObject.string)({
+                name: 'Title',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Title');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual(doc);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'string',
+                name: 'Title'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should validate input through isString when input is string', ()=>{
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('abc', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe('abc');
+            (0, external_vitest_namespaceObject.expect)(isStringMock).toHaveBeenCalledWith('abc');
+        });
+        (0, external_vitest_namespaceObject.it)('should return input for all chain methods when constraints are valid', ()=>{
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.min('abcd', schemaContextMock)(3)).toBe('abcd');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.max('abcd', schemaContextMock)(5)).toBe('abcd');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.email('a@b.c', schemaContextMock)()).toBe('a@b.c');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.regex('abc-123', schemaContextMock)(/^[a-z]+-\d+$/)).toBe('abc-123');
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw schema error payload when input is not string', ()=>{
+            isStringMock.mockReturnValue(false);
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate(10, schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Data is not a string',
+                code: 'string.type'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw min error when input length is below minimum', ()=>{
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.min('ab', schemaContextMock)(3));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'String is too short',
+                code: 'string.min',
+                context: {
+                    min: 3
+                }
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw max error when input length is above maximum', ()=>{
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.max('abcdef', schemaContextMock)(5));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'String is too long',
+                code: 'string.max',
+                context: {
+                    max: 5
+                }
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw email error when input is not an email', ()=>{
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.email('abc', schemaContextMock)());
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Invalid email format',
+                code: 'string.email'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw regex error when input does not match pattern', ()=>{
+            (0, external_string_cjs_namespaceObject.string)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.regex('abc', schemaContextMock)(/^\d+$/));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'String does not match pattern',
+                code: 'string.regex',
+                context: {
+                    pattern: '^\\d+$'
+                }
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/string.spec.d.ts

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

package/dist/string.spec.js

@@ -0,0 +1,152 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { schemaFactory } from "./schemaFactory.js";
+import { string } from "./string.js";
+import { isString } from "./typeGuards.js";
+import { captureThrow, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isString: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isStringMock = vi.mocked(isString);
+const schemaContextMock = createSchemaContextMock();
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+describe('string()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isStringMock.mockReset();
+        isStringMock.mockReturnValue(true);
+    });
+    afterEach(()=>{
+        isStringMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isStringMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when string schema is created', ()=>{
+            const result = string();
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('string');
+            expect(factoryInput.type).toBe('string');
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'string',
+                name: 'string'
+            });
+            expect(Object.keys(factoryInput.chain)).toEqual([
+                'min',
+                'max',
+                'email',
+                'regex'
+            ]);
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'string doc'
+            };
+            string({
+                name: 'Title',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Title');
+            expect(factoryInput.doc).toEqual(doc);
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'string',
+                name: 'Title'
+            });
+        });
+        it('should validate input through isString when input is string', ()=>{
+            string();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('abc', schemaContextMock);
+            expect(parsed).toBe('abc');
+            expect(isStringMock).toHaveBeenCalledWith('abc');
+        });
+        it('should return input for all chain methods when constraints are valid', ()=>{
+            string();
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.chain.min('abcd', schemaContextMock)(3)).toBe('abcd');
+            expect(factoryInput.chain.max('abcd', schemaContextMock)(5)).toBe('abcd');
+            expect(factoryInput.chain.email('a@b.c', schemaContextMock)()).toBe('a@b.c');
+            expect(factoryInput.chain.regex('abc-123', schemaContextMock)(/^[a-z]+-\d+$/)).toBe('abc-123');
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw schema error payload when input is not string', ()=>{
+            isStringMock.mockReturnValue(false);
+            string();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate(10, schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Data is not a string',
+                code: 'string.type'
+            });
+        });
+        it('should throw min error when input length is below minimum', ()=>{
+            string();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.min('ab', schemaContextMock)(3));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'String is too short',
+                code: 'string.min',
+                context: {
+                    min: 3
+                }
+            });
+        });
+        it('should throw max error when input length is above maximum', ()=>{
+            string();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.max('abcdef', schemaContextMock)(5));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'String is too long',
+                code: 'string.max',
+                context: {
+                    max: 5
+                }
+            });
+        });
+        it('should throw email error when input is not an email', ()=>{
+            string();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.email('abc', schemaContextMock)());
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Invalid email format',
+                code: 'string.email'
+            });
+        });
+        it('should throw regex error when input does not match pattern', ()=>{
+            string();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.regex('abc', schemaContextMock)(/^\d+$/));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'String does not match pattern',
+                code: 'string.regex',
+                context: {
+                    pattern: '^\\d+$'
+                }
+            });
+        });
+    });
+});

package/dist/testing/mocks/assertions.mock.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    captureThrow: ()=>captureThrow
+});
+const captureThrow = (fn)=>{
+    try {
+        fn();
+        return {
+            threw: false
+        };
+    } catch (error) {
+        return {
+            threw: true,
+            value: error
+        };
+    }
+};
+exports.captureThrow = __webpack_exports__.captureThrow;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "captureThrow"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/testing/mocks/assertions.mock.d.ts

@@ -0,0 +1,5 @@
+export interface CapturedThrow {
+    threw: boolean;
+    value?: unknown;
+}
+export declare const captureThrow: (fn: () => unknown) => CapturedThrow;

package/dist/testing/mocks/assertions.mock.js

@@ -0,0 +1,14 @@
+const captureThrow = (fn)=>{
+    try {
+        fn();
+        return {
+            threw: false
+        };
+    } catch (error) {
+        return {
+            threw: true,
+            value: error
+        };
+    }
+};
+export { captureThrow };

package/dist/testing/mocks/index.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createSchemaWithChainMock: ()=>external_schema_mock_cjs_namespaceObject.createSchemaWithChainMock,
+    createBaseSchemaMock: ()=>external_schema_mock_cjs_namespaceObject.createBaseSchemaMock,
+    captureThrow: ()=>external_assertions_mock_cjs_namespaceObject.captureThrow,
+    createSchemaContextMock: ()=>external_schema_mock_cjs_namespaceObject.createSchemaContextMock,
+    createSchemaFactoryMock: ()=>external_schema_mock_cjs_namespaceObject.createSchemaFactoryMock,
+    createSchemaStateMock: ()=>external_schema_mock_cjs_namespaceObject.createSchemaStateMock
+});
+const external_schema_mock_cjs_namespaceObject = require("./schema.mock.cjs");
+const external_assertions_mock_cjs_namespaceObject = require("./assertions.mock.cjs");
+exports.captureThrow = __webpack_exports__.captureThrow;
+exports.createBaseSchemaMock = __webpack_exports__.createBaseSchemaMock;
+exports.createSchemaContextMock = __webpack_exports__.createSchemaContextMock;
+exports.createSchemaFactoryMock = __webpack_exports__.createSchemaFactoryMock;
+exports.createSchemaStateMock = __webpack_exports__.createSchemaStateMock;
+exports.createSchemaWithChainMock = __webpack_exports__.createSchemaWithChainMock;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "captureThrow",
+    "createBaseSchemaMock",
+    "createSchemaContextMock",
+    "createSchemaFactoryMock",
+    "createSchemaStateMock",
+    "createSchemaWithChainMock"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/testing/mocks/index.d.ts

@@ -0,0 +1,4 @@
+export { createBaseSchemaMock, createSchemaStateMock, createSchemaContextMock, createSchemaWithChainMock, createSchemaFactoryMock, } from './schema.mock.js';
+export { captureThrow } from './assertions.mock.js';
+export type { BaseSchemaMockOverrides, SchemaStateMockOverrides, SchemaContextMockOverrides, SchemaWithChainMockInput, SchemaFactoryMockInput, SchemaFactoryMock, } from './schema.mock.js';
+export type { CapturedThrow } from './assertions.mock.js';

package/dist/testing/mocks/index.js

@@ -0,0 +1,3 @@
+import { createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock, createSchemaStateMock, createSchemaWithChainMock } from "./schema.mock.js";
+import { captureThrow } from "./assertions.mock.js";
+export { captureThrow, createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock, createSchemaStateMock, createSchemaWithChainMock };

package/dist/testing/mocks/schema.mock.cjs

@@ -0,0 +1,120 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createSchemaWithChainMock: ()=>createSchemaWithChainMock,
+    createBaseSchemaMock: ()=>createBaseSchemaMock,
+    createSchemaContextMock: ()=>createSchemaContextMock,
+    createSchemaFactoryMock: ()=>createSchemaFactoryMock,
+    createSchemaStateMock: ()=>createSchemaStateMock
+});
+const external_vitest_namespaceObject = require("vitest");
+const createSchemaStateMock = (overrides = {})=>({
+        get: external_vitest_namespaceObject.vi.fn(()=>void 0),
+        set: external_vitest_namespaceObject.vi.fn(()=>void 0),
+        update: external_vitest_namespaceObject.vi.fn(()=>void 0),
+        snapshot: external_vitest_namespaceObject.vi.fn(()=>({})),
+        ...overrides
+    });
+const createSchemaContextMock = (overrides = {})=>{
+    const state = overrides.state ?? createSchemaStateMock();
+    const getBuildContext = external_vitest_namespaceObject.vi.fn(()=>overrides.buildContext);
+    const setBuildContext = external_vitest_namespaceObject.vi.fn(()=>void 0);
+    const getRequestContext = external_vitest_namespaceObject.vi.fn(()=>overrides.requestContext);
+    const setRequestContext = external_vitest_namespaceObject.vi.fn((_input)=>void 0);
+    return {
+        getBuildContext,
+        setBuildContext,
+        getRequestContext,
+        setRequestContext,
+        get request () {
+            return overrides.requestContext;
+        },
+        state,
+        ...overrides
+    };
+};
+const createDefaultAstNode = (name, type)=>({
+        name,
+        type
+    });
+const createBaseSchemaMock = (overrides = {})=>{
+    const name = overrides.name ?? 'schema.mock';
+    const type = overrides.type ?? 'schema.mock';
+    const astNode = overrides.astNode ?? createDefaultAstNode(name, type);
+    const outputValue = overrides.outputValue;
+    const validateResult = overrides.validateResult ?? {
+        ok: true,
+        value: outputValue
+    };
+    const schema = {};
+    schema.name = name;
+    schema.type = type;
+    schema.ast = external_vitest_namespaceObject.vi.fn(()=>astNode);
+    schema.validate = external_vitest_namespaceObject.vi.fn(()=>validateResult);
+    schema.parse = external_vitest_namespaceObject.vi.fn(()=>outputValue);
+    schema.typed = external_vitest_namespaceObject.vi.fn((input)=>input);
+    schema.optional = external_vitest_namespaceObject.vi.fn(()=>schema);
+    schema.nullable = external_vitest_namespaceObject.vi.fn(()=>schema);
+    schema.describe = external_vitest_namespaceObject.vi.fn(()=>schema);
+    schema.refine = external_vitest_namespaceObject.vi.fn(()=>schema);
+    schema.before = external_vitest_namespaceObject.vi.fn(()=>schema);
+    schema.after = external_vitest_namespaceObject.vi.fn(()=>schema);
+    schema.and = external_vitest_namespaceObject.vi.fn(()=>schema);
+    return {
+        ...schema,
+        ...overrides
+    };
+};
+const createSchemaWithChainMock = (input = {})=>{
+    const schema = createBaseSchemaMock({
+        name: input.name,
+        type: input.type
+    });
+    (input.chainKeys ?? []).forEach((chainKey)=>{
+        schema[chainKey] = external_vitest_namespaceObject.vi.fn(()=>schema);
+    });
+    return input.overrides ? Object.assign(schema, input.overrides) : schema;
+};
+const createSchemaFactoryMock = ()=>external_vitest_namespaceObject.vi.fn((factoryInput)=>createSchemaWithChainMock({
+            name: factoryInput.name,
+            type: factoryInput.type,
+            chainKeys: Object.keys(factoryInput.chain ?? {})
+        }));
+exports.createBaseSchemaMock = __webpack_exports__.createBaseSchemaMock;
+exports.createSchemaContextMock = __webpack_exports__.createSchemaContextMock;
+exports.createSchemaFactoryMock = __webpack_exports__.createSchemaFactoryMock;
+exports.createSchemaStateMock = __webpack_exports__.createSchemaStateMock;
+exports.createSchemaWithChainMock = __webpack_exports__.createSchemaWithChainMock;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBaseSchemaMock",
+    "createSchemaContextMock",
+    "createSchemaFactoryMock",
+    "createSchemaStateMock",
+    "createSchemaWithChainMock"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/testing/mocks/schema.mock.d.ts

@@ -0,0 +1,37 @@
+import { vi } from 'vitest';
+import type { AstNode, Schema, SchemaBuildContext, SchemaContext, SchemaDoc, SchemaRequestContext, SchemaState, SchemaResult } from '../../types.js';
+import type { SchemaFactoryChainDefinition, SchemaWithChain } from '../../schemaFactory.js';
+export interface BaseSchemaMockOverrides<TValue> extends Partial<Schema<TValue>> {
+    name?: string;
+    type?: string;
+    astNode?: AstNode;
+    outputValue?: TValue;
+    validateResult?: SchemaResult<TValue>;
+}
+export interface SchemaStateMockOverrides extends Partial<SchemaState> {
+}
+export declare const createSchemaStateMock: (overrides?: SchemaStateMockOverrides) => SchemaState;
+export interface SchemaContextMockOverrides extends Partial<SchemaContext> {
+    buildContext?: SchemaBuildContext;
+    requestContext?: SchemaRequestContext;
+    state?: SchemaState;
+}
+export declare const createSchemaContextMock: (overrides?: SchemaContextMockOverrides) => SchemaContext;
+export declare const createBaseSchemaMock: <TValue>(overrides?: BaseSchemaMockOverrides<TValue>) => Schema<TValue>;
+export interface SchemaWithChainMockInput<TValue = unknown> {
+    name?: string;
+    type?: string;
+    chainKeys?: readonly string[];
+    overrides?: Partial<SchemaWithChain<TValue, SchemaFactoryChainDefinition<TValue>>>;
+}
+export declare const createSchemaWithChainMock: <TValue = unknown>(input?: SchemaWithChainMockInput<TValue>) => SchemaWithChain<TValue, SchemaFactoryChainDefinition<TValue>>;
+export interface SchemaFactoryMockInput {
+    name: string;
+    type: string;
+    doc?: SchemaDoc;
+    ast: (ctx: SchemaContext) => AstNode;
+    validate: (input: unknown, ctx: SchemaContext) => unknown;
+    chain?: Record<string, (value: unknown, ctx: SchemaContext) => (...args: readonly unknown[]) => unknown>;
+}
+export type SchemaFactoryMock = ReturnType<typeof vi.fn<(input: SchemaFactoryMockInput) => SchemaWithChain<unknown, SchemaFactoryChainDefinition<unknown>>>>;
+export declare const createSchemaFactoryMock: () => SchemaFactoryMock;