@livon/schema 0.27.0-rc.1

package/dist/api.cjs

@@ -0,0 +1,317 @@
+"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__, {
+    api: ()=>api,
+    composeApi: ()=>composeApi,
+    subscription: ()=>api_subscription
+});
+const external_doc_cjs_namespaceObject = require("./doc.cjs");
+const external_operation_cjs_namespaceObject = require("./operation.cjs");
+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 : (0, external_operation_cjs_namespaceObject.withOperationName)({
+            name: key,
+            operation: op
+        });
+        return acc;
+    }, {});
+    const namedFieldOperations = Object.entries(mergedFieldOperations).reduce((acc, [key, op])=>{
+        acc[key] = op.name ? op : (0, external_operation_cjs_namespaceObject.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 = (0, external_doc_cjs_namespaceObject.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: (0, external_doc_cjs_namespaceObject.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: (0, external_doc_cjs_namespaceObject.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: (0, external_doc_cjs_namespaceObject.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
+                    };
+                })
+            })
+    };
+};
+exports.api = __webpack_exports__.api;
+exports.composeApi = __webpack_exports__.composeApi;
+exports.subscription = __webpack_exports__.subscription;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "api",
+    "composeApi",
+    "subscription"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/api.d.ts

@@ -0,0 +1,107 @@
+import { AstNode, Infer, Schema, SchemaContext, SchemaDoc } from './types.js';
+import { FieldOperation, Operation } from './operation.js';
+type AnySchema = Schema<any>;
+type AnyFieldOperation = FieldOperation<AnySchema, any, AnySchema | undefined, unknown>;
+type AnyResult = any;
+type AnySubscription = Subscription<AnySchema | undefined, AnySchema, AnySchema | undefined, unknown>;
+type InputInfer<TInputSchema extends AnySchema | undefined> = TInputSchema extends AnySchema ? Infer<TInputSchema> : undefined;
+export interface SubscriptionFilter<TInput, TPayload> {
+    (input: TInput, payload: TPayload, ctx: SchemaContext): boolean | Promise<boolean>;
+}
+export interface SubscriptionExecutor<TInput, TPayload, TResult> {
+    (input: TInput, payload: TPayload, ctx: SchemaContext): TResult | Promise<TResult>;
+}
+export interface ApiShape {
+    [key: string]: Operation<AnySchema, AnySchema | undefined, AnyResult>;
+}
+export interface ApiFieldShape {
+    [key: string]: AnyFieldOperation;
+}
+export interface Subscription<TInputSchema extends AnySchema | undefined, TPayloadSchema extends AnySchema, TOutputSchema extends AnySchema | undefined, TResult> {
+    type: 'subscription';
+    input?: TInputSchema;
+    output?: TOutputSchema;
+    payload: TPayloadSchema;
+    filter?: SubscriptionFilter<InputInfer<TInputSchema>, Infer<TPayloadSchema>>;
+    exec?: SubscriptionExecutor<InputInfer<TInputSchema>, Infer<TPayloadSchema>, TResult>;
+    name?: string;
+    doc?: SchemaDoc;
+}
+export interface SubscriptionShape {
+    [key: string]: AnySubscription;
+}
+export interface SubscriptionInput<TInputSchema extends AnySchema | undefined = AnySchema | undefined, TPayloadSchema extends AnySchema = AnySchema, TOutputSchema extends AnySchema | undefined = AnySchema | undefined, TResult = unknown> {
+    input?: TInputSchema;
+    payload: TPayloadSchema;
+    output?: TOutputSchema;
+    filter?: SubscriptionFilter<InputInfer<TInputSchema>, Infer<TPayloadSchema>>;
+    exec?: SubscriptionExecutor<InputInfer<TInputSchema>, Infer<TPayloadSchema>, TResult>;
+    name?: string;
+    doc?: SchemaDoc;
+}
+export interface SubscriptionInputShape {
+    [key: string]: AnySubscription | SubscriptionInput | AnySchema;
+}
+/**
+ * subscription 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/api
+ *
+ * @example
+ * const result = subscription(undefined as never);
+ */
+export declare const subscription: <TInputSchema extends AnySchema | undefined = AnySchema | undefined, TPayloadSchema extends AnySchema = AnySchema, TOutputSchema extends AnySchema | undefined = AnySchema | undefined, TResult = unknown>(input: SubscriptionInput<TInputSchema, TPayloadSchema, TOutputSchema, TResult>) => Subscription<TInputSchema, TPayloadSchema, TOutputSchema, TResult>;
+export interface ApiAst {
+    (): AstNode;
+}
+export interface Api<TType extends AnySchema | undefined, TShape extends ApiShape, TFieldShape extends ApiFieldShape> {
+    type: 'api';
+    entity?: TType;
+    operations: TShape;
+    fieldOperations: TFieldShape;
+    subscriptions: SubscriptionShape;
+    ast: ApiAst;
+}
+export type ApiInput<TType extends AnySchema | undefined, TShape extends ApiShape, TFieldShape extends ApiFieldShape> = {
+    type?: TType;
+    operations?: TShape;
+    fieldOperations?: TFieldShape;
+    subscriptions?: SubscriptionInputShape;
+    doc?: SchemaDoc;
+} & Partial<TShape>;
+/**
+ * api 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/api
+ *
+ * @example
+ * const result = api(undefined as never);
+ */
+export declare const api: <TType extends AnySchema | undefined, TShape extends ApiShape, TFieldShape extends ApiFieldShape>(input: ApiInput<TType, TShape, TFieldShape>) => Api<TType, TShape, TFieldShape>;
+export interface ComposedApi<TApis extends Record<string, Api<AnySchema | undefined, ApiShape, ApiFieldShape>>> {
+    type: 'api-composed';
+    apis: TApis;
+    operations: ApiShape;
+    fieldOperations: ApiFieldShape;
+    subscriptions: SubscriptionShape;
+    ast: ApiAst;
+}
+/**
+ * composeApi 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/api
+ *
+ * @example
+ * const result = composeApi(undefined as never);
+ */
+export declare const composeApi: <TApis extends Record<string, Api<AnySchema | undefined, ApiShape, ApiFieldShape>>>(apis: TApis) => ComposedApi<TApis>;
+export {};