alepha 0.7.3 → 0.7.5

package/queue.d.ts

@@ -1,83 +1,38 @@
 import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha, Module } from '@alepha/core';
 import { DateTimeProvider } from '@alepha/datetime';
-import { RedisProvider } 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 NumberOptions extends SchemaOptions {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-}
-interface TNumber extends TSchema, NumberOptions {
-    [Kind]: 'Number';
-    static: number;
-    type: 'number';
-}
-
-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 QueueProvider {
-    constructor();
+/**
+ * Minimalist Queue interface.
+ *
+ * Will be probably enhanced in the future to support more advanced features. But for now, it's enough!
+ */
+declare abstract class QueueProvider {
     /**
      * Push a message to the queue.
      *
-     * @param queue - The queue name.
-     * @param message - The message to push.
+     * @param queue Name of the queue to push the message to.
+     * @param message String message to be pushed to the queue. Buffer messages are not supported for now.
      */
-    push(_queue: string, _message: string): Promise<void>;
+    abstract push(queue: string, message: string): Promise<void>;
     /**
      * Pop a message from the queue.
      *
-     * @param queue - The queue name.
-     * @returns The message popped.
+     * @param queue Name of the queue to pop the message from.
+     *
+     * @returns The message popped or `undefined` if the queue is empty.
      */
-    pop(_queue: string): Promise<string | undefined>;
+    abstract pop(queue: string): Promise<string | undefined>;
 }
 
 declare const KEY$1 = "QUEUE";
+/**
+ * Queue descriptor.
+ */
+declare const $queue: {
+    <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+    [KIND]: string;
+};
 interface QueueMessageSchema {
     headers?: TSchema$1;
     payload: TSchema$1;
@@ -98,18 +53,15 @@ interface QueueDescriptor<T extends QueueMessageSchema = QueueMessageSchema> {
     provider(): QueueProvider;
     push(...payload: Array<Static<T["payload"]>>): Promise<void>;
 }
+
+declare const KEY = "CONSUMER";
 /**
- * Queue descriptor.
- *
- * @param options - The queue options.
- * @returns The descriptor value.
+ * Consumer descriptor.
  */
-declare const $queue: {
-    <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+declare const $consumer: {
+    <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
     [KIND]: string;
 };
-
-declare const KEY = "CONSUMER";
 interface ConsumerDescriptorOptions<T extends QueueMessageSchema = QueueMessageSchema> {
     queue: QueueDescriptor<T>;
     handler: (message: {
@@ -122,44 +74,66 @@ interface ConsumerDescriptor<T extends QueueMessageSchema = QueueMessageSchema>
     queue(): QueueDescriptor<T>;
     stop(): Promise<void>;
 }
-/**
- * Consumer descriptor.
- *
- * @param options - The consumer options.
- * @returns The descriptor value.
- */
-declare const $consumer: {
-    <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
-    [KIND]: string;
-};
 
 declare class MemoryQueueProvider implements QueueProvider {
-    /**
-     * The in-memory queue list.
-     */
-    protected queueList: Record<string, string[]>;
     protected readonly log: _alepha_core.Logger;
-    /**
-     * Push a message to a queue.
-     * The message is added to the end of the queue.
-     * The queue is created if it does not exist.
-     *
-     * @param queue - The queue to push to.
-     * @param messages The messages to push.
-     */
+    protected queueList: Record<string, string[]>;
     push(queue: string, ...messages: string[]): Promise<void>;
-    /**
-     * Pop a message from a queue.
-     * The message is removed from the queue.
-     * If the queue is empty, this method will return undefined.
-     *
-     * @param queue - The queue to pop from.
-     * @returns The message that was popped from the queue.
-     */
     pop(queue: string): Promise<string | undefined>;
 }
 
-declare const envSchema$1: _alepha_core.TObject<{
+/** 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 NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+
+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 const envSchema: _alepha_core.TObject<{
     /**
      * The interval in milliseconds to wait before checking for new messages.
      */
@@ -175,7 +149,7 @@ declare const envSchema$1: _alepha_core.TObject<{
     QUEUE_WORKER_CONCURRENCY: TNumber;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static<typeof envSchema$1>> {
+    interface Env extends Partial<Static<typeof envSchema>> {
     }
 }
 interface QueueDescriptorProviderState {
@@ -217,90 +191,63 @@ declare class QueueDescriptorProvider {
     protected processQueueDescriptors(): void;
     /**
      * Process the consumer descriptors.
-     *
-     * @protected
      */
     protected processConsumerDescriptors(): void;
+    /**
+     * Get the provider for the queue.
+     */
+    protected provider(options: QueueDescriptorOptions<any>): QueueProvider;
+    /**
+     * Push an item to the queue.
+     */
+    protected push<T extends QueueMessageSchema>(queue: QueueDescriptor<T>, ...payloads: Array<Static<T["payload"]>>): Promise<void>;
     /**
      * Start the workers.
-     *
-     * @param consumers
-     * @protected
+     * This method will create an endless loop that will check for new messages!
      */
     protected startWorkers(consumers: Array<ConsumerDescriptorOptions>): void;
     /**
-     * Wait for the next message.
+     * Wait for the next message, where `n` is the worker number.
      *
-     * @param n
-     * @protected
+     * This method will wait for a certain amount of time, increasing the wait time again if no message is found.
      */
     protected waitForNextMessage(n: number): Promise<void>;
     /**
      * Get the next message.
-     *
-     * @param consumers
-     * @protected
      */
     protected getNextMessage(consumers: Array<ConsumerDescriptorOptions>): Promise<undefined | {
-        message: any;
         consumer: ConsumerDescriptorOptions;
+        message: string;
     }>;
     /**
      * Process a message from a queue.
-     *
-     * @param response
-     * @protected
      */
     protected processMessage(response: {
         message: any;
         consumer: ConsumerDescriptorOptions;
     }): Promise<void>;
     /**
-     * Stop the workers
+     * Stop the workers.
      *
-     * @protected
+     * This method will stop the workers and wait for them to finish processing.
      */
     protected stopWorkers(): Promise<void>;
-    /**
-     * Get the provider for the queue.
-     *
-     * @param options - The queue options.
-     * @protected
-     */
-    protected provider(options: QueueDescriptorOptions<any>): QueueProvider;
-    /**
-     * Push an item to the queue.
-     *
-     * @param queue
-     * @param payloads
-     * @protected
-     */
-    protected push<T extends QueueMessageSchema>(queue: QueueDescriptor<T>, ...payloads: Array<Static<T["payload"]>>): Promise<void>;
-}
-
-declare class RedisQueueProvider implements QueueProvider {
-    protected readonly env: {
-        REDIS_QUEUE_PREFIX: string;
-    };
-    protected readonly redisProvider: RedisProvider;
-    prefix(queue: string): string;
-    push(queue: string, message: string): Promise<void>;
-    pop(queue: string): Promise<string | undefined>;
 }
 
-declare const envSchema: _alepha_core.TObject<{
-    QUEUE_PROVIDER: TUnsafe<"memory" | "redis">;
-}>;
-declare module "alepha/core" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
-}
-declare class QueueModule {
-    protected readonly alepha: Alepha;
-    protected readonly env: {
-        QUEUE_PROVIDER: "memory" | "redis";
-    };
-    constructor();
+/**
+ * Alepha Queue Module
+ *
+ * Generic interface for queueing.
+ * Gives you the ability to create queues and consumers.
+ * This module provides only a memory implementation of the queue provider.
+ *
+ * @see {@link $queue}
+ * @see {@link $consumer}
+ * @module alepha.queue
+ */
+declare class AlephaQueue implements Module {
+    readonly name = "alepha.queue";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $consumer, $queue, type ConsumerDescriptor, type ConsumerDescriptorOptions, MemoryQueueProvider, type QueueDescriptor, type QueueDescriptorOptions, QueueDescriptorProvider, type QueueDescriptorProviderState, type QueueMessageSchema, QueueModule, QueueProvider, RedisQueueProvider };
+export { $consumer, $queue, AlephaQueue, type ConsumerDescriptor, type ConsumerDescriptorOptions, MemoryQueueProvider, type QueueDescriptor, type QueueDescriptorOptions, QueueDescriptorProvider, type QueueDescriptorProviderState, type QueueMessageSchema, QueueProvider };

package/react/auth.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core from '@alepha/core';
-import { Async, KIND, OPTIONS, Alepha } from '@alepha/core';
+import { Async, KIND, OPTIONS, Alepha, Module } from '@alepha/core';
 import { UserAccountToken } from '@alepha/security';
 import * as _alepha_server from '@alepha/server';
 import { HttpVirtualClient, HttpClient } from '@alepha/server';
@@ -142,6 +142,7 @@ interface AuthDescriptorOptions {
         clientSecret?: string;
         redirectUri?: string;
         useIdToken?: boolean;
+        logoutUri?: string;
     };
 }
 interface AuthDescriptor {
@@ -236,6 +237,7 @@ declare class ReactAuthProvider {
         redirectUri: string;
         fallback?: () => Async<AccessToken>;
         useIdToken?: boolean;
+        logoutUri?: string;
     }>;
     /**
      *
@@ -261,6 +263,7 @@ interface AuthProvider {
     };
     fallback?: () => Async<AccessToken>;
     useIdToken?: boolean;
+    logoutUri?: string;
 }
 interface ReactUser {
     id: string;
@@ -300,9 +303,17 @@ declare module "alepha/react" {
         user?: ReactUser;
     }
 }
-declare class ReactAuthModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * Alepha React Authentication Module
+ *
+ * The ReactAuthModule provides authentication services for React applications.
+ *
+ * @see {@link ReactAuthProvider}
+ * @module alepha.react.auth
+ */
+declare class AlephaReactAuth implements Module {
+    readonly name = "alepha.react.auth";
+    readonly $services: (alepha: Alepha) => void;
 }
 
-export { $auth, type AccessToken, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthModule, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };
+export { $auth, type AccessToken, AlephaReactAuth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };