@livon/schema 0.27.0-rc.1

package/dist/schemaModule.spec.js

@@ -0,0 +1,349 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { fieldOperation, operation } from "./operation.js";
+import { createSchemaModuleInput, schemaModule } from "./schemaModule.js";
+import { createBaseSchemaMock } from "./testing/mocks/index.js";
+const createRuntimeContextMock = ()=>{
+    const runtimeContext = {};
+    runtimeContext.emitEvent = vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.emitReceive = vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.emitSend = vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.emitError = vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.state = {
+        get: vi.fn(()=>void 0),
+        set: vi.fn(()=>void 0)
+    };
+    runtimeContext.room = vi.fn(()=>runtimeContext);
+    return runtimeContext;
+};
+const createEnvelope = (overrides = {})=>({
+        id: 'evt-1',
+        event: 'unknown',
+        status: 'receiving',
+        payload: new Uint8Array([
+            1
+        ]),
+        ...overrides
+    });
+const createRegistryMock = (state)=>({
+        onReceive: vi.fn((hook)=>{
+            state.onReceive = hook;
+            return {
+                unsub: ()=>void 0
+            };
+        }),
+        onSend: vi.fn(()=>({
+                unsub: ()=>void 0
+            })),
+        onError: vi.fn(()=>({
+                unsub: ()=>void 0
+            })),
+        emitReceive: vi.fn(async ()=>({
+                ok: true
+            })),
+        emitSend: vi.fn(async ()=>({
+                ok: true
+            })),
+        emitError: vi.fn(async ()=>({
+                ok: true
+            })),
+        state: {
+            get: vi.fn(()=>void 0),
+            set: vi.fn(()=>void 0)
+        }
+    });
+describe('schemaModule utilities', ()=>{
+    let runtimeContext;
+    beforeAll(()=>{
+        runtimeContext = createRuntimeContextMock();
+    });
+    beforeEach(()=>{
+        runtimeContext = createRuntimeContextMock();
+    });
+    afterEach(()=>{
+        vi.clearAllMocks();
+    });
+    afterAll(()=>{
+        vi.restoreAllMocks();
+    });
+    describe('createSchemaModuleInput()', ()=>{
+        describe('happy', ()=>{
+            it('should keep schema module parts when valid module-like input is provided', ()=>{
+                const operations = {
+                    ping: operation({
+                        input: createBaseSchemaMock(),
+                        exec: async ()=>'ok'
+                    })
+                };
+                const fieldOperations = {};
+                const subscriptions = {};
+                const ast = ()=>({
+                        type: 'api'
+                    });
+                const result = createSchemaModuleInput({
+                    operations,
+                    fieldOperations,
+                    subscriptions,
+                    ast
+                });
+                expect(result.operations).toBe(operations);
+                expect(result.fieldOperations).toBe(fieldOperations);
+                expect(result.subscriptions).toBe(subscriptions);
+                expect(result.ast).toBe(ast);
+            });
+        });
+        describe('sad', ()=>{
+            it('should keep empty records when empty module-like input is provided', ()=>{
+                const result = createSchemaModuleInput({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                });
+                expect(result.operations).toEqual({});
+                expect(result.fieldOperations).toEqual({});
+                expect(result.subscriptions).toEqual({});
+            });
+        });
+    });
+    describe('schemaModule()', ()=>{
+        describe('happy', ()=>{
+            it('should register onReceive hook when runtime module register is called', ()=>{
+                const module = schemaModule(createSchemaModuleInput({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }));
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                expect(module.name).toBe('schema');
+                expect(registry.onReceive).toHaveBeenCalledTimes(1);
+                expect(typeof state.onReceive).toBe('function');
+            });
+            it('should emit explain payload when explain option is enabled and explain event is received', async ()=>{
+                const encode = vi.fn(()=>new Uint8Array([
+                        9
+                    ]));
+                const module = schemaModule(createSchemaModuleInput({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api',
+                            name: 'RootApi'
+                        })
+                }), {
+                    explain: true,
+                    now: ()=>1700000000000,
+                    encoder: encode
+                });
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                const next = vi.fn(async ()=>createEnvelope());
+                await state.onReceive?.(createEnvelope({
+                    event: '$explain',
+                    metadata: {
+                        ifNoneMatch: 'different-checksum'
+                    }
+                }), runtimeContext, next);
+                expect(next).not.toHaveBeenCalled();
+                expect(runtimeContext.emitEvent).toHaveBeenCalledTimes(1);
+                expect(encode).toHaveBeenCalledTimes(1);
+            });
+            it('should execute operation and emit operation response when operation event matches schema operation', async ()=>{
+                const decodedInput = {
+                    id: 'u-1'
+                };
+                const decodedOutput = {
+                    result: 'ok'
+                };
+                const decode = vi.fn(()=>decodedInput);
+                const encode = vi.fn(()=>new Uint8Array([
+                        7
+                    ]));
+                const inputSchema = createBaseSchemaMock({
+                    outputValue: decodedInput
+                });
+                const outputSchema = createBaseSchemaMock({
+                    outputValue: decodedOutput
+                });
+                const exec = vi.fn(async ()=>decodedOutput);
+                const module = schemaModule(createSchemaModuleInput({
+                    operations: {
+                        ping: operation({
+                            input: inputSchema,
+                            output: outputSchema,
+                            exec
+                        })
+                    },
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }), {
+                    decoder: decode,
+                    encoder: encode
+                });
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                const next = vi.fn(async ()=>createEnvelope());
+                const envelope = createEnvelope({
+                    event: 'ping'
+                });
+                const result = await state.onReceive?.(envelope, runtimeContext, next);
+                expect(exec).toHaveBeenCalledTimes(1);
+                expect(runtimeContext.emitEvent).toHaveBeenCalledWith({
+                    event: 'ping',
+                    payload: new Uint8Array([
+                        7
+                    ]),
+                    metadata: void 0,
+                    context: void 0
+                });
+                expect(result).toBe(envelope);
+            });
+            it('should execute field operation when field event syntax is received', async ()=>{
+                const decode = vi.fn(()=>({
+                        dependsOn: {
+                            id: 'u-1'
+                        },
+                        input: {
+                            locale: 'en'
+                        }
+                    }));
+                const encode = vi.fn(()=>new Uint8Array([
+                        5
+                    ]));
+                const dependsOnSchema = createBaseSchemaMock({
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const inputSchema = createBaseSchemaMock({
+                    outputValue: {
+                        locale: 'en'
+                    }
+                });
+                const outputSchema = createBaseSchemaMock({
+                    outputValue: {
+                        value: 'Alice'
+                    }
+                });
+                const exec = vi.fn(async ()=>({
+                        value: 'Alice'
+                    }));
+                const module = schemaModule(createSchemaModuleInput({
+                    operations: {},
+                    fieldOperations: {
+                        'User.displayName': fieldOperation({
+                            dependsOn: dependsOnSchema,
+                            input: inputSchema,
+                            output: outputSchema,
+                            exec
+                        })
+                    },
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }), {
+                    decoder: decode,
+                    encoder: encode
+                });
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                const next = vi.fn(async ()=>createEnvelope());
+                await state.onReceive?.(createEnvelope({
+                    event: '$User.displayName'
+                }), runtimeContext, next);
+                expect(exec).toHaveBeenCalledTimes(1);
+                expect(runtimeContext.emitEvent).toHaveBeenCalledWith({
+                    event: '$User.displayName',
+                    payload: new Uint8Array([
+                        5
+                    ]),
+                    metadata: void 0,
+                    context: void 0
+                });
+            });
+        });
+        describe('sad', ()=>{
+            it('should delegate to next when no matching operation or field operation exists', async ()=>{
+                const module = schemaModule(createSchemaModuleInput({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }));
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                const nextResult = createEnvelope({
+                    event: 'fallback'
+                });
+                const next = vi.fn(async ()=>nextResult);
+                const result = await state.onReceive?.(createEnvelope({
+                    event: 'missing.event'
+                }), runtimeContext, next);
+                expect(next).toHaveBeenCalledTimes(1);
+                expect(result).toBe(nextResult);
+            });
+            it('should emit runtime error when operation execution throws', async ()=>{
+                const decode = vi.fn(()=>({
+                        id: 'u-1'
+                    }));
+                const execError = new Error('operation failed');
+                const module = schemaModule(createSchemaModuleInput({
+                    operations: {
+                        ping: operation({
+                            input: createBaseSchemaMock({
+                                outputValue: {
+                                    id: 'u-1'
+                                }
+                            }),
+                            exec: async ()=>{
+                                throw execError;
+                            }
+                        })
+                    },
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }), {
+                    decoder: decode
+                });
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                const next = vi.fn(async ()=>createEnvelope());
+                const envelope = createEnvelope({
+                    event: 'ping'
+                });
+                const result = await state.onReceive?.(envelope, runtimeContext, next);
+                expect(runtimeContext.emitError).toHaveBeenCalledTimes(1);
+                expect(result).toBe(envelope);
+            });
+        });
+    });
+});

