@livon/schema 0.27.0-rc.1

package/dist/operation.cjs

@@ -0,0 +1,182 @@
+"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__, {
+    operation: ()=>operation,
+    withOperationName: ()=>withOperationName,
+    runOperation: ()=>runOperation,
+    withFieldOperationName: ()=>withFieldOperationName,
+    runFieldOperation: ()=>runFieldOperation,
+    fieldOperation: ()=>fieldOperation
+});
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_object_cjs_namespaceObject = require("./object.cjs");
+const isSchema = (value)=>'object' == typeof value && null !== value && 'parse' in value && 'ast' in value;
+const normalizeDependsOn = (dependsOn, name)=>isSchema(dependsOn) ? dependsOn : (0, external_object_cjs_namespaceObject.object)({
+        name: name ?? 'dependsOn',
+        shape: dependsOn
+    });
+function operation(input) {
+    const output = 'output' in input ? input.output : void 0;
+    return {
+        type: 'operation',
+        input: input.input,
+        output,
+        exec: input.exec,
+        publish: input.publish,
+        rooms: input.rooms,
+        ack: input.ack,
+        doc: input.doc
+    };
+}
+function fieldOperation(input) {
+    const dependsOnSchema = normalizeDependsOn(input.dependsOn, 'dependsOn');
+    const inputSchema = input.input ? normalizeDependsOn(input.input, 'input') : void 0;
+    const output = 'output' in input ? input.output : void 0;
+    return {
+        type: 'field',
+        dependsOn: dependsOnSchema,
+        input: inputSchema,
+        output,
+        exec: input.exec,
+        doc: input.doc
+    };
+}
+const withOperationName = ({ name, operation: op })=>({
+        ...op,
+        name
+    });
+const withFieldOperationName = ({ name, operation: op })=>({
+        ...op,
+        name
+    });
+const logPublishError = (error, info, ctx)=>{
+    try {
+        const logger = ctx?.request?.logger ?? ctx?.getRequestContext()?.logger;
+        if (logger?.error) return void logger.error('publish failed', info, error);
+        globalThis.console?.error?.('publish failed', info ?? {}, error);
+    } catch  {}
+};
+const runPublishHooks = async (publish, output, ctx, rooms, operationInput, ack)=>{
+    if (!publish) return;
+    const publisher = ctx.request?.publisher ?? ctx.getRequestContext()?.publisher;
+    if (!publisher) return;
+    const roomList = Array.isArray(rooms) ? rooms : rooms ? [
+        rooms
+    ] : [];
+    await Object.entries(publish).reduce(async (pending, [topic, hook])=>{
+        await pending;
+        try {
+            const payload = await hook(output, ctx);
+            if (void 0 === payload) return;
+            if (0 === roomList.length) return void await publisher({
+                topic,
+                payload,
+                input: operationInput,
+                ack
+            });
+            await roomList.reduce(async (chain, room)=>{
+                await chain;
+                await publisher({
+                    topic,
+                    payload,
+                    input: operationInput,
+                    ack,
+                    meta: {
+                        room
+                    }
+                });
+            }, Promise.resolve());
+        } catch (error) {
+            logPublishError(error, {
+                topic,
+                phase: 'publish-hook'
+            }, ctx);
+            ctx.request?.onPublishError?.(error, {
+                topic,
+                phase: 'publish-hook'
+            });
+        }
+    }, Promise.resolve());
+};
+const wrapPublisher = (ctx)=>{
+    const request = ctx.request ?? ctx.getRequestContext();
+    if (!request?.publisher) return;
+    const original = request.publisher;
+    request.publisher = async (input)=>{
+        try {
+            await original(input);
+        } catch (error) {
+            logPublishError(error, {
+                topic: input.topic,
+                phase: 'publisher'
+            }, ctx);
+            request.onPublishError?.(error, {
+                topic: input.topic,
+                phase: 'publisher'
+            });
+        }
+    };
+};
+const runOperation = async (op, rawInput, ctx)=>{
+    const context = ctx ?? (0, external_context_cjs_namespaceObject.createSchemaContext)();
+    if (!context.getRequestContext()) context.setRequestContext({});
+    wrapPublisher(context);
+    const input = op.input.parse(rawInput, context);
+    const rooms = op.rooms ? op.rooms(input, context) : void 0;
+    const result = await op.exec(input, context);
+    const output = op.output ? op.output.parse(result, context) : result;
+    await runPublishHooks(op.publish, output, context, rooms, input, op.ack);
+    return output;
+};
+const runFieldOperation = async (op, rawDependsOn, rawInputOrContext, ctx)=>{
+    const isContext = (value)=>'object' == typeof value && null !== value && 'getBuildContext' in value && 'getRequestContext' in value;
+    const actualContext = isContext(rawInputOrContext) ? rawInputOrContext : ctx;
+    const rawInput = isContext(rawInputOrContext) ? void 0 : rawInputOrContext;
+    const context = actualContext ?? (0, external_context_cjs_namespaceObject.createSchemaContext)();
+    if (!context.getRequestContext()) context.setRequestContext({});
+    const dependsOn = op.dependsOn.parse(rawDependsOn, context);
+    const input = op.input ? op.input.parse(rawInput, context) : void 0;
+    const result = op.input ? await op.exec(dependsOn, input, context) : await op.exec(dependsOn, context);
+    if (op.output) return op.output.parse(result, context);
+    return result;
+};
+exports.fieldOperation = __webpack_exports__.fieldOperation;
+exports.operation = __webpack_exports__.operation;
+exports.runFieldOperation = __webpack_exports__.runFieldOperation;
+exports.runOperation = __webpack_exports__.runOperation;
+exports.withFieldOperationName = __webpack_exports__.withFieldOperationName;
+exports.withOperationName = __webpack_exports__.withOperationName;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "fieldOperation",
+    "operation",
+    "runFieldOperation",
+    "runOperation",
+    "withFieldOperationName",
+    "withOperationName"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/operation.d.ts

