alepha 0.7.5 → 0.7.7

package/scheduler.d.ts

@@ -1,206 +1,147 @@
-import * as _alepha_core from '@alepha/core';
-import { Async, KIND, OPTIONS, Alepha, Static } from '@alepha/core';
-import { DateTime, DurationLike, DateTimeProvider, Interval } from '@alepha/datetime';
-import * as _alepha_lock from '@alepha/lock';
-import { Cron } from 'cron-schedule';
+import * as _alepha_core9 from "@alepha/core";
+import * as _alepha_core2 from "@alepha/core";
+import { Alepha, Async, KIND, OPTIONS, Static } from "@alepha/core";
+import * as _alepha_lock8 from "@alepha/lock";
+import { DateTime, DateTimeProvider, DurationLike, Interval } from "@alepha/datetime";
+import { Cron } from "cron-schedule";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
+import * as dayjs10 from "dayjs";
 
+//#region src/descriptors/$scheduler.d.ts
 declare const KEY = "SCHEDULER";
 /**
  * Scheduler descriptor.
  */
 declare const $scheduler: {
-    (options: SchedulerDescriptorOptions): SchedulerDescriptor;
-    [KIND]: string;
+  (options: SchedulerDescriptorOptions): SchedulerDescriptor;
+  [KIND]: string;
 };
 declare const isScheduler: (value: any) => value is 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;
