@auto-engineer/pipeline 1.65.0 → 1.67.0

package/src/engine/command-dispatcher.ts

@@ -0,0 +1,46 @@
+import type { SQLiteEventStore } from '@event-driven-io/emmett-sqlite';
+
+type CommandHandler = (command: {
+  type: string;
+  data: Record<string, unknown>;
+}) =>
+  | Array<{ type: string; data: Record<string, unknown> }>
+  | Promise<Array<{ type: string; data: Record<string, unknown> }>>;
+
+export function createCommandDispatcher() {
+  const handlers = new Map<string, CommandHandler>();
+
+  return {
+    register(commandType: string, handler: CommandHandler): void {
+      handlers.set(commandType, handler);
+    },
+
+    registeredTypes(): string[] {
+      return [...handlers.keys()];
+    },
+
+    async dispatch(command: {
+      type: string;
+      data: Record<string, unknown>;
+    }): Promise<Array<{ type: string; data: Record<string, unknown> }>> {
+      const handler = handlers.get(command.type);
+      if (!handler) {
+        throw new Error(`No handler registered for command type: ${command.type}`);
+      }
+      return handler(command);
+    },
+  };
+}
+
+export async function dispatchAndStore(
+  dispatcher: ReturnType<typeof createCommandDispatcher>,
+  eventStore: SQLiteEventStore,
+  streamName: string,
+  command: { type: string; data: Record<string, unknown> },
+): Promise<Array<{ type: string; data: Record<string, unknown> }>> {
+  const results = await dispatcher.dispatch(command);
+  if (results.length > 0) {
+    await eventStore.appendToStream(streamName, results);
+  }
+  return results;
+}

package/src/engine/event-router.specs.ts

@@ -0,0 +1,75 @@
+import { createCommandDispatcher } from './command-dispatcher.js';
+import { createEventRouter } from './event-router.js';
+
+describe('EventRouter', () => {
+  it('dispatches commands when matching event is routed', async () => {
+    const dispatcher = createCommandDispatcher();
+    const dispatched: Array<{ type: string; data: Record<string, unknown> }> = [];
+    dispatcher.register('ProcessPayment', (cmd) => {
+      dispatched.push(cmd);
+      return [{ type: 'PaymentProcessed', data: { amount: cmd.data.amount } }];
+    });
+
+    const router = createEventRouter(dispatcher);
+    router.register({
+      eventType: 'OrderCreated',
+      commands: [{ commandType: 'ProcessPayment', data: { amount: 100 } }],
+    });
+
+    const results = await router.route({ type: 'OrderCreated', data: { orderId: '1' } });
+
+    expect(dispatched).toEqual([{ type: 'ProcessPayment', data: { amount: 100 } }]);
+    expect(results).toEqual([{ type: 'PaymentProcessed', data: { amount: 100 } }]);
+  });
+
+  it('dispatches multiple commands for single event', async () => {
+    const dispatcher = createCommandDispatcher();
+    dispatcher.register('ProcessPayment', () => [{ type: 'PaymentProcessed', data: {} }]);
+    dispatcher.register('SendEmail', () => [{ type: 'EmailSent', data: {} }]);
+
+    const router = createEventRouter(dispatcher);
+    router.register({
+      eventType: 'OrderCreated',
+      commands: [
+        { commandType: 'ProcessPayment', data: { amount: 100 } },
+        { commandType: 'SendEmail', data: { template: 'order' } },
+      ],
+    });
+
+    const results = await router.route({ type: 'OrderCreated', data: {} });
+
+    expect(results).toEqual([
+      { type: 'PaymentProcessed', data: {} },
+      { type: 'EmailSent', data: {} },
+    ]);
+  });
+
+  it('returns empty array for unregistered event type', async () => {
+    const dispatcher = createCommandDispatcher();
+    const router = createEventRouter(dispatcher);
+
+    const results = await router.route({ type: 'Unknown', data: {} });
+
+    expect(results).toEqual([]);
+  });
+
+  it('resolves factory data functions with the event', async () => {
+    const dispatcher = createCommandDispatcher();
+    dispatcher.register('ProcessPayment', (cmd) => [{ type: 'Processed', data: cmd.data }]);
+
+    const router = createEventRouter(dispatcher);
+    router.register({
+      eventType: 'OrderCreated',
+      commands: [
+        {
+          commandType: 'ProcessPayment',
+          data: (event) => ({ orderId: event.data.orderId }),
+        },
+      ],
+    });
+
+    const results = await router.route({ type: 'OrderCreated', data: { orderId: '42' } });
+
+    expect(results).toEqual([{ type: 'Processed', data: { orderId: '42' } }]);
+  });
+});

package/src/engine/event-router.ts

@@ -0,0 +1,36 @@
+import type { createCommandDispatcher } from './command-dispatcher.js';
+
+type Event = { type: string; data: Record<string, unknown> };
+
+type EmitMapping = {
+  eventType: string;
+  commands: Array<{
+    commandType: string;
+    data: Record<string, unknown> | ((event: Event) => Record<string, unknown>);
+  }>;
+};
+
+export function createEventRouter(dispatcher: ReturnType<typeof createCommandDispatcher>) {
+  const mappings = new Map<string, EmitMapping['commands']>();
+
+  return {
+    register(mapping: EmitMapping): void {
+      const existing = mappings.get(mapping.eventType) ?? [];
+      mappings.set(mapping.eventType, [...existing, ...mapping.commands]);
+    },
+
+    async route(event: Event): Promise<Array<{ type: string; data: Record<string, unknown> }>> {
+      const commands = mappings.get(event.type);
+      if (!commands) {
+        return [];
+      }
+
+      const commandPromises = commands.map((command) => {
+        const data = typeof command.data === 'function' ? command.data(event) : command.data;
+        return dispatcher.dispatch({ type: command.commandType, data });
+      });
+      const resultArrays = await Promise.all(commandPromises);
+      return resultArrays.flat();
+    },
+  };
+}

package/src/engine/index.ts

@@ -0,0 +1,39 @@
+export { createCommandDispatcher, dispatchAndStore } from './command-dispatcher';
+export { createEventRouter } from './event-router';
+export { createPipelineEngine } from './pipeline-engine';
+export { itemStatusProjection } from './projections/item-status';
+export { latestRunProjection } from './projections/latest-run';
+export { messageLogProjection } from './projections/message-log';
+export { nodeStatusProjection } from './projections/node-status';
+export { statsProjection } from './projections/stats';
+export { createConsumer } from './sqlite-consumer';
+export { createPipelineStore, type PipelineStore } from './sqlite-store';
+export { createWorkflowProcessor, type WorkflowRegistration } from './workflow-processor';
+export {
+  type AwaitInput,
+  type AwaitOutput,
+  type AwaitState,
+  createAwaitWorkflow,
+  decide as awaitDecide,
+  evolve as awaitEvolve,
+  initialState as awaitInitialState,
+} from './workflows/await-workflow';
+export {
+  createPhasedWorkflow,
+  decide as phasedDecide,
+  evolve as phasedEvolve,
+  initialState as phasedInitialState,
+  type PhasedInput,
+  type PhasedItem,
+  type PhasedOutput,
+  type PhasedState,
+} from './workflows/phased-workflow';
+export {
+  createSettledWorkflow,
+  decide as settledDecide,
+  evolve as settledEvolve,
+  initialState as settledInitialState,
+  type SettledInput,
+  type SettledOutput,
+  type SettledState,
+} from './workflows/settled-workflow';