alepha 0.6.7 → 0.6.9

package/topic.d.ts

@@ -1 +1,301 @@
-export * from '@alepha/topic';
+import * as _alepha_core from '@alepha/core';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
+import { DurationLike, DateTimeProvider } from '@alepha/datetime';
+import { RedisProvider, RedisSubscriberProvider } from '@alepha/redis';
+
+/** Symbol key applied to readonly types */
+declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+declare const Hint: unique symbol;
+/** Symbol key applied to types */
+declare const Kind: unique symbol;
+
+interface TUnsafe<T> extends TSchema {
+    [Kind]: string;
+    static: T;
+}
+
+interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+interface TKind {
+    [Kind]: string;
+}
+interface TSchema extends TKind, SchemaOptions {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+
+declare class TopicProvider {
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Unsubscribe from a topic.
+     *
+     * @param topic - The topic to unsubscribe from.
+     */
+    unsubscribe(topic: string): Promise<void>;
+}
+type SubscribeCallback = (message: string) => Promise<void> | void;
+type UnSubscribeFn = () => Promise<void>;
+
+declare const KEY$1 = "TOPIC";
+interface TopicMessageSchema {
+    headers?: TSchema$1;
+    payload: TSchema$1;
+}
+interface TopicDescriptorOptions<T extends TopicMessageSchema = TopicMessageSchema> {
+    name?: string;
+    description?: string;
+    provider?: "memory" | (() => TopicProvider);
+    schema: T;
+    handler?: (message: {
+        payload: Static<T["payload"]>;
+    }) => Promise<void>;
+}
+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"]>>;
+}
+interface TopicMessage<T extends TopicMessageSchema = TopicMessageSchema> {
+    payload: Static<T["payload"]>;
+}
+interface TopicWaitOptions<T extends TopicMessageSchema> {
+    timeout?: DurationLike;
+    filter?: (message: {
+        payload: Static<T["payload"]>;
+    }) => boolean;
+}
+declare const $topic: {
+    <T extends TopicMessageSchema>(options: TopicDescriptorOptions<T>): TopicDescriptor<T>;
+    [KIND]: string;
+};
+
+declare const KEY = "SUBSCRIBER";
+/**
+ *
+ */
+interface SubscriberDescriptorOptions<T extends TopicMessageSchema = TopicMessageSchema> {
+    /**
+     *
+     */
+    topic: TopicDescriptor<T>;
+    /**
+     *
+     * @param message
+     */
+    handler: (message: {
+        payload: Static<T["payload"]>;
+    }) => Promise<void>;
+}
+/**
+ *
+ */
+interface SubscriberDescriptor<T extends TopicMessageSchema = TopicMessageSchema> {
+    [KIND]: typeof KEY;
+    [OPTIONS]: SubscriberDescriptorOptions<T>;
+    /**
+     *
+     */
+    topic: () => TopicDescriptor<T>;
+}
+/**
+ * Subscriber descriptor.
+ *
+ * @param options - The subscriber options.
+ * @returns The descriptor value.
+ */
+declare const $subscriber: {
+    <T extends TopicMessageSchema>(options: SubscriberDescriptorOptions<T>): SubscriberDescriptor<T>;
+    [KIND]: string;
+};
+
+declare class TopicTimeoutError extends Error {
+    readonly topic: string;
+    readonly timeout: number;
+    constructor(topic: string, timeout: number);
+}
+
+declare class MemoryTopicProvider implements TopicProvider {
+    protected readonly subscriptions: Record<string, SubscribeCallback[]>;
+    /**
+     * 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>;
+}
+
+declare class RedisTopicProvider implements TopicProvider {
+    protected readonly env: {
+        REDIS_TOPIC_PREFIX: string;
+    };
+    protected readonly redisProvider: RedisProvider;
+    protected readonly redisSubscriberProvider: RedisSubscriberProvider;
+    protected readonly subscriptions: Record<string, SubscribeCallback[]>;
+    protected readonly log: _alepha_core.Logger;
+    protected readonly start: _alepha_core.HookDescriptor<"start">;
+    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
+    prefix(queue: string): string;
+    /**
+     * Publish a message to a topic.
+     *
+     * @param topic
+     * @param message
+     */
+    publish(topic: string, message: string): Promise<void>;
+    /**
+     * Subscribe to a topic.
+     *
+     * @param name
+     * @param callback
+     */
+    subscribe(name: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
+    /**
+     * Unsubscribe from a topic.
+     *
+     * @param name
+     * @param callback
+     */
+    unsubscribe(name: string, callback?: SubscribeCallback): Promise<void>;
+    /**
+     * Listen for messages.
+     *
+     * @protected
+     */
+    protected listen(): void;
+}
+
+declare class TopicDescriptorProvider {
+    protected readonly log: _alepha_core.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_core.HookDescriptor<"configure">;
+    protected readonly start: _alepha_core.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;
+    };
+}
+
+declare const envSchema: _alepha_core.TObject<{
+    TOPIC_PROVIDER: TUnsafe<"memory" | "redis">;
+}>;
+declare module "alepha" {
+    interface Env extends Partial<Static<typeof envSchema>> {
+    }
+}
+declare class TopicModule {
+    protected readonly alepha: Alepha;
+    protected readonly env: {
+        TOPIC_PROVIDER: "memory" | "redis";
+    };
+    constructor();
+}
+
+export { $subscriber, $topic, MemoryTopicProvider, RedisTopicProvider, type SubscribeCallback, type SubscriberDescriptor, type SubscriberDescriptorOptions, type TopicDescriptor, type TopicDescriptorOptions, TopicDescriptorProvider, type TopicMessage, type TopicMessageSchema, TopicModule, TopicProvider, TopicTimeoutError, type TopicWaitOptions, type UnSubscribeFn };

