@livon/schema 0.27.0-rc.1

package/dist/schemaModule.spec.cjs

@@ -0,0 +1,355 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_operation_cjs_namespaceObject = require("./operation.cjs");
+const external_schemaModule_cjs_namespaceObject = require("./schemaModule.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+const createRuntimeContextMock = ()=>{
+    const runtimeContext = {};
+    runtimeContext.emitEvent = external_vitest_namespaceObject.vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.emitReceive = external_vitest_namespaceObject.vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.emitSend = external_vitest_namespaceObject.vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.emitError = external_vitest_namespaceObject.vi.fn(async ()=>({
+            ok: true
+        }));
+    runtimeContext.state = {
+        get: external_vitest_namespaceObject.vi.fn(()=>void 0),
+        set: external_vitest_namespaceObject.vi.fn(()=>void 0)
+    };
+    runtimeContext.room = external_vitest_namespaceObject.vi.fn(()=>runtimeContext);
+    return runtimeContext;
+};
+const createEnvelope = (overrides = {})=>({
+        id: 'evt-1',
+        event: 'unknown',
+        status: 'receiving',
+        payload: new Uint8Array([
+            1
+        ]),
+        ...overrides
+    });
+const createRegistryMock = (state)=>({
+        onReceive: external_vitest_namespaceObject.vi.fn((hook)=>{
+            state.onReceive = hook;
+            return {
+                unsub: ()=>void 0
+            };
+        }),
+        onSend: external_vitest_namespaceObject.vi.fn(()=>({
+                unsub: ()=>void 0
+            })),
+        onError: external_vitest_namespaceObject.vi.fn(()=>({
+                unsub: ()=>void 0
+            })),
+        emitReceive: external_vitest_namespaceObject.vi.fn(async ()=>({
+                ok: true
+            })),
+        emitSend: external_vitest_namespaceObject.vi.fn(async ()=>({
+                ok: true
+            })),
+        emitError: external_vitest_namespaceObject.vi.fn(async ()=>({
+                ok: true
+            })),
+        state: {
+            get: external_vitest_namespaceObject.vi.fn(()=>void 0),
+            set: external_vitest_namespaceObject.vi.fn(()=>void 0)
+        }
+    });
+(0, external_vitest_namespaceObject.describe)('schemaModule utilities', ()=>{
+    let runtimeContext;
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        runtimeContext = createRuntimeContextMock();
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        runtimeContext = createRuntimeContextMock();
+    });
+    (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)('createSchemaModuleInput()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should keep schema module parts when valid module-like input is provided', ()=>{
+                const operations = {
+                    ping: (0, external_operation_cjs_namespaceObject.operation)({
+                        input: (0, index_cjs_namespaceObject.createBaseSchemaMock)(),
+                        exec: async ()=>'ok'
+                    })
+                };
+                const fieldOperations = {};
+                const subscriptions = {};
+                const ast = ()=>({
+                        type: 'api'
+                    });
+                const result = (0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations,
+                    fieldOperations,
+                    subscriptions,
+                    ast
+                });
+                (0, external_vitest_namespaceObject.expect)(result.operations).toBe(operations);
+                (0, external_vitest_namespaceObject.expect)(result.fieldOperations).toBe(fieldOperations);
+                (0, external_vitest_namespaceObject.expect)(result.subscriptions).toBe(subscriptions);
+                (0, external_vitest_namespaceObject.expect)(result.ast).toBe(ast);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should keep empty records when empty module-like input is provided', ()=>{
+                const result = (0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                });
+                (0, external_vitest_namespaceObject.expect)(result.operations).toEqual({});
+                (0, external_vitest_namespaceObject.expect)(result.fieldOperations).toEqual({});
+                (0, external_vitest_namespaceObject.expect)(result.subscriptions).toEqual({});
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('schemaModule()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should register onReceive hook when runtime module register is called', ()=>{
+                const module = (0, external_schemaModule_cjs_namespaceObject.schemaModule)((0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }));
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                (0, external_vitest_namespaceObject.expect)(module.name).toBe('schema');
+                (0, external_vitest_namespaceObject.expect)(registry.onReceive).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(typeof state.onReceive).toBe('function');
+            });
+            (0, external_vitest_namespaceObject.it)('should emit explain payload when explain option is enabled and explain event is received', async ()=>{
+                const encode = external_vitest_namespaceObject.vi.fn(()=>new Uint8Array([
+                        9
+                    ]));
+                const module = (0, external_schemaModule_cjs_namespaceObject.schemaModule)((0, external_schemaModule_cjs_namespaceObject.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 = external_vitest_namespaceObject.vi.fn(async ()=>createEnvelope());
+                await state.onReceive?.(createEnvelope({
+                    event: '$explain',
+                    metadata: {
+                        ifNoneMatch: 'different-checksum'
+                    }
+                }), runtimeContext, next);
+                (0, external_vitest_namespaceObject.expect)(next).not.toHaveBeenCalled();
+                (0, external_vitest_namespaceObject.expect)(runtimeContext.emitEvent).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(encode).toHaveBeenCalledTimes(1);
+            });
+            (0, external_vitest_namespaceObject.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 = external_vitest_namespaceObject.vi.fn(()=>decodedInput);
+                const encode = external_vitest_namespaceObject.vi.fn(()=>new Uint8Array([
+                        7
+                    ]));
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: decodedInput
+                });
+                const outputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: decodedOutput
+                });
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>decodedOutput);
+                const module = (0, external_schemaModule_cjs_namespaceObject.schemaModule)((0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations: {
+                        ping: (0, external_operation_cjs_namespaceObject.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 = external_vitest_namespaceObject.vi.fn(async ()=>createEnvelope());
+                const envelope = createEnvelope({
+                    event: 'ping'
+                });
+                const result = await state.onReceive?.(envelope, runtimeContext, next);
+                (0, external_vitest_namespaceObject.expect)(exec).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(runtimeContext.emitEvent).toHaveBeenCalledWith({
+                    event: 'ping',
+                    payload: new Uint8Array([
+                        7
+                    ]),
+                    metadata: void 0,
+                    context: void 0
+                });
+                (0, external_vitest_namespaceObject.expect)(result).toBe(envelope);
+            });
+            (0, external_vitest_namespaceObject.it)('should execute field operation when field event syntax is received', async ()=>{
+                const decode = external_vitest_namespaceObject.vi.fn(()=>({
+                        dependsOn: {
+                            id: 'u-1'
+                        },
+                        input: {
+                            locale: 'en'
+                        }
+                    }));
+                const encode = external_vitest_namespaceObject.vi.fn(()=>new Uint8Array([
+                        5
+                    ]));
+                const dependsOnSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: {
+                        locale: 'en'
+                    }
+                });
+                const outputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: {
+                        value: 'Alice'
+                    }
+                });
+                const exec = external_vitest_namespaceObject.vi.fn(async ()=>({
+                        value: 'Alice'
+                    }));
+                const module = (0, external_schemaModule_cjs_namespaceObject.schemaModule)((0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations: {},
+                    fieldOperations: {
+                        'User.displayName': (0, external_operation_cjs_namespaceObject.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 = external_vitest_namespaceObject.vi.fn(async ()=>createEnvelope());
+                await state.onReceive?.(createEnvelope({
+                    event: '$User.displayName'
+                }), runtimeContext, next);
+                (0, external_vitest_namespaceObject.expect)(exec).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(runtimeContext.emitEvent).toHaveBeenCalledWith({
+                    event: '$User.displayName',
+                    payload: new Uint8Array([
+                        5
+                    ]),
+                    metadata: void 0,
+                    context: void 0
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should delegate to next when no matching operation or field operation exists', async ()=>{
+                const module = (0, external_schemaModule_cjs_namespaceObject.schemaModule)((0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations: {},
+                    fieldOperations: {},
+                    subscriptions: {},
+                    ast: ()=>({
+                            type: 'api'
+                        })
+                }));
+                const state = {};
+                const registry = createRegistryMock(state);
+                module.register(registry);
+                const nextResult = createEnvelope({
+                    event: 'fallback'
+                });
+                const next = external_vitest_namespaceObject.vi.fn(async ()=>nextResult);
+                const result = await state.onReceive?.(createEnvelope({
+                    event: 'missing.event'
+                }), runtimeContext, next);
+                (0, external_vitest_namespaceObject.expect)(next).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(result).toBe(nextResult);
+            });
+            (0, external_vitest_namespaceObject.it)('should emit runtime error when operation execution throws', async ()=>{
+                const decode = external_vitest_namespaceObject.vi.fn(()=>({
+                        id: 'u-1'
+                    }));
+                const execError = new Error('operation failed');
+                const module = (0, external_schemaModule_cjs_namespaceObject.schemaModule)((0, external_schemaModule_cjs_namespaceObject.createSchemaModuleInput)({
+                    operations: {
+                        ping: (0, external_operation_cjs_namespaceObject.operation)({
+                            input: (0, index_cjs_namespaceObject.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 = external_vitest_namespaceObject.vi.fn(async ()=>createEnvelope());
+                const envelope = createEnvelope({
+                    event: 'ping'
+                });
+                const result = await state.onReceive?.(envelope, runtimeContext, next);
+                (0, external_vitest_namespaceObject.expect)(runtimeContext.emitError).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(result).toBe(envelope);
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/schemaModule.spec.d.ts

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