@codenameryuu/adonis-scheduler 1.0.0

package/build/src/scheduler.d.ts

@@ -0,0 +1,130 @@
+import { BaseCommand } from "@adonisjs/core/ace";
+import type { ApplicationService } from "@adonisjs/core/types";
+type Range<START extends number, END extends number, ARR extends unknown[] = [], ACC extends number = never> = ARR["length"] extends END ? ACC | START | END : Range<START, END, [...ARR, 1], ARR[START] extends undefined ? ACC : ACC | ARR["length"]>;
+type DAYS = 0 | 1 | 2 | 3 | 4 | 5 | 6 | "0" | "1" | "2" | "3" | "4" | "5" | "6";
+export declare abstract class BaseSchedule {
+    SUNDAY: 0;
+    MONDAY: 1;
+    TUESDAY: 2;
+    WEDNESDAY: 3;
+    THURSDAY: 4;
+    FRIDAY: 5;
+    SATURDAY: 6;
+    abstract type: string;
+    expression: string;
+    config: {
+        tag: string;
+        enabled: boolean;
+        immediate: boolean;
+        withoutOverlapping: boolean;
+        expiresAt: number;
+        timezone: string | undefined;
+    };
+    beforeCallbacks: (() => Promise<void>)[];
+    afterCallbacks: (() => Promise<void>)[];
+    before(callback: () => Promise<void>): this;
+    after(callback: () => Promise<void>): this;
+    timezone(timezone: string): this;
+    skip(state?: boolean): this;
+    tag(tag: string): this;
+    immediate(state?: boolean): this;
+    withoutOverlapping(expiresAt?: number): this;
+    everyMinutes(minutes: number): this;
+    everyMinute(): this;
+    everyTwoMinutes(): this;
+    everyThreeMinutes(): this;
+    everyFourMinutes(): this;
+    everyFiveMinutes(): this;
+    everyTenMinutes(): this;
+    everyFifteenMinutes(): this;
+    everyThirtyMinutes(): this;
+    hourly(): this;
+    hourlyAt(offset: string | number | Range<0, 59> | Range<0, 59>[]): this;
+    everyHours(hours: number, offset?: any[] | string | number): this;
+    everyOddHour(offset?: any[] | string | number): this;
+    everyTwoHours(offset?: any[] | string | number): this;
+    everyThreeHours(offset?: any[] | string | number): this;
+    everyFourHours(offset?: any[] | string | number): this;
+    everyFiveHours(offset?: any[] | string | number): this;
+    everySixHours(offset?: any[] | string | number): this;
+    daily(): this;
+    weekdays(): this;
+    weekends(): this;
+    mondays(): this;
+    tuesdays(): this;
+    wednesdays(): this;
+    thursdays(): this;
+    fridays(): this;
+    saturdays(): this;
+    sundays(): this;
+    weekly(): this;
+    weeklyOn(dayOfWeek?: Range<0, 7>, time?: string): this;
+    monthly(): this;
+    quarterly(): this;
+    yearly(): this;
+    yearlyOn(month?: number, dayOfMonth?: string | Range<1, 31>, time?: string): this;
+    everySecond(): this;
+    everySeconds(second: Range<1, 59>): this;
+    everyFiveSeconds(): this;
+    everyTenSeconds(): this;
+    everyFifteenSeconds(): this;
+    everyThirtySeconds(): this;
+    cron(expression: string): this;
+    protected spliceIntoPosition(position: number, value: string | number): this;
+    protected hourBasedSchedule(minutes: string | number | Range<0, 59>[], hours: string | number | Range<0, 59>[]): this;
+    days(days: DAYS | DAYS[]): this;
+    at(time: string): this;
+    dailyAt(time: string): this;
+    twiceDailyAt(first?: Range<0, 23>, second?: Range<0, 23>, offset?: number): this;
+    twiceDaily(first?: Range<0, 23>, second?: Range<0, 23>): this;
+    twiceMonthly(first?: Range<1, 31>, second?: Range<1, 31>, time?: string): this;
+    lastDayOfMonth(time?: string): this;
+    monthlyOn(dayOfMonth?: Range<1, 31>, time?: string): this;
+    getExpression(): string;
+}
+export declare class ScheduleCommand extends BaseSchedule {
+    type: "command";
+    commandName: string;
+    commandArgs: string[];
+    constructor(commandName: string, commandArgs?: string[]);
+}
+export declare class ScheduleCallback extends BaseSchedule {
+    type: "callback";
+    callback: Function;
+    constructor(callback: Function);
+}
+export declare class Scheduler {
+    protected app: ApplicationService;
+    SUNDAY: 0;
+    MONDAY: 1;
+    TUESDAY: 2;
+    WEDNESDAY: 3;
+    THURSDAY: 4;
+    FRIDAY: 5;
+    SATURDAY: 6;
+    constructor(app: ApplicationService);
+    static __decorator_schedules: (ScheduleCallback | ScheduleCommand)[];
+    items: (ScheduleCallback | ScheduleCommand)[];
+    onStartingCallback?: ({ tag }: {
+        tag: string;
+    }) => void | Promise<void>;
+    onStartedCallback?: ({ tag }: {
+        tag: string;
+    }) => void | Promise<void>;
+    onBootCallback?: () => void | Promise<void>;
+    boot(): Promise<void>;
+    command(name: string | typeof BaseCommand, args?: string | string[]): ScheduleCommand;
+    call(callback: Function): ScheduleCallback;
+    withoutOverlapping(callback: () => void, config?: {
+        expiresAt: number;
+    }): void;
+    withTag(callback: () => void, tag: string): void;
+    onStarting(callback: ({ tag }: {
+        tag: string;
+    }) => void | Promise<void>): void;
+    onStarted(callback: ({ tag }: {
+        tag: string;
+    }) => void | Promise<void>): void;
+    onBoot(callback: () => void | Promise<void>): void;
+}
+export {};

