alepha 0.6.7 → 0.6.9

package/queue.d.ts

@@ -1 +1,305 @@
-export * from '@alepha/queue';
+import * as _alepha_core from '@alepha/core';
+import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha } 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 {
+    /**
+     * Push a message to the queue.
+     *
+     * @param queue - The queue name.
+     * @param message - The message to push.
+     */
+    push(queue: string, message: string): Promise<void>;
+    /**
+     * Pop a message from the queue.
+     *
+     * @param queue - The queue name.
+     * @returns The message popped.
+     */
+    pop(queue: string): Promise<string | undefined>;
+}
+
+declare const KEY$1 = "QUEUE";
+interface QueueMessageSchema {
+    headers?: TSchema$1;
+    payload: TSchema$1;
+}
+interface QueueDescriptorOptions<T extends QueueMessageSchema> {
+    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>;
+}
+/**
+ * Queue descriptor.
+ *
+ * @param options - The queue options.
+ * @returns The descriptor value.
+ */
+declare const $queue: {
+    <T extends QueueMessageSchema>(options: QueueDescriptorOptions<T>): QueueDescriptor<T>;
+    [KIND]: string;
+};
+
+declare const KEY = "CONSUMER";
+interface ConsumerDescriptorOptions<T extends QueueMessageSchema = QueueMessageSchema> {
+    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>;
+}
+/**
+ * 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.
+     */
+    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<{
+    /**
+     * 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;
+}>;
+declare module "alepha" {
+    interface Env extends Partial<Static<typeof envSchema$1>> {
+    }
+}
+interface QueueDescriptorProviderState {
+    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
+     */
+    protected processConsumerDescriptors(): void;
+    /**
+     * Start the workers.
+     *
+     * @param consumers
+     * @protected
+     */
+    protected startWorkers(consumers: Array<ConsumerDescriptorOptions>): void;
+    /**
+     * Wait for the next message.
+     *
+     * @param n
+     * @protected
+     */
+    protected waitForNextMessage(n: number): Promise<void>;
+    /**
+     * Get the next message.
+     *
+     * @param consumers
+     * @protected
+     */
+    protected getNextMessage(consumers: Array<ConsumerDescriptorOptions>): Promise<undefined | {
+        message: any;
+        consumer: ConsumerDescriptorOptions;
+    }>;
+    /**
+     * Process a message from a queue.
+     *
+     * @param response
+     * @protected
+     */
+    protected processMessage(response: {
+        message: any;
+        consumer: ConsumerDescriptorOptions;
+    }): Promise<void>;
+    /**
+     * Stop the workers
+     *
+     * @protected
+     */
+    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();
+}
+
+export { $consumer, $queue, type ConsumerDescriptor, type ConsumerDescriptorOptions, MemoryQueueProvider, type QueueDescriptor, type QueueDescriptorOptions, QueueDescriptorProvider, type QueueDescriptorProviderState, type QueueMessageSchema, QueueModule, QueueProvider, RedisQueueProvider };

package/react/auth.d.ts

