@livon/schema 0.27.0-rc.1

package/dist/number.spec.js

@@ -0,0 +1,149 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { number } from "./number.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { isNumber } from "./typeGuards.js";
+import { captureThrow, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isNumber: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isNumberMock = vi.mocked(isNumber);
+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('number()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isNumberMock.mockReset();
+        isNumberMock.mockReturnValue(true);
+    });
+    afterEach(()=>{
+        isNumberMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isNumberMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when number schema is created', ()=>{
+            const result = number();
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('number');
+            expect(factoryInput.type).toBe('number');
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'number',
+                name: 'number'
+            });
+            expect(Object.keys(factoryInput.chain)).toEqual([
+                'min',
+                'max',
+                'int',
+                'positive'
+            ]);
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'number doc'
+            };
+            number({
+                name: 'Count',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Count');
+            expect(factoryInput.doc).toEqual(doc);
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'number',
+                name: 'Count'
+            });
+        });
+        it('should validate input through isNumber when input is number', ()=>{
+            number();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(42, schemaContextMock);
+            expect(parsed).toBe(42);
+            expect(isNumberMock).toHaveBeenCalledWith(42);
+        });
+        it('should return input for all chain methods when constraints are valid', ()=>{
+            number();
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.chain.min(5, schemaContextMock)(1)).toBe(5);
+            expect(factoryInput.chain.max(5, schemaContextMock)(8)).toBe(5);
+            expect(factoryInput.chain.int(5, schemaContextMock)()).toBe(5);
+            expect(factoryInput.chain.positive(5, schemaContextMock)()).toBe(5);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw schema error payload when input is not number', ()=>{
+            isNumberMock.mockReturnValue(false);
+            number();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Data is not a number',
+                code: 'number.type'
+            });
+        });
+        it('should throw min error when value is below minimum', ()=>{
+            number();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.min(1, schemaContextMock)(5));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected number >= 5',
+                code: 'number.min',
+                context: {
+                    min: 5
+                }
+            });
+        });
+        it('should throw max error when value is above maximum', ()=>{
+            number();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.max(10, schemaContextMock)(8));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected number <= 8',
+                code: 'number.max',
+                context: {
+                    max: 8
+                }
+            });
+        });
+        it('should throw int error when value is not integer', ()=>{
+            number();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.int(2.5, schemaContextMock)());
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected integer',
+                code: 'number.int'
+            });
+        });
+        it('should throw positive error when value is not positive', ()=>{
+            number();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.positive(0, schemaContextMock)());
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected positive number',
+                code: 'number.positive'
+            });
+        });
+    });
+});

package/dist/object.cjs

@@ -0,0 +1,66 @@
+"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__, {
+    object: ()=>object
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const object = ({ name, shape, doc })=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'object',
+        doc,
+        ast: (ctx)=>{
+            const build = ctx.getBuildContext();
+            return {
+                type: 'object',
+                name,
+                children: Object.entries(shape).map(([key, schema])=>({
+                        type: 'field',
+                        name: key,
+                        children: [
+                            schema.ast(build ?? void 0)
+                        ]
+                    }))
+            };
+        },
+        validate: (input, ctx)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isRecord)(input)) throw {
+                message: 'Expected object',
+                code: 'object.type'
+            };
+            return Object.entries(shape).reduce((acc, [key, schema])=>({
+                    ...acc,
+                    [key]: schema.parse(input[key], ctx)
+                }), {});
+        }
+    });
+exports.object = __webpack_exports__.object;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "object"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/object.d.ts

@@ -0,0 +1,37 @@
+import { SchemaWithChain } from './schemaFactory.js';
+import { Schema, Shape, SchemaDoc } from './types.js';
+type AnySchema = Schema<any>;
+export interface ObjectSchemaInput<TShape extends Shape> {
+    name: string;
+    shape: TShape;
+    doc?: SchemaDoc;
+}
+/**
+ * object is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/object
+ *
+ * @example
+ * // Creates an object schema with id and age fields.
+ * const User = object({
+ *   name: 'user',
+ *   shape: {
+ *     id: string(),
+ *     age: number(),
+ *   },
+ * });
+ * User.parse({ id: 'u1', age: 21 });
+ *
+ * @example
+ * // Extends object validation to also allow null.
+ * const MaybeUser = object({
+ *   name: 'user',
+ *   shape: { id: string() },
+ * }).nullable();
+ * MaybeUser.parse(null);
+ */
+export declare const object: <TShape extends Record<string, AnySchema>>({ name, shape, doc, }: ObjectSchemaInput<TShape>) => SchemaWithChain<{ [K in keyof TShape]: ReturnType<TShape[K]["parse"]>; }, {}>;
+export {};

package/dist/object.js

@@ -0,0 +1,32 @@
+import { schemaFactory } from "./schemaFactory.js";
+import { isRecord } from "./typeGuards.js";
+const object = ({ name, shape, doc })=>schemaFactory({
+        name,
+        type: 'object',
+        doc,
+        ast: (ctx)=>{
+            const build = ctx.getBuildContext();
+            return {
+                type: 'object',
+                name,
+                children: Object.entries(shape).map(([key, schema])=>({
+                        type: 'field',
+                        name: key,
+                        children: [
+                            schema.ast(build ?? void 0)
+                        ]
+                    }))
+            };
+        },
+        validate: (input, ctx)=>{
+            if (!isRecord(input)) throw {
+                message: 'Expected object',
+                code: 'object.type'
+            };
+            return Object.entries(shape).reduce((acc, [key, schema])=>({
+                    ...acc,
+                    [key]: schema.parse(input[key], ctx)
+                }), {});
+        }
+    });
+export { object };

package/dist/object.spec.cjs

