alepha 0.7.4 → 0.7.6

package/postgres.js

@@ -1 +1 @@
-export * from '@alepha/postgres';
+export * from '@alepha/postgres'

package/queue/redis.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/queue-redis');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/queue/redis.d.ts

@@ -0,0 +1,31 @@
+import { QueueProvider } from "@alepha/queue";
+import { Alepha, Module } from "@alepha/core";
+import { RedisProvider } from "@alepha/redis";
+
+//#region src/providers/RedisQueueProvider.d.ts
+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>;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Alepha Queue Redis Module
+ *
+ * Plugin for Alepha Queue that provides Redis queue capabilities.
+ *
+ * @see {@link RedisQueueProvider}
+ * @module alepha.queue.redis
+ */
+declare class AlephaQueueRedis implements Module {
+  readonly name = "alepha.queue.redis";
+  readonly $services: (alepha: Alepha) => Alepha;
+}
+//#endregion
+export { AlephaQueueRedis, RedisQueueProvider };
+//# sourceMappingURL=index.d.ts.map

package/queue/redis.js

@@ -0,0 +1 @@
+export * from '@alepha/queue-redis'

package/queue.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var queue = require('@alepha/queue');
-
-
-
-Object.keys(queue).forEach(function (k) {
+var m = require('@alepha/queue');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return queue[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});

package/queue.d.ts

@@ -1,239 +1,195 @@
-import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha, Module } from '@alepha/core';
-import { DateTimeProvider } from '@alepha/datetime';
+import * as _alepha_core0 from "@alepha/core";
+import * as _alepha_core4 from "@alepha/core";
+import { Alepha, KIND, Module, OPTIONS, Static, TSchema } from "@alepha/core";
+import { DateTimeProvider } from "@alepha/datetime";
+import * as _sinclair_typebox1 from "@sinclair/typebox";
 
+//#region src/providers/QueueProvider.d.ts
 /**
  * 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 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.
-     */
-    abstract push(queue: string, message: string): Promise<void>;
-    /**
-     * Pop a message from the queue.
-     *
-     * @param queue Name of the queue to pop the message from.
-     *
-     * @returns The message popped or `undefined` if the queue is empty.
-     */
-    abstract pop(queue: string): Promise<string | undefined>;
-}
-
+  /**
+   * Push a message to the queue.
+   *
+   * @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.
+   */
+  abstract push(queue: string, message: string): Promise<void>;
+  /**
+   * Pop a message from the queue.
+   *
+   * @param queue Name of the queue to pop the message from.
+   *
+   * @returns The message popped or `undefined` if the queue is empty.
+   */
+  abstract pop(queue: string): Promise<string | undefined>;
+}
+//#endregion
+//#region src/descriptors/$queue.d.ts
 declare const KEY$1 = "QUEUE";
 /**
  * Queue descriptor.
  */
 declare const $queue: {
-    <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
-    [KIND]: string;
+  <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+  [KIND]: string;
 };
 interface QueueMessageSchema {
-    headers?: TSchema$1;
-    payload: TSchema$1;
+  headers?: TSchema;
+  payload: TSchema;
 }
 interface QueueDescriptorOptions<T extends QueueMessageSchema> {
-    name?: string;
-    description?: string;
-    provider?: "memory" | (() => QueueProvider);
-    schema: T;
-    handler?: (message: {
-        payload: Static<T["payload"]>;
-    }) => Promise<void>;
+  name?: string;
+  description?: string;
+  provider?: "memory" | (() => QueueProvider);
+  schema: T;
+  handler?: (message: {
+    payload: Static<T["payload"]>;
+  }) => Promise<void>;
 }
 interface QueueDescriptor<T extends QueueMessageSchema = QueueMessageSchema> {
-    [KIND]: typeof KEY$1;
-    [OPTIONS]: QueueDescriptorOptions<T>;
-    name(): string;
-    provider(): QueueProvider;
-    push(...payload: Array<Static<T["payload"]>>): Promise<void>;
-}
-
+  [KIND]: typeof KEY$1;
+  [OPTIONS]: QueueDescriptorOptions<T>;
+  name(): string;
+  provider(): QueueProvider;
+  push(...payload: Array<Static<T["payload"]>>): Promise<void>;
+}
+//#endregion
+//#region src/descriptors/$consumer.d.ts
 declare const KEY = "CONSUMER";
 /**
  * Consumer descriptor.
  */
 declare const $consumer: {
-    <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
-    [KIND]: string;
+  <T extends QueueMessageSchema>(options: ConsumerDescriptorOptions<T>): ConsumerDescriptor<T>;
+  [KIND]: string;
 };
 interface ConsumerDescriptorOptions<T extends QueueMessageSchema = QueueMessageSchema> {
-    queue: QueueDescriptor<T>;
-    handler: (message: {
-        payload: Static<T["payload"]>;
-    }) => Promise<void>;
+  queue: QueueDescriptor<T>;
+  handler: (message: {
+    payload: Static<T["payload"]>;
+  }) => Promise<void>;
 }
 interface ConsumerDescriptor<T extends QueueMessageSchema = QueueMessageSchema> {
-    [KIND]: typeof KEY;
-    [OPTIONS]: ConsumerDescriptorOptions<T>;
-    queue(): QueueDescriptor<T>;
-    stop(): Promise<void>;
+  [KIND]: typeof KEY;
+  [OPTIONS]: ConsumerDescriptorOptions<T>;
+  queue(): QueueDescriptor<T>;
+  stop(): Promise<void>;
 }