package/vite.d.ts

@@ -1 +1,80 @@
-export * from '@alepha/vite';
+import viteReactPlugin from '@vitejs/plugin-react';
+import { Plugin } from 'vite';
+
+interface ViteAlephaBuildOptions {
+    /**
+     * The entry point for the application. This is the file that will be executed when the application is run.
+     *
+     * @default 'src/index.ts'
+     */
+    entry?: string;
+    /**
+     *
+     */
+    vercel?: boolean | {
+        projectId: string;
+        orgId: string;
+        settings: any;
+    };
+}
+/**
+ *
+ */
+declare function viteAlephaBuild(options?: ViteAlephaBuildOptions): Plugin;
+
+interface ViteAlephaDevOptions {
+    /**
+     * The entry point for the application. This is the file that will be executed when the application is run.
+     *
+     * @default 'src/index.ts'
+     */
+    entry?: string;
+    /**
+     * Enable or disable debug mode
+     *
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Enable or disable Vercel support
+     */
+    vercel?: boolean | {
+        projectId: string;
+        orgId: string;
+        settings: any;
+    };
+}
+/**
+ *
+ */
+declare function viteAlephaDev(options?: ViteAlephaDevOptions): Plugin;
+
+type ViteAlephaOptions = ViteAlephaDevOptions & ViteAlephaBuildOptions;
+declare function viteAlepha(options?: ViteAlephaOptions): Plugin[];
+
+interface ViteAlephaBuildVercelOptions {
+    /**
+     * The name of the output file.
+     *
+     * @default 'index'
+     */
+    filename?: string;
+    /**
+     * The name of the client directory.
+     *
+     * @default 'client'
+     */
+    client?: string;
+}
+/**
+ *
+ */
+declare function viteAlephaBuildVercel(opts?: ViteAlephaBuildVercelOptions): {
+    name: string;
+    apply: string;
+    writeBundle(): void;
+};
+
+declare const viteReact: typeof viteReactPlugin;
+
+export { type ViteAlephaBuildOptions, type ViteAlephaBuildVercelOptions, type ViteAlephaDevOptions, type ViteAlephaOptions, viteAlepha, viteAlephaBuild, viteAlephaBuildVercel, viteAlephaDev, viteReact };