@livon/schema 0.27.0-rc.1

package/dist/operation.spec.cjs

@@ -0,0 +1,454 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_operation_cjs_namespaceObject = require("./operation.cjs");
+const external_string_cjs_namespaceObject = require("./string.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+(0, external_vitest_namespaceObject.describe)('operation utilities', ()=>{
+    let context;
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        context = (0, external_context_cjs_namespaceObject.createSchemaContext)();
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        context = (0, external_context_cjs_namespaceObject.createSchemaContext)();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.clearAllMocks();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        external_vitest_namespaceObject.vi.restoreAllMocks();
+    });
+    (0, external_vitest_namespaceObject.describe)('operation()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should return operation payload when output schema is provided', ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Input',
+                    type: 'input',
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const outputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Output',
+                    type: 'output',
+                    outputValue: {
+                        ok: true
+                    }
+                });
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>({
+                        ok: true
+                    }));
+                const result = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    output: outputSchema,
+                    exec,
+                    doc: {
+                        summary: 'operation doc'
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(result.type).toBe('operation');
+                (0, external_vitest_namespaceObject.expect)(result.input).toBe(inputSchema);
+                (0, external_vitest_namespaceObject.expect)(result.output).toBe(outputSchema);
+                (0, external_vitest_namespaceObject.expect)(result.exec).toBe(exec);
+                (0, external_vitest_namespaceObject.expect)(result.doc).toEqual({
+                    summary: 'operation doc'
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should keep output undefined when output schema is omitted', ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'input'
+                });
+                const result = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: (input)=>input.length
+                });
+                (0, external_vitest_namespaceObject.expect)(result.output).toBeUndefined();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('fieldOperation()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should normalize shape dependsOn and shape input when shape values are provided', ()=>{
+                const result = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: {
+                        id: (0, external_string_cjs_namespaceObject.string)()
+                    },
+                    input: {
+                        name: (0, external_string_cjs_namespaceObject.string)()
+                    },
+                    exec: ()=>'ok'
+                });
+                (0, external_vitest_namespaceObject.expect)(result.type).toBe('field');
+                (0, external_vitest_namespaceObject.expect)(result.dependsOn.name).toBe('dependsOn');
+                (0, external_vitest_namespaceObject.expect)(result.input?.name).toBe('input');
+            });
+            (0, external_vitest_namespaceObject.it)('should keep provided schema dependsOn without wrapping when schema is provided', ()=>{
+                const dependsOn = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'DependsOnSchema',
+                    type: 'dependsOn',
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const result = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn,
+                    exec: ()=>'ok'
+                });
+                (0, external_vitest_namespaceObject.expect)(result.dependsOn).toBe(dependsOn);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should keep output undefined when output is omitted', ()=>{
+                const dependsOn = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const result = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn,
+                    exec: ()=>'ok'
+                });
+                (0, external_vitest_namespaceObject.expect)(result.output).toBeUndefined();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('withOperationName()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should set operation name when wrapper is used', ()=>{
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                        outputValue: 'value'
+                    }),
+                    exec: ()=>'ok'
+                });
+                const named = (0, external_operation_cjs_namespaceObject.withOperationName)({
+                    name: 'createUser',
+                    operation: op
+                });
+                (0, external_vitest_namespaceObject.expect)(named.name).toBe('createUser');
+                (0, external_vitest_namespaceObject.expect)(named.type).toBe('operation');
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should preserve original operation members when name is injected', ()=>{
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>'ok');
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                        outputValue: 'value'
+                    }),
+                    exec
+                });
+                const named = (0, external_operation_cjs_namespaceObject.withOperationName)({
+                    name: 'createUser',
+                    operation: op
+                });
+                (0, external_vitest_namespaceObject.expect)(named.exec).toBe(exec);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('withFieldOperationName()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should set field operation name when wrapper is used', ()=>{
+                const op = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                        outputValue: {
+                            id: 'u-1'
+                        }
+                    }),
+                    exec: ()=>'ok'
+                });
+                const named = (0, external_operation_cjs_namespaceObject.withFieldOperationName)({
+                    name: 'user.displayName',
+                    operation: op
+                });
+                (0, external_vitest_namespaceObject.expect)(named.name).toBe('user.displayName');
+                (0, external_vitest_namespaceObject.expect)(named.type).toBe('field');
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should preserve original field operation members when name is injected', ()=>{
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>'ok');
+                const dependsOn = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const op = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn,
+                    exec
+                });
+                const named = (0, external_operation_cjs_namespaceObject.withFieldOperationName)({
+                    name: 'user.displayName',
+                    operation: op
+                });
+                (0, external_vitest_namespaceObject.expect)(named.dependsOn).toBe(dependsOn);
+                (0, external_vitest_namespaceObject.expect)(named.exec).toBe(exec);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('runOperation()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should parse input and output and publish to all rooms when publish hook returns payload', async ()=>{
+                const parsedInput = {
+                    id: 'u-1'
+                };
+                const parsedOutput = {
+                    id: 'result'
+                };
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: parsedInput
+                });
+                const outputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: parsedOutput
+                });
+                const publisher = external_vitest_namespaceObject.vi.fn(async ()=>void 0);
+                const publishHook = external_vitest_namespaceObject.vi.fn(()=>({
+                        event: 'created'
+                    }));
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>parsedOutput);
+                context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                    request: {
+                        publisher
+                    }
+                });
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    output: outputSchema,
+                    publish: {
+                        userCreated: publishHook
+                    },
+                    rooms: ()=>[
+                            'room-a',
+                            'room-b'
+                        ],
+                    ack: {
+                        required: true,
+                        mode: 'handled'
+                    },
+                    exec
+                });
+                const result = await (0, external_operation_cjs_namespaceObject.runOperation)(op, {
+                    rawInput: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(exec).toHaveBeenCalledWith(parsedInput, context);
+                (0, external_vitest_namespaceObject.expect)(outputSchema.parse).toHaveBeenCalledWith(parsedOutput, context);
+                (0, external_vitest_namespaceObject.expect)(publishHook).toHaveBeenCalledWith(parsedOutput, context);
+                (0, external_vitest_namespaceObject.expect)(publisher).toHaveBeenCalledTimes(2);
+                (0, external_vitest_namespaceObject.expect)(publisher).toHaveBeenNthCalledWith(1, {
+                    topic: 'userCreated',
+                    payload: {
+                        event: 'created'
+                    },
+                    input: parsedInput,
+                    ack: {
+                        required: true,
+                        mode: 'handled'
+                    },
+                    meta: {
+                        room: 'room-a'
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(publisher).toHaveBeenNthCalledWith(2, {
+                    topic: 'userCreated',
+                    payload: {
+                        event: 'created'
+                    },
+                    input: parsedInput,
+                    ack: {
+                        required: true,
+                        mode: 'handled'
+                    },
+                    meta: {
+                        room: 'room-b'
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(result).toEqual(parsedOutput);
+            });
+            (0, external_vitest_namespaceObject.it)('should skip publish when request publisher is missing', async ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'parsed-input'
+                });
+                const outputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'parsed-output'
+                });
+                const publishHook = external_vitest_namespaceObject.vi.fn(()=>'payload');
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>'result');
+                context = (0, external_context_cjs_namespaceObject.createSchemaContext)();
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    output: outputSchema,
+                    publish: {
+                        topic: publishHook
+                    },
+                    exec
+                });
+                const result = await (0, external_operation_cjs_namespaceObject.runOperation)(op, 'raw-input', context);
+                (0, external_vitest_namespaceObject.expect)(result).toBe('parsed-output');
+                (0, external_vitest_namespaceObject.expect)(publishHook).not.toHaveBeenCalled();
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should report publish hook errors when publish hook throws', async ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'parsed-input'
+                });
+                const publisher = external_vitest_namespaceObject.vi.fn(async ()=>void 0);
+                const publishHookError = new Error('hook failed');
+                const publishHook = external_vitest_namespaceObject.vi.fn(()=>{
+                    throw publishHookError;
+                });
+                const onPublishError = external_vitest_namespaceObject.vi.fn();
+                const logger = {
+                    error: external_vitest_namespaceObject.vi.fn()
+                };
+                context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                    request: {
+                        publisher,
+                        onPublishError,
+                        logger
+                    }
+                });
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: async ()=>'output',
+                    publish: {
+                        topic: publishHook
+                    }
+                });
+                await (0, external_operation_cjs_namespaceObject.runOperation)(op, 'raw-input', context);
+                (0, external_vitest_namespaceObject.expect)(onPublishError).toHaveBeenCalledWith(publishHookError, {
+                    topic: 'topic',
+                    phase: 'publish-hook'
+                });
+                (0, external_vitest_namespaceObject.expect)(logger.error).toHaveBeenCalled();
+            });
+            (0, external_vitest_namespaceObject.it)('should report publisher errors when publisher throws', async ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'parsed-input'
+                });
+                const publisherError = new Error('publisher failed');
+                const publisher = external_vitest_namespaceObject.vi.fn(async ()=>{
+                    throw publisherError;
+                });
+                const onPublishError = external_vitest_namespaceObject.vi.fn();
+                const logger = {
+                    error: external_vitest_namespaceObject.vi.fn()
+                };
+                context = (0, external_context_cjs_namespaceObject.createSchemaContext)({
+                    request: {
+                        publisher,
+                        onPublishError,
+                        logger
+                    }
+                });
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: async ()=>'output',
+                    publish: {
+                        topic: ()=>({
+                                ok: true
+                            })
+                    }
+                });
+                await (0, external_operation_cjs_namespaceObject.runOperation)(op, 'raw-input', context);
+                (0, external_vitest_namespaceObject.expect)(onPublishError).toHaveBeenCalledWith(publisherError, {
+                    topic: 'topic',
+                    phase: 'publisher'
+                });
+                (0, external_vitest_namespaceObject.expect)(logger.error).toHaveBeenCalled();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('runFieldOperation()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should parse dependsOn and input and output when input and output schemas are provided', async ()=>{
+                const parsedDependsOn = {
+                    id: 'u-1'
+                };
+                const parsedInput = {
+                    field: 'name'
+                };
+                const parsedOutput = {
+                    value: 'Alice'
+                };
+                const dependsOnSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: parsedDependsOn
+                });
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: parsedInput
+                });
+                const outputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: parsedOutput
+                });
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>({
+                        raw: true
+                    }));
+                const op = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: dependsOnSchema,
+                    input: inputSchema,
+                    output: outputSchema,
+                    exec
+                });
+                const result = await (0, external_operation_cjs_namespaceObject.runFieldOperation)(op, {
+                    rawDependsOn: true
+                }, {
+                    rawInput: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(dependsOnSchema.parse).toHaveBeenCalledWith({
+                    rawDependsOn: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(inputSchema.parse).toHaveBeenCalledWith({
+                    rawInput: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(exec).toHaveBeenCalledWith(parsedDependsOn, parsedInput, context);
+                (0, external_vitest_namespaceObject.expect)(outputSchema.parse).toHaveBeenCalledWith({
+                    raw: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(result).toEqual(parsedOutput);
+            });
+            (0, external_vitest_namespaceObject.it)('should treat second parameter as context when input schema is missing', async ()=>{
+                const parsedDependsOn = {
+                    id: 'u-1'
+                };
+                const dependsOnSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: parsedDependsOn
+                });
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>'resolved');
+                const op = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: dependsOnSchema,
+                    exec
+                });
+                const result = await (0, external_operation_cjs_namespaceObject.runFieldOperation)(op, {
+                    rawDependsOn: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(exec).toHaveBeenCalledWith(parsedDependsOn, context);
+                (0, external_vitest_namespaceObject.expect)(result).toBe('resolved');
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should create request context when context has no request before execution', async ()=>{
+                const dependsOnSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                context = (0, external_context_cjs_namespaceObject.createSchemaContext)();
+                const op = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: dependsOnSchema,
+                    exec: async ()=>'ok'
+                });
+                await (0, external_operation_cjs_namespaceObject.runFieldOperation)(op, {
+                    rawDependsOn: true
+                }, context);
+                (0, external_vitest_namespaceObject.expect)(context.getRequestContext()).toBeDefined();
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/operation.spec.d.ts

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