-
+//#endregion
+//#region src/providers/MemoryQueueProvider.d.ts
 declare class MemoryQueueProvider implements QueueProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected queueList: Record<string, string[]>;
-    push(queue: string, ...messages: string[]): Promise<void>;
-    pop(queue: string): Promise<string | undefined>;
-}
-
-/** 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.
-     */
-    QUEUE_WORKER_INTERVAL: TNumber;
-    /**
-     * The maximum interval in milliseconds to wait before checking for new messages.
-     */
-    QUEUE_WORKER_MAX_INTERVAL: TNumber;
-    /**
-     * The number of workers to run concurrently. Defaults to 1.
-     * Useful only if you are doing a lot of I/O.
-     */
-    QUEUE_WORKER_CONCURRENCY: TNumber;
+  protected readonly log: _alepha_core0.Logger;
+  protected queueList: Record<string, string[]>;
+  push(queue: string, ...messages: string[]): Promise<void>;
+  pop(queue: string): Promise<string | undefined>;
+}
+//#endregion
+//#region src/providers/QueueDescriptorProvider.d.ts
+declare const envSchema: _alepha_core4.TObject<{
+  /**
+   * The interval in milliseconds to wait before checking for new messages.
+   */
+  QUEUE_WORKER_INTERVAL: _sinclair_typebox1.TNumber;
+  /**
+   * The maximum interval in milliseconds to wait before checking for new messages.
+   */
+  QUEUE_WORKER_MAX_INTERVAL: _sinclair_typebox1.TNumber;
+  /**
+   * The number of workers to run concurrently. Defaults to 1.
+   * Useful only if you are doing a lot of I/O.
+   */
+  QUEUE_WORKER_CONCURRENCY: _sinclair_typebox1.TNumber;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
+  interface Env extends Partial<Static<typeof envSchema>> {}
 }
 interface QueueDescriptorProviderState {
-    queues: Array<QueueDescriptor>;
-    consumers: Array<ConsumerDescriptorOptions>;
-    workerPromises: Array<Promise<void>>;
-    isWorkersRunning: boolean;
-    abortController: AbortController;
-    workerIntervals: Record<number, number>;
+  queues: Array<QueueDescriptor>;
+  consumers: Array<ConsumerDescriptorOptions>;
+  workerPromises: Array<Promise<void>>;
+  isWorkersRunning: boolean;
+  abortController: AbortController;
+  workerIntervals: Record<number, number>;
 }
 declare class QueueDescriptorProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly env: {
-        QUEUE_WORKER_INTERVAL: number;
-        QUEUE_WORKER_MAX_INTERVAL: number;
-        QUEUE_WORKER_CONCURRENCY: number;
-    };
-    protected readonly alepha: Alepha;
-    protected readonly queueProvider: QueueProvider;
-    protected readonly memoryQueueProvider: MemoryQueueProvider;
-    protected readonly dateTimeProvider: DateTimeProvider;
-    protected readonly state: QueueDescriptorProviderState;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    protected readonly start: _alepha_core.HookDescriptor<"start">;
-    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
-    getQueues(): QueueDescriptor<QueueMessageSchema>[];
-    getConsumers(): ConsumerDescriptorOptions<QueueMessageSchema>[];
-    /**
-     * Process the descriptors.
-     *
-     * @protected
-     */
-    protected processDescriptors(): void;
-    /**
-     * Process the queue descriptors.
-     *
-     * @protected
-     */
-    protected processQueueDescriptors(): void;
-    /**
-     * Process the consumer descriptors.
-     */
-    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.
-     * This method will create an endless loop that will check for new messages!
-     */
-    protected startWorkers(consumers: Array<ConsumerDescriptorOptions>): void;
-    /**
-     * Wait for the next message, where `n` is the worker number.
-     *
-     * 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.
-     */
-    protected getNextMessage(consumers: Array<ConsumerDescriptorOptions>): Promise<undefined | {
-        consumer: ConsumerDescriptorOptions;
-        message: string;
-    }>;
-    /**
-     * Process a message from a queue.
-     */
-    protected processMessage(response: {
-        message: any;
-        consumer: ConsumerDescriptorOptions;
-    }): Promise<void>;
-    /**
-     * Stop the workers.
-     *
-     * This method will stop the workers and wait for them to finish processing.
-     */
-    protected stopWorkers(): Promise<void>;
-}
-
+  protected readonly log: _alepha_core4.Logger;
+  protected readonly env: {
+    QUEUE_WORKER_INTERVAL: number;
+    QUEUE_WORKER_MAX_INTERVAL: number;
+    QUEUE_WORKER_CONCURRENCY: number;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly queueProvider: QueueProvider;
+  protected readonly memoryQueueProvider: MemoryQueueProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly state: QueueDescriptorProviderState;
+  protected readonly configure: _alepha_core4.HookDescriptor<"configure">;
+  protected readonly start: _alepha_core4.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core4.HookDescriptor<"stop">;
+  getQueues(): QueueDescriptor<QueueMessageSchema>[];
+  getConsumers(): ConsumerDescriptorOptions<QueueMessageSchema>[];
+  /**
+   * Process the descriptors.
+   *
+   * @protected
+   */
+  protected processDescriptors(): void;
+  /**
+   * Process the queue descriptors.
+   *
+   * @protected
+   */
+  protected processQueueDescriptors(): void;
+  /**
+   * Process the consumer descriptors.
+   */
+  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.
+   * This method will create an endless loop that will check for new messages!
+   */
+  protected startWorkers(consumers: Array<ConsumerDescriptorOptions>): void;
+  /**
+   * Wait for the next message, where `n` is the worker number.
+   *
+   * 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.
+   */
+  protected getNextMessage(consumers: Array<ConsumerDescriptorOptions>): Promise<undefined | {
+    consumer: ConsumerDescriptorOptions;
+    message: string;
+  }>;
+  /**
+   * Process a message from a queue.
+   */
+  protected processMessage(response: {
+    message: any;
+    consumer: ConsumerDescriptorOptions;
+  }): Promise<void>;
+  /**
+   * Stop the workers.
+   *
+   * This method will stop the workers and wait for them to finish processing.
+   */
+  protected stopWorkers(): Promise<void>;
+}
+//#endregion
+//#region src/index.d.ts
 /**
  * Alepha Queue Module
  *
@@ -246,8 +202,9 @@ declare class QueueDescriptorProvider {
  * @module alepha.queue
  */
 declare class AlephaQueue implements Module {
-    readonly name = "alepha.queue";
-    readonly $services: (alepha: Alepha) => Alepha;
+  readonly name = "alepha.queue";
+  readonly $services: (alepha: Alepha) => Alepha;
 }
-
-export { $consumer, $queue, AlephaQueue, type ConsumerDescriptor, type ConsumerDescriptorOptions, MemoryQueueProvider, type QueueDescriptor, type QueueDescriptorOptions, QueueDescriptorProvider, type QueueDescriptorProviderState, type QueueMessageSchema, QueueProvider };
+//#endregion
+export { $consumer, $queue, AlephaQueue, ConsumerDescriptor, ConsumerDescriptorOptions, MemoryQueueProvider, QueueDescriptor, QueueDescriptorOptions, QueueDescriptorProvider, QueueDescriptorProviderState, QueueMessageSchema, QueueProvider };
+//# sourceMappingURL=index.d.ts.map

package/queue.js

@@ -1 +1 @@
-export * from '@alepha/queue';
+export * from '@alepha/queue'

package/react/auth.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var reactAuth = require('@alepha/react-auth');
-
-
-
-Object.keys(reactAuth).forEach(function (k) {
+var m = require('@alepha/react-auth');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return reactAuth[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});