@livon/schema 0.27.0-rc.1

package/PROMPT.md

@@ -0,0 +1,21 @@
+<!-- @agent.entry -->
+<!-- @agent.load: ../../PROMPT.md -->
+<!-- @agent.load: ../../PROMPTS.md -->
+<!-- @agent.load: ../../AGENTS.md -->
+<!-- @agent.load: ../../website/docs/core/testing-and-quality.md -->
+<!-- @agent.load: ../../website/docs/packages/schema.md -->
+<!-- @agent.load: ../../website/docs/schema/index.md -->
+<!-- @agent.load: ../../website/docs/schema/schema-factory.md -->
+<!-- @agent.load: ../../website/docs/schema/type-safety.md -->
+
+# @livon/schema Prompt
+
+This prompt applies only to the schema package.
+
+Canonical sources:
+
+- `/docs/packages/schema`
+- `/docs/schema`
+- `/docs/core/testing-and-quality` (test structure, mocking, executable documentation rules)
+
+Read the schema docs before making changes in this package.

package/README.md

@@ -0,0 +1,13 @@
+# @livon/schema Redirect
+
+Canonical sources moved to Docusaurus:
+
+- `/docs/packages/schema`
+- `/docs/schema`
+
+File sources:
+
+- `website/docs/packages/schema.md`
+- `website/docs/schema/index.md`
+
+This file is a compatibility redirect only.

package/SCHEMA.md

@@ -0,0 +1,13 @@
+# Schema System Redirect
+
+Canonical sources moved to Docusaurus:
+
+- `/docs/packages/schema`
+- `/docs/schema`
+
+File sources:
+
+- `website/docs/packages/schema.md`
+- `website/docs/schema/index.md`
+
+This file is a compatibility redirect only.

package/dist/SchemaValidationError.cjs

@@ -0,0 +1,41 @@
+"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__, {
+    createSchemaValidationError: ()=>createSchemaValidationError
+});
+const createSchemaValidationError = ({ issues, meta })=>{
+    const error = new Error('Schema validation failed');
+    error.issues = issues;
+    error.meta = meta;
+    return error;
+};
+exports.createSchemaValidationError = __webpack_exports__.createSchemaValidationError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSchemaValidationError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/SchemaValidationError.d.ts

@@ -0,0 +1,20 @@
+import { SchemaIssue, SchemaErrorMeta } from './types.js';
+export type SchemaValidationError = Error & {
+    issues: readonly SchemaIssue[];
+    meta?: SchemaErrorMeta;
+};
+/**
+ * createSchemaValidationError 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/type-safety
+ *
+ * @example
+ * const result = createSchemaValidationError(undefined as never);
+ */
+export declare const createSchemaValidationError: ({ issues, meta, }: {
+    issues: readonly SchemaIssue[];
+    meta?: SchemaErrorMeta;
+}) => SchemaValidationError;

package/dist/SchemaValidationError.js

@@ -0,0 +1,7 @@
+const createSchemaValidationError = ({ issues, meta })=>{
+    const error = new Error('Schema validation failed');
+    error.issues = issues;
+    error.meta = meta;
+    return error;
+};
+export { createSchemaValidationError };

