@livon/schema 0.27.0-rc.1

package/dist/api.js

@@ -0,0 +1,277 @@
+import { normalizeDoc } from "./doc.js";
+import { withFieldOperationName, withOperationName } from "./operation.js";
+const api_subscription = (input)=>({
+        type: "subscription",
+        payload: input.payload,
+        ...input.input ? {
+            input: input.input
+        } : {},
+        ...input.output ? {
+            output: input.output
+        } : {},
+        ...input.filter ? {
+            filter: input.filter
+        } : {},
+        ...input.exec ? {
+            exec: input.exec
+        } : {},
+        ...input.name ? {
+            name: input.name
+        } : {},
+        ...input.doc ? {
+            doc: input.doc
+        } : {}
+    });
+const isOperation = (value)=>'object' == typeof value && null !== value && 'type' in value && 'operation' === value.type;
+const isSchema = (value)=>'object' == typeof value && null !== value && 'parse' in value && 'ast' in value;
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const mergeOperations = (input, explicit)=>{
+    const ops = {
+        ...explicit ?? {}
+    };
+    Object.entries(input).forEach(([key, value])=>{
+        if (!ops[key] && isOperation(value)) ops[key] = value;
+    });
+    return ops;
+};
+const mergeFieldOperations = (input)=>({
+        ...input ?? {}
+    });
+const subscriptionFromInput = (name, value)=>{
+    if (isRecord(value) && 'payload' in value && isSchema(value.payload)) {
+        const payload = value.payload;
+        const input = isSchema(value.input) ? value.input : void 0;
+        const output = isSchema(value.output) ? value.output : void 0;
+        const filter = 'function' == typeof value.filter ? value.filter : void 0;
+        const exec = 'function' == typeof value.exec ? value.exec : void 0;
+        const doc = value.doc;
+        const normalized = value.name;
+        return {
+            type: "subscription",
+            payload,
+            ...input ? {
+                input
+            } : {},
+            ...output ? {
+                output
+            } : {},
+            ...filter ? {
+                filter
+            } : {},
+            ...exec ? {
+                exec
+            } : {},
+            ...doc ? {
+                doc
+            } : {},
+            ...normalized ? {
+                name: normalized
+            } : {}
+        };
+    }
+    if (isSchema(value)) return {
+        type: "subscription",
+        payload: value,
+        name
+    };
+};
+const mergeSubscriptions = (input)=>{
+    const subs = {};
+    if (!input) return subs;
+    Object.entries(input).forEach(([key, value])=>{
+        const subscription = subscriptionFromInput(key, value);
+        if (subscription) subs[key] = subscription;
+    });
+    return subs;
+};
+const api = (input)=>{
+    const { type, operations, fieldOperations, subscriptions, ...rest } = input;
+    const mergedOperations = mergeOperations(rest, operations);
+    const mergedFieldOperations = mergeFieldOperations(fieldOperations);
+    const mergedSubscriptions = mergeSubscriptions(subscriptions);
+    if (Object.keys(mergedFieldOperations).length > 0 && !type) throw new Error('api.type is required when fieldOperations are provided.');
+    const namedOperations = Object.entries(mergedOperations).reduce((acc, [key, op])=>{
+        acc[key] = op.name ? op : withOperationName({
+            name: key,
+            operation: op
+        });
+        return acc;
+    }, {});
+    const namedFieldOperations = Object.entries(mergedFieldOperations).reduce((acc, [key, op])=>{
+        acc[key] = op.name ? op : withFieldOperationName({
+            name: key,
+            operation: op
+        });
+        return acc;
+    }, {});
+    const namedSubscriptions = Object.entries(mergedSubscriptions).reduce((acc, [key, sub])=>{
+        acc[key] = sub.name ? sub : {
+            ...sub,
+            name: key
+        };
+        return acc;
+    }, {});
+    Object.entries(namedOperations).forEach(([operationName, op])=>{
+        const topics = Object.keys(op.publish ?? {});
+        topics.forEach((topic)=>{
+            if (!namedSubscriptions[topic]) throw new Error(`api: operation "${operationName}" publishes "${topic}" but no subscription with that name exists.`);
+        });
+    });
+    const apiDoc = normalizeDoc(input.doc);
+    return {
+        type: 'api',
+        entity: type,
+        operations: namedOperations,
+        fieldOperations: namedFieldOperations,
+        subscriptions: namedSubscriptions,
+        ast: ()=>({
+                type: 'api',
+                name: type?.name,
+                doc: apiDoc,
+                children: [
+                    ...Object.entries(namedOperations).map(([name, op])=>{
+                        const publishTopics = Object.keys(op.publish ?? {});
+                        const requestType = op.input?.name ?? void 0;
+                        const responseType = op.output?.name ?? void 0;
+                        const ackConfig = op.ack;
+                        const constraints = {
+                            ...publishTopics.length > 0 ? {
+                                publish: publishTopics
+                            } : {},
+                            ...void 0 !== ackConfig ? {
+                                ack: ackConfig
+                            } : {},
+                            ...requestType ? {
+                                request: requestType
+                            } : {},
+                            ...responseType ? {
+                                response: responseType
+                            } : {}
+                        };
+                        return {
+                            type: 'operation',
+                            name,
+                            constraints: Object.keys(constraints).length > 0 ? constraints : void 0,
+                            doc: normalizeDoc(op.doc),
+                            request: requestType,
+                            response: responseType,
+                            children: [
+                                op.input.ast(),
+                                ...op.output ? [
+                                    op.output.ast()
+                                ] : []
+                            ]
+                        };
+                    }),
+                    ...Object.entries(namedSubscriptions).map(([name, sub])=>{
+                        const inputType = sub.input?.name ?? void 0;
+                        const payloadType = sub.payload?.name ?? void 0;
+                        const outputType = sub.output?.name ?? payloadType;
+                        const constraints = {
+                            ...inputType ? {
+                                input: inputType
+                            } : {},
+                            ...payloadType ? {
+                                payload: payloadType
+                            } : {},
+                            ...outputType ? {
+                                output: outputType
+                            } : {}
+                        };
+                        return {
+                            type: "subscription",
+                            name,
+                            constraints: Object.keys(constraints).length > 0 ? constraints : void 0,
+                            doc: normalizeDoc(sub.doc),
+                            request: inputType,
+                            response: outputType,
+                            children: [
+                                sub.payload.ast(),
+                                ...sub.input ? [
+                                    sub.input.ast()
+                                ] : [],
+                                ...sub.output ? [
+                                    sub.output.ast()
+                                ] : []
+                            ]
+                        };
+                    }),
+                    ...Object.entries(namedFieldOperations).map(([fieldName, op])=>{
+                        const requestType = op.input?.name ?? void 0;
+                        const responseType = op.output?.name ?? void 0;
+                        const dependsOnType = op.dependsOn?.name ?? void 0;
+                        const constraints = {
+                            owner: type?.name,
+                            field: fieldName,
+                            ...requestType ? {
+                                request: requestType
+                            } : {},
+                            ...responseType ? {
+                                response: responseType
+                            } : {},
+                            ...dependsOnType ? {
+                                dependsOn: dependsOnType
+                            } : {}
+                        };
+                        return {
+                            type: 'field',
+                            name: type?.name ? `${type.name}.${fieldName}` : fieldName,
+                            constraints,
+                            doc: normalizeDoc(op.doc),
+                            request: requestType,
+                            response: responseType,
+                            dependsOn: dependsOnType,
+                            children: [
+                                op.dependsOn.ast(),
+                                ...op.input ? [
+                                    op.input.ast()
+                                ] : [],
+                                ...op.output ? [
+                                    op.output.ast()
+                                ] : []
+                            ]
+                        };
+                    })
+                ]
+            })
+    };
+};
+const composeApi = (apis)=>{
+    const operations = {};
+    const fieldOperations = {};
+    const subscriptions = {};
+    Object.values(apis).forEach((apiInstance)=>{
+        Object.entries(apiInstance.operations).forEach(([name, op])=>{
+            if (operations[name]) throw new Error(`composeApi: duplicate operation name \"${name}\"`);
+            operations[name] = op;
+        });
+        Object.entries(apiInstance.fieldOperations).forEach(([name, op])=>{
+            const owner = apiInstance.entity?.name;
+            const key = owner ? `${owner}.${name}` : name;
+            if (fieldOperations[key]) throw new Error(`composeApi: duplicate field operation name \"${key}\"`);
+            fieldOperations[key] = op;
+        });
+        Object.entries(apiInstance.subscriptions ?? {}).forEach(([name, sub])=>{
+            if (subscriptions[name]) throw new Error(`composeApi: duplicate subscription name "${name}"`);
+            subscriptions[name] = sub;
+        });
+    });
+    return {
+        type: 'api-composed',
+        apis,
+        operations,
+        fieldOperations,
+        subscriptions,
+        ast: ()=>({
+                type: 'api-composed',
+                children: Object.entries(apis).map(([name, apiInstance])=>{
+                    const node = apiInstance.ast();
+                    return {
+                        ...node,
+                        name
+                    };
+                })
+            })
+    };
+};
+export { api, composeApi, api_subscription as subscription };