alepha 0.12.1 → 0.13.1

package/dist/topic/index.d.cts

@@ -1,523 +0,0 @@
-import * as alepha1 from "alepha";
-import { Alepha, Descriptor, KIND, Service, Static, TSchema } from "alepha";
-import * as alepha_logger0 from "alepha/logger";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-
-//#region src/topic/providers/TopicProvider.d.ts
-/**
- * Base class for topic providers.
- */
-declare abstract class TopicProvider {
-  protected readonly alepha: Alepha;
-  /**
-   * Publish a message to a topic.
-   *
-   * @param topic - The topic to publish to.
-   * @param message - The message to publish.
-   */
-  abstract publish(topic: string, message: string): Promise<void>;
-  /**
-   * Subscribe to a topic.
-   *
-   * @param topic - The topic to subscribe to.
-   * @param callback - The callback to call when a message is received.
-   */
-  abstract subscribe(topic: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
-  /**
-   * Unsubscribe from a topic.
-   *
-   * @param topic - The topic to unsubscribe from.
-   */
-  abstract unsubscribe(topic: string): Promise<void>;
-  /**
-   * Returns the list of $subscribers for this provider.
-   */
-  protected subscribers(): Array<() => Promise<unknown>>;
-}
-type SubscribeCallback = (message: string) => Promise<void> | void;
-type UnSubscribeFn = () => Promise<void>;
-//#endregion
-//#region src/topic/descriptors/$topic.d.ts
-/**
- * Creates a topic descriptor for publish/subscribe messaging and event-driven architecture.
- *
- * Enables decoupled communication through a pub/sub pattern where publishers send messages
- * and multiple subscribers receive them. Supports type-safe messages, real-time delivery,
- * event filtering, and pluggable backends (memory, Redis, custom providers).
- *
- * **Use Cases**: User notifications, real-time chat, event broadcasting, microservice communication
- *
- * @example
- * ```ts
- * class NotificationService {
- *   userActivity = $topic({
- *     name: "user-activity",
- *     schema: {
- *       payload: t.object({
- *         userId: t.text(),
- *         action: t.enum(["login", "logout", "purchase"]),
- *         timestamp: t.number()
- *       })
- *     },
- *     handler: async (message) => {
- *       console.log(`User ${message.payload.userId}: ${message.payload.action}`);
- *     }
- *   });
- *
- *   async trackLogin(userId: string) {
- *     await this.userActivity.publish({ userId, action: "login", timestamp: Date.now() });
- *   }
- *
- *   async subscribeToEvents() {
- *     await this.userActivity.subscribe(async (message) => {
- *       // Additional subscriber logic
- *     });
- *   }
- * }
- * ```
- */
-declare const $topic: {
-  <T extends TopicMessageSchema>(options: TopicDescriptorOptions<T>): TopicDescriptor<T>;
-  [KIND]: typeof TopicDescriptor;
-};
-interface TopicDescriptorOptions<T extends TopicMessageSchema> {
-  /**
-   * Unique name identifier for the topic.
-   *
-   * This name is used for:
-   * - Topic identification across the pub/sub system
-   * - Message routing between publishers and subscribers
-   * - Logging and debugging topic-related operations
-   * - Provider-specific topic management (channels, keys, etc.)
-   *
-   * If not provided, defaults to the property key where the topic is declared.
-   *
-   * **Naming Conventions**:
-   * - Use descriptive, hierarchical names: "user.activity", "order.events"
-   * - Avoid spaces and special characters
-   * - Consider using dot notation for categorization
-   * - Keep names concise but meaningful
-   *
-   * @example "user-activity"
-   * @example "chat.messages"
-   * @example "system.health.checks"
-   * @example "payment.webhooks"
-   */
-  name?: string;
-  /**
-   * Human-readable description of the topic's purpose and usage.
-   *
-   * Used for:
-   * - Documentation generation and API references
-   * - Developer onboarding and understanding
-   * - Monitoring dashboards and admin interfaces
-   * - Team communication about system architecture
-   *
-   * **Description Best Practices**:
-   * - Explain what events/messages this topic handles
-   * - Mention key use cases and subscribers
-   * - Include any important timing or ordering guarantees
-   * - Note any special processing requirements
-   *
-   * @example "Real-time user activity events for analytics and notifications"
-   * @example "Order lifecycle events from creation to delivery"
-   * @example "Chat messages broadcast to all room participants"
-   * @example "System health checks and service status updates"
-   */
-  description?: string;
-  /**
-   * Topic provider configuration for message storage and delivery.
-   *
-   * Options:
-   * - **"memory"**: In-memory provider (default for development, lost on restart)
-   * - **Service<TopicProvider>**: Custom provider class (e.g., RedisTopicProvider)
-   * - **undefined**: Uses the default topic provider from dependency injection
-   *
-   * **Provider Selection Guidelines**:
-   * - **Development**: Use "memory" for fast, simple testing without external dependencies
-   * - **Production**: Use Redis or message brokers for persistence and scalability
-   * - **Distributed systems**: Use Redis/RabbitMQ for cross-service communication
-   * - **High-throughput**: Use specialized providers with connection pooling
-   * - **Real-time**: Ensure provider supports low-latency message delivery
-   *
-   * **Provider Capabilities**:
-   * - Message persistence and durability
-   * - Subscriber management and connection handling
-   * - Message ordering and delivery guarantees
-   * - Horizontal scaling and load distribution
-   *
-   * @default Uses injected TopicProvider
-   * @example "memory"
-   * @example RedisTopicProvider
-   * @example RabbitMQTopicProvider
-   */
-  provider?: "memory" | Service<TopicProvider>;
-  /**
-   * TypeBox schema defining the structure of messages published to this topic.
-   *
-   * The schema must include:
-   * - **payload**: Required schema for the main message data
-   * - **headers**: Optional schema for message metadata
-   *
-   * This schema:
-   * - Validates all messages published to the topic
-   * - Provides full TypeScript type inference for subscribers
-   * - Ensures type safety between publishers and subscribers
-   * - Enables automatic serialization/deserialization
-   *
-   * **Schema Design Best Practices**:
-   * - Keep payload schemas focused and cohesive
-   * - Use optional fields for data that might not always be present
-   * - Include timestamp fields for event ordering
-   * - Consider versioning for schema evolution
-   * - Use union types for different event types in the same topic
-   *
-   * @example
-   * ```ts
-   * {
-   *   payload: t.object({
-   *     eventId: t.text(),
-   *     eventType: t.enum(["created", "updated"]),
-   *     data: t.record(t.text(), t.any()),
-   *     timestamp: t.number(),
-   *     userId: t.optional(t.text())
-   *   }),
-   *   headers: t.optional(t.object({
-   *     source: t.text(),
-   *     correlationId: t.text()
-   *   }))
-   * }
-   * ```
-   */
-  schema: T;
-  /**
-   * Default subscriber handler function that processes messages published to this topic.
-   *
-   * This handler:
-   * - Automatically subscribes when the topic is initialized
-   * - Receives all messages published to the topic
-   * - Runs for every message without additional subscription setup
-   * - Can be supplemented with additional subscribers via `subscribe()` method
-   * - Should handle errors gracefully to avoid breaking other subscribers
-   *
-   * **Handler Design Guidelines**:
-   * - Keep handlers focused on a single responsibility
-   * - Use proper error handling and logging
-   * - Consider performance impact for high-frequency topics
-   * - Make handlers idempotent when possible
-   * - Validate business rules within the handler logic
-   * - Log important processing steps for debugging
-   *
-   * **Error Handling Strategy**:
-   * - Log errors but don't re-throw to avoid affecting other subscribers
-   * - Use try-catch blocks for external service calls
-   * - Consider implementing circuit breakers for resilience
-   * - Monitor error rates and patterns for system health
-   *
-   * @param message - The topic message with validated payload and headers
-   * @param message.payload - The typed message data based on the schema
-   * @returns Promise that resolves when processing is complete
-   *
-   * @example
-   * ```ts
-   * handler: async (message) => {
-   *   const { eventType, data, timestamp } = message.payload;
-   *
-   *   try {
-   *     // Log message receipt
-   *     this.logger.info(`Processing ${eventType} event`, { timestamp, data });
-   *
-   *     // Process based on event type
-   *     switch (eventType) {
-   *       case "created":
-   *         await this.handleCreation(data);
-   *         break;
-   *       case "updated":
-   *         await this.handleUpdate(data);
-   *         break;
-   *       default:
-   *         this.logger.warn(`Unknown event type: ${eventType}`);
-   *     }
-   *
-   *     this.logger.info(`Successfully processed ${eventType} event`);
-   *
-   *   } catch (error) {
-   *     // Log error but don't re-throw to avoid affecting other subscribers
-   *     this.logger.error(`Failed to process ${eventType} event`, {
-   *       error: error.message,
-   *       eventType,
-   *       timestamp,
-   *       data
-   *     });
-   *   }
-   * }
-   * ```
-   */
-  handler?: TopicHandler<T>;
-}
-declare class TopicDescriptor<T extends TopicMessageSchema> extends Descriptor<TopicDescriptorOptions<T>> {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  readonly provider: TopicProvider;
-  get name(): string;
-  publish(payload: TopicMessage<T>["payload"]): Promise<void>;
-  subscribe(handler: TopicHandler<T>): Promise<UnSubscribeFn>;
-  wait(options?: TopicWaitOptions<T>): Promise<TopicMessage<T>>;
-  protected $provider(): TopicProvider;
-  protected parseMessage(message: string): TopicMessage<T>;
-}
-interface TopicMessage<T extends TopicMessageSchema> {
-  payload: Static<T["payload"]>;
-}
-interface TopicWaitOptions<T extends TopicMessageSchema> {
-  timeout?: DurationLike;
-  filter?: (message: {
-    payload: Static<T["payload"]>;
-  }) => boolean;
-}
-interface TopicMessageSchema {
-  payload: TSchema;
-}
-type TopicHandler<T extends TopicMessageSchema = TopicMessageSchema> = (message: TopicMessage<T>) => unknown;
-//#endregion
-//#region src/topic/descriptors/$subscriber.d.ts
-/**
- * Creates a subscriber descriptor to listen for messages from a specific topic.
- *
- * Provides a dedicated message subscriber that connects to a topic and processes messages
- * with custom handler logic, enabling scalable pub/sub architectures where multiple
- * subscribers can react to the same events independently.
- *
- * **Key Features**
- * - Seamless integration with any $topic descriptor
- * - Full type safety inherited from topic schema
- * - Real-time message delivery when events are published
- * - Error isolation between subscribers
- * - Support for multiple independent subscribers per topic
- *
- * **Common Use Cases**
- * - Notification services and audit logging
- * - Analytics and metrics collection
- * - Data synchronization and real-time UI updates
- *
- * @example
- * ```ts
- * class UserActivityService {
- *   userEvents = $topic({
- *     name: "user-activity",
- *     schema: {
- *       payload: t.object({
- *         userId: t.text(),
- *         action: t.enum(["login", "logout", "purchase"]),
- *         timestamp: t.number()
- *       })
- *     }
- *   });
- *
- *   activityLogger = $subscriber({
- *     topic: this.userEvents,
- *     handler: async (message) => {
- *       const { userId, action, timestamp } = message.payload;
- *       await this.auditLogger.log({
- *         userId,
- *         action,
- *         timestamp
- *       });
- *     }
- *   });
- *
- *   async trackUserLogin(userId: string) {
- *     await this.userEvents.publish({
- *       userId,
- *       action: "login",
- *       timestamp: Date.now()
- *     });
- *   }
- * }
- * ```
- */
-declare const $subscriber: {
-  <T extends TopicMessageSchema>(options: SubscriberDescriptorOptions<T>): SubscriberDescriptor<T>;
-  [KIND]: typeof SubscriberDescriptor;
-};
-interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
-  /**
-   * The topic descriptor that this subscriber will listen to for messages.
-   *
-   * This establishes the connection between the subscriber and its source topic:
-   * - The subscriber inherits the topic's message schema for type safety
-   * - Messages published to the topic will be automatically delivered to this subscriber
-   * - Multiple subscribers can listen to the same topic independently
-   * - The subscriber will use the topic's provider and configuration settings
-   *
-   * **Topic Integration Benefits**:
-   * - Type safety: Subscriber handler gets fully typed message payloads
-   * - Schema validation: Messages are validated before reaching the subscriber
-   * - Real-time delivery: Messages are delivered immediately upon publication
-   * - Error isolation: Subscriber errors don't affect the topic or other subscribers
-   * - Monitoring: Topic metrics include subscriber processing statistics
-   *
-   * @example
-   * ```ts
-   * // First, define a topic
-   * userEvents = $topic({
-   *   name: "user-activity",
-   *   schema: {
-   *     payload: t.object({ userId: t.text(), action: t.text() })
-   *   }
-   * });
-   *
-   * // Then, create a subscriber for that topic
-   * activitySubscriber = $subscriber({
-   *   topic: this.userEvents,  // Reference the topic descriptor
-   *   handler: async (message) => { } // Process messages here
-   * });
-   * ```
-   */
-  topic: TopicDescriptor<T>;
-  /**
-   * Message handler function that processes individual messages from the topic.
-   *
-   * This function:
-   * - Receives fully typed and validated message payloads from the connected topic
-   * - Executes immediately when messages are published to the topic
-   * - Should implement the core business logic for reacting to these events
-   * - Runs independently of other subscribers to the same topic
-   * - Should handle errors gracefully to avoid affecting other subscribers
-   * - Has access to the full Alepha dependency injection container
-   *
-   * **Handler Design Guidelines**:
-   * - Keep handlers focused on a single responsibility
-   * - Use proper error handling and logging
-   * - Consider performance impact for high-frequency topics
-   * - Make handlers idempotent when possible for reliability
-   * - Validate business rules within the handler logic
-   * - Log important processing steps for debugging and monitoring
-   *
-   * **Error Handling Strategy**:
-   * - Log errors but don't re-throw to avoid affecting other subscribers
-   * - Use try-catch blocks for external service calls
-   * - Implement circuit breakers for resilience with external systems
-   * - Monitor error rates and patterns for system health
-   * - Consider implementing retry logic for temporary failures
-   *
-   * **Performance Considerations**:
-   * - Keep handler execution time minimal for high-throughput topics
-   * - Use background queues for heavy processing triggered by events
-   * - Implement batching for efficiency when processing many similar events
-   * - Consider async processing patterns for non-critical operations
-   *
-   * @param message - The topic message with validated payload and optional headers
-   * @param message.payload - The typed message data based on the topic's schema
-   * @returns Promise that resolves when processing is complete
-   *
-   * @example
-   * ```ts
-   * handler: async (message) => {
-   *   const { userId, eventType, timestamp } = message.payload;
-   *
-   *   try {
-   *     // Log event receipt
-   *     this.logger.info(`Processing ${eventType} event for user ${userId}`, {
-   *       timestamp,
-   *       userId,
-   *       eventType
-   *     });
-   *
-   *     // Perform event-specific processing
-   *     switch (eventType) {
-   *       case 'user.login':
-   *         await this.updateLastLogin(userId, timestamp);
-   *         await this.sendWelcomeNotification(userId);
-   *         break;
-   *       case 'user.logout':
-   *         await this.updateSessionDuration(userId, timestamp);
-   *         break;
-   *       case 'user.purchase':
-   *         await this.updateRewardsPoints(userId, message.payload.purchaseAmount);
-   *         await this.triggerRecommendations(userId);
-   *         break;
-   *       default:
-   *         this.logger.warn(`Unknown event type: ${eventType}`);
-   *     }
-   *
-   *     // Update analytics
-   *     await this.analytics.track(eventType, {
-   *       userId,
-   *       timestamp,
-   *       source: 'topic-subscriber'
-   *     });
-   *
-   *     this.logger.info(`Successfully processed ${eventType} for user ${userId}`);
-   *
-   *   } catch (error) {
-   *     // Log error but don't re-throw to avoid affecting other subscribers
-   *     this.logger.error(`Failed to process ${eventType} for user ${userId}`, {
-   *       error: error.message,
-   *       stack: error.stack,
-   *       userId,
-   *       eventType,
-   *       timestamp
-   *     });
-   *
-   *     // Optionally send to error tracking service
-   *     await this.errorTracker.captureException(error, {
-   *       context: { userId, eventType, timestamp },
-   *       tags: { component: 'topic-subscriber' }
-   *     });
-   *   }
-   * }
-   * ```
-   */
-  handler: TopicHandler<T>;
-}
-declare class SubscriberDescriptor<T extends TopicMessageSchema> extends Descriptor<SubscriberDescriptorOptions<T>> {}
-//#endregion
-//#region src/topic/errors/TopicTimeoutError.d.ts
-declare class TopicTimeoutError extends Error {
-  readonly topic: string;
-  readonly timeout: number;
-  constructor(topic: string, timeout: number);
-}
-//#endregion
-//#region src/topic/providers/MemoryTopicProvider.d.ts
-declare class MemoryTopicProvider extends TopicProvider {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly subscriptions: Record<string, SubscribeCallback[]>;
-  protected readonly start: alepha1.HookDescriptor<"start">;
-  /**
-   * Publish a message to a topic.
-   *
-   * @param topic
-   * @param message
-   */
-  publish(topic: string, message: string): Promise<void>;
-  /**
-   * Subscribe to a topic.
-   *
-   * @param topic - The topic to subscribe to.
-   * @param callback
-   */
-  subscribe(topic: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
-  /**
-   * Unsubscribe from a topic.
-   *
-   * @param topic - The topic to unsubscribe from.
-   */
-  unsubscribe(topic: string): Promise<void>;
-}
-//#endregion
-//#region src/topic/index.d.ts
-/**
- * Generic interface for pub/sub messaging.
- * Gives you the ability to create topics and subscribers.
- * This module provides only a memory implementation of the topic provider.
- *
- * @see {@link $topic}
- * @see {@link $subscriber}
- * @module alepha.topic
- */
-declare const AlephaTopic: alepha1.Service<alepha1.Module>;
-//#endregion
-export { $subscriber, $topic, AlephaTopic, MemoryTopicProvider, SubscribeCallback, SubscriberDescriptor, SubscriberDescriptorOptions, TopicDescriptor, TopicDescriptorOptions, TopicHandler, TopicMessage, TopicMessageSchema, TopicProvider, TopicTimeoutError, TopicWaitOptions, UnSubscribeFn };
-//# sourceMappingURL=index.d.cts.map

package/dist/topic-redis/index.cjs

@@ -1,71 +0,0 @@
-let alepha = require("alepha");
-let alepha_topic = require("alepha/topic");
-let alepha_logger = require("alepha/logger");
-let alepha_redis = require("alepha/redis");
-
-//#region src/topic-redis/providers/RedisTopicProvider.ts
-const envSchema = alepha.t.object({ REDIS_TOPIC_PREFIX: alepha.t.text({ default: "topic" }) });
-var RedisTopicProvider = class extends alepha_topic.TopicProvider {
-	env = (0, alepha.$env)(envSchema);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	redisProvider = (0, alepha.$inject)(alepha_redis.RedisProvider);
-	redisSubscriberProvider = (0, alepha.$inject)(alepha_redis.RedisSubscriberProvider);
-	log = (0, alepha_logger.$logger)();
-	start = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			const subscribers = this.subscribers();
-			if (subscribers.length) {
-				await Promise.all(subscribers.map((fn) => fn()));
-				for (const subscriber of subscribers) this.log.debug(`Subscribed to topic '${subscriber.name}'`);
-			}
-		}
-	});
-	prefix(queue) {
-		return `${this.env.REDIS_TOPIC_PREFIX}:${queue}`;
-	}
-	/**
-	* Publish a message to a topic.
-	*/
-	async publish(topic, message) {
-		await this.redisProvider.publisher.publish(this.prefix(topic), message);
-	}
-	/**
-	* Subscribe to a topic.
-	*/
-	async subscribe(name, callback) {
-		const topic = this.prefix(name);
-		await this.redisSubscriberProvider.subscriber.subscribe(topic, callback);
-		return () => this.unsubscribe(name, callback);
-	}
-	/**
-	* Unsubscribe from a topic.
-	*/
-	async unsubscribe(name, callback) {
-		const topic = this.prefix(name);
-		await this.redisSubscriberProvider.subscriber.unsubscribe(topic, callback);
-	}
-};
-
-//#endregion
-//#region src/topic-redis/index.ts
-/**
-* Plugin for Alepha Topic that provides Redis pub/sub capabilities.
-*
-* @see {@link RedisTopicProvider}
-* @module alepha.topic.redis
-*/
-const AlephaTopicRedis = (0, alepha.$module)({
-	name: "alepha.topic.redis",
-	services: [RedisTopicProvider],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: alepha_topic.TopicProvider,
-		use: RedisTopicProvider
-	}).with(alepha_topic.AlephaTopic)
-});
-
-//#endregion
-exports.AlephaTopicRedis = AlephaTopicRedis;
-exports.RedisTopicProvider = RedisTopicProvider;
-//# sourceMappingURL=index.cjs.map

