@livon/schema 0.27.0-rc.1

package/dist/schemaModule.cjs

@@ -0,0 +1,280 @@
+"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__, {
+    schemaModule: ()=>schemaModule,
+    createSchemaModuleInput: ()=>createSchemaModuleInput
+});
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_operation_cjs_namespaceObject = require("./operation.cjs");
+const external_msgpackr_namespaceObject = require("msgpackr");
+const createSchemaModuleInput = (input)=>({
+        operations: input.operations,
+        fieldOperations: input.fieldOperations,
+        subscriptions: input.subscriptions,
+        ast: input.ast
+    });
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const defaultEncode = (value)=>(0, external_msgpackr_namespaceObject.pack)(value);
+const defaultDecode = (payload)=>payload instanceof Uint8Array ? (0, external_msgpackr_namespaceObject.unpack)(payload) : payload;
+const stableStringify = (value)=>{
+    if (null === value || 'object' != typeof value) return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map((entry)=>stableStringify(entry)).join(',')}]`;
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((key)=>`${JSON.stringify(key)}:${stableStringify(record[key])}`).join(',')}}`;
+};
+const hashString = (input)=>Array.from(input).reduce((hash, char)=>{
+        const next = (hash ^ char.charCodeAt(0)) >>> 0;
+        return Math.imul(next, 16777619) >>> 0;
+    }, 2166136261).toString(16).padStart(8, '0');
+const getEnvelopeMetadata = (envelope)=>{
+    if (envelope.metadata) return envelope.metadata;
+    return envelope.meta;
+};
+const normalizeFieldPayload = (payload)=>isRecord(payload) && 'dependsOn' in payload ? payload : {
+        dependsOn: payload
+    };
+const splitFieldEvent = (event)=>{
+    if (!event.startsWith('$')) return;
+    const body = event.slice(1);
+    const dotIndex = body.indexOf('.');
+    if (dotIndex <= 0 || dotIndex === body.length - 1) return;
+    return {
+        owner: body.slice(0, dotIndex),
+        field: body.slice(dotIndex + 1)
+    };
+};
+const mergeMetadata = (base, extra)=>{
+    if (!base && !extra) return;
+    return {
+        ...base ?? {},
+        ...extra ?? {}
+    };
+};
+const buildExplainPayload = (input)=>({
+        ast: input.ast,
+        checksum: input.checksum,
+        schemaVersion: input.schemaVersion,
+        generatedAt: new Date(input.now()).toISOString(),
+        etag: input.checksum,
+        ...input.notModified ? {
+            notModified: true
+        } : {}
+    });
+const eventErrorFromUnknown = (error, info)=>{
+    if (error instanceof Error) return {
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+        context: info
+    };
+    return {
+        message: 'string' == typeof error ? error : 'Unknown error',
+        context: info
+    };
+};
+const normalizeAckConfig = (ack)=>{
+    if (void 0 === ack || false === ack) return;
+    if (true === ack) return {
+        required: true,
+        mode: 'received'
+    };
+    return {
+        required: ack.required ?? true,
+        mode: ack.mode ?? 'received',
+        ...'number' == typeof ack.timeoutMs ? {
+            timeoutMs: ack.timeoutMs
+        } : {},
+        ...'number' == typeof ack.retries ? {
+            retries: ack.retries
+        } : {}
+    };
+};
+const resolveSubscriptionPayload = async (input)=>{
+    const parsedInput = input.subscription.input ? input.subscription.input.parse(input.input, input.ctx) : input.input;
+    const parsedPayload = input.subscription.payload.parse(input.payload, input.ctx);
+    if (input.subscription.filter) {
+        const allowed = await input.subscription.filter(parsedInput, parsedPayload, input.ctx);
+        if (!allowed) return {
+            skip: true
+        };
+    }
+    const executed = input.subscription.exec ? await input.subscription.exec(parsedInput, parsedPayload, input.ctx) : parsedPayload;
+    const output = input.subscription.output ? input.subscription.output.parse(executed, input.ctx) : executed;
+    return {
+        skip: false,
+        payload: output
+    };
+};
+const emitErrorEvent = async (input)=>input.ctx.emitError({
+        id: input.envelope.id,
+        event: input.envelope.event,
+        status: input.envelope.status,
+        ...void 0 !== input.envelope.payload ? {
+            payload: input.envelope.payload
+        } : {},
+        error: eventErrorFromUnknown(input.error, input.info),
+        metadata: input.metadata,
+        context: input.envelope.context ? {
+            ...input.envelope.context
+        } : void 0
+    });
+const schemaModule = (schema, options = {})=>{
+    const encode = options.encoder ?? defaultEncode;
+    const decode = options.decoder ?? defaultDecode;
+    const now = options.now ?? Date.now;
+    const ast = schema.ast();
+    const checksum = hashString(stableStringify(ast));
+    const onReceive = async (envelope, ctx, next)=>{
+        if ('$explain' === envelope.event) {
+            if (!options.explain) return next();
+            const metadata = getEnvelopeMetadata(envelope);
+            const ifNoneMatch = 'string' == typeof metadata?.ifNoneMatch ? metadata.ifNoneMatch : void 0;
+            const notModified = Boolean(ifNoneMatch && ifNoneMatch === checksum);
+            const payload = buildExplainPayload({
+                notModified,
+                ast,
+                checksum,
+                schemaVersion: options.schemaVersion,
+                now
+            });
+            await ctx.emitEvent({
+                event: envelope.event,
+                payload: encode(payload),
+                metadata,
+                context: envelope.context ? {
+                    ...envelope.context
+                } : void 0
+            });
+            return envelope;
+        }
+        const op = schema.operations[envelope.event];
+        const fieldInfo = op ? void 0 : splitFieldEvent(envelope.event);
+        const fieldKey = fieldInfo ? `${fieldInfo.owner}.${fieldInfo.field}` : void 0;
+        const fieldOp = fieldInfo && !op ? schema.fieldOperations[fieldKey] ?? schema.fieldOperations[fieldInfo.field] : void 0;
+        if (!op && !fieldOp) return next();
+        const metadata = getEnvelopeMetadata(envelope);
+        const requestOverrides = options.getRequestContext ? options.getRequestContext(envelope, ctx) : void 0;
+        const externalPublisher = requestOverrides?.publisher;
+        const externalOnPublishError = requestOverrides?.onPublishError;
+        const schemaContext = (0, external_context_cjs_namespaceObject.createSchemaContext)();
+        const publisher = async (input)=>{
+            const subscription = schema.subscriptions[input.topic];
+            if (!subscription) throw new Error(`schemaModule: publish topic "${input.topic}" has no matching subscription.`);
+            const resolved = await resolveSubscriptionPayload({
+                subscription,
+                input: input.input,
+                payload: input.payload,
+                ctx: schemaContext
+            });
+            if (resolved.skip) return;
+            const keyMeta = input.key ? {
+                key: input.key
+            } : void 0;
+            const ackMeta = normalizeAckConfig(input.ack);
+            const ackWrapper = ackMeta ? {
+                ack: ackMeta
+            } : void 0;
+            const publishMeta = mergeMetadata(metadata, mergeMetadata(input.meta, mergeMetadata(keyMeta, ackWrapper)));
+            await ctx.emitEvent({
+                event: input.topic,
+                payload: encode(resolved.payload),
+                metadata: publishMeta,
+                context: envelope.context ? {
+                    ...envelope.context
+                } : void 0
+            });
+            if (externalPublisher) await externalPublisher({
+                ...input,
+                payload: resolved.payload,
+                ...ackMeta ? {
+                    ack: ackMeta
+                } : {}
+            });
+        };
+        const handlePublishError = (error, info)=>{
+            if (externalOnPublishError) externalOnPublishError(error, info);
+            emitErrorEvent({
+                ctx,
+                envelope,
+                metadata,
+                error,
+                info
+            });
+        };
+        const requestContext = {
+            ...requestOverrides,
+            metadata: mergeMetadata(metadata, requestOverrides?.metadata),
+            publisher,
+            onPublishError: handlePublishError,
+            logger: requestOverrides?.logger ?? options.logger
+        };
+        schemaContext.setRequestContext(requestContext);
+        const input = decode(envelope.payload);
+        const fieldPayload = op ? void 0 : normalizeFieldPayload(input);
+        let result;
+        try {
+            result = op ? await (0, external_operation_cjs_namespaceObject.runOperation)(op, input, schemaContext) : await (0, external_operation_cjs_namespaceObject.runFieldOperation)(fieldOp, fieldPayload?.dependsOn, fieldPayload?.input, schemaContext);
+        } catch (error) {
+            await emitErrorEvent({
+                ctx,
+                envelope,
+                metadata,
+                error,
+                info: {
+                    phase: 'execute',
+                    event: envelope.event
+                }
+            });
+            return envelope;
+        }
+        await ctx.emitEvent({
+            event: envelope.event,
+            payload: encode(result),
+            metadata,
+            context: envelope.context ? {
+                ...envelope.context
+            } : void 0
+        });
+        return envelope;
+    };
+    const register = (registry)=>{
+        registry.onReceive(onReceive);
+    };
+    return {
+        name: 'schema',
+        register
+    };
+};
+exports.createSchemaModuleInput = __webpack_exports__.createSchemaModuleInput;
+exports.schemaModule = __webpack_exports__.schemaModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSchemaModuleInput",
+    "schemaModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/schemaModule.d.ts