@@ -0,0 +1,197 @@
+import { Schema, Shape, Infer, SchemaContext, SchemaDoc, PublishAck } from './types.js';
+type AnySchema = Schema<any>;
+type InputSource = AnySchema | Shape | undefined;
+type InputInfer<TInput> = TInput extends AnySchema ? Infer<TInput> : TInput extends Shape ? ShapeInfer<TInput> : undefined;
+export interface OperationExecutor<TInput, TResult> {
+    (input: TInput, ctx: SchemaContext): TResult | Promise<TResult>;
+}
+export interface OperationRooms<TInput> {
+    (input: TInput, ctx: SchemaContext): string | readonly string[] | undefined;
+}
+export type OperationResult<TOutputSchema extends AnySchema | undefined, TResult> = TOutputSchema extends Schema<infer TOutput> ? TOutput : TResult;
+export interface OperationPublishHook<TOutput> {
+    (output: TOutput, ctx: SchemaContext): unknown | void | Promise<unknown | void>;
+}
+export type OperationPublishMap<TOutput> = Record<string, OperationPublishHook<TOutput>>;
+export type ShapeInfer<TShape extends Shape> = {
+    [K in keyof TShape]: Infer<TShape[K]>;
+};
+export interface Operation<TInputSchema extends AnySchema, TOutputSchema extends AnySchema | undefined, TResult> {
+    type: 'operation';
+    name?: string;
+    doc?: SchemaDoc;
+    input: TInputSchema;
+    output?: TOutputSchema;
+    exec: OperationExecutor<Infer<TInputSchema>, TResult>;
+    publish?: OperationPublishMap<OperationResult<TOutputSchema, TResult>>;
+    rooms?: OperationRooms<Infer<TInputSchema>>;
+    ack?: PublishAck;
+}
+export interface OperationInput<TInputSchema extends AnySchema, TResult> {
+    input: TInputSchema;
+    doc?: SchemaDoc;
+    exec: OperationExecutor<Infer<TInputSchema>, TResult>;
+    publish?: OperationPublishMap<TResult>;
+    rooms?: OperationRooms<Infer<TInputSchema>>;
+    ack?: PublishAck;
+}
+export interface OperationInputWithOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema> {
+    input: TInputSchema;
+    output: TOutputSchema;
+    doc?: SchemaDoc;
+    exec: OperationExecutor<Infer<TInputSchema>, Infer<TOutputSchema>>;
+    publish?: OperationPublishMap<Infer<TOutputSchema>>;
+    rooms?: OperationRooms<Infer<TInputSchema>>;
+    ack?: PublishAck;
+}
+export interface OperationInputWithOptionalOutput<TInputSchema extends AnySchema, TResult> extends OperationInput<TInputSchema, TResult> {
+    output?: AnySchema;
+}
+export interface FieldOperationExecutor<TDependsOn, TInput, TResult> {
+    (dependsOn: TDependsOn, ctx: SchemaContext): TResult | Promise<TResult>;
+    (dependsOn: TDependsOn, input: TInput, ctx: SchemaContext): TResult | Promise<TResult>;
+}
+export interface FieldOperation<TDependsOnSchema extends AnySchema, TInput extends InputSource, TOutputSchema extends AnySchema | undefined, TResult> {
+    type: 'field';
+    name?: string;
+    doc?: SchemaDoc;
+    dependsOn: TDependsOnSchema;
+    input?: AnySchema;
+    output?: TOutputSchema;
+    exec: FieldOperationExecutor<Infer<TDependsOnSchema>, InputInfer<TInput>, TResult>;
+}
+export interface FieldOperationInput<TDependsOnSchema extends AnySchema, TResult, TInput extends InputSource = undefined> {
+    dependsOn: TDependsOnSchema;
+    input?: TInput;
+    doc?: SchemaDoc;
+    exec: FieldOperationExecutor<Infer<TDependsOnSchema>, InputInfer<TInput>, TResult>;
+}
+export interface FieldOperationInputWithOutput<TDependsOnSchema extends AnySchema, TOutputSchema extends AnySchema, TInput extends InputSource = undefined> {
+    dependsOn: TDependsOnSchema;
+    input?: TInput;
+    output: TOutputSchema;
+    doc?: SchemaDoc;
+    exec: FieldOperationExecutor<Infer<TDependsOnSchema>, InputInfer<TInput>, Infer<TOutputSchema>>;
+}
+export interface FieldOperationInputShape<TShape extends Shape, TResult, TInput extends InputSource = undefined> {
+    dependsOn: TShape;
+    input?: TInput;
+    doc?: SchemaDoc;
+    exec: FieldOperationExecutor<ShapeInfer<TShape>, InputInfer<TInput>, TResult>;
+}
+export interface FieldOperationInputShapeWithOutput<TShape extends Shape, TOutputSchema extends AnySchema, TInput extends InputSource = undefined> {
+    dependsOn: TShape;
+    input?: TInput;
+    output: TOutputSchema;
+    doc?: SchemaDoc;
+    exec: FieldOperationExecutor<ShapeInfer<TShape>, InputInfer<TInput>, Infer<TOutputSchema>>;
+}
+export interface FieldOperationInputWithOptionalOutput<TDependsOnSchema extends AnySchema, TResult> {
+    dependsOn: TDependsOnSchema;
+    input?: InputSource;
+    output?: AnySchema;
+    doc?: SchemaDoc;
+    exec: FieldOperationExecutor<Infer<TDependsOnSchema>, InputInfer<InputSource>, TResult>;
+}
+export interface FieldOperationInputShapeWithOptionalOutput<TResult> {
+    dependsOn: Shape;
+    input?: InputSource;
+    output?: AnySchema;
+    doc?: SchemaDoc;
+    exec: FieldOperationExecutor<ShapeInfer<Shape>, InputInfer<InputSource>, TResult>;
+}
+export interface OperationWithName<TInputSchema extends AnySchema, TOutputSchema extends AnySchema | undefined, TResult> {
+    name: string;
+    operation: Operation<TInputSchema, TOutputSchema, TResult>;
+}
+export interface FieldOperationWithName<TDependsOnSchema extends AnySchema, TInput extends InputSource, TOutputSchema extends AnySchema | undefined, TResult> {
+    name: string;
+    operation: FieldOperation<TDependsOnSchema, TInput, TOutputSchema, TResult>;
+}
+export interface OperationFactory {
+    <TInputSchema extends AnySchema, TOutputSchema extends AnySchema>(input: OperationInputWithOutput<TInputSchema, TOutputSchema>): Operation<TInputSchema, TOutputSchema, Infer<TOutputSchema>>;
+    <TInputSchema extends AnySchema, TResult>(input: OperationInput<TInputSchema, TResult>): Operation<TInputSchema, undefined, TResult>;
+}
+/**
+ * operation 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/operation
+ *
+ * @example
+ * const result = operation(undefined as never);
+ */
+export declare function operation<TInputSchema extends AnySchema, TOutputSchema extends AnySchema>(input: OperationInputWithOutput<TInputSchema, TOutputSchema>): Operation<TInputSchema, TOutputSchema, Infer<TOutputSchema>>;
+export declare function operation<TInputSchema extends AnySchema, TResult>(input: OperationInput<TInputSchema, TResult>): Operation<TInputSchema, undefined, TResult>;
+export interface FieldOperationFactory {
+    <TDependsOnSchema extends AnySchema, TOutputSchema extends AnySchema, TInput extends InputSource = undefined>(input: FieldOperationInputWithOutput<TDependsOnSchema, TOutputSchema, TInput>): FieldOperation<TDependsOnSchema, TInput, TOutputSchema, Infer<TOutputSchema>>;
+    <TDependsOnSchema extends AnySchema, TResult, TInput extends InputSource = undefined>(input: FieldOperationInput<TDependsOnSchema, TResult, TInput>): FieldOperation<TDependsOnSchema, TInput, undefined, TResult>;
+    <TShape extends Shape, TOutputSchema extends AnySchema, TInput extends InputSource = undefined>(input: FieldOperationInputShapeWithOutput<TShape, TOutputSchema, TInput>): FieldOperation<AnySchema, TInput, TOutputSchema, Infer<TOutputSchema>>;
+    <TShape extends Shape, TResult, TInput extends InputSource = undefined>(input: FieldOperationInputShape<TShape, TResult, TInput>): FieldOperation<AnySchema, TInput, undefined, TResult>;
+}
+/**
+ * fieldOperation 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/operation
+ *
+ * @example
+ * const result = fieldOperation(undefined as never);
+ */
+export declare function fieldOperation<TDependsOnSchema extends AnySchema, TOutputSchema extends AnySchema, TInput extends InputSource = undefined>(input: FieldOperationInputWithOutput<TDependsOnSchema, TOutputSchema, TInput>): FieldOperation<TDependsOnSchema, TInput, TOutputSchema, Infer<TOutputSchema>>;
+export declare function fieldOperation<TDependsOnSchema extends AnySchema, TResult, TInput extends InputSource = undefined>(input: FieldOperationInput<TDependsOnSchema, TResult, TInput>): FieldOperation<TDependsOnSchema, TInput, undefined, TResult>;
+export declare function fieldOperation<TShape extends Shape, TOutputSchema extends AnySchema, TInput extends InputSource = undefined>(input: FieldOperationInputShapeWithOutput<TShape, TOutputSchema, TInput>): FieldOperation<AnySchema, TInput, TOutputSchema, Infer<TOutputSchema>>;
+export declare function fieldOperation<TShape extends Shape, TResult, TInput extends InputSource = undefined>(input: FieldOperationInputShape<TShape, TResult, TInput>): FieldOperation<AnySchema, TInput, undefined, TResult>;
+/**
+ * withOperationName 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/operation
+ *
+ * @example
+ * const result = withOperationName(undefined as never);
+ */
+export declare const withOperationName: <TInputSchema extends AnySchema, TOutputSchema extends AnySchema | undefined, TResult>({ name, operation: op, }: OperationWithName<TInputSchema, TOutputSchema, TResult>) => Operation<TInputSchema, TOutputSchema, TResult>;
+/**
+ * withFieldOperationName 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/operation
+ *
+ * @example
+ * const result = withFieldOperationName(undefined as never);
+ */
+export declare const withFieldOperationName: <TDependsOnSchema extends AnySchema, TInput extends InputSource, TOutputSchema extends AnySchema | undefined, TResult>({ name, operation: op, }: FieldOperationWithName<TDependsOnSchema, TInput, TOutputSchema, TResult>) => FieldOperation<TDependsOnSchema, TInput, TOutputSchema, TResult>;
+/**
+ * runOperation 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/operation
+ *
+ * @example
+ * const result = runOperation(undefined as never);
+ */
+export declare const runOperation: <TInputSchema extends AnySchema, TOutputSchema extends AnySchema | undefined, TResult>(op: Operation<TInputSchema, TOutputSchema, TResult>, rawInput: unknown, ctx?: SchemaContext) => Promise<OperationResult<TOutputSchema, TResult>>;
+/**
+ * runFieldOperation 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/operation
+ *
+ * @example
+ * const result = runFieldOperation(undefined as never);
+ */
+export declare const runFieldOperation: <TDependsOnSchema extends AnySchema, TInput extends InputSource, TOutputSchema extends AnySchema | undefined, TResult>(op: FieldOperation<TDependsOnSchema, TInput, TOutputSchema, TResult>, rawDependsOn: unknown, rawInputOrContext?: unknown, ctx?: SchemaContext) => Promise<OperationResult<TOutputSchema, TResult>>;
+export {};