+  /**
+   * 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;
 };
 interface SchedulerDescriptor {
-    [KIND]: typeof KEY;
-    [OPTIONS]: SchedulerDescriptorOptions;
-    (): Promise<void>;
+  [KIND]: typeof KEY;
+  [OPTIONS]: SchedulerDescriptorOptions;
+  (): Promise<void>;
 }
 interface SchedulerHandlerArguments {
-    now: DateTime;
-}
-
-/** 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 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';
-}
-
-type TOptional<T extends TSchema> = T & {
-    [OptionalKind]: 'Optional';
-};
-
-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;
+  now: DateTime;
 }
-interface TSchema extends TKind, SchemaOptions {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}
-
+//#endregion
+//#region src/providers/CronScheduler.d.ts
 interface CronJob {
-    handler: (context: {
-        now: DateTime;
-    }) => Promise<void>;
-    cron: Cron;
-    loop: boolean;
-    running?: boolean;
-    onError?: (error: Error) => void;
-    abort: AbortController;
+  handler: (context: {
+    now: DateTime;
+  }) => Promise<void>;
+  cron: Cron;
+  loop: boolean;
+  running?: boolean;
+  onError?: (error: Error) => void;
+  abort: AbortController;
 }
 declare class CronProvider {
-    protected readonly dt: DateTimeProvider;
-    protected readonly alepha: Alepha;
-    protected readonly log: _alepha_core.Logger;
-    start(cron: CronJob): void;
-    stop(cron: CronJob): void;
-    create(expression: string, handler: (context: {
-        now: DateTime;
-    }) => Promise<void>): CronJob;
-    run(task: CronJob, now?: undefined): void;
+  protected readonly dt: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  protected readonly log: _alepha_core9.Logger;
+  start(cron: CronJob): void;
+  stop(cron: CronJob): void;
+  create(expression: string, handler: (context: {
+    now: DateTime;
+  }) => Promise<void>): CronJob;
+  run(task: CronJob, now?: dayjs10.Dayjs): void;
 }
-
-declare const envSchema: _alepha_core.TObject<{
-    SCHEDULER_PREFIX: TOptional<TString>;
+//#endregion
+//#region src/providers/SchedulerDescriptorProvider.d.ts
+declare const envSchema: _alepha_core2.TObject<{
+  SCHEDULER_PREFIX: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
+  interface Env extends Partial<Static<typeof envSchema>> {}
 }
 declare class SchedulerDescriptorProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly env: {
-        SCHEDULER_PREFIX?: string | undefined;
-    };
-    protected readonly alepha: Alepha;
-    protected readonly dateTimeProvider: DateTimeProvider;
-    protected readonly cronProvider: CronProvider;
-    protected readonly schedulers: Scheduler[];
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    protected readonly start: _alepha_core.HookDescriptor<"start">;
-    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
-    protected createContextId(): string;
-    /**
-     * Get the schedulers.
-     */
-    getSchedulers(): Scheduler[];
-    /**
-     * Process scheduler descriptors.
-     *
-     * @protected
-     */
-    protected processSchedulerDescriptors(): void;
-    /**
-     * Create a scheduler.
-     *
-     * @param options - The scheduler options.
-     * @param instance - The instance of the scheduler.
-     * @param key - Property key name.
-     * @protected
-     */
-    protected createScheduler(options: SchedulerDescriptorOptions, instance: any, key: string): Scheduler;
-    protected createHandler(name: string, options: SchedulerDescriptorOptions): (args: SchedulerHandlerArguments) => Promise<void>;
-    trigger(name: string): Promise<void>;
-    protected runLock: _alepha_lock.LockDescriptor<(options: SchedulerDescriptorOptions & {
-        name: string;
-        args: SchedulerHandlerArguments;
-    }) => Promise<void>>;
-    /**
-     * Prefix the scheduler key.
-     */
-    protected prefix(key: string): string;
-    /**
-     *
-     * @param options
-     * @protected
-     */
-    protected getLockGracePeriod(options: SchedulerDescriptorOptions): number;
+  protected readonly log: _alepha_core2.Logger;
+  protected readonly env: {
+    SCHEDULER_PREFIX?: string | undefined;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly cronProvider: CronProvider;
+  protected readonly schedulers: Scheduler[];
+  protected readonly configure: _alepha_core2.HookDescriptor<"configure">;
+  protected readonly start: _alepha_core2.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core2.HookDescriptor<"stop">;
+  /**
+   * Get the schedulers.
+   */
+  getSchedulers(): Scheduler[];
+  /**
+   * Process scheduler descriptors.
+   *
+   * @protected
+   */
+  protected processSchedulerDescriptors(): void;
+  /**
+   * Create a scheduler.
+   *
+   * @param options - The scheduler options.
+   * @param instance - The instance of the scheduler.
+   * @param key - Property key name.
+   * @protected
+   */
+  protected createScheduler(options: SchedulerDescriptorOptions, instance: any, key: string): Scheduler;
+  protected createHandler(name: string, options: SchedulerDescriptorOptions): (args: SchedulerHandlerArguments) => Promise<void>;
+  trigger(name: string): Promise<void>;
+  protected runLock: _alepha_lock8.LockDescriptor<(options: SchedulerDescriptorOptions & {
+    name: string;
+    args: SchedulerHandlerArguments;
+  }) => Promise<void>>;
+  /**
+   * Prefix the scheduler key.
+   */
+  protected prefix(key: string): string;
+  /**
+   *
+   * @param options
+   * @protected
+   */
+  protected getLockGracePeriod(options: SchedulerDescriptorOptions): number;
 }
 interface Scheduler {
-    name: string;
-    options: SchedulerDescriptorOptions;
-    trigger: (args: SchedulerHandlerArguments) => Promise<void>;
-    cron?: CronJob;
-    interval?: Interval;
+  name: string;
+  options: SchedulerDescriptorOptions;
+  trigger: (args: SchedulerHandlerArguments) => Promise<void>;
+  cron?: CronJob;
+  interval?: Interval;
 }
-
+//#endregion
+//#region src/index.d.ts
 /**
  * Alepha Scheduler Module
  *
@@ -210,8 +151,9 @@ interface Scheduler {
  * @module alepha.scheduler
  */
 declare class AlephaScheduler {
-    readonly name = "alepha.scheduler";
-    readonly $services: (alepha: Alepha) => Alepha;
+  readonly name = "alepha.scheduler";
+  readonly $services: (alepha: Alepha) => Alepha;
 }
-
-export { $scheduler, AlephaScheduler, type Scheduler, type SchedulerDescriptor, type SchedulerDescriptorOptions, SchedulerDescriptorProvider, type SchedulerHandlerArguments, isScheduler };
+//#endregion
+export { $scheduler, AlephaScheduler, Scheduler, SchedulerDescriptor, SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerHandlerArguments, isScheduler };
+//# sourceMappingURL=index.d.ts.map

package/scheduler.js

@@ -1 +1 @@
-export * from '@alepha/scheduler';
+export * from '@alepha/scheduler'

package/security.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var security = require('@alepha/security');
-
-
-
-Object.keys(security).forEach(function (k) {
+var m = require('@alepha/security');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return security[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});