@@ -1 +1,300 @@
-export * from '@alepha/react-auth';
+import * as _alepha_core from '@alepha/core';
+import { Alepha, KIND, OPTIONS } from '@alepha/core';
+import { UserAccountToken } from '@alepha/security';
+import * as _alepha_server from '@alepha/server';
+import { HttpClient } from '@alepha/server';
+import * as _alepha_server_cookies from '@alepha/server-cookies';
+import { ServerCookiesProvider, Cookies } from '@alepha/server-cookies';
+import { Configuration } from 'openid-client';
+
+/** 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;
+
+type TReadonly<T extends TSchema> = T & {
+    [ReadonlyKind]: 'Readonly';
+};
+
+type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+interface StringOptions extends SchemaOptions {
+    /** The maximum string length */
+    maxLength?: number;
+    /** The minimum string length */
+    minLength?: number;
+    /** A regular expression pattern this string should match */
+    pattern?: string;
+    /** A format this string should match */
+    format?: StringFormatOption;
+    /** The content encoding for this string */
+    contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
+    contentMediaType?: string;
+}
+interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+
+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';
+}
+
+type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+
+/** Creates a static type from a TypeBox type */
+type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
+    params: Params;
+})['static']> = Result;
+
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+type TPropertyKey = string | number;
+type TProperties = Record<TPropertyKey, TSchema>;
+type TAdditionalProperties = undefined | TSchema | boolean;
+interface ObjectOptions extends SchemaOptions {
+    /** Additional property constraints for this object */
+    additionalProperties?: TAdditionalProperties;
+    /** The minimum number of properties allowed on this object */
+    minProperties?: number;
+    /** The maximum number of properties allowed on this object */
+    maxProperties?: number;
+}
+interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: ObjectStatic<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+
+type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+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 ReactAuthProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly serverCookiesProvider: ServerCookiesProvider;
+    protected authProviders: AuthProvider[];
+    protected readonly authorizationCode: _alepha_server_cookies.CookieDescriptor<TObject<{
+        codeVerifier: TOptional<TString>;
+        redirectUri: TOptional<TString>;
+    }>>;
+    protected readonly tokens: _alepha_server_cookies.CookieDescriptor<TObject<{
+        access_token: TOptional<TString>;
+        expires_in: TOptional<TNumber>;
+        refresh_token: TOptional<TString>;
+        id_token: TOptional<TString>;
+        scope: TOptional<TString>;
+        issued_at: TOptional<TNumber>;
+    }>>;
+    readonly user: _alepha_server_cookies.CookieDescriptor<TObject<{
+        id: TString;
+        name: TOptional<TString>;
+        email: TOptional<TString>;
+    }>>;
+    readonly onRender: _alepha_core.HookDescriptor<"react:server:render">;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    /**
+     * Configure Fastify to forward Session Access Token to Header Authorization.
+     */
+    protected readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
+    /**
+     *
+     * @param cookies
+     * @protected
+     */
+    protected refresh(cookies: Cookies): Promise<SessionTokens | undefined>;
+    /**
+     *
+     */
+    readonly login: _alepha_server.RouteDescriptor<{
+        query: TObject<{
+            redirect: TOptional<TString>;
+            provider: TOptional<TString>;
+        }>;
+    }>;
+    /**
+     *
+     */
+    readonly callback: _alepha_server.RouteDescriptor<{
+        query: TObject<{
+            provider: TOptional<TString>;
+        }>;
+    }>;
+    /**
+     *
+     * @param accessToken
+     * @protected
+     */
+    protected userFromAccessToken(accessToken: string): {
+        id: any;
+        name: any;
+        email: any;
+    } | undefined;
+    /**
+     *
+     */
+    readonly logout: _alepha_server.RouteDescriptor<{
+        query: TObject<{
+            redirect: TOptional<TString>;
+            provider: TOptional<TString>;
+        }>;
+    }>;
+    /**
+     *
+     * @param name
+     * @protected
+     */
+    protected provider(name?: string): Promise<{
+        client: Configuration;
+        name: string;
+        redirectUri: string;
+    }>;
+    /**
+     *
+     * @param file
+     * @protected
+     */
+    protected isViteFile(file: string): boolean;
+}
+interface SessionTokens {
+    access_token?: string;
+    expires_in?: number;
+    refresh_token?: string;
+    id_token?: string;
+    scope?: string;
+    issued_at?: number;
+}
+interface AuthProvider {
+    name: string;
+    redirectUri: string;
+    client: {
+        get: () => Promise<Configuration>;
+    };
+}
+interface ReactUser {
+    id: string;
+    name?: string;
+    email?: string;
+}
+
+declare const KEY = "AUTH";
+interface AuthDescriptorOptions {
+    name?: string;
+    oidc?: {
+        issuer: string;
+        clientId: string;
+        clientSecret?: string;
+        redirectUri?: string;
+    };
+}
+interface AuthDescriptor {
+    [KIND]: typeof KEY;
+    [OPTIONS]: AuthDescriptorOptions;
+    jwks: () => string;
+}
+declare const $auth: {
+    (options: AuthDescriptorOptions): AuthDescriptor;
+    [KIND]: string;
+};
+
+declare const useAuth: () => AuthHook;
+interface AuthHook {
+    user?: UserAccountToken;
+    logout: () => void;
+    login: (provider?: string) => void;
+    can: (something: {
+        can: () => boolean;
+    }) => boolean;
+}
+
+declare class ReactAuth {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly client: HttpClient;
+    readonly slugs: {
+        login: string;
+        logout: string;
+    };
+    readonly start: _alepha_core.HookDescriptor<"client:onError">;
+    readonly onRender: _alepha_core.HookDescriptor<"react:browser:render">;
+    protected getUserFromCookies(): UserAccountToken | undefined;
+    login(): void;
+    logout(): void;
+}
+
+declare module "alepha/react" {
+    interface PageReactContext {
+        user?: UserAccountToken;
+    }
+    interface ReactHydrationState {
+        user?: ReactUser;
+    }
+}
+declare class ReactAuthModule {
+    protected readonly alepha: Alepha;
+    constructor();
+}
+
+export { $auth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthModule, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };