@zdavison/matador 3.0.2 → 3.0.5

package/cli.ts

@@ -252,26 +252,75 @@ async function runSendTestEvent(
   await dispatchEvent(config, config.testEvent, options);
 }
 
-async function dispatchEvent(
-  config: ConfigExport,
-  eventSpec: EventExport,
-  options: { dryRun: boolean; timeout: number; verbose: boolean },
-): Promise<void> {
-  // Validate event exists in config
-  const schemaEntry = config.schema[eventSpec.eventKey];
+function resolveSchemaEntry(config: ConfigExport, eventKey: string) {
+  const schemaEntry = config.schema[eventKey];
   if (!schemaEntry) {
-    logError(`Event "${eventSpec.eventKey}" not found in config`);
+    logError(`Event "${eventKey}" not found in config`);
     logInfo(`Available events: ${Object.keys(config.schema).join(', ')}`);
     process.exit(1);
   }
-
-  // Extract EventClass and subscribers from schema entry
   const EventClass = isSchemaEntryTuple(schemaEntry)
     ? schemaEntry[0]
     : schemaEntry.eventClass;
   const subscribers = isSchemaEntryTuple(schemaEntry)
     ? schemaEntry[1]
     : schemaEntry.subscribers;
+  return { EventClass, subscribers };
+}
+
+function logEventDetails(eventSpec: EventExport): void {
+  logInfo(`Data: ${JSON.stringify(eventSpec.data, null, 2)}`);
+  if (eventSpec.before) {
+    logInfo(`Before: ${JSON.stringify(eventSpec.before, null, 2)}`);
+  }
+  if (eventSpec.options) {
+    logInfo(`Options: ${JSON.stringify(eventSpec.options, null, 2)}`);
+  }
+}
+
+function logSendResult(result: {
+  eventKey: string;
+  subscribersSent: number;
+  subscribersSkipped: number;
+  errors: ReadonlyArray<{ subscriberName: string; error: Error }>;
+}): void {
+  logSection('Send Result');
+  logInfo(`Event key: ${result.eventKey}`);
+  logInfo(`Subscribers sent: ${result.subscribersSent}`);
+  logInfo(`Subscribers skipped: ${result.subscribersSkipped}`);
+
+  if (result.errors.length > 0) {
+    logWarning(`Dispatch errors: ${result.errors.length}`);
+    for (const err of result.errors) {
+      logError(`  [${err.subscriberName}] ${err.error.message}`);
+    }
+  }
+}
+
+function buildCliHooks(config: ConfigExport, verbose: boolean): MatadorHooks {
+  return {
+    logger: verbose ? consoleLogger : undefined,
+    onWorkerSuccess: (ctx) => {
+      logSuccess(`[${ctx.subscriber.name}] processed in ${ctx.durationMs}ms`);
+    },
+    onWorkerError: (ctx) => {
+      logError(
+        `[${ctx.subscriber.name}] failed after ${ctx.durationMs}ms: ${ctx.error.message}`,
+      );
+    },
+    ...config.hooks,
+  };
+}
+
+async function dispatchEvent(
+  config: ConfigExport,
+  eventSpec: EventExport,
+  options: { dryRun: boolean; timeout: number; verbose: boolean },
+): Promise<void> {
+  const { EventClass, subscribers } = resolveSchemaEntry(
+    config,
+    eventSpec.eventKey,
+  );
 
   if (!subscribers || subscribers.length === 0) {
     logWarning(`No subscribers registered for event "${eventSpec.eventKey}"`);
@@ -288,7 +337,6 @@ async function dispatchEvent(
 
   logSection('Dispatching Event');
 
-  // Create topology
   const topology =
     config.topology ??
     TopologyBuilder.create()
@@ -297,24 +345,9 @@ async function dispatchEvent(
       .withoutDeadLetter()
       .build();
 
-  // Create transport
   const transport = new LocalTransport();
+  const hooks = buildCliHooks(config, options.verbose);
 
-  // Create hooks for logging
-  const hooks: MatadorHooks = {
-    logger: options.verbose ? consoleLogger : undefined,
-    onWorkerSuccess: (ctx) => {
-      logSuccess(`[${ctx.subscriber.name}] processed in ${ctx.durationMs}ms`);
-    },
-    onWorkerError: (ctx) => {
-      logError(
-        `[${ctx.subscriber.name}] failed after ${ctx.durationMs}ms: ${ctx.error.message}`,
-      );
-    },
-    ...config.hooks,
-  };
-
-  // Create Matador instance with schema and hooks
   const matador = new Matador(
     {
       transport,
@@ -329,35 +362,16 @@ async function dispatchEvent(
     await matador.start();
     logSuccess('[Matador] Started.');
 
-    // Create and dispatch the event
     const event = new EventClass(eventSpec.data, eventSpec.before);
     logInfo(`Dispatching: ${eventSpec.eventKey}`);
 
     if (options.verbose) {
-      logInfo(`Data: ${JSON.stringify(eventSpec.data, null, 2)}`);
-      if (eventSpec.before) {
-        logInfo(`Before: ${JSON.stringify(eventSpec.before, null, 2)}`);
-      }
-      if (eventSpec.options) {
-        logInfo(`Options: ${JSON.stringify(eventSpec.options, null, 2)}`);
-      }
+      logEventDetails(eventSpec);
     }
 
     const result = await matador.send(event, eventSpec.options);
+    logSendResult(result);
 
-    logSection('Send Result');
-    logInfo(`Event key: ${result.eventKey}`);
-    logInfo(`Subscribers sent: ${result.subscribersSent}`);
-    logInfo(`Subscribers skipped: ${result.subscribersSkipped}`);
-
-    if (result.errors.length > 0) {
-      logWarning(`Dispatch errors: ${result.errors.length}`);
-      for (const err of result.errors) {
-        logError(`  [${err.subscriberName}] ${err.error.message}`);
-      }
-    }
-
-    // Wait for processing
     logSection('Processing');
     const idle = await matador.waitForIdle(options.timeout);
 
@@ -413,8 +427,8 @@ async function main(): Promise<void> {
       process.exit(1);
     }
 
-    const [configPath, eventPath] = positionals;
-    await runSend(configPath!, eventPath!, {
+    const [configPath, eventPath] = positionals as [string, string];
+    await runSend(configPath, eventPath, {
       dryRun: values['dry-run'] ?? false,
       timeout: Number.parseInt(values.timeout ?? '5000', 10),
       verbose: values.verbose ?? false,
@@ -436,8 +450,8 @@ async function main(): Promise<void> {
       process.exit(1);
     }
 
-    const [configPath] = positionals;
-    await runSendTestEvent(configPath!, {
+    const [configPath] = positionals as [string];
+    await runSendTestEvent(configPath, {
       dryRun: values['dry-run'] ?? false,
       timeout: Number.parseInt(values.timeout ?? '5000', 10),
       verbose: values.verbose ?? false,

package/dist/checkpoint/context.test.js

@@ -119,9 +119,13 @@ describe('ResumableContext', () => {
             });
             await context.io('step-1', () => 'result-1');
             let checkpoint = await store.get(envelope.id);
+            if (!checkpoint)
+                throw new Error('expected checkpoint after step-1');
             expect(Object.keys(checkpoint.completedSteps)).toHaveLength(1);
             await context.io('step-2', () => 'result-2');
             checkpoint = await store.get(envelope.id);
+            if (!checkpoint)
+                throw new Error('expected checkpoint after step-2');
             expect(Object.keys(checkpoint.completedSteps)).toHaveLength(2);
         });
         it('should support various JSON-serializable return types', async () => {

package/dist/codec/rabbitmq-codec.test.js

@@ -323,6 +323,37 @@ const V1_MESSAGE_FIXTURES = [
     //   },
     // },
 ];
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+function assertV1Id(envelope, expectedId) {
+    if (expectedId !== undefined) {
+        expect(envelope.id).toBe(expectedId);
+    }
+    else {
+        expect(envelope.id).toMatch(UUID_PATTERN);
+    }
+}
+function assertV1Metadata(metadata, expected) {
+    if (expected !== undefined) {
+        expect(metadata).toEqual(expected);
+    }
+    else {
+        expect(metadata === undefined || Object.keys(metadata).length === 0).toBe(true);
+    }
+}
+function assertV1Translation(envelope, expected) {
+    expect(envelope.docket.eventKey).toBe(expected.eventKey);
+    expect(envelope.docket.targetSubscriber).toBe(expected.targetSubscriber);
+    expect(envelope.data).toEqual(expected.data);
+    assertV1Id(envelope, expected.id);
+    assertV1Metadata(envelope.docket.metadata, expected.metadata);
+    if (expected.correlationId !== undefined) {
+        expect(envelope.docket.correlationId).toBe(expected.correlationId);
+    }
+    expect(envelope.docket.attempts).toBe(expected.attempts ?? 1);
+    expect(envelope.docket.importance).toBe(expected.importance ?? 'should-investigate');
+    expect(envelope.docket.createdAt).toMatch(ISO_DATE_PATTERN);
+}
 describe('RabbitMQCodec', () => {
     const codec = new RabbitMQCodec();
     describe('v1 to v2 translation', () => {
@@ -331,45 +362,7 @@ describe('RabbitMQCodec', () => {
                 const body = new TextEncoder().encode(JSON.stringify(fixture.body));
                 const headers = fixture.headers ?? {};
                 const envelope = codec.decode(body, headers);
-                // Check required fields
-                expect(envelope.docket.eventKey).toBe(fixture.expected.eventKey);
-                expect(envelope.docket.targetSubscriber).toBe(fixture.expected.targetSubscriber);
-                expect(envelope.data).toEqual(fixture.expected.data);
-                // Check optional ID (may be generated if not specified)
-                if (fixture.expected.id !== undefined) {
-                    expect(envelope.id).toBe(fixture.expected.id);
-                }
-                else {
-                    expect(envelope.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-                }
-                // Check metadata
-                if (fixture.expected.metadata !== undefined) {
-                    expect(envelope.docket.metadata).toEqual(fixture.expected.metadata);
-                }
-                else {
-                    expect(envelope.docket.metadata === undefined ||
-                        Object.keys(envelope.docket.metadata).length === 0).toBe(true);
-                }
-                // Check correlation ID
-                if (fixture.expected.correlationId !== undefined) {
-                    expect(envelope.docket.correlationId).toBe(fixture.expected.correlationId);
-                }
-                // Check attempts (defaults to 1)
-                if (fixture.expected.attempts !== undefined) {
-                    expect(envelope.docket.attempts).toBe(fixture.expected.attempts);
-                }
-                else {
-                    expect(envelope.docket.attempts).toBe(1);
-                }
-                // Check importance (defaults to 'should-investigate')
-                if (fixture.expected.importance !== undefined) {
-                    expect(envelope.docket.importance).toBe(fixture.expected.importance);
-                }
-                else {
-                    expect(envelope.docket.importance).toBe('should-investigate');
-                }
-                // Check createdAt is a valid ISO string
-                expect(envelope.docket.createdAt).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/);
+                assertV1Translation(envelope, fixture.expected);
             });
         }
     });
@@ -385,8 +378,10 @@ describe('RabbitMQCodec', () => {
             const before = Date.now();
             const envelope = codec.decode(encoded, {});
             const after = Date.now();
-            expect(envelope.docket.scheduledFor).toBeDefined();
-            const scheduledTime = new Date(envelope.docket.scheduledFor).getTime();
+            const { scheduledFor } = envelope.docket;
+            if (!scheduledFor)
+                throw new Error('expected scheduledFor to be set');
+            const scheduledTime = new Date(scheduledFor).getTime();
             expect(scheduledTime).toBeGreaterThanOrEqual(before + 5000);
             expect(scheduledTime).toBeLessThanOrEqual(after + 5000);
         });

package/dist/core/fanout.test.js

@@ -151,6 +151,8 @@ describe('FanoutEngine', () => {
             await fanout.send(UserCreatedEvent, event);
             const sendCall = transport.send.mock
                 .calls[0];
+            if (!sendCall)
+                throw new Error('expected transport.send to be called');
             const envelope = sendCall[1];
             expect(envelope.docket.eventKey).toBe('user.created');
             expect(envelope.docket.eventDescription).toBe('Fired when a new user is created');
@@ -176,6 +178,8 @@ describe('FanoutEngine', () => {
             await fanout.send(OrderPlacedEvent, event);
             const sendCall = transport.send.mock
                 .calls[0];
+            if (!sendCall)
+                throw new Error('expected transport.send to be called');
             const envelope = sendCall[1];
             expect(envelope.docket.eventKey).toBe('order.placed');
             expect(envelope.docket.eventDescription).toBe('Fired when an order is placed');
@@ -819,7 +823,10 @@ describe('FanoutEngine', () => {
                 transport: 'mock',
             });
             const calls = onEnqueueSuccess.mock.calls;
-            const callArgs = calls[0][0];
+            const firstCall = calls[0];
+            if (!firstCall)
+                throw new Error('expected onEnqueueSuccess to be called');
+            const callArgs = firstCall[0];
             expect(callArgs.envelope.docket.eventKey).toBe('user.created');
             expect(callArgs.envelope.docket.targetSubscriber).toBe('handle-user');
         });
@@ -860,7 +867,10 @@ describe('FanoutEngine', () => {
                 transport: 'mock',
             });
             const calls = onEnqueueError.mock.calls;
-            const callArgs = calls[0][0];
+            const firstCall = calls[0];
+            if (!firstCall)
+                throw new Error('expected onEnqueueError to be called');
+            const callArgs = firstCall[0];
             expect(callArgs.envelope.docket.eventKey).toBe('user.created');
             expect(callArgs.error).toBeInstanceOf(TransportSendError);
         });

package/dist/index.cjs

@@ -471,50 +471,11 @@ var TopologyBuilder = class _TopologyBuilder {
    * Validates the topology configuration.
    */
   validate() {
-    const issues = [];
-    if (!this.namespace || this.namespace.trim() === "") {
-      issues.push("Namespace is required");
-    } else if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(this.namespace)) {
-      issues.push(
-        "Namespace must start with a letter and contain only alphanumeric characters, underscores, and hyphens"
-      );
-    }
-    if (this.queues.length === 0) {
-      issues.push("At least one queue is required");
-    }
-    const queueNames = /* @__PURE__ */ new Set();
-    for (const queue of this.queues) {
-      if (!queue.name || queue.name.trim() === "") {
-        issues.push("Queue name cannot be empty");
-      } else if (!queue.exact && !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(queue.name)) {
-        issues.push(
-          `Queue name "${queue.name}" must start with a letter and contain only alphanumeric characters, underscores, and hyphens`
-        );
-      } else if (queueNames.has(queue.name)) {
-        issues.push(`Duplicate queue name: "${queue.name}"`);
-      } else {
-        queueNames.add(queue.name);
-      }
-      if (queue.concurrency !== void 0 && queue.concurrency < 1) {
-        issues.push(`Queue "${queue.name}" concurrency must be at least 1`);
-      }
-      if (queue.consumerTimeout !== void 0 && queue.consumerTimeout < 0) {
-        issues.push(
-          `Queue "${queue.name}" consumer timeout must be non-negative`
-        );
-      }
-    }
-    if (this.retry.enabled) {
-      if (this.retry.defaultDelayMs < 0) {
-        issues.push("Default retry delay must be non-negative");
-      }
-      if (this.retry.maxDelayMs < this.retry.defaultDelayMs) {
-        issues.push(
-          "Max retry delay must be greater than or equal to default delay"
-        );
-      }
-    }
-    return issues;
+    return [
+      ...validateNamespace(this.namespace),
+      ...validateQueues(this.queues),
+      ...validateRetry(this.retry)
+    ];
   }
   /**
    * Builds the topology configuration.
@@ -536,6 +497,68 @@ var TopologyBuilder = class _TopologyBuilder {
     };
   }
 };
+var IDENTIFIER_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+function validateNamespace(namespace) {
+  if (!namespace || namespace.trim() === "") {
+    return ["Namespace is required"];
+  }
+  if (!IDENTIFIER_PATTERN.test(namespace)) {
+    return [
+      "Namespace must start with a letter and contain only alphanumeric characters, underscores, and hyphens"
+    ];
+  }
+  return [];
+}
+function validateQueueName(queue, seen) {
+  if (!queue.name || queue.name.trim() === "") {
+    return ["Queue name cannot be empty"];
+  }
+  if (!queue.exact && !IDENTIFIER_PATTERN.test(queue.name)) {
+    return [
+      `Queue name "${queue.name}" must start with a letter and contain only alphanumeric characters, underscores, and hyphens`
+    ];
+  }
+  if (seen.has(queue.name)) {
+    return [`Duplicate queue name: "${queue.name}"`];
+  }
+  seen.add(queue.name);
+  return [];
+}
+function validateQueueLimits(queue) {
+  const issues = [];
+  if (queue.concurrency !== void 0 && queue.concurrency < 1) {
+    issues.push(`Queue "${queue.name}" concurrency must be at least 1`);
+  }
+  if (queue.consumerTimeout !== void 0 && queue.consumerTimeout < 0) {
+    issues.push(`Queue "${queue.name}" consumer timeout must be non-negative`);
+  }
+  return issues;
+}
+function validateQueues(queues) {
+  const issues = [];
+  if (queues.length === 0) {
+    issues.push("At least one queue is required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const queue of queues) {
+    issues.push(...validateQueueName(queue, seen));
+    issues.push(...validateQueueLimits(queue));
+  }
+  return issues;
+}
+function validateRetry(retry) {
+  if (!retry.enabled) return [];
+  const issues = [];
+  if (retry.defaultDelayMs < 0) {
+    issues.push("Default retry delay must be non-negative");
+  }
+  if (retry.maxDelayMs < retry.defaultDelayMs) {
+    issues.push(
+      "Max retry delay must be greater than or equal to default delay"
+    );
+  }
+  return issues;
+}
 
 // src/types/common.ts
 function validResult() {
@@ -2645,6 +2668,7 @@ var MultiTransport = class {
     const errors = [];
     for (let i = 0; i < transportOrder.length; i++) {
       const transport = transportOrder[i];
+      if (!transport) continue;
       try {
         return await transport.send(queue, envelope, options);
       } catch (error) {
@@ -3096,31 +3120,30 @@ var RabbitMQTransport = class {
       });
     });
   }
+  buildWorkQueueOptions(topology, queueDef) {
+    const queueOptions = {
+      durable: true,
+      arguments: {}
+    };
+    if (this.config.quorumQueues && !queueDef.exact) {
+      queueOptions.arguments["x-queue-type"] = "quorum";
+    }
+    if (topology.deadLetter.unhandled.enabled || topology.deadLetter.undeliverable.enabled) {
+      queueOptions.arguments["x-dead-letter-exchange"] = this.getDLXExchangeName(topology.namespace);
+    }
+    if (queueDef.priorities) {
+      queueOptions.arguments["x-max-priority"] = 10;
+    }
+    if (queueDef.consumerTimeout) {
+      queueOptions.arguments["x-consumer-timeout"] = queueDef.consumerTimeout;
+    }
+    return queueOptions;
+  }
   async assertWorkQueue(channel, topology, queueDef) {
     const queueName = queueDef.exact ? queueDef.name : `${topology.namespace}.${queueDef.name}`;
     const rabbitmqOptions = queueDef.transport?.rabbitmq?.options;
-    if (rabbitmqOptions) {
-      await channel.assertQueue(queueName, rabbitmqOptions);
-    } else {
-      const queueOptions = {
-        durable: true,
-        arguments: {}
-      };
-      if (this.config.quorumQueues && !queueDef.exact) {
-        queueOptions.arguments["x-queue-type"] = "quorum";
-      }
-      const dlxExchange = this.getDLXExchangeName(topology.namespace);
-      if (topology.deadLetter.unhandled.enabled || topology.deadLetter.undeliverable.enabled) {
-        queueOptions.arguments["x-dead-letter-exchange"] = dlxExchange;
-      }
-      if (queueDef.priorities) {
-        queueOptions.arguments["x-max-priority"] = 10;
-      }
-      if (queueDef.consumerTimeout) {
-        queueOptions.arguments["x-consumer-timeout"] = queueDef.consumerTimeout;
-      }
-      await channel.assertQueue(queueName, queueOptions);
-    }
+    const queueOptions = rabbitmqOptions ?? this.buildWorkQueueOptions(topology, queueDef);
+    await channel.assertQueue(queueName, queueOptions);
     const mainExchange = this.getMainExchangeName(topology.namespace);
     await channel.bindQueue(queueName, mainExchange, queueName);
     if (this.delayedExchangeAvailable) {