alepha 0.6.7 → 0.6.8

package/datetime.d.ts

@@ -1 +1,167 @@
-export * from '@alepha/datetime';
+import * as _alepha_core from '@alepha/core';
+import { Async } from '@alepha/core';
+import { DurationLike as DurationLike$1, DateTime as DateTime$1, Duration as Duration$1, DurationLikeObject } from 'luxon';
+
+interface IntervalDescriptorOptions {
+    /**
+     * Whether to start the interval immediately.
+     *
+     * @default false
+     */
+    run?: boolean;
+    /**
+     * Whether to attach the interval to the context.
+     *
+     * Attached intervals are automatically started when the context starts and stopped when the context stops.
+     *
+     * @default true
+     */
+    attach?: boolean;
+    /**
+     * The interval handler.
+     */
+    handler: () => Async<void>;
+    /**
+     * The interval duration.
+     */
+    duration: DurationLike$1;
+}
+/**
+ * Registers a new interval.
+ */
+declare const $interval: (options: IntervalDescriptorOptions) => Interval;
+
+declare class Timeout {
+    private timer;
+    private duration;
+    private readonly now;
+    private readonly callback;
+    constructor(now: number, duration: number, callback: () => void);
+    /**
+     * Add time to the timeout.
+     */
+    add(amountMs: number): void;
+    /**
+     * Clear the timeout.
+     */
+    clear(): void;
+    /**
+     * Start the timeout.
+     *
+     * @private
+     */
+    private start;
+}
+
+declare class Interval {
+    private timer;
+    private readonly run;
+    private duration;
+    private options;
+    constructor(duration: number, options: IntervalDescriptorOptions);
+    /**
+     * Start the interval.
+     */
+    start(): Promise<void>;
+    /**
+     * Add time to the interval.
+     *
+     * @param amountMs
+     */
+    add(amountMs: number): Promise<void>;
+    /**
+     * Clear the interval.
+     */
+    clear(): void;
+}
+
+declare class DateTimeProvider {
+    protected log: _alepha_core.Logger;
+    protected ref: DateTime$1 | null;
+    protected readonly timeouts: Timeout[];
+    protected readonly intervals: Interval[];
+    protected readonly start: _alepha_core.HookDescriptor<"start">;
+    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
+    /**
+     * Create a new DateTime instance.
+     *
+     * @param date
+     */
+    of(date: Date | string | DateTime$1): DateTime$1<true>;
+    /**
+     * Get the current date.
+     */
+    now(): DateTime$1<true>;
+    /**
+     * Get the current date as a string.
+     *
+     * @param date
+     */
+    toISOString(date?: Date | string | DateTime$1): string;
+    /**
+     * Get the current date as a string.
+     */
+    nowISOString(): string;
+    /**
+     * Get the current date as a string.
+     *
+     * @protected
+     */
+    protected getCurrentDate(): DateTime$1<true>;
+    /**
+     * Create a new Duration instance.
+     *
+     * @param duration
+     */
+    duration(duration: DurationLike$1 | string): Duration$1;
+    /**
+     * Add time to the current date.
+     */
+    add(duration: DurationLikeObject): Promise<void>;
+    /**
+     * Return a promise that resolves after a next tick.
+     * It uses `setTimeout` with 0ms delay.
+     */
+    tick(): Promise<void>;
+    /**
+     * Stop the time.
+     */
+    pause(): DateTime$1<boolean>;
+    /**
+     * Reset the reference date.
+     */
+    reset(): void;
+    /**
+     * Wait for a certain duration.
+     *
+     * @param duration
+     * @param signal
+     */
+    wait(duration: DurationLike$1, signal?: AbortSignal): Promise<void>;
+    /**
+     * Run a callback after a certain duration.
+     *
+     * @param callback
+     * @param duration
+     */
+    timeout(callback: () => void, duration: DurationLike$1): Timeout;
+    /**
+     * Create an interval.
+     *
+     * @param args
+     */
+    interval(args: IntervalDescriptorOptions): Interval;
+    /**
+     * Run a function with a deadline.
+     *
+     * @param fn
+     * @param duration
+     */
+    deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike$1): Promise<T>;
+}
+
+type DurationLike = DurationLike$1;
+type DateTime = DateTime$1;
+type Duration = Duration$1;
+
+export { $interval, type DateTime, DateTimeProvider, type Duration, type DurationLike, Interval, type IntervalDescriptorOptions, Timeout };

package/lock.d.ts