package/dist/string.cjs

@@ -0,0 +1,93 @@
+"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__, {
+    string: ()=>string
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const string = ({ name = 'string', doc } = {})=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'string',
+        doc,
+        ast: ()=>({
+                type: 'string',
+                name
+            }),
+        validate: (input)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isString)(input)) throw {
+                message: 'Data is not a string',
+                code: 'string.type'
+            };
+            return input;
+        },
+        chain: {
+            min: (data, _ctx)=>(min)=>{
+                    if (data.length < min) throw {
+                        message: 'String is too short',
+                        code: 'string.min',
+                        context: {
+                            min
+                        }
+                    };
+                    return data;
+                },
+            max: (data, _ctx)=>(max)=>{
+                    if (data.length > max) throw {
+                        message: 'String is too long',
+                        code: 'string.max',
+                        context: {
+                            max
+                        }
+                    };
+                    return data;
+                },
+            email: (data, _ctx)=>()=>{
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    if (!emailRegex.test(data)) throw {
+                        message: 'Invalid email format',
+                        code: 'string.email'
+                    };
+                    return data;
+                },
+            regex: (data, _ctx)=>(pattern)=>{
+                    if (!pattern.test(data)) throw {
+                        message: 'String does not match pattern',
+                        code: 'string.regex',
+                        context: {
+                            pattern: pattern.source
+                        }
+                    };
+                    return data;
+                }
+        }
+    });
+exports.string = __webpack_exports__.string;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "string"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/string.d.ts

