@celerity-sdk/topic 0.3.1 → 0.4.0

package/README.md

@@ -1,12 +1,13 @@
 # @celerity-sdk/topic
 
-Pub/Sub topic abstraction for the Celerity Node SDK.
+Cloud-agnostic pub/sub topic abstraction for the Celerity Node SDK.
 
-Provides a unified `TopicClient` interface for publishing messages to topics across cloud providers:
+Provides a unified `TopicClient` interface for publishing messages to topics across cloud providers. The Celerity runtime handles all consumption — this package is **publish-only** (`publish`, `publishBatch`).
 
-- **AWS**:Amazon SNS
-- **GCP**:Google Cloud Pub/Sub
-- **Azure**:Azure Service Bus Topics
+- **AWS**: Amazon SNS
+- **GCP**: Google Cloud Pub/Sub *(planned)*
+- **Azure**: Azure Service Bus Topics *(planned)*
+- **Local**: Redis pub/sub channels via Celerity CLI
 
 ## Installation
 
@@ -20,17 +21,14 @@ Install the cloud SDK for your target platform as a peer dependency:
 # AWS
 pnpm add @aws-sdk/client-sns
 
-# GCP
-pnpm add @google-cloud/pubsub
-
-# Azure
-pnpm add @azure/service-bus
+# Local development (managed by Celerity CLI, but needed for direct usage)
+pnpm add ioredis
 ```
 
 ## Status
 
-This package is a stub:the interface and provider implementations are planned but not yet implemented.
+This package implements the `TopicClient` interface with providers for AWS SNS and Redis (local development). Support for Google Cloud Pub/Sub and Azure Service Bus Topics will be added in future releases.
 
 ## Part of the Celerity Framework
 
-See [celerityframework.com](https://celerityframework.com) for full documentation.
+See [celerityframework.io](https://celerityframework.io) for full documentation.

package/dist/index.cjs

@@ -1,8 +1,15 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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))
@@ -11,9 +18,458 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
+__export(index_exports, {
+  DEFAULT_TOPIC_TOKEN: () => DEFAULT_TOPIC_TOKEN,
+  RedisTopicClient: () => RedisTopicClient,
+  SNSTopicClient: () => SNSTopicClient,
+  Topic: () => Topic,
+  TopicClient: () => TopicClient,
+  TopicError: () => TopicError,
+  TopicLayer: () => TopicLayer,
+  createTopicClient: () => createTopicClient,
+  getTopic: () => getTopic,
+  topicToken: () => topicToken
+});
 module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var TopicClient = /* @__PURE__ */ Symbol.for("TopicClient");
+
+// src/providers/sns/sns-topic-client.ts
+var import_client_sns2 = require("@aws-sdk/client-sns");
+
+// src/providers/sns/sns-topic.ts
+var import_debug = __toESM(require("debug"), 1);
+var import_client_sns = require("@aws-sdk/client-sns");
+
+// src/errors.ts
+var TopicError = class extends Error {
+  static {
+    __name(this, "TopicError");
+  }
+  topic;
+  constructor(message, topic, options) {
+    super(message, options), this.topic = topic;
+    this.name = "TopicError";
+  }
+};
+
+// src/providers/sns/sns-topic.ts
+var debug = (0, import_debug.default)("celerity:topic:sns");
+var SNS_MAX_BATCH_SIZE = 10;
+var SNSTopic = class {
+  static {
+    __name(this, "SNSTopic");
+  }
+  topicArn;
+  client;
+  tracer;
+  constructor(topicArn, client, tracer) {
+    this.topicArn = topicArn;
+    this.client = client;
+    this.tracer = tracer;
+  }
+  async publish(body, options) {
+    debug("publish %s", this.topicArn);
+    return this.traced("celerity.topic.publish", {
+      "topic.arn": this.topicArn
+    }, async () => {
+      try {
+        const result = await this.client.send(new import_client_sns.PublishCommand({
+          TopicArn: this.topicArn,
+          Message: JSON.stringify(body),
+          MessageGroupId: options?.groupId,
+          MessageDeduplicationId: options?.deduplicationId,
+          Subject: options?.subject,
+          MessageAttributes: options?.attributes ? toSNSAttributes(options.attributes) : void 0
+        }));
+        return {
+          messageId: result.MessageId
+        };
+      } catch (error) {
+        throw new TopicError(`Failed to publish message to topic "${this.topicArn}"`, this.topicArn, {
+          cause: error
+        });
+      }
+    });
+  }
+  async publishBatch(entries) {
+    debug("publishBatch %s (%d entries)", this.topicArn, entries.length);
+    return this.traced("celerity.topic.publish_batch", {
+      "topic.arn": this.topicArn,
+      "topic.message_count": entries.length
+    }, async () => {
+      const successful = [];
+      const failed = [];
+      for (let i = 0; i < entries.length; i += SNS_MAX_BATCH_SIZE) {
+        const chunk = entries.slice(i, i + SNS_MAX_BATCH_SIZE);
+        const snsEntries = chunk.map((entry) => ({
+          Id: entry.id,
+          Message: JSON.stringify(entry.body),
+          MessageGroupId: entry.options?.groupId,
+          MessageDeduplicationId: entry.options?.deduplicationId,
+          Subject: entry.options?.subject,
+          MessageAttributes: entry.options?.attributes ? toSNSAttributes(entry.options.attributes) : void 0
+        }));
+        try {
+          const result = await this.client.send(new import_client_sns.PublishBatchCommand({
+            TopicArn: this.topicArn,
+            PublishBatchRequestEntries: snsEntries
+          }));
+          for (const s of result.Successful ?? []) {
+            successful.push({
+              id: s.Id,
+              messageId: s.MessageId
+            });
+          }
+          for (const f of result.Failed ?? []) {
+            failed.push({
+              id: f.Id,
+              code: f.Code,
+              message: f.Message ?? "Unknown error"
+            });
+          }
+        } catch (error) {
+          throw new TopicError(`Failed to publish message batch to topic "${this.topicArn}"`, this.topicArn, {
+            cause: error
+          });
+        }
+      }
+      return {
+        successful,
+        failed
+      };
+    });
+  }
+  traced(name, attributes, fn) {
+    if (!this.tracer) return fn();
+    return this.tracer.withSpan(name, (span) => fn(span), attributes);
+  }
+};
+function toSNSAttributes(attrs) {
+  const result = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    result[key] = {
+      DataType: "String",
+      StringValue: value
+    };
+  }
+  return result;
+}
+__name(toSNSAttributes, "toSNSAttributes");
+
+// src/providers/sns/config.ts
+function captureSNSConfig() {
+  return {
+    region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION,
+    endpoint: process.env.AWS_ENDPOINT_URL,
+    credentials: process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY ? {
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+    } : void 0
+  };
+}
+__name(captureSNSConfig, "captureSNSConfig");
+
+// src/providers/sns/sns-topic-client.ts
+var SNSTopicClient = class {
+  static {
+    __name(this, "SNSTopicClient");
+  }
+  tracer;
+  client = null;
+  config;
+  constructor(config, tracer) {
+    this.tracer = tracer;
+    this.config = config ?? captureSNSConfig();
+  }
+  topic(name) {
+    return new SNSTopic(name, this.getClient(), this.tracer);
+  }
+  close() {
+    this.client?.destroy();
+    this.client = null;
+  }
+  getClient() {
+    if (!this.client) {
+      this.client = new import_client_sns2.SNSClient({
+        region: this.config.region,
+        endpoint: this.config.endpoint,
+        credentials: this.config.credentials
+      });
+    }
+    return this.client;
+  }
+};
+
+// src/providers/redis/redis-topic.ts
+var import_node_crypto = require("crypto");
+var import_debug2 = __toESM(require("debug"), 1);
+var debug2 = (0, import_debug2.default)("celerity:topic:redis");
+var RedisTopic = class {
+  static {
+    __name(this, "RedisTopic");
+  }
+  channelName;
+  client;
+  tracer;
+  constructor(channelName, client, tracer) {
+    this.channelName = channelName;
+    this.client = client;
+    this.tracer = tracer;
+  }
+  async publish(body, options) {
+    debug2("publish %s", this.channelName);
+    return this.traced("celerity.topic.publish", {
+      "topic.channel": this.channelName
+    }, async () => {
+      try {
+        const messageId = (0, import_node_crypto.randomUUID)();
+        const payload = buildEnvelope(body, messageId, options);
+        await this.client.publish(this.channelName, payload);
+        return {
+          messageId
+        };
+      } catch (error) {
+        throw new TopicError(`Failed to publish message to channel "${this.channelName}"`, this.channelName, {
+          cause: error
+        });
+      }
+    });
+  }
+  async publishBatch(entries) {
+    debug2("publishBatch %s (%d entries)", this.channelName, entries.length);
+    return this.traced("celerity.topic.publish_batch", {
+      "topic.channel": this.channelName,
+      "topic.message_count": entries.length
+    }, async () => {
+      const successful = [];
+      const failed = [];
+      const messageIds = [];
+      const pipeline = this.client.pipeline();
+      for (const entry of entries) {
+        const messageId = (0, import_node_crypto.randomUUID)();
+        messageIds.push(messageId);
+        const payload = buildEnvelope(entry.body, messageId, entry.options);
+        pipeline.publish(this.channelName, payload);
+      }
+      try {
+        const results = await pipeline.exec();
+        if (!results) {
+          throw new Error("Pipeline returned null");
+        }
+        for (let i = 0; i < entries.length; i++) {
+          const [err] = results[i];
+          if (err) {
+            failed.push({
+              id: entries[i].id,
+              code: err.name ?? "PipelineError",
+              message: err.message
+            });
+          } else {
+            successful.push({
+              id: entries[i].id,
+              messageId: messageIds[i]
+            });
+          }
+        }
+      } catch (error) {
+        throw new TopicError(`Failed to publish message batch to channel "${this.channelName}"`, this.channelName, {
+          cause: error
+        });
+      }
+      return {
+        successful,
+        failed
+      };
+    });
+  }
+  traced(name, attributes, fn) {
+    if (!this.tracer) return fn();
+    return this.tracer.withSpan(name, (span) => fn(span), attributes);
+  }
+};
+function buildEnvelope(body, messageId, options) {
+  const envelope = {
+    body: JSON.stringify(body),
+    messageId
+  };
+  if (options?.subject) {
+    envelope.subject = options.subject;
+  }
+  if (options?.attributes && Object.keys(options.attributes).length > 0) {
+    envelope.attributes = options.attributes;
+  }
+  return JSON.stringify(envelope);
+}
+__name(buildEnvelope, "buildEnvelope");
+
+// src/providers/redis/config.ts
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+function captureRedisConfig() {
+  return {
+    url: process.env.CELERITY_LOCAL_REDIS_URL ?? DEFAULT_REDIS_URL
+  };
+}
+__name(captureRedisConfig, "captureRedisConfig");
+
+// src/providers/redis/redis-topic-client.ts
+var RedisTopicClient = class {
+  static {
+    __name(this, "RedisTopicClient");
+  }
+  tracer;
+  client = null;
+  config;
+  constructor(config, tracer) {
+    this.tracer = tracer;
+    this.config = config ?? captureRedisConfig();
+  }
+  topic(name) {
+    return new RedisTopic(name, this.getClient(), this.tracer);
+  }
+  async close() {
+    if (this.client) {
+      await this.client.quit();
+      this.client = null;
+    }
+  }
+  getClient() {
+    if (!this.client) {
+      const Redis = require("ioredis").default ?? require("ioredis");
+      this.client = new Redis(this.config.url);
+    }
+    return this.client;
+  }
+};
+
+// src/factory.ts
+var import_config3 = require("@celerity-sdk/config");
+function createTopicClient(options) {
+  const resolved = (0, import_config3.resolveConfig)("topic");
+  const provider = options?.provider ?? resolved.provider;
+  switch (provider) {
+    case "aws":
+      return new SNSTopicClient(options?.aws, options?.tracer);
+    // Local environments always use Redis pub/sub regardless of deploy target.
+    // The Celerity CLI manages the Redis instance and local-events sidecar.
+    case "local":
+      return new RedisTopicClient(options?.local, options?.tracer);
+    // case "gcp":
+    //   v1: Google Cloud Pub/Sub
+    // case "azure":
+    //   v1: Azure Service Bus Topics
+    default:
+      throw new Error(`Unsupported topic provider: "${provider}"`);
+  }
+}
+__name(createTopicClient, "createTopicClient");
+
+// src/decorators.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@celerity-sdk/common");
+function topicToken(resourceName) {
+  return /* @__PURE__ */ Symbol.for(`celerity:topic:${resourceName}`);
+}
+__name(topicToken, "topicToken");
+var DEFAULT_TOPIC_TOKEN = /* @__PURE__ */ Symbol.for("celerity:topic:default");
+function Topic(resourceName) {
+  return (target, _propertyKey, parameterIndex) => {
+    const token = resourceName ? topicToken(resourceName) : DEFAULT_TOPIC_TOKEN;
+    const existing = Reflect.getOwnMetadata(import_common.INJECT_METADATA, target) ?? /* @__PURE__ */ new Map();
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(import_common.INJECT_METADATA, existing, target);
+    if (resourceName) {
+      const resources = Reflect.getOwnMetadata(import_common.USE_RESOURCE_METADATA, target) ?? [];
+      if (!resources.includes(resourceName)) {
+        Reflect.defineMetadata(import_common.USE_RESOURCE_METADATA, [
+          ...resources,
+          resourceName
+        ], target);
+      }
+    }
+  };
+}
+__name(Topic, "Topic");
+
+// src/helpers.ts
+function getTopic(container, resourceName) {
+  const token = resourceName ? topicToken(resourceName) : DEFAULT_TOPIC_TOKEN;
+  return container.resolve(token);
+}
+__name(getTopic, "getTopic");
+
+// src/layer.ts
+var import_debug3 = __toESM(require("debug"), 1);
+var import_common2 = require("@celerity-sdk/common");
+var import_config4 = require("@celerity-sdk/config");
+var debug3 = (0, import_debug3.default)("celerity:topic");
+var TopicLayer = class {
+  static {
+    __name(this, "TopicLayer");
+  }
+  initialized = false;
+  async handle(context, next) {
+    if (!this.initialized) {
+      const tracer = context.container.has(import_common2.TRACER_TOKEN) ? await context.container.resolve(import_common2.TRACER_TOKEN) : void 0;
+      const client = createTopicClient({
+        tracer
+      });
+      debug3("registering TopicClient");
+      context.container.register("TopicClient", {
+        useValue: client
+      });
+      const links = (0, import_config4.captureResourceLinks)();
+      const topicLinks = (0, import_config4.getLinksOfType)(links, "topic");
+      if (topicLinks.size > 0) {
+        const configService = await context.container.resolve(import_common2.CONFIG_SERVICE_TOKEN);
+        const resourceConfig = configService.namespace(import_config4.RESOURCE_CONFIG_NAMESPACE);
+        for (const [resourceName, configKey] of topicLinks) {
+          const actualName = await resourceConfig.getOrThrow(configKey);
+          debug3("registered topic resource %s \u2192 %s", resourceName, actualName);
+          context.container.register(topicToken(resourceName), {
+            useValue: client.topic(actualName)
+          });
+        }
+        if (topicLinks.size === 1) {
+          const [, configKey] = [
+            ...topicLinks.entries()
+          ][0];
+          const actualName = await resourceConfig.getOrThrow(configKey);
+          debug3("registered default topic \u2192 %s", actualName);
+          context.container.register(DEFAULT_TOPIC_TOKEN, {
+            useValue: client.topic(actualName)
+          });
+        }
+      }
+      this.initialized = true;
+    }
+    return next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_TOPIC_TOKEN,
+  RedisTopicClient,
+  SNSTopicClient,
+  Topic,
+  TopicClient,
+  TopicError,
+  TopicLayer,
+  createTopicClient,
+  getTopic,
+  topicToken
+});
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// TODO: Implement pub/sub topic abstraction.\n// Key modules: interfaces (TopicClient), factory (createTopicClient), providers (sns, google-pubsub, azure-service-bus)\nexport {};\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/types.ts","../src/providers/sns/sns-topic-client.ts","../src/providers/sns/sns-topic.ts","../src/errors.ts","../src/providers/sns/config.ts","../src/providers/redis/redis-topic.ts","../src/providers/redis/config.ts","../src/providers/redis/redis-topic-client.ts","../src/factory.ts","../src/decorators.ts","../src/helpers.ts","../src/layer.ts"],"sourcesContent":["// Core types\nexport {\n  TopicClient,\n  type PublishOptions,\n  type PublishResult,\n  type BatchPublishEntry,\n  type BatchPublishResult,\n  type BatchPublishSuccess,\n  type BatchPublishFailure,\n} from \"./types\";\n\nexport { SNSTopicClient } from \"./providers/sns/sns-topic-client\";\nexport type { SNSTopicConfig } from \"./providers/sns/types\";\nexport { RedisTopicClient } from \"./providers/redis/redis-topic-client\";\nexport type { RedisTopicConfig } from \"./providers/redis/types\";\n\nexport { createTopicClient } from \"./factory\";\nexport type { CreateTopicClientOptions } from \"./factory\";\n\nexport { Topic, topicToken, DEFAULT_TOPIC_TOKEN } from \"./decorators\";\n\nexport { getTopic } from \"./helpers\";\n\nexport { TopicLayer } from \"./layer\";\n\nexport { TopicError } from \"./errors\";\n","import type { Closeable } from \"@celerity-sdk/types\";\n\nexport const TopicClient = Symbol.for(\"TopicClient\");\n\n/**\n * A topic client abstraction for pub/sub topics. Provides access to named\n * topics, each representing a logical destination for published messages.\n */\nexport interface TopicClient extends Closeable {\n  /**\n   * Retrieves a topic instance by its name. The returned topic is a lightweight\n   * handle — no network calls are made until an operation is invoked.\n   *\n   * @param name The topic identifier (SNS topic ARN, Redis channel name, etc.).\n   */\n  topic(name: string): Topic;\n}\n\n/**\n * A topic represents a logical pub/sub destination. It provides methods for\n * publishing messages individually or in batches. The Celerity runtime handles\n * all subscription and consumption — this interface is producer-only.\n */\nexport interface Topic {\n  /**\n   * Publish a single message to the topic. The body is serialized to JSON.\n   *\n   * @param body The message body (serialized to JSON string for transport).\n   * @param options Optional publish parameters such as FIFO ordering or subject.\n   * @returns A promise that resolves to the publish result with the provider-assigned message ID.\n   */\n  publish<T = Record<string, unknown>>(body: T, options?: PublishOptions): Promise<PublishResult>;\n\n  /**\n   * Publish multiple messages in a single batch. The provider may impose batch\n   * size limits (e.g. SNS limits to 10 per request) — the implementation\n   * handles chunking transparently.\n   *\n   * @param entries The batch of messages to publish, each with a caller-assigned ID for correlation.\n   * @returns A promise that resolves to the batch result with successful and failed entries.\n   */\n  publishBatch<T = Record<string, unknown>>(\n    entries: BatchPublishEntry<T>[],\n  ): Promise<BatchPublishResult>;\n}\n\n/**\n * Options for the publish and publishBatch operations.\n */\nexport type PublishOptions = {\n  /** Message group ID for FIFO topics (SNS: MessageGroupId, Pub/Sub: ordering key). */\n  groupId?: string;\n  /** Deduplication ID for FIFO topics. */\n  deduplicationId?: string;\n  /** Message subject (SNS: Subject). */\n  subject?: string;\n  /** String key-value message attributes (metadata sent alongside the body). */\n  attributes?: Record<string, string>;\n};\n\n/**\n * The result of a single publish call.\n */\nexport type PublishResult = {\n  /** The provider-assigned message identifier. */\n  messageId: string;\n};\n\n/**\n * A single entry in a batch publish request.\n */\nexport type BatchPublishEntry<T = Record<string, unknown>> = {\n  /** Caller-assigned ID for correlating results within the batch. */\n  id: string;\n  /** The message body (serialized to JSON). */\n  body: T;\n  /** Per-message publish options. */\n  options?: PublishOptions;\n};\n\n/**\n * The result of a batch publish operation.\n */\nexport type BatchPublishResult = {\n  /** Entries that were published successfully. */\n  successful: BatchPublishSuccess[];\n  /** Entries that failed. */\n  failed: BatchPublishFailure[];\n};\n\n/**\n * A successfully published entry from a batch operation.\n */\nexport type BatchPublishSuccess = {\n  /** The caller-assigned entry ID. */\n  id: string;\n  /** The provider-assigned message ID. */\n  messageId: string;\n};\n\n/**\n * A failed entry from a batch operation.\n */\nexport type BatchPublishFailure = {\n  /** The caller-assigned entry ID. */\n  id: string;\n  /** Provider error code. */\n  code: string;\n  /** Human-readable error message. */\n  message: string;\n};\n","import { SNSClient } from \"@aws-sdk/client-sns\";\nimport type { CelerityTracer } from \"@celerity-sdk/types\";\nimport type { TopicClient, Topic } from \"../../types\";\nimport { SNSTopic } from \"./sns-topic\";\nimport type { SNSTopicConfig } from \"./types\";\nimport { captureSNSConfig } from \"./config\";\n\nexport class SNSTopicClient implements TopicClient {\n  private client: SNSClient | null = null;\n  private readonly config: SNSTopicConfig;\n\n  constructor(\n    config?: SNSTopicConfig,\n    private readonly tracer?: CelerityTracer,\n  ) {\n    this.config = config ?? captureSNSConfig();\n  }\n\n  topic(name: string): Topic {\n    return new SNSTopic(name, this.getClient(), this.tracer);\n  }\n\n  close(): void {\n    this.client?.destroy();\n    this.client = null;\n  }\n\n  private getClient(): SNSClient {\n    if (!this.client) {\n      this.client = new SNSClient({\n        region: this.config.region,\n        endpoint: this.config.endpoint,\n        credentials: this.config.credentials,\n      });\n    }\n    return this.client;\n  }\n}\n","import createDebug from \"debug\";\nimport {\n  type SNSClient,\n  PublishCommand,\n  PublishBatchCommand,\n  type MessageAttributeValue,\n  type PublishBatchRequestEntry,\n} from \"@aws-sdk/client-sns\";\nimport type { CelerityTracer, CeleritySpan } from \"@celerity-sdk/types\";\nimport type {\n  Topic,\n  PublishOptions,\n  PublishResult,\n  BatchPublishEntry,\n  BatchPublishResult,\n  BatchPublishSuccess,\n  BatchPublishFailure,\n} from \"../../types\";\nimport { TopicError } from \"../../errors\";\n\nconst debug = createDebug(\"celerity:topic:sns\");\n\nconst SNS_MAX_BATCH_SIZE = 10;\n\nexport class SNSTopic implements Topic {\n  constructor(\n    private readonly topicArn: string,\n    private readonly client: SNSClient,\n    private readonly tracer?: CelerityTracer,\n  ) {}\n\n  async publish<T = Record<string, unknown>>(\n    body: T,\n    options?: PublishOptions,\n  ): Promise<PublishResult> {\n    debug(\"publish %s\", this.topicArn);\n    return this.traced(\"celerity.topic.publish\", { \"topic.arn\": this.topicArn }, async () => {\n      try {\n        const result = await this.client.send(\n          new PublishCommand({\n            TopicArn: this.topicArn,\n            Message: JSON.stringify(body),\n            MessageGroupId: options?.groupId,\n            MessageDeduplicationId: options?.deduplicationId,\n            Subject: options?.subject,\n            MessageAttributes: options?.attributes\n              ? toSNSAttributes(options.attributes)\n              : undefined,\n          }),\n        );\n        return { messageId: result.MessageId! };\n      } catch (error) {\n        throw new TopicError(\n          `Failed to publish message to topic \"${this.topicArn}\"`,\n          this.topicArn,\n          { cause: error },\n        );\n      }\n    });\n  }\n\n  async publishBatch<T = Record<string, unknown>>(\n    entries: BatchPublishEntry<T>[],\n  ): Promise<BatchPublishResult> {\n    debug(\"publishBatch %s (%d entries)\", this.topicArn, entries.length);\n    return this.traced(\n      \"celerity.topic.publish_batch\",\n      { \"topic.arn\": this.topicArn, \"topic.message_count\": entries.length },\n      async () => {\n        const successful: BatchPublishSuccess[] = [];\n        const failed: BatchPublishFailure[] = [];\n\n        // Auto-chunk into groups of 10 (SNS limit)\n        for (let i = 0; i < entries.length; i += SNS_MAX_BATCH_SIZE) {\n          const chunk = entries.slice(i, i + SNS_MAX_BATCH_SIZE);\n          const snsEntries: PublishBatchRequestEntry[] = chunk.map((entry) => ({\n            Id: entry.id,\n            Message: JSON.stringify(entry.body),\n            MessageGroupId: entry.options?.groupId,\n            MessageDeduplicationId: entry.options?.deduplicationId,\n            Subject: entry.options?.subject,\n            MessageAttributes: entry.options?.attributes\n              ? toSNSAttributes(entry.options.attributes)\n              : undefined,\n          }));\n\n          try {\n            const result = await this.client.send(\n              new PublishBatchCommand({\n                TopicArn: this.topicArn,\n                PublishBatchRequestEntries: snsEntries,\n              }),\n            );\n\n            for (const s of result.Successful ?? []) {\n              successful.push({ id: s.Id!, messageId: s.MessageId! });\n            }\n            for (const f of result.Failed ?? []) {\n              failed.push({ id: f.Id!, code: f.Code!, message: f.Message ?? \"Unknown error\" });\n            }\n          } catch (error) {\n            throw new TopicError(\n              `Failed to publish message batch to topic \"${this.topicArn}\"`,\n              this.topicArn,\n              { cause: error },\n            );\n          }\n        }\n\n        return { successful, failed };\n      },\n    );\n  }\n\n  private traced<T>(\n    name: string,\n    attributes: Record<string, string | number | boolean>,\n    fn: (span?: CeleritySpan) => Promise<T>,\n  ): Promise<T> {\n    if (!this.tracer) return fn();\n    return this.tracer.withSpan(name, (span) => fn(span), attributes);\n  }\n}\n\nfunction toSNSAttributes(attrs: Record<string, string>): Record<string, MessageAttributeValue> {\n  const result: Record<string, MessageAttributeValue> = {};\n  for (const [key, value] of Object.entries(attrs)) {\n    result[key] = { DataType: \"String\", StringValue: value };\n  }\n  return result;\n}\n","/**\n * Base error for topic operations. Wraps provider SDK errors and includes\n * the topic identifier for context.\n */\nexport class TopicError extends Error {\n  constructor(\n    message: string,\n    public readonly topic: string,\n    options?: { cause?: unknown },\n  ) {\n    super(message, options);\n    this.name = \"TopicError\";\n  }\n}\n","import type { SNSTopicConfig } from \"./types\";\n\n/**\n * Captures SNS configuration from environment variables.\n * This is the only place that reads `process.env` for SNS config.\n */\nexport function captureSNSConfig(): SNSTopicConfig {\n  return {\n    region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION,\n    endpoint: process.env.AWS_ENDPOINT_URL,\n    credentials:\n      process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY\n        ? {\n            accessKeyId: process.env.AWS_ACCESS_KEY_ID,\n            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,\n          }\n        : undefined,\n  };\n}\n","import { randomUUID } from \"node:crypto\";\nimport createDebug from \"debug\";\nimport type Redis from \"ioredis\";\nimport type { CelerityTracer, CeleritySpan } from \"@celerity-sdk/types\";\nimport type {\n  Topic,\n  PublishOptions,\n  PublishResult,\n  BatchPublishEntry,\n  BatchPublishResult,\n  BatchPublishSuccess,\n  BatchPublishFailure,\n} from \"../../types\";\nimport { TopicError } from \"../../errors\";\n\nconst debug = createDebug(\"celerity:topic:redis\");\n\nexport class RedisTopic implements Topic {\n  constructor(\n    private readonly channelName: string,\n    private readonly client: Redis,\n    private readonly tracer?: CelerityTracer,\n  ) {}\n\n  async publish<T = Record<string, unknown>>(\n    body: T,\n    options?: PublishOptions,\n  ): Promise<PublishResult> {\n    debug(\"publish %s\", this.channelName);\n    return this.traced(\n      \"celerity.topic.publish\",\n      { \"topic.channel\": this.channelName },\n      async () => {\n        try {\n          const messageId = randomUUID();\n          const payload = buildEnvelope(body, messageId, options);\n          await this.client.publish(this.channelName, payload);\n          return { messageId };\n        } catch (error) {\n          throw new TopicError(\n            `Failed to publish message to channel \"${this.channelName}\"`,\n            this.channelName,\n            { cause: error },\n          );\n        }\n      },\n    );\n  }\n\n  async publishBatch<T = Record<string, unknown>>(\n    entries: BatchPublishEntry<T>[],\n  ): Promise<BatchPublishResult> {\n    debug(\"publishBatch %s (%d entries)\", this.channelName, entries.length);\n    return this.traced(\n      \"celerity.topic.publish_batch\",\n      { \"topic.channel\": this.channelName, \"topic.message_count\": entries.length },\n      async () => {\n        const successful: BatchPublishSuccess[] = [];\n        const failed: BatchPublishFailure[] = [];\n\n        const messageIds: string[] = [];\n        const pipeline = this.client.pipeline();\n        for (const entry of entries) {\n          const messageId = randomUUID();\n          messageIds.push(messageId);\n          const payload = buildEnvelope(entry.body, messageId, entry.options);\n          pipeline.publish(this.channelName, payload);\n        }\n\n        try {\n          const results = await pipeline.exec();\n          if (!results) {\n            throw new Error(\"Pipeline returned null\");\n          }\n\n          for (let i = 0; i < entries.length; i++) {\n            const [err] = results[i];\n            if (err) {\n              failed.push({\n                id: entries[i].id,\n                code: err.name ?? \"PipelineError\",\n                message: err.message,\n              });\n            } else {\n              successful.push({\n                id: entries[i].id,\n                messageId: messageIds[i],\n              });\n            }\n          }\n        } catch (error) {\n          throw new TopicError(\n            `Failed to publish message batch to channel \"${this.channelName}\"`,\n            this.channelName,\n            { cause: error },\n          );\n        }\n\n        return { successful, failed };\n      },\n    );\n  }\n\n  private traced<T>(\n    name: string,\n    attributes: Record<string, string | number | boolean>,\n    fn: (span?: CeleritySpan) => Promise<T>,\n  ): Promise<T> {\n    if (!this.tracer) return fn();\n    return this.tracer.withSpan(name, (span) => fn(span), attributes);\n  }\n}\n\n/**\n * Builds the JSON envelope published to the pub/sub channel.\n * The local-events bridge parses this envelope and extracts individual\n * fields when writing to target consumer streams.\n *\n * `messageId`, `subject`, and `attributes` are included in the envelope.\n * `groupId` and `deduplicationId` are silently ignored — ordering is\n * inherent in the single-instance bridge architecture.\n */\nfunction buildEnvelope<T>(body: T, messageId: string, options?: PublishOptions): string {\n  const envelope: Record<string, unknown> = {\n    body: JSON.stringify(body),\n    messageId,\n  };\n\n  if (options?.subject) {\n    envelope.subject = options.subject;\n  }\n  if (options?.attributes && Object.keys(options.attributes).length > 0) {\n    envelope.attributes = options.attributes;\n  }\n\n  return JSON.stringify(envelope);\n}\n","import type { RedisTopicConfig } from \"./types\";\n\nconst DEFAULT_REDIS_URL = \"redis://localhost:6379\";\n\n/**\n * Captures Redis configuration from environment variables.\n * This is the only place that reads `process.env` for Redis config.\n */\nexport function captureRedisConfig(): RedisTopicConfig {\n  return {\n    url: process.env.CELERITY_LOCAL_REDIS_URL ?? DEFAULT_REDIS_URL,\n  };\n}\n","import type { CelerityTracer } from \"@celerity-sdk/types\";\nimport type { TopicClient, Topic } from \"../../types\";\nimport { RedisTopic } from \"./redis-topic\";\nimport type { RedisTopicConfig } from \"./types\";\nimport { captureRedisConfig } from \"./config\";\n\nexport class RedisTopicClient implements TopicClient {\n  private client: import(\"ioredis\").default | null = null;\n  private readonly config: RedisTopicConfig;\n\n  constructor(\n    config?: RedisTopicConfig,\n    private readonly tracer?: CelerityTracer,\n  ) {\n    this.config = config ?? captureRedisConfig();\n  }\n\n  topic(name: string): Topic {\n    return new RedisTopic(name, this.getClient(), this.tracer);\n  }\n\n  async close(): Promise<void> {\n    if (this.client) {\n      await this.client.quit();\n      this.client = null;\n    }\n  }\n\n  private getClient(): import(\"ioredis\").default {\n    if (!this.client) {\n      // Dynamic require to avoid bundling ioredis when not used.\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const Redis = require(\"ioredis\").default ?? require(\"ioredis\");\n      this.client = new Redis(this.config.url);\n    }\n    return this.client!;\n  }\n}\n","import { resolveConfig } from \"@celerity-sdk/config\";\nimport type { CelerityTracer } from \"@celerity-sdk/types\";\nimport type { TopicClient } from \"./types\";\nimport type { SNSTopicConfig } from \"./providers/sns/types\";\nimport type { RedisTopicConfig } from \"./providers/redis/types\";\nimport { SNSTopicClient } from \"./providers/sns/sns-topic-client\";\nimport { RedisTopicClient } from \"./providers/redis/redis-topic-client\";\n\nexport type CreateTopicClientOptions = {\n  /** Override provider selection. If omitted, derived from platform config. */\n  provider?: \"aws\" | \"local\" | \"gcp\" | \"azure\";\n  /** SNS-specific configuration overrides. */\n  aws?: SNSTopicConfig;\n  /** Redis-specific configuration overrides (local environment). */\n  local?: RedisTopicConfig;\n  /** Optional tracer for Celerity-level span instrumentation. */\n  tracer?: CelerityTracer;\n};\n\nexport function createTopicClient(options?: CreateTopicClientOptions): TopicClient {\n  const resolved = resolveConfig(\"topic\");\n  const provider = options?.provider ?? resolved.provider;\n\n  switch (provider) {\n    case \"aws\":\n      return new SNSTopicClient(options?.aws, options?.tracer);\n    // Local environments always use Redis pub/sub regardless of deploy target.\n    // The Celerity CLI manages the Redis instance and local-events sidecar.\n    case \"local\":\n      return new RedisTopicClient(options?.local, options?.tracer);\n    // case \"gcp\":\n    //   v1: Google Cloud Pub/Sub\n    // case \"azure\":\n    //   v1: Azure Service Bus Topics\n    default:\n      throw new Error(`Unsupported topic provider: \"${provider}\"`);\n  }\n}\n","import \"reflect-metadata\";\nimport { INJECT_METADATA, USE_RESOURCE_METADATA } from \"@celerity-sdk/common\";\nimport type { Topic as TopicType } from \"./types\";\n\n// Re-declare as interface so the type merges with the decorator function below.\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface Topic extends TopicType {}\n\nexport function topicToken(resourceName: string): symbol {\n  return Symbol.for(`celerity:topic:${resourceName}`);\n}\n\nexport const DEFAULT_TOPIC_TOKEN = Symbol.for(\"celerity:topic:default\");\n\n/**\n * Parameter decorator that injects a {@link Topic} instance for the given\n * blueprint resource. Writes both DI injection metadata and CLI resource-ref\n * metadata using well-known `Symbol.for()` keys (no dependency on core).\n *\n * When `resourceName` is omitted, the default topic token is used — this\n * auto-resolves when exactly one topic resource exists.\n *\n * @example\n * ```ts\n * @Controller(\"/orders\")\n * class OrderController {\n *   constructor(@Topic(\"orderEvents\") private events: Topic) {}\n * }\n * ```\n */\nexport function Topic(resourceName?: string): ParameterDecorator {\n  return (target, _propertyKey, parameterIndex) => {\n    const token = resourceName ? topicToken(resourceName) : DEFAULT_TOPIC_TOKEN;\n    const existing: Map<number, unknown> =\n      Reflect.getOwnMetadata(INJECT_METADATA, target) ?? new Map();\n    existing.set(parameterIndex, token);\n    Reflect.defineMetadata(INJECT_METADATA, existing, target);\n\n    if (resourceName) {\n      const resources: string[] = Reflect.getOwnMetadata(USE_RESOURCE_METADATA, target) ?? [];\n      if (!resources.includes(resourceName)) {\n        Reflect.defineMetadata(USE_RESOURCE_METADATA, [...resources, resourceName], target);\n      }\n    }\n  };\n}\n","import type { ServiceContainer } from \"@celerity-sdk/types\";\nimport type { Topic } from \"./types\";\nimport { topicToken, DEFAULT_TOPIC_TOKEN } from \"./decorators\";\n\n/**\n * Resolves a {@link Topic} instance from the DI container.\n * For function-based handlers where parameter decorators aren't available.\n *\n * @param container - The service container (typically `context.container`).\n * @param resourceName - The blueprint resource name. Omit when exactly one\n *   topic resource exists to use the default.\n *\n * @example\n * ```ts\n * const handler = createHttpHandler(async (req, ctx) => {\n *   const events = await getTopic(ctx.container, \"orderEvents\");\n *   await events.publish({ orderId: \"123\", action: \"created\" });\n * });\n * ```\n */\nexport function getTopic(container: ServiceContainer, resourceName?: string): Promise<Topic> {\n  const token = resourceName ? topicToken(resourceName) : DEFAULT_TOPIC_TOKEN;\n  return container.resolve<Topic>(token);\n}\n","import createDebug from \"debug\";\nimport type { CelerityLayer, BaseHandlerContext, CelerityTracer } from \"@celerity-sdk/types\";\nimport { TRACER_TOKEN, CONFIG_SERVICE_TOKEN } from \"@celerity-sdk/common\";\nimport {\n  type ConfigService,\n  captureResourceLinks,\n  getLinksOfType,\n  RESOURCE_CONFIG_NAMESPACE,\n} from \"@celerity-sdk/config\";\nimport { createTopicClient } from \"./factory\";\nimport { topicToken, DEFAULT_TOPIC_TOKEN } from \"./decorators\";\n\nconst debug = createDebug(\"celerity:topic\");\n\n/**\n * System layer that auto-registers {@link TopicClient} and per-resource\n * {@link Topic} handles in the DI container.\n *\n * Reads resource link topology from `CELERITY_RESOURCE_LINKS` and resolves\n * actual topic ARNs / channel names from the ConfigService \"resources\" namespace.\n * Must run after ConfigLayer in the layer pipeline.\n */\nexport class TopicLayer implements CelerityLayer<BaseHandlerContext> {\n  private initialized = false;\n\n  async handle(context: BaseHandlerContext, next: () => Promise<unknown>): Promise<unknown> {\n    if (!this.initialized) {\n      const tracer = context.container.has(TRACER_TOKEN)\n        ? await context.container.resolve<CelerityTracer>(TRACER_TOKEN)\n        : undefined;\n\n      const client = createTopicClient({ tracer });\n      debug(\"registering TopicClient\");\n      context.container.register(\"TopicClient\", { useValue: client });\n\n      const links = captureResourceLinks();\n      const topicLinks = getLinksOfType(links, \"topic\");\n\n      if (topicLinks.size > 0) {\n        const configService = await context.container.resolve<ConfigService>(CONFIG_SERVICE_TOKEN);\n        const resourceConfig = configService.namespace(RESOURCE_CONFIG_NAMESPACE);\n\n        for (const [resourceName, configKey] of topicLinks) {\n          const actualName = await resourceConfig.getOrThrow(configKey);\n          debug(\"registered topic resource %s → %s\", resourceName, actualName);\n          context.container.register(topicToken(resourceName), {\n            useValue: client.topic(actualName),\n          });\n        }\n\n        if (topicLinks.size === 1) {\n          const [, configKey] = [...topicLinks.entries()][0];\n          const actualName = await resourceConfig.getOrThrow(configKey);\n          debug(\"registered default topic → %s\", actualName);\n          context.container.register(DEFAULT_TOPIC_TOKEN, {\n            useValue: client.topic(actualName),\n          });\n        }\n      }\n\n      this.initialized = true;\n    }\n\n    return next();\n  }\n}\n"],"mappings":"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","names":["TopicClient","Symbol","for","import_client_sns","TopicError","Error","message","topic","options","name","debug","createDebug","SNS_MAX_BATCH_SIZE","SNSTopic","topicArn","client","tracer","publish","body","options","traced","result","send","PublishCommand","TopicArn","Message","JSON","stringify","MessageGroupId","groupId","MessageDeduplicationId","deduplicationId","Subject","subject","MessageAttributes","attributes","toSNSAttributes","undefined","messageId","MessageId","error","TopicError","cause","publishBatch","entries","length","successful","failed","i","chunk","slice","snsEntries","map","entry","Id","id","PublishBatchCommand","PublishBatchRequestEntries","s","Successful","push","f","Failed","code","Code","message","name","fn","withSpan","span","attrs","key","value","Object","DataType","StringValue","captureSNSConfig","region","process","env","AWS_REGION","AWS_DEFAULT_REGION","endpoint","AWS_ENDPOINT_URL","credentials","AWS_ACCESS_KEY_ID","AWS_SECRET_ACCESS_KEY","accessKeyId","secretAccessKey","undefined","SNSTopicClient","client","config","tracer","captureSNSConfig","topic","name","SNSTopic","getClient","close","destroy","SNSClient","region","endpoint","credentials","import_debug","debug","createDebug","RedisTopic","channelName","client","tracer","publish","body","options","traced","messageId","randomUUID","payload","buildEnvelope","error","TopicError","cause","publishBatch","entries","length","successful","failed","messageIds","pipeline","entry","push","results","exec","Error","i","err","id","code","name","message","attributes","fn","withSpan","span","envelope","JSON","stringify","subject","Object","keys","DEFAULT_REDIS_URL","captureRedisConfig","url","process","env","CELERITY_LOCAL_REDIS_URL","RedisTopicClient","client","config","tracer","captureRedisConfig","topic","name","RedisTopic","getClient","close","quit","Redis","require","default","url","import_config","createTopicClient","options","resolved","resolveConfig","provider","SNSTopicClient","aws","tracer","RedisTopicClient","local","Error","topicToken","resourceName","Symbol","for","DEFAULT_TOPIC_TOKEN","Topic","target","_propertyKey","parameterIndex","token","existing","Reflect","getOwnMetadata","INJECT_METADATA","Map","set","defineMetadata","resources","USE_RESOURCE_METADATA","includes","getTopic","container","resourceName","token","topicToken","DEFAULT_TOPIC_TOKEN","resolve","import_debug","import_common","import_config","debug","createDebug","TopicLayer","initialized","handle","context","next","tracer","container","has","TRACER_TOKEN","resolve","undefined","client","createTopicClient","register","useValue","links","captureResourceLinks","topicLinks","getLinksOfType","size","configService","CONFIG_SERVICE_TOKEN","resourceConfig","namespace","RESOURCE_CONFIG_NAMESPACE","resourceName","configKey","actualName","getOrThrow","topicToken","topic","entries","DEFAULT_TOPIC_TOKEN"]}