@@ -0,0 +1,171 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_object_cjs_namespaceObject = require("./object.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.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', ()=>({
+        isRecord: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isRecordMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isRecord);
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const buildContextMock = {
+    buildId: 'build-object',
+    builder: {
+        add: external_vitest_namespaceObject.vi.fn((node)=>node),
+        getAll: external_vitest_namespaceObject.vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)({
+    buildContext: buildContextMock
+});
+const idSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'idSchema',
+    parse: external_vitest_namespaceObject.vi.fn((value)=>`id:${String(value)}`),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'string',
+            name: 'Id'
+        }))
+});
+const ageSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'ageSchema',
+    parse: external_vitest_namespaceObject.vi.fn((value)=>Number(value)),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'number',
+            name: 'Age'
+        }))
+});
+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)('object()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+        isRecordMock.mockImplementation((value)=>'object' == typeof value && null !== value && !Array.isArray(value));
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isRecordMock.mockClear();
+        external_vitest_namespaceObject.vi.mocked(idSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(idSchemaMock.ast).mockClear();
+        external_vitest_namespaceObject.vi.mocked(ageSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(ageSchemaMock.ast).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(idSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(ageSchemaMock.parse).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isRecordMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when object schema is created', ()=>{
+            const result = (0, external_object_cjs_namespaceObject.object)({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('User');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('object');
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should build field ast nodes when shape entries are provided', ()=>{
+            (0, external_object_cjs_namespaceObject.object)({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(ast).toEqual({
+                type: 'object',
+                name: 'User',
+                children: [
+                    {
+                        type: 'field',
+                        name: 'id',
+                        children: [
+                            {
+                                type: 'string',
+                                name: 'Id'
+                            }
+                        ]
+                    },
+                    {
+                        type: 'field',
+                        name: 'age',
+                        children: [
+                            {
+                                type: 'number',
+                                name: 'Age'
+                            }
+                        ]
+                    }
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(idSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+            (0, external_vitest_namespaceObject.expect)(ageSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        (0, external_vitest_namespaceObject.it)('should parse each field when input is a record', ()=>{
+            (0, external_object_cjs_namespaceObject.object)({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate({
+                id: 'u1',
+                age: '21'
+            }, schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toEqual({
+                id: 'id:u1',
+                age: 21
+            });
+            (0, external_vitest_namespaceObject.expect)(idSchemaMock.parse).toHaveBeenCalledWith('u1', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(ageSchemaMock.parse).toHaveBeenCalledWith('21', schemaContextMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw object.type when input is not a record', ()=>{
+            isRecordMock.mockReturnValueOnce(false);
+            (0, external_object_cjs_namespaceObject.object)({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('x', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected object',
+                code: 'object.type'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/object.spec.d.ts

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

package/dist/object.spec.js

@@ -0,0 +1,165 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { object } from "./object.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { isRecord } from "./typeGuards.js";
+import { captureThrow, createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isRecord: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isRecordMock = vi.mocked(isRecord);
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const buildContextMock = {
+    buildId: 'build-object',
+    builder: {
+        add: vi.fn((node)=>node),
+        getAll: vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = createSchemaContextMock({
+    buildContext: buildContextMock
+});
+const idSchemaMock = createBaseSchemaMock({
+    name: 'idSchema',
+    parse: vi.fn((value)=>`id:${String(value)}`),
+    ast: vi.fn(()=>({
+            type: 'string',
+            name: 'Id'
+        }))
+});
+const ageSchemaMock = createBaseSchemaMock({
+    name: 'ageSchema',
+    parse: vi.fn((value)=>Number(value)),
+    ast: vi.fn(()=>({
+            type: 'number',
+            name: 'Age'
+        }))
+});
+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('object()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+        isRecordMock.mockImplementation((value)=>'object' == typeof value && null !== value && !Array.isArray(value));
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isRecordMock.mockClear();
+        vi.mocked(idSchemaMock.parse).mockClear();
+        vi.mocked(idSchemaMock.ast).mockClear();
+        vi.mocked(ageSchemaMock.parse).mockClear();
+        vi.mocked(ageSchemaMock.ast).mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(idSchemaMock.parse).mockClear();
+        vi.mocked(ageSchemaMock.parse).mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isRecordMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when object schema is created', ()=>{
+            const result = object({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('User');
+            expect(factoryInput.type).toBe('object');
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should build field ast nodes when shape entries are provided', ()=>{
+            object({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            expect(ast).toEqual({
+                type: 'object',
+                name: 'User',
+                children: [
+                    {
+                        type: 'field',
+                        name: 'id',
+                        children: [
+                            {
+                                type: 'string',
+                                name: 'Id'
+                            }
+                        ]
+                    },
+                    {
+                        type: 'field',
+                        name: 'age',
+                        children: [
+                            {
+                                type: 'number',
+                                name: 'Age'
+                            }
+                        ]
+                    }
+                ]
+            });
+            expect(idSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+            expect(ageSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        it('should parse each field when input is a record', ()=>{
+            object({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate({
+                id: 'u1',
+                age: '21'
+            }, schemaContextMock);
+            expect(parsed).toEqual({
+                id: 'id:u1',
+                age: 21
+            });
+            expect(idSchemaMock.parse).toHaveBeenCalledWith('u1', schemaContextMock);
+            expect(ageSchemaMock.parse).toHaveBeenCalledWith('21', schemaContextMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw object.type when input is not a record', ()=>{
+            isRecordMock.mockReturnValueOnce(false);
+            object({
+                name: 'User',
+                shape: {
+                    id: idSchemaMock,
+                    age: ageSchemaMock
+                }
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected object',
+                code: 'object.type'
+            });
+        });
+    });
+});