package/dist/topic-redis/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["t","TopicProvider","Alepha","RedisProvider","RedisSubscriberProvider","alepha","TopicProvider","AlephaTopic"],"sources":["../../src/topic-redis/providers/RedisTopicProvider.ts","../../src/topic-redis/index.ts"],"sourcesContent":["import { $env, $hook, $inject, Alepha, t } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport { RedisProvider, RedisSubscriberProvider } from \"alepha/redis\";\nimport {\n  type SubscribeCallback,\n  TopicProvider,\n  type UnSubscribeFn,\n} from \"alepha/topic\";\n\nconst envSchema = t.object({\n  REDIS_TOPIC_PREFIX: t.text({\n    default: \"topic\",\n  }),\n});\n\nexport class RedisTopicProvider extends TopicProvider {\n  protected readonly env = $env(envSchema);\n  protected readonly alepha = $inject(Alepha);\n  protected readonly redisProvider = $inject(RedisProvider);\n  protected readonly redisSubscriberProvider = $inject(RedisSubscriberProvider);\n\n  protected readonly log = $logger();\n\n  protected readonly start = $hook({\n    on: \"start\",\n    handler: async () => {\n      const subscribers = this.subscribers();\n      if (subscribers.length) {\n        await Promise.all(subscribers.map((fn) => fn()));\n        for (const subscriber of subscribers) {\n          this.log.debug(`Subscribed to topic '${subscriber.name}'`);\n        }\n      }\n    },\n  });\n\n  public prefix(queue: string): string {\n    return `${this.env.REDIS_TOPIC_PREFIX}:${queue}`;\n  }\n\n  /**\n   * Publish a message to a topic.\n   */\n  public async publish(topic: string, message: string): Promise<void> {\n    await this.redisProvider.publisher.publish(this.prefix(topic), message);\n  }\n\n  /**\n   * Subscribe to a topic.\n   */\n  public async subscribe(\n    name: string,\n    callback: SubscribeCallback,\n  ): Promise<UnSubscribeFn> {\n    const topic = this.prefix(name);\n    await this.redisSubscriberProvider.subscriber.subscribe(topic, callback);\n\n    return () => this.unsubscribe(name, callback);\n  }\n\n  /**\n   * Unsubscribe from a topic.\n   */\n  public async unsubscribe(\n    name: string,\n    callback?: SubscribeCallback,\n  ): Promise<void> {\n    const topic = this.prefix(name);\n\n    await this.redisSubscriberProvider.subscriber.unsubscribe(topic, callback);\n  }\n}\n","import { $module, type Alepha } from \"alepha\";\nimport { AlephaTopic, TopicProvider } from \"alepha/topic\";\nimport { RedisTopicProvider } from \"./providers/RedisTopicProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/RedisTopicProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Topic that provides Redis pub/sub capabilities.\n *\n * @see {@link RedisTopicProvider}\n * @module alepha.topic.redis\n */\nexport const AlephaTopicRedis = $module({\n  name: \"alepha.topic.redis\",\n  services: [RedisTopicProvider],\n  register: (alepha: Alepha): Alepha =>\n    alepha\n      .with({\n        optional: true,\n        provide: TopicProvider,\n        use: RedisTopicProvider,\n      })\n      .with(AlephaTopic),\n});\n"],"mappings":";;;;;;AASA,MAAM,YAAYA,SAAE,OAAO,EACzB,oBAAoBA,SAAE,KAAK,EACzB,SAAS,SACV,CAAC,EACH,CAAC;AAEF,IAAa,qBAAb,cAAwCC,2BAAc;CACpD,AAAmB,uBAAW,UAAU;CACxC,AAAmB,6BAAiBC,cAAO;CAC3C,AAAmB,oCAAwBC,2BAAc;CACzD,AAAmB,8CAAkCC,qCAAwB;CAE7E,AAAmB,kCAAe;CAElC,AAAmB,0BAAc;EAC/B,IAAI;EACJ,SAAS,YAAY;GACnB,MAAM,cAAc,KAAK,aAAa;AACtC,OAAI,YAAY,QAAQ;AACtB,UAAM,QAAQ,IAAI,YAAY,KAAK,OAAO,IAAI,CAAC,CAAC;AAChD,SAAK,MAAM,cAAc,YACvB,MAAK,IAAI,MAAM,wBAAwB,WAAW,KAAK,GAAG;;;EAIjE,CAAC;CAEF,AAAO,OAAO,OAAuB;AACnC,SAAO,GAAG,KAAK,IAAI,mBAAmB,GAAG;;;;;CAM3C,MAAa,QAAQ,OAAe,SAAgC;AAClE,QAAM,KAAK,cAAc,UAAU,QAAQ,KAAK,OAAO,MAAM,EAAE,QAAQ;;;;;CAMzE,MAAa,UACX,MACA,UACwB;EACxB,MAAM,QAAQ,KAAK,OAAO,KAAK;AAC/B,QAAM,KAAK,wBAAwB,WAAW,UAAU,OAAO,SAAS;AAExE,eAAa,KAAK,YAAY,MAAM,SAAS;;;;;CAM/C,MAAa,YACX,MACA,UACe;EACf,MAAM,QAAQ,KAAK,OAAO,KAAK;AAE/B,QAAM,KAAK,wBAAwB,WAAW,YAAY,OAAO,SAAS;;;;;;;;;;;;ACrD9E,MAAa,uCAA2B;CACtC,MAAM;CACN,UAAU,CAAC,mBAAmB;CAC9B,WAAW,aACTC,SACG,KAAK;EACJ,UAAU;EACV,SAASC;EACT,KAAK;EACN,CAAC,CACD,KAAKC,yBAAY;CACvB,CAAC"}

