alepha 0.7.6 → 0.8.0

package/datetime.d.ts

@@ -1,5 +1,4 @@
-import * as _alepha_core1 from "@alepha/core";
-import { Async } from "@alepha/core";
+import { Async, HookDescriptor, Logger } from "alepha";
 import dayjs, { Dayjs, ManipulateType } from "dayjs";
 import dayjsDuration from "dayjs/plugin/duration.js";
 
@@ -11,18 +10,18 @@ declare class Interval {
   private options;
   constructor(duration: number, options: IntervalDescriptorOptions);
   /**
-   * Start the interval.
-   */
+  * Start the interval.
+  */
   start(): Promise<void>;
   /**
-   * Add time to the interval.
-   *
-   * @param amountMs
-   */
+  * Add time to the interval.
+  *
+  * @param amountMs
+  */
   add(amountMs: number): Promise<void>;
   /**
-   * Clear the interval.
-   */
+  * Clear the interval.
+  */
   clear(): void;
 }
 //#endregion
@@ -34,18 +33,18 @@ declare class Timeout {
   private readonly callback;
   constructor(now: number, duration: number, callback: () => void);
   /**
-   * Add time to the timeout.
-   */
+  * Add time to the timeout.
+  */
   add(amountMs: number): void;
   /**
-   * Clear the timeout.
-   */
+  * Clear the timeout.
+  */
   clear(): void;
   /**
-   * Start the timeout.
-   *
-   * @private
-   */
+  * Start the timeout.
+  *
+  * @private
+  */
   private start;
 }
 //#endregion
@@ -54,113 +53,114 @@ type DateTime = dayjs.Dayjs;
 type Duration = dayjsDuration.Duration;
 type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
 declare class DateTimeProvider {
-  protected log: _alepha_core1.Logger;
+  protected log: Logger;
   protected ref: DateTime | null;
   protected readonly timeouts: Timeout[];
   protected readonly intervals: Interval[];
   constructor();
-  protected readonly start: _alepha_core1.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
+  protected readonly start: HookDescriptor<"start">;
+  protected readonly stop: HookDescriptor<"stop">;
   /**
-   * Create a new DateTime instance.
-   */
+  * Create a new DateTime instance.
+  */
   of(date: string | number | Date | Dayjs | null | undefined): DateTime;
   /**
-   * Get the current date.
-   */
+  * Get the current date.
+  */
   now(): DateTime;
   /**
-   * Get the current date as a string.
-   *
-   * @param date
-   */
+  * Get the current date as a string.
+  *
+  * @param date
+  */
   toISOString(date?: Date | string | DateTime): string;
   /**
-   * Get the current date as a string.
-   */
+  * Get the current date as a string.
+  */
   nowISOString(): string;
   /**
-   * Get the current date as a string.
-   *
-   * @protected
-   */
+  * Get the current date as a string.
+  *
+  * @protected
+  */
   protected getCurrentDate(): DateTime;
   /**
-   * Create a new Duration instance.
-   */
+  * Create a new Duration instance.
+  */
   duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
   isDurationLike(value: unknown): value is DurationLike;
   /**
-   * Return a promise that resolves after a next tick.
-   * It uses `setTimeout` with 0ms delay.
-   */
+  * Return a promise that resolves after a next tick.
+  * It uses `setTimeout` with 0ms delay.
+  */
   tick(): Promise<void>;
   /**
-   * Wait for a certain duration.
-   *
-   * You can clear the timeout by using the `AbortSignal` API.
-   * Aborted signal will resolve the promise immediately, it does not reject it.
-   */
+  * Wait for a certain duration.
+  *
+  * You can clear the timeout by using the `AbortSignal` API.
+  * Aborted signal will resolve the promise immediately, it does not reject it.
+  */
   wait(duration: DurationLike, options?: {
     signal?: AbortSignal;
     now?: number;
   }): Promise<void>;
   /**
-   * Run a callback after a certain duration.
-   */
+  * Run a callback after a certain duration.
+  */
   timeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
   /**
-   * Create an interval.
-   *
-   * @param args
-   */
+  * Create an interval.
+  *
+  * @param args
+  */
   interval(args: IntervalDescriptorOptions): Interval;
   /**
-   * Run a function with a deadline.
-   */
+  * Run a function with a deadline.
+  */
   deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
+  // Testing
   /**
-   * Add time to the current date.
-   */
+  * Add time to the current date.
+  */
   travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
   /**
-   * Stop the time.
-   */
-  pause(): dayjs.Dayjs;
+  * Stop the time.
+  */
+  pause(): DateTime;
   /**
-   * Reset the reference date.
-   */
+  * Reset the reference date.
+  */
   reset(): void;
 }
 //#endregion
 //#region src/descriptors/$interval.d.ts
 interface IntervalDescriptorOptions {
   /**
-   * Whether to start the interval immediately.
-   *
-   * @default false
-   */
+  * 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
-   */
+  * 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.
-   */
+  * The interval handler.
+  */
   handler: () => Async<void>;
   /**
-   * The interval duration.
-   */
+  * The interval duration.
+  */
   duration: DurationLike;
 }
 /**
- * Registers a new interval.
- */
+* Registers a new interval.
+*/
 declare const $interval: (options: IntervalDescriptorOptions) => Interval;
 //#endregion
 export { $interval, DateTime, DateTimeProvider, Duration, DurationLike, Interval, IntervalDescriptorOptions, Timeout };

