@livon/schema 0.27.0-rc.1

package/dist/union.spec.cjs

@@ -0,0 +1,159 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_union_cjs_namespaceObject = require("./union.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const buildContextMock = {
+    buildId: 'build-union',
+    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 firstOptionMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'firstOption',
+    parse: external_vitest_namespaceObject.vi.fn(()=>{
+        throw {
+            code: 'first.fail'
+        };
+    }),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'string',
+            name: 'FirstOption'
+        }))
+});
+const secondOptionMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'secondOption',
+    parse: external_vitest_namespaceObject.vi.fn(()=>2),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'number',
+            name: 'SecondOption'
+        }))
+});
+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)('union()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.parse).mockReset();
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.parse).mockImplementation(()=>{
+            throw {
+                code: 'first.fail'
+            };
+        });
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.ast).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockReset();
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockReturnValue(2);
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.ast).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(firstOptionMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when union schema is created', ()=>{
+            const result = (0, external_union_cjs_namespaceObject.union)({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('TextOrCount');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('union');
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should build ast from option schemas when build context is available', ()=>{
+            (0, external_union_cjs_namespaceObject.union)({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(ast).toEqual({
+                type: 'union',
+                name: 'TextOrCount',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'FirstOption'
+                    },
+                    {
+                        type: 'number',
+                        name: 'SecondOption'
+                    }
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(firstOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+            (0, external_vitest_namespaceObject.expect)(secondOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        (0, external_vitest_namespaceObject.it)('should return first successful parse result when one option matches', ()=>{
+            (0, external_union_cjs_namespaceObject.union)({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('input', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(2);
+            (0, external_vitest_namespaceObject.expect)(firstOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(secondOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw union.match when no option matches', ()=>{
+            external_vitest_namespaceObject.vi.mocked(secondOptionMock.parse).mockImplementation(()=>{
+                throw {
+                    code: 'second.fail'
+                };
+            });
+            (0, external_union_cjs_namespaceObject.union)({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('input', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'No union match',
+                code: 'union.match'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/union.spec.d.ts

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

package/dist/union.spec.js

@@ -0,0 +1,153 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { schemaFactory } from "./schemaFactory.js";
+import { union } from "./union.js";
+import { captureThrow, createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const buildContextMock = {
+    buildId: 'build-union',
+    builder: {
+        add: vi.fn((node)=>node),
+        getAll: vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = createSchemaContextMock({
+    buildContext: buildContextMock
+});
+const firstOptionMock = createBaseSchemaMock({
+    name: 'firstOption',
+    parse: vi.fn(()=>{
+        throw {
+            code: 'first.fail'
+        };
+    }),
+    ast: vi.fn(()=>({
+            type: 'string',
+            name: 'FirstOption'
+        }))
+});
+const secondOptionMock = createBaseSchemaMock({
+    name: 'secondOption',
+    parse: vi.fn(()=>2),
+    ast: vi.fn(()=>({
+            type: 'number',
+            name: 'SecondOption'
+        }))
+});
+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('union()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        vi.mocked(firstOptionMock.parse).mockReset();
+        vi.mocked(firstOptionMock.parse).mockImplementation(()=>{
+            throw {
+                code: 'first.fail'
+            };
+        });
+        vi.mocked(firstOptionMock.ast).mockClear();
+        vi.mocked(secondOptionMock.parse).mockReset();
+        vi.mocked(secondOptionMock.parse).mockReturnValue(2);
+        vi.mocked(secondOptionMock.ast).mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(firstOptionMock.parse).mockClear();
+        vi.mocked(secondOptionMock.parse).mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when union schema is created', ()=>{
+            const result = union({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('TextOrCount');
+            expect(factoryInput.type).toBe('union');
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should build ast from option schemas when build context is available', ()=>{
+            union({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            expect(ast).toEqual({
+                type: 'union',
+                name: 'TextOrCount',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'FirstOption'
+                    },
+                    {
+                        type: 'number',
+                        name: 'SecondOption'
+                    }
+                ]
+            });
+            expect(firstOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+            expect(secondOptionMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        it('should return first successful parse result when one option matches', ()=>{
+            union({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate('input', schemaContextMock);
+            expect(parsed).toBe(2);
+            expect(firstOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+            expect(secondOptionMock.parse).toHaveBeenCalledWith('input', schemaContextMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw union.match when no option matches', ()=>{
+            vi.mocked(secondOptionMock.parse).mockImplementation(()=>{
+                throw {
+                    code: 'second.fail'
+                };
+            });
+            union({
+                name: 'TextOrCount',
+                options: [
+                    firstOptionMock,
+                    secondOptionMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('input', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'No union match',
+                code: 'union.match'
+            });
+        });
+    });
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@livon/schema",
+  "version": "0.27.0-rc.1",
+  "private": false,
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "PROMPT.md",
+    "SCHEMA.md"
+  ],
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "msgpackr": "latest",
+    "@livon/config": "0.27.0-rc.1",
+    "@livon/runtime": "0.27.0-rc.1"
+  },
+  "devDependencies": {
+    "@rslib/core": "latest",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
+    "eslint": "9.0.0",
+    "typescript": "latest",
+    "vitest": "latest",
+    "@livon/config": "0.27.0-rc.1"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "build:watch": "rslib dev",
+    "dev": "true",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run -c vitest.unit.config.ts",
+    "test:unit": "vitest run -c vitest.unit.config.ts",
+    "test:integration": "vitest run -c vitest.integration.config.ts"
+  }
+}