package/build/src/scheduler.js

@@ -0,0 +1,308 @@
+import { FsLoader } from "@adonisjs/core/ace";
+import { DateTime } from "luxon";
+import { arrayWrap } from "./utils.js";
+export class BaseSchedule {
+    SUNDAY = 0;
+    MONDAY = 1;
+    TUESDAY = 2;
+    WEDNESDAY = 3;
+    THURSDAY = 4;
+    FRIDAY = 5;
+    SATURDAY = 6;
+    expression = "0 * * * * *"; // seconds minutes hours dayOfMonth month dayOfWeek
+    config = {
+        tag: "default",
+        enabled: true,
+        immediate: false,
+        withoutOverlapping: false,
+        expiresAt: 3600000,
+        timezone: undefined,
+    };
+    beforeCallbacks = [];
+    afterCallbacks = [];
+    before(callback) {
+        this.beforeCallbacks.push(callback);
+        return this;
+    }
+    after(callback) {
+        this.afterCallbacks.push(callback);
+        return this;
+    }
+    timezone(timezone) {
+        this.config.timezone = timezone;
+        return this;
+    }
+    skip(state = true) {
+        this.config.enabled = !state;
+        return this;
+    }
+    tag(tag) {
+        this.config.tag = tag;
+        return this;
+    }
+    immediate(state = true) {
+        this.config.immediate = state;
+        return this;
+    }
+    withoutOverlapping(expiresAt = 3600000) {
+        this.config.withoutOverlapping = true;
+        this.config.expiresAt = expiresAt;
+        return this;
+    }
+    everyMinutes(minutes) {
+        return this.spliceIntoPosition(1, `*/${minutes}`);
+    }
+    everyMinute() {
+        return this.spliceIntoPosition(1, "*");
+    }
+    everyTwoMinutes() {
+        return this.everyMinutes(2);
+    }
+    everyThreeMinutes() {
+        return this.everyMinutes(3);
+    }
+    everyFourMinutes() {
+        return this.everyMinutes(4);
+    }
+    everyFiveMinutes() {
+        return this.everyMinutes(5);
+    }
+    everyTenMinutes() {
+        return this.everyMinutes(10);
+    }
+    everyFifteenMinutes() {
+        return this.everyMinutes(15);
+    }
+    everyThirtyMinutes() {
+        return this.everyMinutes(30);
+    }
+    hourly() {
+        return this.spliceIntoPosition(1, 0);
+    }
+    hourlyAt(offset) {
+        return this.hourBasedSchedule(offset, "*");
+    }
+    everyHours(hours, offset = 0) {
+        return this.hourBasedSchedule(offset, `*/${hours}`);
+    }
+    everyOddHour(offset = 0) {
+        return this.hourBasedSchedule(offset, "1-23/2");
+    }
+    everyTwoHours(offset = 0) {
+        return this.everyHours(2, offset);
+    }
+    everyThreeHours(offset = 0) {
+        return this.everyHours(3, offset);
+    }
+    everyFourHours(offset = 0) {
+        return this.everyHours(4, offset);
+    }
+    everyFiveHours(offset = 0) {
+        return this.everyHours(5, offset);
+    }
+    everySixHours(offset = 0) {
+        return this.everyHours(6, offset);
+    }
+    daily() {
+        return this.hourBasedSchedule(0, 0);
+    }
+    weekdays() {
+        return this.spliceIntoPosition(5, "1-5");
+    }
+    weekends() {
+        return this.spliceIntoPosition(5, "6,0");
+    }
+    mondays() {
+        return this.days(1);
+    }
+    tuesdays() {
+        return this.days(2);
+    }
+    wednesdays() {
+        return this.days(3);
+    }
+    thursdays() {
+        return this.days(4);
+    }
+    fridays() {
+        return this.days(5);
+    }
+    saturdays() {
+        return this.days(6);
+    }
+    sundays() {
+        return this.days(0);
+    }
+    weekly() {
+        return this.spliceIntoPosition(1, 0).spliceIntoPosition(2, 0).spliceIntoPosition(5, 0);
+    }
+    weeklyOn(dayOfWeek = 1, time = "0:0") {
+        this.dailyAt(time);
+        return this.days(dayOfWeek);
+    }
+    monthly() {
+        return this.spliceIntoPosition(1, 0).spliceIntoPosition(2, 0).spliceIntoPosition(3, 1);
+    }
+    quarterly() {
+        return this.spliceIntoPosition(1, 0).spliceIntoPosition(2, 0).spliceIntoPosition(3, 1).spliceIntoPosition(4, "1-12/3");
+    }
+    yearly() {
+        return this.spliceIntoPosition(1, 0).spliceIntoPosition(2, 0).spliceIntoPosition(3, 1).spliceIntoPosition(4, 1);
+    }
+    yearlyOn(month = 1, dayOfMonth = 1, time = "0:0") {
+        this.dailyAt(time);
+        return this.spliceIntoPosition(3, dayOfMonth).spliceIntoPosition(4, month);
+    }
+    everySecond() {
+        return this.spliceIntoPosition(0, "*");
+    }
+    everySeconds(second) {
+        return this.spliceIntoPosition(0, `*/${second}`);
+    }
+    everyFiveSeconds() {
+        return this.everySeconds(5);
+    }
+    everyTenSeconds() {
+        return this.everySeconds(10);
+    }
+    everyFifteenSeconds() {
+        return this.everySeconds(15);
+    }
+    everyThirtySeconds() {
+        return this.everySeconds(30);
+    }
+    cron(expression) {
+        this.expression = expression;
+        return this;
+    }
+    spliceIntoPosition(position, value) {
+        const segements = this.expression.split(" ");
+        segements[position] = String(value);
+        this.cron(segements.join(" "));
+        return this;
+    }
+    hourBasedSchedule(minutes, hours) {
+        minutes = Array.isArray(minutes) ? minutes.join(",") : minutes;
+        hours = Array.isArray(hours) ? hours.join(",") : hours;
+        return this.spliceIntoPosition(1, minutes).spliceIntoPosition(2, hours);
+    }
+    days(days) {
+        return this.spliceIntoPosition(5, Array.isArray(days) ? days.join(",") : days);
+    }
+    at(time) {
+        return this.dailyAt(time);
+    }
+    dailyAt(time) {
+        let segments = time.split(":");
+        return this.hourBasedSchedule(segments.length === 2 ? Number(segments[1]) : "0", Number(segments[0]));
+    }
+    twiceDailyAt(first = 1, second = 13, offset = 0) {
+        const hours = first + "," + second;
+        return this.hourBasedSchedule(offset, hours);
+    }
+    twiceDaily(first = 1, second = 13) {
+        return this.twiceDailyAt(first, second, 0);
+    }
+    twiceMonthly(first = 1, second = 13, time = "0:0") {
+        const dayOfMonth = first + "," + second;
+        this.dailyAt(time);
+        return this.spliceIntoPosition(3, dayOfMonth);
+    }
+    lastDayOfMonth(time = "0:0") {
+        this.dailyAt(time);
+        return this.spliceIntoPosition(3, DateTime.now().endOf("month").day);
+    }
+    monthlyOn(dayOfMonth = 1, time = "0:0") {
+        this.dailyAt(time);
+        return this.spliceIntoPosition(3, dayOfMonth);
+    }
+    getExpression() {
+        return this.expression;
+    }
+}
+export class ScheduleCommand extends BaseSchedule {
+    type = "command";
+    commandName;
+    commandArgs;
+    constructor(commandName, commandArgs = []) {
+        super();
+        this.commandName = commandName;
+        this.commandArgs = commandArgs;
+    }
+}
+export class ScheduleCallback extends BaseSchedule {
+    type = "callback";
+    callback;
+    constructor(callback) {
+        super();
+        this.callback = callback;
+    }
+}
+export class Scheduler {
+    app;
+    SUNDAY = 0;
+    MONDAY = 1;
+    TUESDAY = 2;
+    WEDNESDAY = 3;
+    THURSDAY = 4;
+    FRIDAY = 5;
+    SATURDAY = 6;
+    constructor(app) {
+        this.app = app;
+        this.app = app;
+    }
+    static __decorator_schedules = [];
+    items = [];
+    onStartingCallback;
+    onStartedCallback;
+    onBootCallback;
+    async boot() {
+        await this.onBootCallback?.();
+        const fsLoader = new FsLoader(this.app.commandsPath());
+        await fsLoader.getMetaData();
+        for (const command of this.app.rcFile.commands) {
+            const loader = await (typeof command === "function" ? command() : command);
+            await loader.getMetaData();
+        }
+        if (!Scheduler.__decorator_schedules || Scheduler.__decorator_schedules.length === 0)
+            return;
+        this.items.push(...Scheduler.__decorator_schedules);
+    }
+    command(name, args = []) {
+        let newCommand = new ScheduleCommand(typeof name === "string" ? name : name.commandName, arrayWrap(args));
+        this.items.push(newCommand);
+        return newCommand;
+    }
+    call(callback) {
+        let newCommand = new ScheduleCallback(callback);
+        this.items.push(newCommand);
+        return newCommand;
+    }
+    withoutOverlapping(callback, config = { expiresAt: 3600000 }) {
+        const lastLength = this.items.length;
+        callback();
+        const currentLength = this.items.length;
+        const newItems = this.items.slice(lastLength, currentLength);
+        for (const item of newItems) {
+            item.withoutOverlapping(config.expiresAt);
+        }
+    }
+    withTag(callback, tag) {
+        const lastLength = this.items.length;
+        callback();
+        const currentLength = this.items.length;
+        const newItems = this.items.slice(lastLength, currentLength);
+        for (const item of newItems) {
+            item.tag(tag);
+        }
+    }
+    onStarting(callback) {
+        this.onStartingCallback = callback;
+    }
+    onStarted(callback) {
+        this.onStartedCallback = callback;
+    }
+    onBoot(callback) {
+        this.onBootCallback = callback;
+    }
+}