package/dist/operation.js

@@ -0,0 +1,133 @@
+import { createSchemaContext } from "./context.js";
+import { object } from "./object.js";
+const isSchema = (value)=>'object' == typeof value && null !== value && 'parse' in value && 'ast' in value;
+const normalizeDependsOn = (dependsOn, name)=>isSchema(dependsOn) ? dependsOn : object({
+        name: name ?? 'dependsOn',
+        shape: dependsOn
+    });
+function operation(input) {
+    const output = 'output' in input ? input.output : void 0;
+    return {
+        type: 'operation',
+        input: input.input,
+        output,
+        exec: input.exec,
+        publish: input.publish,
+        rooms: input.rooms,
+        ack: input.ack,
+        doc: input.doc
+    };
+}
+function fieldOperation(input) {
+    const dependsOnSchema = normalizeDependsOn(input.dependsOn, 'dependsOn');
+    const inputSchema = input.input ? normalizeDependsOn(input.input, 'input') : void 0;
+    const output = 'output' in input ? input.output : void 0;
+    return {
+        type: 'field',
+        dependsOn: dependsOnSchema,
+        input: inputSchema,
+        output,
+        exec: input.exec,
+        doc: input.doc
+    };
+}
+const withOperationName = ({ name, operation: op })=>({
+        ...op,
+        name
+    });
+const withFieldOperationName = ({ name, operation: op })=>({
+        ...op,
+        name
+    });
+const logPublishError = (error, info, ctx)=>{
+    try {
+        const logger = ctx?.request?.logger ?? ctx?.getRequestContext()?.logger;
+        if (logger?.error) return void logger.error('publish failed', info, error);
+        globalThis.console?.error?.('publish failed', info ?? {}, error);
+    } catch  {}
+};
+const runPublishHooks = async (publish, output, ctx, rooms, operationInput, ack)=>{
+    if (!publish) return;
+    const publisher = ctx.request?.publisher ?? ctx.getRequestContext()?.publisher;
+    if (!publisher) return;
+    const roomList = Array.isArray(rooms) ? rooms : rooms ? [
+        rooms
+    ] : [];
+    await Object.entries(publish).reduce(async (pending, [topic, hook])=>{
+        await pending;
+        try {
+            const payload = await hook(output, ctx);
+            if (void 0 === payload) return;
+            if (0 === roomList.length) return void await publisher({
+                topic,
+                payload,
+                input: operationInput,
+                ack
+            });
+            await roomList.reduce(async (chain, room)=>{
+                await chain;
+                await publisher({
+                    topic,
+                    payload,
+                    input: operationInput,
+                    ack,
+                    meta: {
+                        room
+                    }
+                });
+            }, Promise.resolve());
+        } catch (error) {
+            logPublishError(error, {
+                topic,
+                phase: 'publish-hook'
+            }, ctx);
+            ctx.request?.onPublishError?.(error, {
+                topic,
+                phase: 'publish-hook'
+            });
+        }
+    }, Promise.resolve());
+};
+const wrapPublisher = (ctx)=>{
+    const request = ctx.request ?? ctx.getRequestContext();
+    if (!request?.publisher) return;
+    const original = request.publisher;
+    request.publisher = async (input)=>{
+        try {
+            await original(input);
+        } catch (error) {
+            logPublishError(error, {
+                topic: input.topic,
+                phase: 'publisher'
+            }, ctx);
+            request.onPublishError?.(error, {
+                topic: input.topic,
+                phase: 'publisher'
+            });
+        }
+    };
+};
+const runOperation = async (op, rawInput, ctx)=>{
+    const context = ctx ?? createSchemaContext();
+    if (!context.getRequestContext()) context.setRequestContext({});
+    wrapPublisher(context);
+    const input = op.input.parse(rawInput, context);
+    const rooms = op.rooms ? op.rooms(input, context) : void 0;
+    const result = await op.exec(input, context);
+    const output = op.output ? op.output.parse(result, context) : result;
+    await runPublishHooks(op.publish, output, context, rooms, input, op.ack);
+    return output;
+};
+const runFieldOperation = async (op, rawDependsOn, rawInputOrContext, ctx)=>{
+    const isContext = (value)=>'object' == typeof value && null !== value && 'getBuildContext' in value && 'getRequestContext' in value;
+    const actualContext = isContext(rawInputOrContext) ? rawInputOrContext : ctx;
+    const rawInput = isContext(rawInputOrContext) ? void 0 : rawInputOrContext;
+    const context = actualContext ?? createSchemaContext();
+    if (!context.getRequestContext()) context.setRequestContext({});
+    const dependsOn = op.dependsOn.parse(rawDependsOn, context);
+    const input = op.input ? op.input.parse(rawInput, context) : void 0;
+    const result = op.input ? await op.exec(dependsOn, input, context) : await op.exec(dependsOn, context);
+    if (op.output) return op.output.parse(result, context);
+    return result;
+};
+export { fieldOperation, operation, runFieldOperation, runOperation, withFieldOperationName, withOperationName };