@livon/schema 0.27.0-rc.1

package/dist/api.spec.cjs

@@ -0,0 +1,512 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_api_cjs_namespaceObject = require("./api.cjs");
+const external_operation_cjs_namespaceObject = require("./operation.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+(0, external_vitest_namespaceObject.describe)('api utilities', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        external_vitest_namespaceObject.vi.useRealTimers();
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        external_vitest_namespaceObject.vi.clearAllMocks();
+    });
+    (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)("subscription()", ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should include optional fields when optional values are provided', ()=>{
+                const payload = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Payload',
+                    type: 'payload'
+                });
+                const input = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Input',
+                    type: 'input'
+                });
+                const output = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Output',
+                    type: 'output'
+                });
+                const filter = external_vitest_namespaceObject.vi.fn(()=>true);
+                const exec = external_vitest_namespaceObject.vi.fn(()=>({
+                        event: 'created'
+                    }));
+                const result = (0, external_api_cjs_namespaceObject.subscription)({
+                    name: 'userCreated',
+                    input,
+                    payload,
+                    output,
+                    filter,
+                    exec,
+                    doc: {
+                        summary: "subscription doc"
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(result.type).toBe("subscription");
+                (0, external_vitest_namespaceObject.expect)(result.name).toBe('userCreated');
+                (0, external_vitest_namespaceObject.expect)(result.input).toBe(input);
+                (0, external_vitest_namespaceObject.expect)(result.payload).toBe(payload);
+                (0, external_vitest_namespaceObject.expect)(result.output).toBe(output);
+                (0, external_vitest_namespaceObject.expect)(result.filter).toBe(filter);
+                (0, external_vitest_namespaceObject.expect)(result.exec).toBe(exec);
+                (0, external_vitest_namespaceObject.expect)(result.doc).toEqual({
+                    summary: "subscription doc"
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should only include mandatory payload when optional values are omitted', ()=>{
+                const payload = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Payload',
+                    type: 'payload'
+                });
+                const result = (0, external_api_cjs_namespaceObject.subscription)({
+                    payload
+                });
+                (0, external_vitest_namespaceObject.expect)(result.type).toBe("subscription");
+                (0, external_vitest_namespaceObject.expect)(result.payload).toBe(payload);
+                (0, external_vitest_namespaceObject.expect)(result.input).toBeUndefined();
+                (0, external_vitest_namespaceObject.expect)(result.output).toBeUndefined();
+                (0, external_vitest_namespaceObject.expect)(result.filter).toBeUndefined();
+                (0, external_vitest_namespaceObject.expect)(result.exec).toBeUndefined();
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('api()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)('should merge explicit and inline operations when both are provided', ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Input',
+                    type: 'input',
+                    outputValue: 'x'
+                });
+                const explicitOperation = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: async ()=>'explicit'
+                });
+                const inlineOperation = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: async ()=>'inline'
+                });
+                const result = (0, external_api_cjs_namespaceObject.api)({
+                    operations: {
+                        explicit: explicitOperation
+                    },
+                    inline: inlineOperation
+                });
+                const operations = result.operations;
+                (0, external_vitest_namespaceObject.expect)(operations.explicit?.name).toBe('explicit');
+                (0, external_vitest_namespaceObject.expect)(operations.explicit?.exec).toBe(explicitOperation.exec);
+                (0, external_vitest_namespaceObject.expect)(operations.inline?.name).toBe('inline');
+                (0, external_vitest_namespaceObject.expect)(operations.inline?.exec).toBe(inlineOperation.exec);
+            });
+            (0, external_vitest_namespaceObject.it)("should assign missing names to operations field operations and subscriptions", ()=>{
+                const entity = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'User',
+                    type: 'object',
+                    astNode: {
+                        type: 'object',
+                        name: 'User'
+                    },
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Input',
+                    type: 'input',
+                    outputValue: 'x'
+                });
+                const payloadSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Payload',
+                    type: 'payload'
+                });
+                const op = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: async ()=>'ok'
+                });
+                const fieldOp = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: entity,
+                    exec: async ()=>'field'
+                });
+                const sub = (0, external_api_cjs_namespaceObject.subscription)({
+                    payload: payloadSchema
+                });
+                const result = (0, external_api_cjs_namespaceObject.api)({
+                    type: entity,
+                    operations: {
+                        createUser: op
+                    },
+                    fieldOperations: {
+                        displayName: fieldOp
+                    },
+                    subscriptions: {
+                        userCreated: sub
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(result.operations.createUser.name).toBe('createUser');
+                (0, external_vitest_namespaceObject.expect)(result.fieldOperations.displayName.name).toBe('displayName');
+                (0, external_vitest_namespaceObject.expect)(result.subscriptions.userCreated?.name).toBe('userCreated');
+            });
+            (0, external_vitest_namespaceObject.it)("should build ast with operation subscription and field nodes when ast is requested", ()=>{
+                const entity = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'User',
+                    type: 'object',
+                    astNode: {
+                        type: 'object',
+                        name: 'User'
+                    },
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const operationInput = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'OperationInput',
+                    type: 'operation-input',
+                    astNode: {
+                        type: 'object',
+                        name: 'OperationInput'
+                    },
+                    outputValue: {
+                        name: 'Alice'
+                    }
+                });
+                const operationOutput = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'OperationOutput',
+                    type: 'operation-output',
+                    astNode: {
+                        type: 'object',
+                        name: 'OperationOutput'
+                    },
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const subscriptionPayload = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: "SubscriptionPayload",
+                    type: "subscription-payload",
+                    astNode: {
+                        type: 'object',
+                        name: "SubscriptionPayload"
+                    }
+                });
+                const fieldInput = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'FieldInput',
+                    type: 'field-input',
+                    astNode: {
+                        type: 'object',
+                        name: 'FieldInput'
+                    },
+                    outputValue: {
+                        locale: 'en'
+                    }
+                });
+                const fieldOutput = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'FieldOutput',
+                    type: 'field-output',
+                    astNode: {
+                        type: 'object',
+                        name: 'FieldOutput'
+                    },
+                    outputValue: {
+                        value: 'Alice'
+                    }
+                });
+                const createUser = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: operationInput,
+                    output: operationOutput,
+                    exec: async ()=>({
+                            id: 'u-1'
+                        }),
+                    publish: {
+                        userCreated: ()=>({
+                                id: 'u-1'
+                            })
+                    },
+                    ack: {
+                        required: true,
+                        mode: 'handled'
+                    },
+                    doc: {
+                        summary: 'create user'
+                    }
+                });
+                const displayName = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: entity,
+                    input: fieldInput,
+                    output: fieldOutput,
+                    exec: async ()=>({
+                            value: 'Alice'
+                        }),
+                    doc: {
+                        summary: 'field doc'
+                    }
+                });
+                const userCreated = (0, external_api_cjs_namespaceObject.subscription)({
+                    payload: subscriptionPayload,
+                    doc: {
+                        summary: 'sub doc'
+                    }
+                });
+                const result = (0, external_api_cjs_namespaceObject.api)({
+                    doc: {
+                        summary: 'api doc'
+                    },
+                    type: entity,
+                    operations: {
+                        createUser
+                    },
+                    fieldOperations: {
+                        displayName
+                    },
+                    subscriptions: {
+                        userCreated
+                    }
+                });
+                const ast = result.ast();
+                const operationNode = ast.children?.find((node)=>'operation' === node.type);
+                const subscriptionNode = ast.children?.find((node)=>"subscription" === node.type);
+                const fieldNode = ast.children?.find((node)=>'field' === node.type);
+                (0, external_vitest_namespaceObject.expect)(ast.type).toBe('api');
+                (0, external_vitest_namespaceObject.expect)(ast.doc).toEqual({
+                    summary: 'api doc'
+                });
+                (0, external_vitest_namespaceObject.expect)(operationNode).toMatchObject({
+                    name: 'createUser',
+                    constraints: {
+                        publish: [
+                            'userCreated'
+                        ],
+                        ack: {
+                            required: true,
+                            mode: 'handled'
+                        },
+                        request: 'OperationInput',
+                        response: 'OperationOutput'
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(subscriptionNode).toMatchObject({
+                    name: 'userCreated',
+                    constraints: {
+                        payload: "SubscriptionPayload",
+                        output: "SubscriptionPayload"
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(fieldNode).toMatchObject({
+                    name: 'User.displayName',
+                    constraints: {
+                        owner: 'User',
+                        field: 'displayName',
+                        request: 'FieldInput',
+                        response: 'FieldOutput',
+                        dependsOn: 'User'
+                    }
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should throw when field operations are provided without entity type', ()=>{
+                const fieldOp = (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                    dependsOn: (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                        outputValue: {
+                            id: 'u-1'
+                        }
+                    }),
+                    exec: async ()=>'field'
+                });
+                (0, external_vitest_namespaceObject.expect)(()=>(0, external_api_cjs_namespaceObject.api)({
+                        fieldOperations: {
+                            displayName: fieldOp
+                        }
+                    })).toThrowError('api.type is required when fieldOperations are provided.');
+            });
+            (0, external_vitest_namespaceObject.it)("should throw when operation publishes topic without matching subscription", ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'x'
+                });
+                const publishingOperation = (0, external_operation_cjs_namespaceObject.operation)({
+                    input: inputSchema,
+                    exec: async ()=>'ok',
+                    publish: {
+                        missingTopic: ()=>({
+                                payload: true
+                            })
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(()=>(0, external_api_cjs_namespaceObject.api)({
+                        operations: {
+                            createUser: publishingOperation
+                        }
+                    })).toThrowError('api: operation "createUser" publishes "missingTopic" but no subscription with that name exists.');
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('composeApi()', ()=>{
+        (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+            (0, external_vitest_namespaceObject.it)("should compose operations field operations and subscriptions from multiple apis", ()=>{
+                const userSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'User',
+                    type: 'object',
+                    astNode: {
+                        type: 'object',
+                        name: 'User'
+                    },
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'x'
+                });
+                const payloadSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Payload',
+                    type: 'payload'
+                });
+                const usersApi = (0, external_api_cjs_namespaceObject.api)({
+                    type: userSchema,
+                    operations: {
+                        createUser: (0, external_operation_cjs_namespaceObject.operation)({
+                            input: inputSchema,
+                            exec: async ()=>'ok'
+                        })
+                    },
+                    fieldOperations: {
+                        displayName: (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                            dependsOn: userSchema,
+                            exec: async ()=>'name'
+                        })
+                    },
+                    subscriptions: {
+                        userCreated: (0, external_api_cjs_namespaceObject.subscription)({
+                            payload: payloadSchema
+                        })
+                    }
+                });
+                const systemApi = (0, external_api_cjs_namespaceObject.api)({
+                    operations: {
+                        health: (0, external_operation_cjs_namespaceObject.operation)({
+                            input: inputSchema,
+                            exec: async ()=>'ok'
+                        })
+                    }
+                });
+                const composed = (0, external_api_cjs_namespaceObject.composeApi)({
+                    users: usersApi,
+                    system: systemApi
+                });
+                const ast = composed.ast();
+                (0, external_vitest_namespaceObject.expect)(composed.type).toBe('api-composed');
+                (0, external_vitest_namespaceObject.expect)(Object.keys(composed.operations)).toEqual([
+                    'createUser',
+                    'health'
+                ]);
+                (0, external_vitest_namespaceObject.expect)(Object.keys(composed.fieldOperations)).toEqual([
+                    'User.displayName'
+                ]);
+                (0, external_vitest_namespaceObject.expect)(Object.keys(composed.subscriptions)).toEqual([
+                    'userCreated'
+                ]);
+                (0, external_vitest_namespaceObject.expect)(ast.type).toBe('api-composed');
+                (0, external_vitest_namespaceObject.expect)(ast.children?.map((node)=>node.name)).toEqual([
+                    'users',
+                    'system'
+                ]);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+            (0, external_vitest_namespaceObject.it)('should throw when two apis contain duplicate operation names', ()=>{
+                const inputSchema = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    outputValue: 'x'
+                });
+                const left = (0, external_api_cjs_namespaceObject.api)({
+                    operations: {
+                        ping: (0, external_operation_cjs_namespaceObject.operation)({
+                            input: inputSchema,
+                            exec: async ()=>'left'
+                        })
+                    }
+                });
+                const right = (0, external_api_cjs_namespaceObject.api)({
+                    operations: {
+                        ping: (0, external_operation_cjs_namespaceObject.operation)({
+                            input: inputSchema,
+                            exec: async ()=>'right'
+                        })
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(()=>(0, external_api_cjs_namespaceObject.composeApi)({
+                        left,
+                        right
+                    })).toThrowError('composeApi: duplicate operation name "ping"');
+            });
+            (0, external_vitest_namespaceObject.it)('should throw when two apis contain duplicate field operation names', ()=>{
+                const owner = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'User',
+                    type: 'object',
+                    astNode: {
+                        type: 'object',
+                        name: 'User'
+                    },
+                    outputValue: {
+                        id: 'u-1'
+                    }
+                });
+                const left = (0, external_api_cjs_namespaceObject.api)({
+                    type: owner,
+                    fieldOperations: {
+                        displayName: (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                            dependsOn: owner,
+                            exec: async ()=>'left'
+                        })
+                    }
+                });
+                const right = (0, external_api_cjs_namespaceObject.api)({
+                    type: owner,
+                    fieldOperations: {
+                        displayName: (0, external_operation_cjs_namespaceObject.fieldOperation)({
+                            dependsOn: owner,
+                            exec: async ()=>'right'
+                        })
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(()=>(0, external_api_cjs_namespaceObject.composeApi)({
+                        left,
+                        right
+                    })).toThrowError('composeApi: duplicate field operation name "User.displayName"');
+            });
+            (0, external_vitest_namespaceObject.it)("should throw when two apis contain duplicate subscription names", ()=>{
+                const payload = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+                    name: 'Payload',
+                    type: 'payload'
+                });
+                const left = (0, external_api_cjs_namespaceObject.api)({
+                    subscriptions: {
+                        userCreated: (0, external_api_cjs_namespaceObject.subscription)({
+                            payload
+                        })
+                    }
+                });
+                const right = (0, external_api_cjs_namespaceObject.api)({
+                    subscriptions: {
+                        userCreated: (0, external_api_cjs_namespaceObject.subscription)({
+                            payload
+                        })
+                    }
+                });
+                (0, external_vitest_namespaceObject.expect)(()=>(0, external_api_cjs_namespaceObject.composeApi)({
+                        left,
+                        right
+                    })).toThrowError('composeApi: duplicate subscription name "userCreated"');
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/api.spec.d.ts

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