@@ -0,0 +1,97 @@
+import { type Operation, type FieldOperation } from './operation.js';
+import type { AstNode, Logger, SchemaRequestContextInput, Schema } from './types.js';
+import type { Subscription } from './api.js';
+import type { EventEnvelope, RuntimeContext, RuntimeModule } from '@livon/runtime';
+type AnySchema = Schema<any>;
+type AnyInput = any;
+type AnyResult = any;
+type AnyOperation = Operation<AnySchema, AnySchema | undefined, AnyResult>;
+type AnyFieldOperation = FieldOperation<AnySchema, AnyInput, AnySchema | undefined, AnyResult>;
+type AnySubscription = Subscription<AnySchema | undefined, AnySchema, AnySchema | undefined, unknown>;
+export type SchemaModuleInput = {
+    operations: Record<string, AnyOperation>;
+    fieldOperations: Record<string, AnyFieldOperation>;
+    subscriptions: Record<string, AnySubscription>;
+    ast: () => AstNode;
+};
+export interface SchemaModuleLike {
+    operations: Record<string, AnyOperation>;
+    fieldOperations: Record<string, AnyFieldOperation>;
+    subscriptions: Record<string, AnySubscription>;
+    ast: () => AstNode;
+}
+/**
+ * createSchemaModuleInput 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/packages/schema
+ *
+ * @example
+ * const result = createSchemaModuleInput(undefined as never);
+ */
+export declare const createSchemaModuleInput: (input: SchemaModuleLike) => SchemaModuleInput;
+export type SchemaModuleOptions = {
+    explain?: boolean;
+    schemaVersion?: string;
+    now?: SchemaModuleNow;
+    encoder?: SchemaModuleEncoder;
+    decoder?: SchemaModuleDecoder;
+    logger?: Logger;
+    getRequestContext?: SchemaModuleGetRequestContext;
+};
+export interface SchemaModuleNow {
+    (): number;
+}
+export interface SchemaModuleEncoder {
+    (value: unknown): Uint8Array;
+}
+export interface SchemaModuleDecoder {
+    (payload: Uint8Array | unknown): unknown;
+}
+export interface SchemaModuleGetRequestContext {
+    (envelope: EventEnvelope, ctx: RuntimeContext): SchemaRequestContextInput | undefined;
+}
+export interface ExplainPayload {
+    ast: AstNode;
+    checksum: string;
+    schemaVersion?: string;
+    generatedAt: string;
+    etag: string;
+    notModified?: boolean;
+}
+export interface FieldPayload {
+    dependsOn: unknown;
+    input?: unknown;
+}
+export interface BuildExplainPayloadInput {
+    notModified?: boolean;
+    ast: AstNode;
+    checksum: string;
+    schemaVersion?: string;
+    now: () => number;
+}
+export interface EmitErrorEventInput {
+    ctx: RuntimeContext;
+    envelope: EventEnvelope;
+    metadata?: Readonly<Record<string, unknown>>;
+    error: unknown;
+    info?: Readonly<Record<string, unknown>>;
+}
+export type EnvelopeWithMeta = EventEnvelope & {
+    meta?: Readonly<Record<string, unknown>>;
+};
+/**
+ * schemaModule 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/packages/schema
+ *
+ * @example
+ * const result = schemaModule(undefined as never);
+ */
+export declare const schemaModule: (schema: SchemaModuleInput, options?: SchemaModuleOptions) => RuntimeModule;
+export {};