package/dist/SchemaValidationError.spec.cjs

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_SchemaValidationError_cjs_namespaceObject = require("./SchemaValidationError.cjs");
+(0, external_vitest_namespaceObject.describe)('createSchemaValidationError()', ()=>{
+    let issues;
+    let meta;
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        issues = [];
+        meta = {};
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        issues = [
+            {
+                path: [
+                    'user',
+                    'name'
+                ],
+                message: 'Expected non-empty value',
+                code: 'string.min'
+            }
+        ];
+        meta = {
+            type: 'string',
+            name: 'UserName'
+        };
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        issues = [];
+        meta = {};
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        issues = [];
+        meta = {};
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should create error instance when issues are provided', ()=>{
+            const error = (0, external_SchemaValidationError_cjs_namespaceObject.createSchemaValidationError)({
+                issues
+            });
+            (0, external_vitest_namespaceObject.expect)(error).toBeInstanceOf(Error);
+            (0, external_vitest_namespaceObject.expect)(error.message).toBe('Schema validation failed');
+            (0, external_vitest_namespaceObject.expect)(error.issues).toEqual(issues);
+        });
+        (0, external_vitest_namespaceObject.it)('should attach meta when meta is provided', ()=>{
+            const error = (0, external_SchemaValidationError_cjs_namespaceObject.createSchemaValidationError)({
+                issues,
+                meta
+            });
+            (0, external_vitest_namespaceObject.expect)(error.meta).toEqual(meta);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should keep meta undefined when meta is omitted', ()=>{
+            const error = (0, external_SchemaValidationError_cjs_namespaceObject.createSchemaValidationError)({
+                issues
+            });
+            (0, external_vitest_namespaceObject.expect)(error.meta).toBeUndefined();
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/SchemaValidationError.spec.d.ts

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

package/dist/SchemaValidationError.spec.js

@@ -0,0 +1,59 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { createSchemaValidationError } from "./SchemaValidationError.js";
+describe('createSchemaValidationError()', ()=>{
+    let issues;
+    let meta;
+    beforeAll(()=>{
+        issues = [];
+        meta = {};
+    });
+    beforeEach(()=>{
+        issues = [
+            {
+                path: [
+                    'user',
+                    'name'
+                ],
+                message: 'Expected non-empty value',
+                code: 'string.min'
+            }
+        ];
+        meta = {
+            type: 'string',
+            name: 'UserName'
+        };
+    });
+    afterEach(()=>{
+        issues = [];
+        meta = {};
+    });
+    afterAll(()=>{
+        issues = [];
+        meta = {};
+    });
+    describe('happy', ()=>{
+        it('should create error instance when issues are provided', ()=>{
+            const error = createSchemaValidationError({
+                issues
+            });
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toBe('Schema validation failed');
+            expect(error.issues).toEqual(issues);
+        });
+        it('should attach meta when meta is provided', ()=>{
+            const error = createSchemaValidationError({
+                issues,
+                meta
+            });
+            expect(error.meta).toEqual(meta);
+        });
+    });
+    describe('sad', ()=>{
+        it('should keep meta undefined when meta is omitted', ()=>{
+            const error = createSchemaValidationError({
+                issues
+            });
+            expect(error.meta).toBeUndefined();
+        });
+    });
+});

package/dist/after.cjs

@@ -0,0 +1,36 @@
+"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__, {
+    after: ()=>after
+});
+const after = ({ schema, hook })=>schema.after(hook);
+exports.after = __webpack_exports__.after;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "after"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/after.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from './types.js';
+export interface AfterInput<T> {
+    schema: Schema<T>;
+    hook: Parameters<Schema<T>['after']>[0];
+}
+/**
+ * after 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/after
+ *
+ * @example
+ * // Postprocesses validated string output by converting it to uppercase.
+ * const UppercaseName = after({
+ *   schema: string(),
+ *   hook: (value: string) => value.toUpperCase(),
+ * });
+ * UppercaseName.parse('alice');
+ *
+ * @example
+ * // Extends the postprocessed schema to also allow undefined.
+ * const MaybeUppercaseName = after({
+ *   schema: string(),
+ *   hook: (value: string) => value.toUpperCase(),
+ * }).optional();
+ * MaybeUppercaseName.parse(undefined);
+ */
+export declare const after: <T>({ schema, hook }: AfterInput<T>) => Schema<unknown>;

package/dist/after.js

@@ -0,0 +1,2 @@
+const after = ({ schema, hook })=>schema.after(hook);
+export { after };

package/dist/after.spec.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_after_cjs_namespaceObject = require("./after.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+const schemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)();
+const nextSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'next.after.schema'
+});
+const hookMock = external_vitest_namespaceObject.vi.fn((value)=>value.length);
+(0, external_vitest_namespaceObject.describe)('after()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.after).mockImplementation(()=>nextSchemaMock);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.after).mockClear();
+        hookMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.after).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        external_vitest_namespaceObject.vi.mocked(schemaMock.after).mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schema.after when hook is provided', ()=>{
+            const result = (0, external_after_cjs_namespaceObject.after)({
+                schema: schemaMock,
+                hook: hookMock
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaMock.after).toHaveBeenCalledTimes(1);
+            (0, external_vitest_namespaceObject.expect)(schemaMock.after).toHaveBeenCalledWith(hookMock);
+            (0, external_vitest_namespaceObject.expect)(result).toBe(nextSchemaMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should rethrow error when schema.after throws', ()=>{
+            const afterError = new Error('after hook failed');
+            external_vitest_namespaceObject.vi.mocked(schemaMock.after).mockImplementationOnce(()=>{
+                throw afterError;
+            });
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>(0, external_after_cjs_namespaceObject.after)({
+                    schema: schemaMock,
+                    hook: hookMock
+                }));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toBe(afterError);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/after.spec.d.ts

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

package/dist/after.spec.js

@@ -0,0 +1,48 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { after } from "./after.js";
+import { captureThrow, createBaseSchemaMock } from "./testing/mocks/index.js";
+const schemaMock = createBaseSchemaMock();
+const nextSchemaMock = createBaseSchemaMock({
+    name: 'next.after.schema'
+});
+const hookMock = vi.fn((value)=>value.length);
+describe('after()', ()=>{
+    beforeAll(()=>{
+        vi.mocked(schemaMock.after).mockImplementation(()=>nextSchemaMock);
+    });
+    beforeEach(()=>{
+        vi.mocked(schemaMock.after).mockClear();
+        hookMock.mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(schemaMock.after).mockClear();
+    });
+    afterAll(()=>{
+        vi.mocked(schemaMock.after).mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schema.after when hook is provided', ()=>{
+            const result = after({
+                schema: schemaMock,
+                hook: hookMock
+            });
+            expect(schemaMock.after).toHaveBeenCalledTimes(1);
+            expect(schemaMock.after).toHaveBeenCalledWith(hookMock);
+            expect(result).toBe(nextSchemaMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should rethrow error when schema.after throws', ()=>{
+            const afterError = new Error('after hook failed');
+            vi.mocked(schemaMock.after).mockImplementationOnce(()=>{
+                throw afterError;
+            });
+            const thrown = captureThrow(()=>after({
+                    schema: schemaMock,
+                    hook: hookMock
+                }));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toBe(afterError);
+        });
+    });
+});