package/build/src/utils.d.ts

@@ -0,0 +1 @@
+export declare const arrayWrap: <T extends any>(value: T | T[]) => T[];

package/build/src/utils.js

@@ -0,0 +1,3 @@
+export const arrayWrap = (value) => {
+    return Array.isArray(value) ? value : [value];
+};

package/build/src/worker.d.ts

@@ -0,0 +1,14 @@
+import type { ApplicationService } from "@adonisjs/core/types";
+import cron from "node-cron";
+import { Kernel } from "@adonisjs/core/ace";
+export declare class Worker {
+    app: ApplicationService;
+    tasks: cron.ScheduledTask[];
+    loaders: any[];
+    booted: boolean;
+    kernel: Kernel;
+    constructor(app: ApplicationService);
+    boot(): Promise<void>;
+    start(tag?: string): Promise<void>;
+    stop(): Promise<void>;
+}

package/build/src/worker.js

@@ -0,0 +1,112 @@
+import cron from "node-cron";
+import AsyncLock from "async-lock";
+import { FsLoader, Kernel } from "@adonisjs/core/ace";
+const lock = new AsyncLock();
+const run = async (cb, options) => {
+    if (!options.enabled)
+        return await cb();
+    if (lock.isBusy(options.key)) {
+        if (options.onBusy) {
+            await options.onBusy();
+        }
+        return;
+    }
+    await lock.acquire(options.key, cb, { maxPending: 1, timeout: options.timeout });
+};
+export class Worker {
+    app;
+    tasks = [];
+    loaders = [];
+    booted = false;
+    constructor(app) {
+        this.app = app;
+    }
+    async boot() {
+        if (this.booted)
+            return;
+        const schedule = await this.app.container.make("scheduler");
+        await schedule.boot();
+        const fsLoader = new FsLoader(this.app.commandsPath());
+        this.loaders = [fsLoader];
+        this.app.rcFile.commands.forEach((commandModule) => {
+            this.loaders.push(() => (typeof commandModule === "function" ? commandModule() : this.app.import(commandModule)));
+        });
+        this.kernel = new Kernel(this.app);
+        for (const loader of this.loaders) {
+            this.kernel.addLoader(loader);
+        }
+        await this.kernel.boot();
+        this.booted = true;
+    }
+    async start(tag = "default") {
+        await this.boot();
+        const schedule = await this.app.container.make("scheduler");
+        const logger = await this.app.container.make("logger");
+        if (schedule.onStartingCallback) {
+            await schedule.onStartingCallback({
+                tag,
+            });
+        }
+        for (let index = 0; index < schedule.items.length; index++) {
+            const command = schedule.items[index];
+            if (command.config.tag !== tag) {
+                continue;
+            }
+            this.tasks.push(cron.schedule(command.expression, async () => {
+                try {
+                    switch (command.type) {
+                        case "command":
+                            for (const callback of command.beforeCallbacks) {
+                                await callback();
+                            }
+                            await run(() => this.kernel.exec(command.commandName, command.commandArgs), {
+                                enabled: command.config.withoutOverlapping,
+                                timeout: command.config.expiresAt,
+                                key: `${index}-${command.commandName}-${command.commandArgs}`,
+                                onBusy: () => {
+                                    logger.warn(`Command ${index}-${command.commandName}-${command.commandArgs} is busy`);
+                                },
+                            });
+                            for (const callback of command.afterCallbacks) {
+                                await callback();
+                            }
+                            break;
+                        case "callback":
+                            for (const callback of command.beforeCallbacks) {
+                                await callback();
+                            }
+                            await run(() => command.callback(), {
+                                enabled: command.config.withoutOverlapping,
+                                timeout: command.config.expiresAt,
+                                key: `${index}-callback`,
+                                onBusy: () => {
+                                    logger.warn(`Callback ${index} is busy`);
+                                },
+                            });
+                            for (const callback of command.afterCallbacks) {
+                                await callback();
+                            }
+                        default:
+                            break;
+                    }
+                }
+                catch (error) {
+                    logger.error(error);
+                }
+            }, {
+                scheduled: command.config.enabled,
+                timezone: command.config.timezone,
+                runOnInit: command.config.enabled && command.config.immediate,
+            }));
+        }
+        logger.info(`[${tag}] Schedule worker started successfully.`);
+        if (schedule.onStartedCallback) {
+            await schedule.onStartedCallback({
+                tag,
+            });
+        }
+    }
+    async stop() {
+        await Promise.all(this.tasks.map((task) => task.stop()));
+    }
+}

package/build/stubs/main.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export declare const stubsRoot: string;

package/build/stubs/main.js

@@ -0,0 +1,7 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export const stubsRoot = dirname(fileURLToPath(import.meta.url));

package/build/stubs/start/scheduler.stub

@@ -0,0 +1,11 @@
+{{{
+  exports({ to: app.startPath('scheduler.ts') })
+}}}
+
+import scheduler from '@codenameryuu/adonis-scheduler/services/main'
+
+scheduler.command("inspire").everyFiveSeconds();
+
+scheduler.call(() => {
+    console.log("Pruge DB!");
+}).weekly();

package/build/tests/expression.spec.d.ts

@@ -0,0 +1 @@
+export {};