@@ -1 +1,280 @@
-export * from '@alepha/lock';
+import * as _alepha_core from '@alepha/core';
+import { AsyncFn, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
+import { DurationLike, DateTimeProvider, DateTime, Timeout } from '@alepha/datetime';
+import * as _alepha_topic from '@alepha/topic';
+import { TopicProvider } from '@alepha/topic';
+import { RedisProvider, RedisClient } 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;
+}
+
+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 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 KEY = "LOCK";
+interface LockDescriptorOptions<TFunc extends AsyncFn> {
+    /**
+     * Function executed when the lock is acquired.
+     */
+    handler: TFunc;
+    /**
+     * If true, the handler will wait for the lock to be released.
+     *
+     * @default false
+     */
+    wait?: boolean;
+    /**
+     *
+     */
+    key?: string | ((...args: Parameters<TFunc>) => string);
+    /**
+     *
+     */
+    maxDuration?: DurationLike;
+    /**
+     *
+     */
+    gracePeriod?: DurationLike | ((...args: Parameters<TFunc>) => DurationLike | undefined);
+}
+interface LockDescriptor<TFunc extends AsyncFn> {
+    [KIND]: typeof KEY;
+    [OPTIONS]: LockDescriptorOptions<TFunc>;
+    /**
+     * Apply the lock.
+     *
+     * @param args
+     */
+    (...args: Parameters<TFunc>): Promise<void>;
+}
+/**
+ * Lock descriptor
+ *
+ * Make sure that only one instance of the handler is running at a time.
+ *
+ * When connected to a remote store, the lock is shared across all processes.
+ *
+ * @param options
+ */
+declare const $lock: {
+    <TFunc extends AsyncFn>(options: LockDescriptorOptions<TFunc>): LockDescriptor<TFunc>;
+    [KIND]: string;
+};
+
+/**
+ * Store Provider Interface
+ */
+declare class LockProvider {
+    /**
+     * Set the string value of a key.
+     *
+     * @param key The key of the value to set.
+     * @param value The value to set.
+     * @param nx If set to true, the key will only be set if it does not already exist.
+     * @param px Set the specified expire time, in milliseconds.
+     */
+    set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
+    /**
+     * Remove the specified keys.
+     *
+     * @param keys The keys to delete.
+     */
+    del(...keys: string[]): Promise<void>;
+}
+
+declare class LockTopicProvider extends TopicProvider {
+}
+
+declare const envSchema$1: _alepha_core.TObject<{
+    LOCK_PREFIX_KEY: TString;
+}>;
+declare module "alepha" {
+    interface Env extends Partial<Static<typeof envSchema$1>> {
+    }
+}
+declare class LockDescriptorProvider {
+    protected readonly alepha: Alepha;
+    protected readonly dateTimeProvider: DateTimeProvider;
+    protected readonly lockProvider: LockProvider;
+    protected readonly lockTopicProvider: LockTopicProvider;
+    protected readonly log: _alepha_core.Logger;
+    protected readonly env: {
+        LOCK_PREFIX_KEY: string;
+    };
+    protected readonly id: string;
+    protected readonly locks: Map<string, LockDescriptorValue>;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    protected readonly topicLockEnd: _alepha_topic.TopicDescriptor<{
+        payload: _alepha_core.TObject<{
+            name: TString;
+        }>;
+    }>;
+    protected prefixKey(key: string): string;
+    /**
+     * Run the lock handler.
+     *
+     * @param value
+     * @param args
+     */
+    protected run(value: LockDescriptorValue, ...args: any[]): Promise<void>;
+    protected wait(key: string, maxDuration: DurationLike): Promise<void>;
+    /**
+     * Lock the key.
+     *
+     * @param key - The key to lock.
+     * @param item - The lock descriptor value.
+     */
+    protected lock(key: string, item: LockDescriptorValue): Promise<LockObject>;
+    protected parse(value: string): LockObject;
+}
+interface LockDescriptorValue {
+    options: LockDescriptorOptions<AsyncFn>;
+    key: (...args: any[]) => string;
+    maxDuration: DurationLike;
+}
+interface LockObject {
+    id: string;
+    createdAt: DateTime;
+    endedAt?: DateTime;
+    response?: string;
+}
+
+/**
+ * A simple in-memory store provider.
+ */
+declare class MemoryLockProvider implements LockProvider {
+    protected readonly dateTimeProvider: DateTimeProvider;
+    protected readonly log: _alepha_core.Logger;
+    /**
+     * The in-memory store.
+     */
+    protected store: Record<string, string>;
+    /**
+     * Timeouts used to expire keys.
+     */
+    protected storeTimeout: Record<string, Timeout>;
+    /**
+     * Set the string value of a key.
+     *
+     * @param key The key of the value to set.
+     * @param value The value to set.
+     * @param nx If set to true, the key will only be set if it does not already exist.
+     * @param px Set the specified expire time, in milliseconds.
+     */
+    set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
+    /**
+     * Remove the specified keys.
+     *
+     * @param keys The keys to delete.
+     */
+    del(...keys: string[]): Promise<void>;
+    /**
+     * Set a timeout for a key.
+     *
+     * @param key The key to set the timeout for.
+     * @param ms The number of milliseconds to wait before deleting the key.
+     */
+    private ttl;
+}
+
+/**
+ * A store provider that uses Redis.
+ */
+declare class RedisLockProvider extends LockProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly redisProvider: RedisProvider;
+    /**
+     * Get the Redis publisher.
+     */
+    protected get publisher(): RedisClient;
+    /**
+     * Set the string value of a key.
+     *
+     * @param key The key of the value to set.
+     * @param value The value to set.
+     * @param nx If set to true, the key will only be set if it does not already exist.
+     * @param px Set the specified expire time, in milliseconds.
+     */
+    set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
+    /**
+     * Remove the specified keys.
+     *
+     * @param keys The keys to delete.
+     */
+    del(...keys: string[]): Promise<void>;
+}
+
+declare const envSchema: _alepha_core.TObject<{
+    LOCK_PROVIDER: TUnsafe<"memory" | "redis">;
+}>;
+declare module "alepha/core" {
+    interface Env extends Partial<Static<typeof envSchema>> {
+    }
+}
+declare class LockModule {
+    protected readonly alepha: Alepha;
+    protected readonly env: {
+        LOCK_PROVIDER: "memory" | "redis";
+    };
+    constructor();
+}
+
+export { $lock, type LockDescriptor, type LockDescriptorOptions, LockDescriptorProvider, type LockDescriptorValue, LockModule, type LockObject, LockProvider, LockTopicProvider, MemoryLockProvider, RedisLockProvider };