package/dist/topic-redis/index.d.cts

@@ -1,42 +0,0 @@
-import * as alepha1 from "alepha";
-import { Alepha } from "alepha";
-import * as alepha_logger0 from "alepha/logger";
-import { RedisProvider, RedisSubscriberProvider } from "alepha/redis";
-import { SubscribeCallback, TopicProvider, UnSubscribeFn } from "alepha/topic";
-
-//#region src/topic-redis/providers/RedisTopicProvider.d.ts
-declare class RedisTopicProvider extends TopicProvider {
-  protected readonly env: {
-    REDIS_TOPIC_PREFIX: string;
-  };
-  protected readonly alepha: Alepha;
-  protected readonly redisProvider: RedisProvider;
-  protected readonly redisSubscriberProvider: RedisSubscriberProvider;
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly start: alepha1.HookDescriptor<"start">;
-  prefix(queue: string): string;
-  /**
-   * Publish a message to a topic.
-   */
-  publish(topic: string, message: string): Promise<void>;
-  /**
-   * Subscribe to a topic.
-   */
-  subscribe(name: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
-  /**
-   * Unsubscribe from a topic.
-   */
-  unsubscribe(name: string, callback?: SubscribeCallback): Promise<void>;
-}
-//#endregion
-//#region src/topic-redis/index.d.ts
-/**
- * Plugin for Alepha Topic that provides Redis pub/sub capabilities.
- *
- * @see {@link RedisTopicProvider}
- * @module alepha.topic.redis
- */
-declare const AlephaTopicRedis: alepha1.Service<alepha1.Module>;
-//#endregion
-export { AlephaTopicRedis, RedisTopicProvider };
-//# sourceMappingURL=index.d.cts.map