package/dist/schemaModule.js

@@ -0,0 +1,243 @@
+import { createSchemaContext } from "./context.js";
+import { runFieldOperation, runOperation } from "./operation.js";
+import { pack, unpack } from "msgpackr";
+const createSchemaModuleInput = (input)=>({
+        operations: input.operations,
+        fieldOperations: input.fieldOperations,
+        subscriptions: input.subscriptions,
+        ast: input.ast
+    });
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const defaultEncode = (value)=>pack(value);
+const defaultDecode = (payload)=>payload instanceof Uint8Array ? unpack(payload) : payload;
+const stableStringify = (value)=>{
+    if (null === value || 'object' != typeof value) return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map((entry)=>stableStringify(entry)).join(',')}]`;
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((key)=>`${JSON.stringify(key)}:${stableStringify(record[key])}`).join(',')}}`;
+};
+const hashString = (input)=>Array.from(input).reduce((hash, char)=>{
+        const next = (hash ^ char.charCodeAt(0)) >>> 0;
+        return Math.imul(next, 16777619) >>> 0;
+    }, 2166136261).toString(16).padStart(8, '0');
+const getEnvelopeMetadata = (envelope)=>{
+    if (envelope.metadata) return envelope.metadata;
+    return envelope.meta;
+};
+const normalizeFieldPayload = (payload)=>isRecord(payload) && 'dependsOn' in payload ? payload : {
+        dependsOn: payload
+    };
+const splitFieldEvent = (event)=>{
+    if (!event.startsWith('$')) return;
+    const body = event.slice(1);
+    const dotIndex = body.indexOf('.');
+    if (dotIndex <= 0 || dotIndex === body.length - 1) return;
+    return {
+        owner: body.slice(0, dotIndex),
+        field: body.slice(dotIndex + 1)
+    };
+};
+const mergeMetadata = (base, extra)=>{
+    if (!base && !extra) return;
+    return {
+        ...base ?? {},
+        ...extra ?? {}
+    };
+};
+const buildExplainPayload = (input)=>({
+        ast: input.ast,
+        checksum: input.checksum,
+        schemaVersion: input.schemaVersion,
+        generatedAt: new Date(input.now()).toISOString(),
+        etag: input.checksum,
+        ...input.notModified ? {
+            notModified: true
+        } : {}
+    });
+const eventErrorFromUnknown = (error, info)=>{
+    if (error instanceof Error) return {
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+        context: info
+    };
+    return {
+        message: 'string' == typeof error ? error : 'Unknown error',
+        context: info
+    };
+};
+const normalizeAckConfig = (ack)=>{
+    if (void 0 === ack || false === ack) return;
+    if (true === ack) return {
+        required: true,
+        mode: 'received'
+    };
+    return {
+        required: ack.required ?? true,
+        mode: ack.mode ?? 'received',
+        ...'number' == typeof ack.timeoutMs ? {
+            timeoutMs: ack.timeoutMs
+        } : {},
+        ...'number' == typeof ack.retries ? {
+            retries: ack.retries
+        } : {}
+    };
+};
+const resolveSubscriptionPayload = async (input)=>{
+    const parsedInput = input.subscription.input ? input.subscription.input.parse(input.input, input.ctx) : input.input;
+    const parsedPayload = input.subscription.payload.parse(input.payload, input.ctx);
+    if (input.subscription.filter) {
+        const allowed = await input.subscription.filter(parsedInput, parsedPayload, input.ctx);
+        if (!allowed) return {
+            skip: true
+        };
+    }
+    const executed = input.subscription.exec ? await input.subscription.exec(parsedInput, parsedPayload, input.ctx) : parsedPayload;
+    const output = input.subscription.output ? input.subscription.output.parse(executed, input.ctx) : executed;
+    return {
+        skip: false,
+        payload: output
+    };
+};
+const emitErrorEvent = async (input)=>input.ctx.emitError({
+        id: input.envelope.id,
+        event: input.envelope.event,
+        status: input.envelope.status,
+        ...void 0 !== input.envelope.payload ? {
+            payload: input.envelope.payload
+        } : {},
+        error: eventErrorFromUnknown(input.error, input.info),
+        metadata: input.metadata,
+        context: input.envelope.context ? {
+            ...input.envelope.context
+        } : void 0
+    });
+const schemaModule = (schema, options = {})=>{
+    const encode = options.encoder ?? defaultEncode;
+    const decode = options.decoder ?? defaultDecode;
+    const now = options.now ?? Date.now;
+    const ast = schema.ast();
+    const checksum = hashString(stableStringify(ast));
+    const onReceive = async (envelope, ctx, next)=>{
+        if ('$explain' === envelope.event) {
+            if (!options.explain) return next();
+            const metadata = getEnvelopeMetadata(envelope);
+            const ifNoneMatch = 'string' == typeof metadata?.ifNoneMatch ? metadata.ifNoneMatch : void 0;
+            const notModified = Boolean(ifNoneMatch && ifNoneMatch === checksum);
+            const payload = buildExplainPayload({
+                notModified,
+                ast,
+                checksum,
+                schemaVersion: options.schemaVersion,
+                now
+            });
+            await ctx.emitEvent({
+                event: envelope.event,
+                payload: encode(payload),
+                metadata,
+                context: envelope.context ? {
+                    ...envelope.context
+                } : void 0
+            });
+            return envelope;
+        }
+        const op = schema.operations[envelope.event];
+        const fieldInfo = op ? void 0 : splitFieldEvent(envelope.event);
+        const fieldKey = fieldInfo ? `${fieldInfo.owner}.${fieldInfo.field}` : void 0;
+        const fieldOp = fieldInfo && !op ? schema.fieldOperations[fieldKey] ?? schema.fieldOperations[fieldInfo.field] : void 0;
+        if (!op && !fieldOp) return next();
+        const metadata = getEnvelopeMetadata(envelope);
+        const requestOverrides = options.getRequestContext ? options.getRequestContext(envelope, ctx) : void 0;
+        const externalPublisher = requestOverrides?.publisher;
+        const externalOnPublishError = requestOverrides?.onPublishError;
+        const schemaContext = createSchemaContext();
+        const publisher = async (input)=>{
+            const subscription = schema.subscriptions[input.topic];
+            if (!subscription) throw new Error(`schemaModule: publish topic "${input.topic}" has no matching subscription.`);
+            const resolved = await resolveSubscriptionPayload({
+                subscription,
+                input: input.input,
+                payload: input.payload,
+                ctx: schemaContext
+            });
+            if (resolved.skip) return;
+            const keyMeta = input.key ? {
+                key: input.key
+            } : void 0;
+            const ackMeta = normalizeAckConfig(input.ack);
+            const ackWrapper = ackMeta ? {
+                ack: ackMeta
+            } : void 0;
+            const publishMeta = mergeMetadata(metadata, mergeMetadata(input.meta, mergeMetadata(keyMeta, ackWrapper)));
+            await ctx.emitEvent({
+                event: input.topic,
+                payload: encode(resolved.payload),
+                metadata: publishMeta,
+                context: envelope.context ? {
+                    ...envelope.context
+                } : void 0
+            });
+            if (externalPublisher) await externalPublisher({
+                ...input,
+                payload: resolved.payload,
+                ...ackMeta ? {
+                    ack: ackMeta
+                } : {}
+            });
+        };
+        const handlePublishError = (error, info)=>{
+            if (externalOnPublishError) externalOnPublishError(error, info);
+            emitErrorEvent({
+                ctx,
+                envelope,
+                metadata,
+                error,
+                info
+            });
+        };
+        const requestContext = {
+            ...requestOverrides,
+            metadata: mergeMetadata(metadata, requestOverrides?.metadata),
+            publisher,
+            onPublishError: handlePublishError,
+            logger: requestOverrides?.logger ?? options.logger
+        };
+        schemaContext.setRequestContext(requestContext);
+        const input = decode(envelope.payload);
+        const fieldPayload = op ? void 0 : normalizeFieldPayload(input);
+        let result;
+        try {
+            result = op ? await runOperation(op, input, schemaContext) : await runFieldOperation(fieldOp, fieldPayload?.dependsOn, fieldPayload?.input, schemaContext);
+        } catch (error) {
+            await emitErrorEvent({
+                ctx,
+                envelope,
+                metadata,
+                error,
+                info: {
+                    phase: 'execute',
+                    event: envelope.event
+                }
+            });
+            return envelope;
+        }
+        await ctx.emitEvent({
+            event: envelope.event,
+            payload: encode(result),
+            metadata,
+            context: envelope.context ? {
+                ...envelope.context
+            } : void 0
+        });
+        return envelope;
+    };
+    const register = (registry)=>{
+        registry.onReceive(onReceive);
+    };
+    return {
+        name: 'schema',
+        register
+    };
+};
+export { createSchemaModuleInput, schemaModule };