@@ -0,0 +1,85 @@
+import { SchemaFactoryChainDefinition } from './schemaFactory.js';
+import { SchemaContext, SchemaDoc } from './types.js';
+export interface StringFactoryInput {
+    name?: string;
+    doc?: SchemaDoc;
+}
+/**
+ * Chain operation: validates minimum length.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/string
+ *
+ * @example
+ * // Enforces at least 3 characters for a string value.
+ * string().min(3)
+ */
+export interface StringChainMin {
+    (data: string, ctx: SchemaContext): (min: number) => string;
+}
+/**
+ * Chain operation: validates maximum length.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/string
+ *
+ * @example
+ * // Enforces at most 120 characters for a string value.
+ * string().max(120)
+ */
+export interface StringChainMax {
+    (data: string, ctx: SchemaContext): (max: number) => string;
+}
+/**
+ * Chain operation: validates e-mail format.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/string
+ *
+ * @example
+ * // Validates that the string matches a basic e-mail pattern.
+ * string().email()
+ */
+export interface StringChainEmail {
+    (data: string, ctx: SchemaContext): () => string;
+}
+/**
+ * Chain operation: validates a custom regular expression.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/string
+ *
+ * @example
+ * // Validates the string against a custom regular expression.
+ * string().regex(/^[a-z]+$/i)
+ */
+export interface StringChainRegex {
+    (data: string, ctx: SchemaContext): (pattern: RegExp) => string;
+}
+/**
+ * Chain map for `string()` schemas.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/string
+ */
+export interface StringChainDefinition extends SchemaFactoryChainDefinition<string> {
+    min: StringChainMin;
+    max: StringChainMax;
+    email: StringChainEmail;
+    regex: StringChainRegex;
+}
+export type StringSchema = ReturnType<typeof string>;
+/**
+ * string 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/string
+ *
+ * @example
+ * // Creates a basic string schema and validates a username.
+ * const Username = string();
+ * Username.parse('alice');
+ *
+ * @example
+ * // Adds chain rules to enforce a username length range.
+ * const Username = string().min(3).max(20);
+ * Username.parse('alice');
+ */
+export declare const string: ({ name, doc }?: StringFactoryInput) => import("./schemaFactory.js").SchemaWithChain<string, StringChainDefinition>;

package/dist/string.js

@@ -0,0 +1,59 @@
+import { schemaFactory } from "./schemaFactory.js";
+import { isString } from "./typeGuards.js";
+const string = ({ name = 'string', doc } = {})=>schemaFactory({
+        name,
+        type: 'string',
+        doc,
+        ast: ()=>({
+                type: 'string',
+                name
+            }),
+        validate: (input)=>{
+            if (!isString(input)) throw {
+                message: 'Data is not a string',
+                code: 'string.type'
+            };
+            return input;
+        },
+        chain: {
+            min: (data, _ctx)=>(min)=>{
+                    if (data.length < min) throw {
+                        message: 'String is too short',
+                        code: 'string.min',
+                        context: {
+                            min
+                        }
+                    };
+                    return data;
+                },
+            max: (data, _ctx)=>(max)=>{
+                    if (data.length > max) throw {
+                        message: 'String is too long',
+                        code: 'string.max',
+                        context: {
+                            max
+                        }
+                    };
+                    return data;
+                },
+            email: (data, _ctx)=>()=>{
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    if (!emailRegex.test(data)) throw {
+                        message: 'Invalid email format',
+                        code: 'string.email'
+                    };
+                    return data;
+                },
+            regex: (data, _ctx)=>(pattern)=>{
+                    if (!pattern.test(data)) throw {
+                        message: 'String does not match pattern',
+                        code: 'string.regex',
+                        context: {
+                            pattern: pattern.source
+                        }
+                    };
+                    return data;
+                }
+        }
+    });
+export { string };