alepha 0.11.4 → 0.11.5

package/redis.d.ts

@@ -1 +1,82 @@
-export * from '@alepha/redis';
+import * as _alepha_core3 from "alepha";
+import { Alepha, Static } from "alepha";
+import * as _alepha_logger0 from "alepha/logger";
+import { RedisClientType, SetOptions, createClient } from "@redis/client";
+
+//#region src/providers/RedisProvider.d.ts
+declare const envSchema: _alepha_core3.TObject<{
+  REDIS_PORT: _alepha_core3.TInteger;
+  REDIS_HOST: _alepha_core3.TString;
+  REDIS_PASSWORD: _alepha_core3.TOptional<_alepha_core3.TString>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+type RedisClient = RedisClientType<{}, {}, {}, 3, {
+  36: BufferConstructor;
+}>;
+type RedisClientOptions = Parameters<typeof createClient>[0];
+type RedisSetOptions = SetOptions;
+/**
+ * Redis client provider.
+ */
+declare class RedisProvider {
+  protected readonly log: _alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly env: {
+    REDIS_PASSWORD?: string | undefined;
+    REDIS_PORT: number;
+    REDIS_HOST: string;
+  };
+  protected readonly client: RedisClient;
+  get publisher(): RedisClient;
+  protected readonly start: _alepha_core3.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core3.HookDescriptor<"stop">;
+  /**
+   * Connect to the Redis server.
+   */
+  connect(): Promise<void>;
+  /**
+   * Close the connection to the Redis server.
+   */
+  close(): Promise<void>;
+  duplicate(options?: Partial<RedisClientOptions>): RedisClient;
+  get(key: string): Promise<Buffer | undefined>;
+  set(key: string, value: Buffer | string, options?: RedisSetOptions): Promise<Buffer>;
+  has(key: string): Promise<boolean>;
+  keys(pattern: string): Promise<string[]>;
+  del(keys: string[]): Promise<void>;
+  /**
+   * Redis subscriber client factory method.
+   */
+  protected createClient(): RedisClient;
+}
+//#endregion
+//#region src/providers/RedisSubscriberProvider.d.ts
+declare class RedisSubscriberProvider {
+  protected readonly log: _alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly redisProvider: RedisProvider;
+  protected readonly client: RedisClient;
+  get subscriber(): RedisClient;
+  protected readonly start: _alepha_core3.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core3.HookDescriptor<"stop">;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  /**
+   * Redis subscriber client factory method.
+   */
+  protected createClient(): RedisClient;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Redis client provider for Alepha applications.
+ *
+ * @see {@link RedisProvider}
+ * @module alepha.redis
+ */
+declare const AlephaRedis: _alepha_core3.Service<_alepha_core3.Module<{}>>;
+//#endregion
+export { AlephaRedis, RedisClient, RedisClientOptions, RedisProvider, RedisSetOptions, RedisSubscriberProvider };
+//# sourceMappingURL=index.d.ts.map

package/scheduler.d.ts

@@ -1 +1,145 @@
-export * from '@alepha/scheduler';
+import * as _alepha_core1 from "alepha";
+import { Alepha, Async, Descriptor, KIND, Static } from "alepha";
+import * as _alepha_lock0 from "alepha/lock";
+import { DateTime, DateTimeProvider, DurationLike } from "alepha/datetime";
+import * as _alepha_logger0 from "alepha/logger";
+import * as dayjs0 from "dayjs";
+import { Cron } from "cron-schedule";
+
+//#region src/constants/CRON.d.ts
+declare const CRON: {
+  EVERY_MINUTE: string;
+  EVERY_5_MINUTES: string;
+  EVERY_15_MINUTES: string;
+  EVERY_30_MINUTES: string;
+  EVERY_HOUR: string;
+  EVERY_DAY_AT_MIDNIGHT: string;
+};
+//#endregion
+//#region src/providers/CronProvider.d.ts
+declare class CronProvider {
+  protected readonly dt: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  protected readonly log: _alepha_logger0.Logger;
+  protected readonly cronJobs: Array<CronJob>;
+  getCronJobs(): Array<CronJob>;
+  protected readonly start: _alepha_core1.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
+  protected boot(name: string | CronJob): void;
+  abort(name: string | CronJob): void;
+  /**
+   * Registers a cron job.
+   *
+   * It's automatically done when using the `$scheduler` descriptor but can also be used manually.
+   */
+  createCronJob(name: string, expression: string, handler: (context: {
+    now: DateTime;
+  }) => Promise<void>, start?: boolean): void;
+  protected run(task: CronJob, now?: dayjs0.Dayjs): void;
+}
+interface CronJob {
+  name: string;
+  expression: string;
+  handler: (context: {
+    now: DateTime;
+  }) => Promise<void>;
+  cron: Cron;
+  loop: boolean;
+  running?: boolean;
+  onError?: (error: Error) => void;
+  abort: AbortController;
+}
+//#endregion
+//#region src/descriptors/$scheduler.d.ts
+/**
+ * Scheduler descriptor.
+ */
+declare const $scheduler: {
+  (options: SchedulerDescriptorOptions): SchedulerDescriptor;
+  [KIND]: typeof SchedulerDescriptor;
+};
+type SchedulerDescriptorOptions = {
+  /**
+   * Function to run on schedule.
+   */
+  handler: (args: SchedulerHandlerArguments) => Async<void>;
+  /**
+   * Name of the scheduler. Defaults to the function name.
+   */
+  name?: string;
+  /**
+   * Optional description of the scheduler.
+   */
+  description?: string;
+  /**
+   * Cron expression or interval to run the scheduler.
+   */
+  cron?: string;
+  /**
+   * Cron expression or interval to run the scheduler.
+   */
+  interval?: DurationLike;
+  /**
+   * If true, the scheduler will be locked and only one instance will run at a time.
+   * You probably need to import {@link AlephaLockRedis} for distributed locking.
+   *
+   * @default true
+   */
+  lock?: boolean;
+};
+declare const envSchema: _alepha_core1.TObject<{
+  SCHEDULER_PREFIX: _alepha_core1.TOptional<_alepha_core1.TString>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+declare class SchedulerDescriptor extends Descriptor<SchedulerDescriptorOptions> {
+  protected readonly log: _alepha_logger0.Logger;
+  protected readonly env: {
+    SCHEDULER_PREFIX?: string | undefined;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly cronProvider: CronProvider;
+  get name(): string;
+  protected onInit(): void;
+  trigger(): Promise<void>;
+  protected schedulerLock: _alepha_lock0.LockDescriptor<(args: SchedulerHandlerArguments) => Promise<void>>;
+}
+interface SchedulerHandlerArguments {
+  now: DateTime;
+}
+//#endregion
+//#region src/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    "scheduler:begin": {
+      name: string;
+      now: DateTime;
+      context: string;
+    };
+    "scheduler:success": {
+      name: string;
+      context: string;
+    };
+    "scheduler:error": {
+      name: string;
+      error: Error;
+      context: string;
+    };
+    "scheduler:end": {
+      name: string;
+      context: string;
+    };
+  }
+}
+/**
+ * Generic interface for scheduling tasks.
+ *
+ * @see {@link $scheduler}
+ * @module alepha.scheduler
+ */
+declare const AlephaScheduler: _alepha_core1.Service<_alepha_core1.Module<{}>>;
+//#endregion
+export { $scheduler, AlephaScheduler, CRON, CronJob, CronProvider, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerHandlerArguments };
+//# sourceMappingURL=index.d.ts.map