package/dist/and.cjs

@@ -0,0 +1,36 @@
+"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__, {
+    and: ()=>and
+});
+const and = ({ left, right })=>left.and(right);
+exports.and = __webpack_exports__.and;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "and"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/and.d.ts

@@ -0,0 +1,26 @@
+import { Schema } from './types.js';
+export interface AndInput<T, U> {
+    left: Schema<T>;
+    right: Schema<U>;
+}
+/**
+ * and 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/and
+ *
+ * @example
+ * // Combines two object schemas into one schema that requires both shapes.
+ * const WithId = object({ name: 'withId', shape: { id: string() } });
+ * const WithAge = object({ name: 'withAge', shape: { age: number() } });
+ * const User = and({ left: WithId, right: WithAge });
+ * User.parse({ id: 'u1', age: 21 });
+ *
+ * @example
+ * // Extends the combined schema to also allow undefined.
+ * const OptionalUser = and({ left: WithId, right: WithAge }).optional();
+ * OptionalUser.parse(undefined);
+ */
+export declare const and: <T, U>({ left, right }: AndInput<T, U>) => Schema<T & U>;

package/dist/and.js

@@ -0,0 +1,2 @@
+const and = ({ left, right })=>left.and(right);
+export { and };

package/dist/and.spec.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_and_cjs_namespaceObject = require("./and.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+const leftSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'left'
+});
+const rightSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'right'
+});
+const mergedSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'merged'
+});
+(0, external_vitest_namespaceObject.describe)('and()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        external_vitest_namespaceObject.vi.mocked(leftSchemaMock.and).mockImplementation(()=>mergedSchemaMock);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(leftSchemaMock.and).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(leftSchemaMock.and).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        external_vitest_namespaceObject.vi.mocked(leftSchemaMock.and).mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to left.and when right schema is provided', ()=>{
+            const result = (0, external_and_cjs_namespaceObject.and)({
+                left: leftSchemaMock,
+                right: rightSchemaMock
+            });
+            (0, external_vitest_namespaceObject.expect)(leftSchemaMock.and).toHaveBeenCalledTimes(1);
+            (0, external_vitest_namespaceObject.expect)(leftSchemaMock.and).toHaveBeenCalledWith(rightSchemaMock);
+            (0, external_vitest_namespaceObject.expect)(result).toBe(mergedSchemaMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should rethrow error when left.and throws', ()=>{
+            const andError = new Error('and failed');
+            external_vitest_namespaceObject.vi.mocked(leftSchemaMock.and).mockImplementationOnce(()=>{
+                throw andError;
+            });
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>(0, external_and_cjs_namespaceObject.and)({
+                    left: leftSchemaMock,
+                    right: rightSchemaMock
+                }));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toBe(andError);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/and.spec.d.ts

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

package/dist/and.spec.js

@@ -0,0 +1,51 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { and } from "./and.js";
+import { captureThrow, createBaseSchemaMock } from "./testing/mocks/index.js";
+const leftSchemaMock = createBaseSchemaMock({
+    name: 'left'
+});
+const rightSchemaMock = createBaseSchemaMock({
+    name: 'right'
+});
+const mergedSchemaMock = createBaseSchemaMock({
+    name: 'merged'
+});
+describe('and()', ()=>{
+    beforeAll(()=>{
+        vi.mocked(leftSchemaMock.and).mockImplementation(()=>mergedSchemaMock);
+    });
+    beforeEach(()=>{
+        vi.mocked(leftSchemaMock.and).mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(leftSchemaMock.and).mockClear();
+    });
+    afterAll(()=>{
+        vi.mocked(leftSchemaMock.and).mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to left.and when right schema is provided', ()=>{
+            const result = and({
+                left: leftSchemaMock,
+                right: rightSchemaMock
+            });
+            expect(leftSchemaMock.and).toHaveBeenCalledTimes(1);
+            expect(leftSchemaMock.and).toHaveBeenCalledWith(rightSchemaMock);
+            expect(result).toBe(mergedSchemaMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should rethrow error when left.and throws', ()=>{
+            const andError = new Error('and failed');
+            vi.mocked(leftSchemaMock.and).mockImplementationOnce(()=>{
+                throw andError;
+            });
+            const thrown = captureThrow(()=>and({
+                    left: leftSchemaMock,
+                    right: rightSchemaMock
+                }));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toBe(andError);
+        });
+    });
+});