package/package.json

@@ -1,31 +1,31 @@
 {
 	"name": "alepha",
-	"version": "0.6.7",
+	"version": "0.6.8",
 	"type": "module",
 	"license": "MIT",
 	"main": "./core.js",
 	"types": "./core.d.ts",
 	"dependencies": {
-		"@alepha/cache": "0.6.7",
-		"@alepha/core": "0.6.7",
-		"@alepha/datetime": "0.6.7",
-		"@alepha/lock": "0.6.7",
-		"@alepha/postgres": "0.6.7",
-		"@alepha/queue": "0.6.7",
-		"@alepha/react": "0.6.7",
-		"@alepha/react-auth": "0.6.7",
-		"@alepha/redis": "0.6.7",
-		"@alepha/scheduler": "0.6.7",
-		"@alepha/security": "0.6.7",
-		"@alepha/server": "0.6.7",
-		"@alepha/server-cookies": "0.6.7",
-		"@alepha/server-metrics": "0.6.7",
-		"@alepha/server-proxy": "0.6.7",
-		"@alepha/server-static": "0.6.7",
-		"@alepha/server-swagger": "0.6.7",
-		"@alepha/testing": "0.6.7",
-		"@alepha/topic": "0.6.7",
-		"@alepha/vite": "0.6.7"
+		"@alepha/cache": "0.6.8",
+		"@alepha/core": "0.6.8",
+		"@alepha/datetime": "0.6.8",
+		"@alepha/lock": "0.6.8",
+		"@alepha/postgres": "0.6.8",
+		"@alepha/queue": "0.6.8",
+		"@alepha/react": "0.6.8",
+		"@alepha/react-auth": "0.6.8",
+		"@alepha/redis": "0.6.8",
+		"@alepha/scheduler": "0.6.8",
+		"@alepha/security": "0.6.8",
+		"@alepha/server": "0.6.8",
+		"@alepha/server-cookies": "0.6.8",
+		"@alepha/server-metrics": "0.6.8",
+		"@alepha/server-proxy": "0.6.8",
+		"@alepha/server-static": "0.6.8",
+		"@alepha/server-swagger": "0.6.8",
+		"@alepha/testing": "0.6.8",
+		"@alepha/topic": "0.6.8",
+		"@alepha/vite": "0.6.8"
 	},
 	"peerDependencies": {
 		"@types/react": "^19",