@saga-bus/transport-inmemory 0.1.2

package/README.md

@@ -0,0 +1,83 @@
+# @saga-bus/transport-inmemory
+
+In-memory transport implementation for testing and development.
+
+## Installation
+
+```bash
+pnpm add @saga-bus/transport-inmemory
+```
+
+## Usage
+
+```typescript
+import { InMemoryTransport } from "@saga-bus/transport-inmemory";
+import { createBus } from "@saga-bus/core";
+
+const transport = new InMemoryTransport({
+  defaultConcurrency: 10,
+});
+
+const bus = createBus({
+  transport,
+  sagas: [...],
+});
+```
+
+## Features
+
+- Zero external dependencies
+- Configurable concurrency via semaphore
+- Synchronous message delivery (great for tests)
+- No network overhead
+
+## Configuration
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `defaultConcurrency` | `number` | `10` | Max concurrent handlers |
+
+## When to Use
+
+**Use for:**
+- Unit and integration tests
+- Local development
+- Prototyping and demos
+
+**Do not use for:**
+- Production deployments
+- Distributed systems
+- Multi-process applications
+
+## Testing Tips
+
+The in-memory transport processes messages synchronously within the same process, making it ideal for testing:
+
+```typescript
+import { TestHarness } from "@saga-bus/test";
+import { InMemoryTransport } from "@saga-bus/transport-inmemory";
+
+// TestHarness uses InMemoryTransport internally
+const harness = await TestHarness.create({
+  sagas: [{ definition: mySaga, store }],
+});
+
+// Messages are processed immediately
+await harness.publish({ type: "OrderSubmitted", orderId: "123" });
+await harness.waitForIdle();
+
+// State is immediately available
+const state = await harness.getSagaState("OrderSaga", "123");
+```
+
+## Limitations
+
+- **Single process only**: Messages are not shared between processes
+- **No persistence**: Messages are lost if not consumed
+- **No ordering guarantees**: Unlike production transports with FIFO support
+
+For production, use [@saga-bus/transport-rabbitmq](../transport-rabbitmq), [@saga-bus/transport-sqs](../transport-sqs), or [@saga-bus/transport-kafka](../transport-kafka).
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,186 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InMemoryTransport: () => InMemoryTransport,
+  Semaphore: () => Semaphore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/InMemoryTransport.ts
+var import_node_crypto = require("crypto");
+
+// src/Semaphore.ts
+var Semaphore = class {
+  permits;
+  waiting = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  /**
+   * Acquire a permit, waiting if none are available.
+   */
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waiting.push(resolve);
+    });
+  }
+  /**
+   * Release a permit, waking a waiting acquirer if any.
+   */
+  release() {
+    const next = this.waiting.shift();
+    if (next) {
+      next();
+    } else {
+      this.permits++;
+    }
+  }
+  /**
+   * Execute a function with a permit.
+   */
+  async withPermit(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  /**
+   * Get the number of available permits.
+   */
+  get available() {
+    return this.permits;
+  }
+  /**
+   * Get the number of waiting acquirers.
+   */
+  get waitingCount() {
+    return this.waiting.length;
+  }
+};
+
+// src/InMemoryTransport.ts
+var InMemoryTransport = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  pendingTimeouts = /* @__PURE__ */ new Set();
+  defaultConcurrency;
+  started = false;
+  constructor(options = {}) {
+    this.defaultConcurrency = options.defaultConcurrency ?? 1;
+  }
+  async start() {
+    this.started = true;
+  }
+  async stop() {
+    this.started = false;
+    this.pendingTimeouts.forEach((timeout) => clearTimeout(timeout));
+    this.pendingTimeouts.clear();
+  }
+  async subscribe(options, handler) {
+    const { endpoint, concurrency = this.defaultConcurrency } = options;
+    const subscription = {
+      options,
+      handler,
+      semaphore: new Semaphore(concurrency)
+    };
+    const existing = this.subscriptions.get(endpoint);
+    if (existing) {
+      existing.push(subscription);
+    } else {
+      this.subscriptions.set(endpoint, [subscription]);
+    }
+  }
+  async publish(message, options) {
+    const { endpoint, headers = {}, delayMs } = options;
+    const envelope = {
+      id: (0, import_node_crypto.randomUUID)(),
+      type: message.type,
+      payload: message,
+      headers: { ...headers },
+      timestamp: /* @__PURE__ */ new Date(),
+      partitionKey: options.key
+    };
+    if (delayMs && delayMs > 0) {
+      const timeout = setTimeout(() => {
+        this.pendingTimeouts.delete(timeout);
+        void this.deliverToSubscribers(endpoint, envelope);
+      }, delayMs);
+      this.pendingTimeouts.add(timeout);
+    } else {
+      setImmediate(() => {
+        void this.deliverToSubscribers(endpoint, envelope);
+      });
+    }
+  }
+  async deliverToSubscribers(endpoint, envelope) {
+    if (!this.started) {
+      return;
+    }
+    const subscriptions = this.subscriptions.get(endpoint);
+    if (!subscriptions || subscriptions.length === 0) {
+      return;
+    }
+    const deliveries = subscriptions.map(async (sub) => {
+      await sub.semaphore.withPermit(async () => {
+        try {
+          await sub.handler(envelope);
+        } catch (error) {
+          console.error(
+            `[InMemoryTransport] Handler error for ${endpoint}:`,
+            error
+          );
+        }
+      });
+    });
+    await Promise.all(deliveries);
+  }
+  /**
+   * Get the number of subscriptions for an endpoint.
+   * Useful for testing.
+   */
+  getSubscriptionCount(endpoint) {
+    return this.subscriptions.get(endpoint)?.length ?? 0;
+  }
+  /**
+   * Check if the transport is started.
+   */
+  get isStarted() {
+    return this.started;
+  }
+  /**
+   * Clear all subscriptions. Useful for testing.
+   */
+  clearSubscriptions() {
+    this.subscriptions.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryTransport,
+  Semaphore
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/InMemoryTransport.ts","../src/Semaphore.ts"],"sourcesContent":["export { InMemoryTransport } from \"./InMemoryTransport.js\";\nexport type { InMemoryTransportOptions } from \"./InMemoryTransport.js\";\nexport { Semaphore } from \"./Semaphore.js\";\n","import { randomUUID } from \"node:crypto\";\nimport type {\n  Transport,\n  TransportSubscribeOptions,\n  TransportPublishOptions,\n  BaseMessage,\n  MessageEnvelope,\n} from \"@saga-bus/core\";\nimport { Semaphore } from \"./Semaphore.js\";\n\ninterface Subscription<T extends BaseMessage = BaseMessage> {\n  options: TransportSubscribeOptions;\n  handler: (envelope: MessageEnvelope<T>) => Promise<void>;\n  semaphore: Semaphore;\n}\n\nexport interface InMemoryTransportOptions {\n  /**\n   * Default concurrency for subscriptions (default: 1)\n   */\n  defaultConcurrency?: number;\n}\n\n/**\n * In-memory transport implementation for testing and local development.\n * Uses a simple pub/sub pattern with concurrency control.\n */\nexport class InMemoryTransport implements Transport {\n  private readonly subscriptions = new Map<string, Subscription[]>();\n  private readonly pendingTimeouts = new Set<ReturnType<typeof setTimeout>>();\n  private readonly defaultConcurrency: number;\n  private started = false;\n\n  constructor(options: InMemoryTransportOptions = {}) {\n    this.defaultConcurrency = options.defaultConcurrency ?? 1;\n  }\n\n  async start(): Promise<void> {\n    this.started = true;\n  }\n\n  async stop(): Promise<void> {\n    this.started = false;\n\n    // Clear all pending delayed messages\n    this.pendingTimeouts.forEach((timeout) => clearTimeout(timeout));\n    this.pendingTimeouts.clear();\n  }\n\n  async subscribe<TMessage extends BaseMessage>(\n    options: TransportSubscribeOptions,\n    handler: (envelope: MessageEnvelope<TMessage>) => Promise<void>\n  ): Promise<void> {\n    const { endpoint, concurrency = this.defaultConcurrency } = options;\n\n    const subscription: Subscription<TMessage> = {\n      options,\n      handler,\n      semaphore: new Semaphore(concurrency),\n    };\n\n    const existing = this.subscriptions.get(endpoint);\n    if (existing) {\n      existing.push(subscription as Subscription);\n    } else {\n      this.subscriptions.set(endpoint, [subscription as Subscription]);\n    }\n  }\n\n  async publish<TMessage extends BaseMessage>(\n    message: TMessage,\n    options: TransportPublishOptions\n  ): Promise<void> {\n    const { endpoint, headers = {}, delayMs } = options;\n\n    const envelope: MessageEnvelope<TMessage> = {\n      id: randomUUID(),\n      type: message.type,\n      payload: message,\n      headers: { ...headers },\n      timestamp: new Date(),\n      partitionKey: options.key,\n    };\n\n    if (delayMs && delayMs > 0) {\n      const timeout = setTimeout(() => {\n        this.pendingTimeouts.delete(timeout);\n        void this.deliverToSubscribers(endpoint, envelope);\n      }, delayMs);\n      this.pendingTimeouts.add(timeout);\n    } else {\n      // Deliver asynchronously to avoid blocking publisher\n      setImmediate(() => {\n        void this.deliverToSubscribers(endpoint, envelope);\n      });\n    }\n  }\n\n  private async deliverToSubscribers<TMessage extends BaseMessage>(\n    endpoint: string,\n    envelope: MessageEnvelope<TMessage>\n  ): Promise<void> {\n    if (!this.started) {\n      return;\n    }\n\n    const subscriptions = this.subscriptions.get(endpoint);\n    if (!subscriptions || subscriptions.length === 0) {\n      return;\n    }\n\n    // Deliver to all subscriptions (fan-out)\n    // Each subscription handles its own concurrency\n    const deliveries = subscriptions.map(async (sub) => {\n      await sub.semaphore.withPermit(async () => {\n        try {\n          await sub.handler(envelope as MessageEnvelope);\n        } catch (error) {\n          // In-memory transport doesn't handle errors - let them propagate\n          // Real error handling is done by the bus runtime\n          console.error(\n            `[InMemoryTransport] Handler error for ${endpoint}:`,\n            error\n          );\n        }\n      });\n    });\n\n    await Promise.all(deliveries);\n  }\n\n  /**\n   * Get the number of subscriptions for an endpoint.\n   * Useful for testing.\n   */\n  getSubscriptionCount(endpoint: string): number {\n    return this.subscriptions.get(endpoint)?.length ?? 0;\n  }\n\n  /**\n   * Check if the transport is started.\n   */\n  get isStarted(): boolean {\n    return this.started;\n  }\n\n  /**\n   * Clear all subscriptions. Useful for testing.\n   */\n  clearSubscriptions(): void {\n    this.subscriptions.clear();\n  }\n}\n","/**\n * Simple semaphore for controlling concurrency.\n */\nexport class Semaphore {\n  private permits: number;\n  private waiting: Array<() => void> = [];\n\n  constructor(permits: number) {\n    this.permits = permits;\n  }\n\n  /**\n   * Acquire a permit, waiting if none are available.\n   */\n  async acquire(): Promise<void> {\n    if (this.permits > 0) {\n      this.permits--;\n      return;\n    }\n\n    return new Promise<void>((resolve) => {\n      this.waiting.push(resolve);\n    });\n  }\n\n  /**\n   * Release a permit, waking a waiting acquirer if any.\n   */\n  release(): void {\n    const next = this.waiting.shift();\n    if (next) {\n      next();\n    } else {\n      this.permits++;\n    }\n  }\n\n  /**\n   * Execute a function with a permit.\n   */\n  async withPermit<T>(fn: () => Promise<T>): Promise<T> {\n    await this.acquire();\n    try {\n      return await fn();\n    } finally {\n      this.release();\n    }\n  }\n\n  /**\n   * Get the number of available permits.\n   */\n  get available(): number {\n    return this.permits;\n  }\n\n  /**\n   * Get the number of waiting acquirers.\n   */\n  get waitingCount(): number {\n    return this.waiting.length;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,68 @@
+import { Transport, BaseMessage, TransportSubscribeOptions, MessageEnvelope, TransportPublishOptions } from '@saga-bus/core';
+
+interface InMemoryTransportOptions {
+    /**
+     * Default concurrency for subscriptions (default: 1)
+     */
+    defaultConcurrency?: number;
+}
+/**
+ * In-memory transport implementation for testing and local development.
+ * Uses a simple pub/sub pattern with concurrency control.
+ */
+declare class InMemoryTransport implements Transport {
+    private readonly subscriptions;
+    private readonly pendingTimeouts;
+    private readonly defaultConcurrency;
+    private started;
+    constructor(options?: InMemoryTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    subscribe<TMessage extends BaseMessage>(options: TransportSubscribeOptions, handler: (envelope: MessageEnvelope<TMessage>) => Promise<void>): Promise<void>;
+    publish<TMessage extends BaseMessage>(message: TMessage, options: TransportPublishOptions): Promise<void>;
+    private deliverToSubscribers;
+    /**
+     * Get the number of subscriptions for an endpoint.
+     * Useful for testing.
+     */
+    getSubscriptionCount(endpoint: string): number;
+    /**
+     * Check if the transport is started.
+     */
+    get isStarted(): boolean;
+    /**
+     * Clear all subscriptions. Useful for testing.
+     */
+    clearSubscriptions(): void;
+}
+
+/**
+ * Simple semaphore for controlling concurrency.
+ */
+declare class Semaphore {
+    private permits;
+    private waiting;
+    constructor(permits: number);
+    /**
+     * Acquire a permit, waiting if none are available.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release a permit, waking a waiting acquirer if any.
+     */
+    release(): void;
+    /**
+     * Execute a function with a permit.
+     */
+    withPermit<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get the number of available permits.
+     */
+    get available(): number;
+    /**
+     * Get the number of waiting acquirers.
+     */
+    get waitingCount(): number;
+}
+
+export { InMemoryTransport, type InMemoryTransportOptions, Semaphore };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { Transport, BaseMessage, TransportSubscribeOptions, MessageEnvelope, TransportPublishOptions } from '@saga-bus/core';
+
+interface InMemoryTransportOptions {
+    /**
+     * Default concurrency for subscriptions (default: 1)
+     */
+    defaultConcurrency?: number;
+}
+/**
+ * In-memory transport implementation for testing and local development.
+ * Uses a simple pub/sub pattern with concurrency control.
+ */
+declare class InMemoryTransport implements Transport {
+    private readonly subscriptions;
+    private readonly pendingTimeouts;
+    private readonly defaultConcurrency;
+    private started;
+    constructor(options?: InMemoryTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    subscribe<TMessage extends BaseMessage>(options: TransportSubscribeOptions, handler: (envelope: MessageEnvelope<TMessage>) => Promise<void>): Promise<void>;
+    publish<TMessage extends BaseMessage>(message: TMessage, options: TransportPublishOptions): Promise<void>;
+    private deliverToSubscribers;
+    /**
+     * Get the number of subscriptions for an endpoint.
+     * Useful for testing.
+     */
+    getSubscriptionCount(endpoint: string): number;
+    /**
+     * Check if the transport is started.
+     */
+    get isStarted(): boolean;
+    /**
+     * Clear all subscriptions. Useful for testing.
+     */
+    clearSubscriptions(): void;
+}
+
+/**
+ * Simple semaphore for controlling concurrency.
+ */
+declare class Semaphore {
+    private permits;
+    private waiting;
+    constructor(permits: number);
+    /**
+     * Acquire a permit, waiting if none are available.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release a permit, waking a waiting acquirer if any.
+     */
+    release(): void;
+    /**
+     * Execute a function with a permit.
+     */
+    withPermit<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get the number of available permits.
+     */
+    get available(): number;
+    /**
+     * Get the number of waiting acquirers.
+     */
+    get waitingCount(): number;
+}
+
+export { InMemoryTransport, type InMemoryTransportOptions, Semaphore };

package/dist/index.js

@@ -0,0 +1,158 @@
+// src/InMemoryTransport.ts
+import { randomUUID } from "crypto";
+
+// src/Semaphore.ts
+var Semaphore = class {
+  permits;
+  waiting = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  /**
+   * Acquire a permit, waiting if none are available.
+   */
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waiting.push(resolve);
+    });
+  }
+  /**
+   * Release a permit, waking a waiting acquirer if any.
+   */
+  release() {
+    const next = this.waiting.shift();
+    if (next) {
+      next();
+    } else {
+      this.permits++;
+    }
+  }
+  /**
+   * Execute a function with a permit.
+   */
+  async withPermit(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  /**
+   * Get the number of available permits.
+   */
+  get available() {
+    return this.permits;
+  }
+  /**
+   * Get the number of waiting acquirers.
+   */
+  get waitingCount() {
+    return this.waiting.length;
+  }
+};
+
+// src/InMemoryTransport.ts
+var InMemoryTransport = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  pendingTimeouts = /* @__PURE__ */ new Set();
+  defaultConcurrency;
+  started = false;
+  constructor(options = {}) {
+    this.defaultConcurrency = options.defaultConcurrency ?? 1;
+  }
+  async start() {
+    this.started = true;
+  }
+  async stop() {
+    this.started = false;
+    this.pendingTimeouts.forEach((timeout) => clearTimeout(timeout));
+    this.pendingTimeouts.clear();
+  }
+  async subscribe(options, handler) {
+    const { endpoint, concurrency = this.defaultConcurrency } = options;
+    const subscription = {
+      options,
+      handler,
+      semaphore: new Semaphore(concurrency)
+    };
+    const existing = this.subscriptions.get(endpoint);
+    if (existing) {
+      existing.push(subscription);
+    } else {
+      this.subscriptions.set(endpoint, [subscription]);
+    }
+  }
+  async publish(message, options) {
+    const { endpoint, headers = {}, delayMs } = options;
+    const envelope = {
+      id: randomUUID(),
+      type: message.type,
+      payload: message,
+      headers: { ...headers },
+      timestamp: /* @__PURE__ */ new Date(),
+      partitionKey: options.key
+    };
+    if (delayMs && delayMs > 0) {
+      const timeout = setTimeout(() => {
+        this.pendingTimeouts.delete(timeout);
+        void this.deliverToSubscribers(endpoint, envelope);
+      }, delayMs);
+      this.pendingTimeouts.add(timeout);
+    } else {
+      setImmediate(() => {
+        void this.deliverToSubscribers(endpoint, envelope);
+      });
+    }
+  }
+  async deliverToSubscribers(endpoint, envelope) {
+    if (!this.started) {
+      return;
+    }
+    const subscriptions = this.subscriptions.get(endpoint);
+    if (!subscriptions || subscriptions.length === 0) {
+      return;
+    }
+    const deliveries = subscriptions.map(async (sub) => {
+      await sub.semaphore.withPermit(async () => {
+        try {
+          await sub.handler(envelope);
+        } catch (error) {
+          console.error(
+            `[InMemoryTransport] Handler error for ${endpoint}:`,
+            error
+          );
+        }
+      });
+    });
+    await Promise.all(deliveries);
+  }
+  /**
+   * Get the number of subscriptions for an endpoint.
+   * Useful for testing.
+   */
+  getSubscriptionCount(endpoint) {
+    return this.subscriptions.get(endpoint)?.length ?? 0;
+  }
+  /**
+   * Check if the transport is started.
+   */
+  get isStarted() {
+    return this.started;
+  }
+  /**
+   * Clear all subscriptions. Useful for testing.
+   */
+  clearSubscriptions() {
+    this.subscriptions.clear();
+  }
+};
+export {
+  InMemoryTransport,
+  Semaphore
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/InMemoryTransport.ts","../src/Semaphore.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type {\n  Transport,\n  TransportSubscribeOptions,\n  TransportPublishOptions,\n  BaseMessage,\n  MessageEnvelope,\n} from \"@saga-bus/core\";\nimport { Semaphore } from \"./Semaphore.js\";\n\ninterface Subscription<T extends BaseMessage = BaseMessage> {\n  options: TransportSubscribeOptions;\n  handler: (envelope: MessageEnvelope<T>) => Promise<void>;\n  semaphore: Semaphore;\n}\n\nexport interface InMemoryTransportOptions {\n  /**\n   * Default concurrency for subscriptions (default: 1)\n   */\n  defaultConcurrency?: number;\n}\n\n/**\n * In-memory transport implementation for testing and local development.\n * Uses a simple pub/sub pattern with concurrency control.\n */\nexport class InMemoryTransport implements Transport {\n  private readonly subscriptions = new Map<string, Subscription[]>();\n  private readonly pendingTimeouts = new Set<ReturnType<typeof setTimeout>>();\n  private readonly defaultConcurrency: number;\n  private started = false;\n\n  constructor(options: InMemoryTransportOptions = {}) {\n    this.defaultConcurrency = options.defaultConcurrency ?? 1;\n  }\n\n  async start(): Promise<void> {\n    this.started = true;\n  }\n\n  async stop(): Promise<void> {\n    this.started = false;\n\n    // Clear all pending delayed messages\n    this.pendingTimeouts.forEach((timeout) => clearTimeout(timeout));\n    this.pendingTimeouts.clear();\n  }\n\n  async subscribe<TMessage extends BaseMessage>(\n    options: TransportSubscribeOptions,\n    handler: (envelope: MessageEnvelope<TMessage>) => Promise<void>\n  ): Promise<void> {\n    const { endpoint, concurrency = this.defaultConcurrency } = options;\n\n    const subscription: Subscription<TMessage> = {\n      options,\n      handler,\n      semaphore: new Semaphore(concurrency),\n    };\n\n    const existing = this.subscriptions.get(endpoint);\n    if (existing) {\n      existing.push(subscription as Subscription);\n    } else {\n      this.subscriptions.set(endpoint, [subscription as Subscription]);\n    }\n  }\n\n  async publish<TMessage extends BaseMessage>(\n    message: TMessage,\n    options: TransportPublishOptions\n  ): Promise<void> {\n    const { endpoint, headers = {}, delayMs } = options;\n\n    const envelope: MessageEnvelope<TMessage> = {\n      id: randomUUID(),\n      type: message.type,\n      payload: message,\n      headers: { ...headers },\n      timestamp: new Date(),\n      partitionKey: options.key,\n    };\n\n    if (delayMs && delayMs > 0) {\n      const timeout = setTimeout(() => {\n        this.pendingTimeouts.delete(timeout);\n        void this.deliverToSubscribers(endpoint, envelope);\n      }, delayMs);\n      this.pendingTimeouts.add(timeout);\n    } else {\n      // Deliver asynchronously to avoid blocking publisher\n      setImmediate(() => {\n        void this.deliverToSubscribers(endpoint, envelope);\n      });\n    }\n  }\n\n  private async deliverToSubscribers<TMessage extends BaseMessage>(\n    endpoint: string,\n    envelope: MessageEnvelope<TMessage>\n  ): Promise<void> {\n    if (!this.started) {\n      return;\n    }\n\n    const subscriptions = this.subscriptions.get(endpoint);\n    if (!subscriptions || subscriptions.length === 0) {\n      return;\n    }\n\n    // Deliver to all subscriptions (fan-out)\n    // Each subscription handles its own concurrency\n    const deliveries = subscriptions.map(async (sub) => {\n      await sub.semaphore.withPermit(async () => {\n        try {\n          await sub.handler(envelope as MessageEnvelope);\n        } catch (error) {\n          // In-memory transport doesn't handle errors - let them propagate\n          // Real error handling is done by the bus runtime\n          console.error(\n            `[InMemoryTransport] Handler error for ${endpoint}:`,\n            error\n          );\n        }\n      });\n    });\n\n    await Promise.all(deliveries);\n  }\n\n  /**\n   * Get the number of subscriptions for an endpoint.\n   * Useful for testing.\n   */\n  getSubscriptionCount(endpoint: string): number {\n    return this.subscriptions.get(endpoint)?.length ?? 0;\n  }\n\n  /**\n   * Check if the transport is started.\n   */\n  get isStarted(): boolean {\n    return this.started;\n  }\n\n  /**\n   * Clear all subscriptions. Useful for testing.\n   */\n  clearSubscriptions(): void {\n    this.subscriptions.clear();\n  }\n}\n","/**\n * Simple semaphore for controlling concurrency.\n */\nexport class Semaphore {\n  private permits: number;\n  private waiting: Array<() => void> = [];\n\n  constructor(permits: number) {\n    this.permits = permits;\n  }\n\n  /**\n   * Acquire a permit, waiting if none are available.\n   */\n  async acquire(): Promise<void> {\n    if (this.permits > 0) {\n      this.permits--;\n      return;\n    }\n\n    return new Promise<void>((resolve) => {\n      this.waiting.push(resolve);\n    });\n  }\n\n  /**\n   * Release a permit, waking a waiting acquirer if any.\n   */\n  release(): void {\n    const next = this.waiting.shift();\n    if (next) {\n      next();\n    } else {\n      this.permits++;\n    }\n  }\n\n  /**\n   * Execute a function with a permit.\n   */\n  async withPermit<T>(fn: () => Promise<T>): Promise<T> {\n    await this.acquire();\n    try {\n      return await fn();\n    } finally {\n      this.release();\n    }\n  }\n\n  /**\n   * Get the number of available permits.\n   */\n  get available(): number {\n    return this.permits;\n  }\n\n  /**\n   * Get the number of waiting acquirers.\n   */\n  get waitingCount(): number {\n    return this.waiting.length;\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@saga-bus/transport-inmemory",
+  "version": "0.1.2",
+  "description": "In-memory transport for saga-bus testing and development",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/d-e-a-n-f/saga-bus.git",
+    "directory": "packages/transport-inmemory"
+  },
+  "bugs": {
+    "url": "https://github.com/d-e-a-n-f/saga-bus/issues"
+  },
+  "homepage": "https://github.com/d-e-a-n-f/saga-bus#readme",
+  "keywords": [
+    "saga",
+    "message-bus",
+    "transport",
+    "inmemory",
+    "testing"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@saga-bus/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "@saga-bus/core": ">=0.1.2"
+  }
+}