alepha 0.8.1 → 0.9.0

package/topic/redis.d.ts

@@ -1,44 +1,45 @@
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha } from "alepha";
 import { SubscribeCallback, TopicProvider, UnSubscribeFn } from "alepha/topic";
-import { Alepha, HookDescriptor, Logger, Module, Static, TObject, TString } from "alepha";
 import { RedisProvider, RedisSubscriberProvider } from "alepha/redis";
 
 //#region src/providers/RedisTopicProvider.d.ts
-declare const envSchema: TObject<{
-  REDIS_TOPIC_PREFIX: TString;
-}>;
-declare class RedisTopicProvider implements TopicProvider {
-  protected readonly env: Static<typeof envSchema>;
+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: Logger;
-  protected readonly stop: HookDescriptor<"stop">;
+  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly start: _alepha_core0$1.HookDescriptor<"start">;
   prefix(queue: string): string;
   /**
-  * Publish a message to a topic.
-  */
+   * Publish a message to a topic.
+   */
   publish(topic: string, message: string): Promise<void>;
   /**
-  * Subscribe to a topic.
-  */
+   * Subscribe to a topic.
+   */
   subscribe(name: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
   /**
-  * Unsubscribe from a topic.
-  */
+   * Unsubscribe from a topic.
+   */
   unsubscribe(name: string, callback?: SubscribeCallback): Promise<void>;
 }
+//# sourceMappingURL=RedisTopicProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-// ---------------------------------------------------------------------------------------------------------------------
 /**
-* Plugin for Alepha Topic that provides Redis pub/sub capabilities.
-*
-* @see {@link RedisTopicProvider}
-* @module alepha.topic.redis
-*/
-declare class AlephaTopicRedis implements Module {
-  readonly name = "alepha.topic.redis";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+ * Plugin for Alepha Topic that provides Redis pub/sub capabilities.
+ *
+ * @see {@link RedisTopicProvider}
+ * @module alepha.topic.redis
+ */
+declare const AlephaTopicRedis: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
 export { AlephaTopicRedis, RedisTopicProvider };
 //# sourceMappingURL=index.d.ts.map

package/topic.d.ts

@@ -1,67 +1,92 @@
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core1 from "alepha";
 import * as _alepha_core0 from "alepha";
-import { Alepha, KIND, Module, OPTIONS, Static, TSchema } from "alepha";
+import { Alepha, Descriptor, KIND, Service, Static, TSchema } from "alepha";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/providers/TopicProvider.d.ts
-declare class TopicProvider {
-  constructor();
+/**
+ * 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.
    */
-  publish(_topic: string, _message: string): Promise<void>;
+  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.
    */
-  subscribe(_topic: string, _callback: SubscribeCallback): Promise<UnSubscribeFn>;
+  abstract subscribe(topic: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
   /**
    * Unsubscribe from a topic.
    *
    * @param topic - The topic to unsubscribe from.
    */
-  unsubscribe(_topic: string): Promise<void>;
+  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>;
 //# sourceMappingURL=TopicProvider.d.ts.map
 //#endregion
 //#region src/descriptors/$topic.d.ts
-declare const KEY$1 = "TOPIC";
 /**
  * Create a new topic.
  */
 declare const $topic: {
   <T extends TopicMessageSchema>(options: TopicDescriptorOptions<T>): TopicDescriptor<T>;
-  [KIND]: string;
+  [KIND]: typeof TopicDescriptor;
 };
-interface TopicMessageSchema {
-  headers?: TSchema;
-  payload: TSchema;
-}
-interface TopicDescriptorOptions<T extends TopicMessageSchema = TopicMessageSchema> {
+interface TopicDescriptorOptions<T extends TopicMessageSchema> {
+  /**
+   * Topic key.
+   *
+   * If not provided, the propertyKey is used as the topic name.
+   */
   name?: string;
+  /**
+   * Describe the topic. For documentation purposes.
+   */
   description?: string;
-  provider?: "memory" | (() => TopicProvider);
+  /**
+   * Override the default topic provider.
+   *
+   * If not provided, the default provider is used.
+   * If "memory" is provided, the default in-memory provider is used.
+   * If a class is provided, it must extend `TopicProvider`.
+   */
+  provider?: "memory" | Service<TopicProvider>;
+  /**
+   * Topic message schema.
+   */
   schema: T;
-  handler?: (message: {
-    payload: Static<T["payload"]>;
-  }) => Promise<void>;
+  /**
+   * Add a subscriber handler.
+   */
+  handler?: TopicHandler<T>;
 }
-interface TopicDescriptor<T extends TopicMessageSchema = TopicMessageSchema> {
-  [KIND]: typeof KEY$1;
-  [OPTIONS]: TopicDescriptorOptions<T>;
-  name(): string;
-  provider(): TopicProvider;
-  publish(payload: Static<T["payload"]>): Promise<void>;
-  subscribe(fn: (message: TopicMessage<T>) => void): Promise<UnSubscribeFn>;
-  wait(options?: TopicWaitOptions<T>): Promise<Static<T["payload"]>>;
+declare class TopicDescriptor<T extends TopicMessageSchema> extends Descriptor<TopicDescriptorOptions<T>> {
+  protected readonly log: _alepha_core0$1.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 = TopicMessageSchema> {
+interface TopicMessage<T extends TopicMessageSchema> {
   payload: Static<T["payload"]>;
 }
 interface TopicWaitOptions<T extends TopicMessageSchema> {
@@ -70,30 +95,27 @@ interface TopicWaitOptions<T extends TopicMessageSchema> {
     payload: Static<T["payload"]>;
   }) => boolean;
 }
+interface TopicMessageSchema {
+  headers?: TSchema;
+  payload: TSchema;
+}
+type TopicHandler<T extends TopicMessageSchema = TopicMessageSchema> = (message: TopicMessage<T>) => unknown;
+//# sourceMappingURL=$topic.d.ts.map
 //#endregion
 //#region src/descriptors/$subscriber.d.ts
-declare const KEY = "SUBSCRIBER";
 /**
- * Subscriber descriptor.
- *
- * @param options - The subscriber options.
- * @returns The descriptor value.
+ * Subscribe to a $topic.
  */
 declare const $subscriber: {
   <T extends TopicMessageSchema>(options: SubscriberDescriptorOptions<T>): SubscriberDescriptor<T>;
-  [KIND]: string;
+  [KIND]: typeof SubscriberDescriptor;
 };
-interface SubscriberDescriptorOptions<T extends TopicMessageSchema = TopicMessageSchema> {
+interface SubscriberDescriptorOptions<T extends TopicMessageSchema> {
   topic: TopicDescriptor<T>;
-  handler: (message: {
-    payload: Static<T["payload"]>;
-  }) => Promise<void>;
-}
-interface SubscriberDescriptor<T extends TopicMessageSchema = TopicMessageSchema> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: SubscriberDescriptorOptions<T>;
-  topic: () => TopicDescriptor<T>;
+  handler: TopicHandler<T>;
 }
+declare class SubscriberDescriptor<T extends TopicMessageSchema> extends Descriptor<SubscriberDescriptorOptions<T>> {}
+//# sourceMappingURL=$subscriber.d.ts.map
 //#endregion
 //#region src/errors/TopicTimeoutError.d.ts
 declare class TopicTimeoutError extends Error {
@@ -104,8 +126,10 @@ declare class TopicTimeoutError extends Error {
 //# sourceMappingURL=TopicTimeoutError.d.ts.map
 //#endregion
 //#region src/providers/MemoryTopicProvider.d.ts
-declare class MemoryTopicProvider implements TopicProvider {
+declare class MemoryTopicProvider extends TopicProvider {
+  protected readonly log: _alepha_core1.Logger;
   protected readonly subscriptions: Record<string, SubscribeCallback[]>;
+  protected readonly start: _alepha_core1.HookDescriptor<"start">;
   /**
    * Publish a message to a topic.
    *
@@ -129,74 +153,6 @@ declare class MemoryTopicProvider implements TopicProvider {
 }
 //# sourceMappingURL=MemoryTopicProvider.d.ts.map
 //#endregion
-//#region src/providers/TopicDescriptorProvider.d.ts
-declare class TopicDescriptorProvider {
-  protected readonly log: _alepha_core0.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly topicProvider: TopicProvider;
-  protected readonly memoryTopicProvider: MemoryTopicProvider;
-  protected readonly topics: TopicDescriptor[];
-  protected readonly subscribers: Array<SubscriberDescriptorOptions & {
-    unsub?: UnSubscribeFn;
-  }>;
-  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
-  protected readonly start: _alepha_core0.HookDescriptor<"start">;
-  /**
-   * Process the descriptors.
-   *
-   * @protected
-   */
-  protected processDescriptors(): void;
-  /**
-   * Process the queue descriptors.
-   *
-   * @protected
-   */
-  protected processTopicDescriptors(): void;
-  /**
-   * Wait for a message on the topic.
-   *
-   * @param topic
-   * @param options
-   * @protected
-   */
-  protected wait(topic: TopicDescriptor, options?: TopicWaitOptions<any>): Promise<unknown>;
-  /**
-   * Process the consumer descriptors.
-   *
-   * @protected
-   */
-  protected processSubscriberDescriptors(): void;
-  /**
-   * Get the provider for the queue.
-   *
-   * @param options - The queue options.
-   * @protected
-   */
-  protected provider(options: TopicDescriptorOptions): TopicProvider;
-  /**
-   * Publish a message to the topic.
-   *
-   * @param topic
-   * @param message
-   * @protected
-   */
-  protected publish<T extends TopicMessageSchema = TopicMessageSchema>(topic: TopicDescriptor<T>, message: TopicMessage<T>): Promise<void>;
-  /**
-   * Process a message.
-   *
-   * @param subscriber
-   * @param message
-   * @protected
-   */
-  protected processMessage(subscriber: SubscriberDescriptorOptions, message: string): Promise<void>;
-  protected parseMessage(schema: any, message: string): {
-    payload: any;
-  };
-}
-//# sourceMappingURL=TopicDescriptorProvider.d.ts.map
-//#endregion
 //#region src/index.d.ts
 /**
  * Generic interface for pub/sub messaging.
@@ -207,12 +163,9 @@ declare class TopicDescriptorProvider {
  * @see {@link $subscriber}
  * @module alepha.topic
  */
-declare class AlephaTopic implements Module {
-  readonly name = "alepha.topic";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaTopic: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion
-export { $subscriber, $topic, AlephaTopic, MemoryTopicProvider, SubscribeCallback, SubscriberDescriptor, SubscriberDescriptorOptions, TopicDescriptor, TopicDescriptorOptions, TopicDescriptorProvider, TopicMessage, TopicMessageSchema, TopicProvider, TopicTimeoutError, TopicWaitOptions, UnSubscribeFn };
+export { $subscriber, $topic, AlephaTopic, MemoryTopicProvider, SubscribeCallback, SubscriberDescriptor, SubscriberDescriptorOptions, TopicDescriptor, TopicDescriptorOptions, TopicHandler, TopicMessage, TopicMessageSchema, TopicProvider, TopicTimeoutError, TopicWaitOptions, UnSubscribeFn };
 //# sourceMappingURL=index.d.ts.map