alepha/scheduler.d.ts

Alepha is a convention-driven TypeScript framework for building robust, end-to-end type-safe applications, from serverless APIs to full-stack React apps.

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