package/lock/redis.d.ts

@@ -1,25 +1,25 @@
-import { LockProvider } from "@alepha/lock";
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha } from "@alepha/core";
-import { RedisProvider } from "@alepha/redis";
+import { LockProvider } from "alepha/lock";
+import { Alepha, Logger } from "alepha";
+import { RedisProvider } from "alepha/redis";
 
 //#region src/providers/RedisLockProvider.d.ts
 declare class RedisLockProvider implements LockProvider {
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: Logger;
   protected readonly redisProvider: RedisProvider;
   set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
   del(...keys: string[]): Promise<void>;
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 /**
- * Alepha Lock Redis Module
- *
- * Plugin for Alepha that provides a locking mechanism.
- *
- * @see {@link RedisLockProvider}
- * @module alepha.lock.redis
- */
+* Alepha Lock Redis Module
+*
+* Plugin for Alepha that provides a locking mechanism.
+*
+* @see {@link RedisLockProvider}
+* @module alepha.lock.redis
+*/
 declare class AlephaLockRedis {
   readonly name = "alepha.lock.redis";
   readonly $services: (alepha: Alepha) => Alepha;

package/lock.d.ts

@@ -1,23 +1,19 @@
-import * as _alepha_core2 from "@alepha/core";
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, AsyncFn, KIND, OPTIONS, Static } from "@alepha/core";
-import * as _alepha_topic8 from "@alepha/topic";
-import { TopicProvider } from "@alepha/topic";
-import { DateTime, DateTimeProvider, DurationLike, Timeout } from "@alepha/datetime";
-import * as _sinclair_typebox1 from "@sinclair/typebox";
+import { Alepha, AsyncFn, HookDescriptor, KIND, Logger, OPTIONS, Static, TObject, TString } from "alepha";
+import { TopicDescriptor, TopicProvider } from "alepha/topic";
+import { DateTime, DateTimeProvider, DurationLike, Timeout } from "alepha/datetime";
 
 //#region src/descriptors/$lock.d.ts
 declare const KEY = "LOCK";
 interface LockDescriptorOptions<TFunc extends AsyncFn> {
   /**
-   * Function executed when the lock is acquired.
-   */
+  * Function executed when the lock is acquired.
+  */
   handler: TFunc;
   /**
-   * If true, the handler will wait for the lock to be released.
-   *
-   * @default false
-   */
+  * If true, the handler will wait for the lock to be released.
+  *
+  * @default false
+  */
   wait?: boolean;
   key?: string | ((...args: Parameters<TFunc>) => string);
   maxDuration?: DurationLike;
@@ -27,21 +23,21 @@ interface LockDescriptor<TFunc extends AsyncFn> {
   [KIND]: typeof KEY;
   [OPTIONS]: LockDescriptorOptions<TFunc>;
   /**
-   * Apply the lock.
-   *
-   * @param args
-   */
+  * 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
- */
+* 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;
@@ -49,23 +45,23 @@ declare const $lock: {
 //#endregion
 //#region src/providers/LockProvider.d.ts
 /**
- * Store Provider Interface
- */
+* Store Provider Interface
+*/
 declare abstract 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 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.
+  */
   abstract set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
   /**
-   * Remove the specified keys.
-   *
-   * @param keys The keys to delete.
-   */
+  * Remove the specified keys.
+  *
+  * @param keys The keys to delete.
+  */
   abstract del(...keys: string[]): Promise<void>;
 }
 //#endregion
@@ -73,8 +69,8 @@ declare abstract class LockProvider {
 declare class LockTopicProvider extends TopicProvider {}
 //#endregion
 //#region src/providers/LockDescriptorProvider.d.ts
-declare const envSchema: _alepha_core2.TObject<{
-  LOCK_PREFIX_KEY: _sinclair_typebox1.TString;
+declare const envSchema: TObject<{
+  LOCK_PREFIX_KEY: TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -84,33 +80,31 @@ declare class LockDescriptorProvider {
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly lockProvider: LockProvider;
   protected readonly lockTopicProvider: LockTopicProvider;
-  protected readonly log: _alepha_core2.Logger;
-  protected readonly env: {
-    LOCK_PREFIX_KEY: string;
-  };
+  protected readonly log: Logger;
+  protected readonly env: Static<typeof envSchema>;
   protected readonly id: string;
   protected readonly locks: Map<string, LockDescriptorValue>;
-  protected readonly configure: _alepha_core2.HookDescriptor<"configure">;
-  protected readonly topicLockEnd: _alepha_topic8.TopicDescriptor<{
-    payload: _alepha_core2.TObject<{
-      name: _sinclair_typebox1.TString;
+  protected readonly configure: HookDescriptor<"configure">;
+  protected readonly topicLockEnd: TopicDescriptor<{
+    payload: TObject<{
+      name: TString;
     }>;
   }>;
   protected prefixKey(key: string): string;
   /**
-   * Run the lock handler.
-   *
-   * @param value
-   * @param args
-   */
+  * 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.
-   */
+  * 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;
 }
@@ -128,18 +122,18 @@ interface LockObject {
 //#endregion
 //#region src/providers/MemoryLockProvider.d.ts
 /**
- * A simple in-memory store provider.
- */
+* A simple in-memory store provider.
+*/
 declare class MemoryLockProvider implements LockProvider {
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: Logger;
   /**
-   * The in-memory store.
-   */
+  * The in-memory store.
+  */
   protected store: Record<string, string>;
   /**
-   * Timeouts used to expire keys.
-   */
+  * Timeouts used to expire keys.
+  */
   protected storeTimeout: Record<string, Timeout>;
   set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
   del(...keys: string[]): Promise<void>;
@@ -147,17 +141,18 @@ declare class MemoryLockProvider implements LockProvider {
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 /**
- * Alepha Lock Module
- *
- * Lock a resource for a certain period of time.
- *
- * This module provides a memory implementation of the lock provider.
- * You probably want to use an implementation like RedisLockProvider for distributed systems.
- *
- * @see {@link $lock}
- * @module alepha.lock
- */
+* Alepha Lock Module
+*
+* Lock a resource for a certain period of time.
+*
+* This module provides a memory implementation of the lock provider.
+* You probably want to use an implementation like RedisLockProvider for distributed systems.
+*
+* @see {@link $lock}
+* @module alepha.lock
+*/
 declare class AlephaLock {
   readonly name = "alepha.lock";
   readonly $services: (alepha: Alepha) => Alepha;