@codenameryuu/adonis-scheduler 1.0.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License
+
+Copyright (c) 2024 Codename Ryuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# @codenameryuu/adonis-lucid-filter
+
+This addon adds the functionality to schedule tasks in Adonis JS 7.
+
+## Requirement
+
+* Adonis Js 7
+* Lucid 22 or higher
+
+## Installation
+
+Install the package from npm using the following command:
+
+```bash
+node ace add @codenameryuu/adonis-scheduler
+```
+
+## Running The Scheduler
+
+```sh
+node ace scheduler:run
+# or
+node ace scheduler:work
+
+# automatically restart the scheduler when files are modified during development mode
+node ace scheduler:run --watch
+
+node ace scheduler:run --tag <tag_name> # Run all schedules with the specified tag
+```
+
+## Defining Schedules
+
+```ts
+// start/scheduler.ts
+
+import scheduler from '@codenameryuu/adonis-scheduler/services/main'
+
+import PurgeUsers from '../commands/purge_users'
+
+scheduler.command('inspire').everyFiveSeconds()
+scheduler.command(PurgeUsers, ['30 days']).everyFiveSeconds().withoutOverlapping()
+
+scheduler.withoutOverlapping(
+  () => {
+    scheduler.command('inspire').everySecond()
+    scheduler.command(PurgeUsers, ['30 days']).everyFiveSeconds()
+  },
+  { expiresAt: 30_000 }
+)
+
+scheduler.withTag(
+  () => {
+    scheduler.command('inspire').everySecond()
+  },
+  'my-tag'
+)
+
+scheduler
+  .call(() => {
+    console.log('Pruge DB!')
+  })
+  .weekly()
+
+scheduler
+  .call(() => {
+    console.log('Pruge DB!')
+  })
+  .tag('my-tag')
+  .weekly()
+```
+
+or define schedule directly on command
+
+```ts
+import { BaseCommand, args } from '@adonisjs/core/ace'
+import { schedule } from '@codenameryuu/adonis-scheduler'
+
+@schedule("* * * * *", ["30 days"])
+@schedule((s) => s.everyFiveSeconds().immediate(), ["7 days"])
+@schedule((s) => s.everyMinute(), ["42 days"])
+export default class PurgeUsers extends BaseCommand {
+  static commandName = 'purge:users'
+  static description = ''
+
+  static options: CommandOptions = {}
+
+  @args.string()
+  declare olderThan: string
+
+  async run() {
+    //
+  }
+}
+```
+
+## Schedule Frequency Options
+
+| Method                           | Description                                             |
+| -------------------------------- | ------------------------------------------------------- |
+| `.cron('* * * * *');` | Run the task on a custom cron schedule                  |
+| `.everyMinute();` | Run the task every minute                               |
+| `.everyTwoMinutes();` | Run the task every two minutes                          |
+| `.everyThreeMinutes();` | Run the task every three minutes                        |
+| `.everyFourMinutes();` | Run the task every four minutes                         |
+| `.everyFiveMinutes();` | Run the task every five minutes                         |
+| `.everyTenMinutes();` | Run the task every ten minutes                          |
+| `.everyFifteenMinutes();` | Run the task every fifteen minutes                      |
+| `.everyThirtyMinutes();` | Run the task every thirty minutes                       |
+| `.hourly();` | Run the task every hour                                 |
+| `.hourlyAt(17);` | Run the task every hour at 17 minutes past the hour.    |
+| `.everyTwoHours();` | Run the task every two hours                            |
+| `.everyThreeHours();` | Run the task every three hours                          |
+| `.everyFourHours();` | Run the task every four hours                           |
+| `.everyFiveHours();` | Run the task every five hours                           |
+| `.everySixHours();` | Run the task every six hours                            |
+| `.daily();` | Run the task every day at midnight                      |
+| `.dailyAt('13:00');` | Run the task every day at 13:00.                        |
+| `.twiceDaily(1, 13);` | Run the task daily at 1:00 & 13:00.                     |
+| `.twiceDailyAt(1, 13, 15);` | Run the task daily at 1:15 & 13:15.                     |
+| `.weekly();` | Run the task every Sunday at 00:00                      |
+| `.weeklyOn(1, '8:00');` | Run the task every week on Monday at 8:00.              |
+| `.monthly();` | Run the task on the first day of every month at 00:00   |
+| `.monthlyOn(4, '15:00');` | Run the task every month on the 4th at 15:00.           |
+| `.twiceMonthly(1, 16, '13:00');` | Run the task monthly on the 1st and 16th at 13:00.      |
+| `.lastDayOfMonth('15:00');` | Run the task on the last day of the month at 15:00.     |
+| `.quarterly();` | Run the task on the first day of every quarter at 00:00.|
+| `.quarterlyOn(4, '14:00');` | Run the task every quarter on the 4th at 14:00.         |
+| `.yearly();` | Run the task on the first day of every year at 00:00.   |
+| `.yearlyOn(6, 1, '17:00');` | Run the task every year on June 1st at 17:00.           |
+| `.timezone('America/New_York');` | Set the timezone for the task.                          |
+| `.immediate();` | Run the task on startup                                 |
+| `.withoutOverlapping();` | Run the task without overlapping                        |
+
+## Alternative Ways to Run the Scheduler
+
+Besides using `node ace scheduler:run` , you can also manually initialize and control the scheduler worker in your code:
+
+```ts
+import { Worker } from '@codenameryuu/adonis-scheduler'
+import app from '@adonisjs/core/services/app'
+
+const worker = new Worker(app)
+
+app.terminating(async () => {
+  await worker.stop()
+})
+
+await worker.start()
+```
+
+Note: make sure to modify `adonisrc.ts` and include the environment where the worker is running.
+
+```ts
+import { defineConfig } from '@adonisjs/core/app'
+
+export default defineConfig({
+ providers: [
+   {
+      file: () => import('@codenameryuu/adonis-scheduler/scheduler_provider'),
+      environment: ['console', 'web'], // <---
+   },
+
+   // or enable for all environments
+   () => import('@codenameryuu/adonis-scheduler/scheduler_provider'),
+})
+```

package/build/bin/test.d.ts

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

package/build/bin/test.js

@@ -0,0 +1,8 @@
+import { assert } from "@japa/assert";
+import { configure, processCLIArgs, run } from "@japa/runner";
+processCLIArgs(process.argv.slice(2));
+configure({
+    files: ["tests/**/*.spec.ts"],
+    plugins: [assert()],
+});
+run();

package/build/commands/commands.json

@@ -0,0 +1 @@
+{"commands":[{"commandName":"inspire","description":"","help":"","namespace":null,"aliases":[],"flags":[],"args":[],"options":{"startApp":true},"filePath":"inspire_command.js"},{"commandName":"scheduler:run","description":"","help":"","namespace":"scheduler","aliases":["scheduler:work","schedule:work","schedule:run"],"flags":[{"name":"watch","flagName":"watch","required":false,"type":"boolean","description":"Restart the scheduler on file changes"},{"name":"tag","flagName":"tag","required":false,"type":"string","description":"Tag for the scheduler","default":"default"}],"args":[],"options":{"startApp":true,"staysAlive":true},"filePath":"scheduler_command.js"},{"commandName":"scheduler:list","description":"","help":"","namespace":"scheduler","aliases":[],"flags":[{"name":"tag","flagName":"tag","required":false,"type":"string","description":"Filter by tag"}],"args":[],"options":{"startApp":true},"filePath":"scheduler_list_command.js"}],"version":1}

package/build/commands/inspire_command.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from "@adonisjs/core/ace";
+import { CommandOptions } from "@adonisjs/core/types/ace";
+export default class InspireCommand extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    run(): Promise<void>;
+}

package/build/commands/inspire_command.js

@@ -0,0 +1,52 @@
+import { BaseCommand } from "@adonisjs/core/ace";
+const quotes = [
+    "Act only according to that maxim whereby you can, at the same time, will that it should become a universal law. - Immanuel Kant",
+    "An unexamined life is not worth living. - Socrates",
+    "Be present above all else. - Naval Ravikant",
+    "Do what you can, with what you have, where you are. - Theodore Roosevelt",
+    "Happiness is not something readymade. It comes from your own actions. - Dalai Lama",
+    "He who is contented is rich. - Laozi",
+    "I begin to speak only when I am certain what I will say is not better left unsaid. - Cato the Younger",
+    "I have not failed. I've just found 10,000 ways that won't work. - Thomas Edison",
+    "If you do not have a consistent goal in life, you can not live it in a consistent way. - Marcus Aurelius",
+    "It is never too late to be what you might have been. - George Eliot",
+    "It is not the man who has too little, but the man who craves more, that is poor. - Seneca",
+    "It is quality rather than quantity that matters. - Lucius Annaeus Seneca",
+    "Knowing is not enough; we must apply. Being willing is not enough; we must do. - Leonardo da Vinci",
+    "Let all your things have their places; let each part of your business have its time. - Benjamin Franklin",
+    "Live as if you were to die tomorrow. Learn as if you were to live forever. - Mahatma Gandhi",
+    "No surplus words or unnecessary actions. - Marcus Aurelius",
+    "Nothing worth having comes easy. - Theodore Roosevelt",
+    "Order your soul. Reduce your wants. - Augustine",
+    "People find pleasure in different ways. I find it in keeping my mind clear. - Marcus Aurelius",
+    "Simplicity is an acquired taste. - Katharine Gerould",
+    "Simplicity is the consequence of refined emotions. - Jean D'Alembert",
+    "Simplicity is the essence of happiness. - Cedric Bledsoe",
+    "Simplicity is the ultimate sophistication. - Leonardo da Vinci",
+    "Smile, breathe, and go slowly. - Thich Nhat Hanh",
+    "The only way to do great work is to love what you do. - Steve Jobs",
+    "The whole future lies in uncertainty: live immediately. - Seneca",
+    "Very little is needed to make a happy life. - Marcus Aurelius",
+    "Waste no more time arguing what a good man should be, be one. - Marcus Aurelius",
+    "Well begun is half done. - Aristotle",
+    "When there is no desire, all things are at peace. - Laozi",
+    "Walk as if you are kissing the Earth with your feet. - Thich Nhat Hanh",
+    "Because you are alive, everything is possible. - Thich Nhat Hanh",
+    "Breathing in, I calm body and mind. Breathing out, I smile. - Thich Nhat Hanh",
+    "Life is available only in the present moment. - Thich Nhat Hanh",
+    "The best way to take care of the future is to take care of the present moment. - Thich Nhat Hanh",
+    "Nothing in life is to be feared, it is only to be understood. Now is the time to understand more, so that we may fear less. - Marie Curie",
+    "The biggest battle is the war against ignorance. - Mustafa Kemal Atatürk",
+    "Always remember that you are absolutely unique. Just like everyone else. - Margaret Mead",
+    "You must be the change you wish to see in the world. - Mahatma Gandhi",
+];
+export default class InspireCommand extends BaseCommand {
+    static commandName = "inspire";
+    static description = "";
+    static options = {
+        startApp: true,
+    };
+    async run() {
+        this.logger.info(quotes[Math.floor(Math.random() * quotes.length)]);
+    }
+}

package/build/commands/main.d.ts

@@ -0,0 +1,4 @@
+import { CommandMetaData, Command } from '@adonisjs/ace/types';
+
+export function getMetaData(): Promise<CommandMetaData[]>
+export function getCommand(metaData: CommandMetaData): Promise<Command | null>

package/build/commands/main.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * In-memory cache of commands after they have been loaded
+ */
+let commandsMetaData
+
+/**
+ * Reads the commands from the "./commands.json" file. Since, the commands.json
+ * file is generated automatically, we do not have to validate its contents
+ */
+export async function getMetaData() {
+  if (commandsMetaData) {
+    return commandsMetaData
+  }
+
+  const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8')
+  commandsMetaData = JSON.parse(commandsIndex).commands
+
+  return commandsMetaData
+}
+
+/**
+ * Imports the command by lookingup its path from the commands
+ * metadata
+ */
+export async function getCommand(metaData) {
+  const commands = await getMetaData()
+  const command = commands.find(({ commandName }) => metaData.commandName === commandName)
+  if (!command) {
+    return null
+  }
+
+  const { default: commandConstructor } = await import(new URL(command.filePath, import.meta.url).href)
+  return commandConstructor
+}

package/build/commands/scheduler_command.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from "@adonisjs/core/ace";
+import { CommandOptions } from "@adonisjs/core/types/ace";
+import { Worker } from "../src/worker.js";
+export default class SchedulerCommand extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static aliases: string[];
+    static options: CommandOptions;
+    watch: boolean;
+    tag: string;
+    worker: Worker;
+    prepare(): void;
+    run(): Promise<void>;
+    runAndWatch(): Promise<void>;
+}

package/build/commands/scheduler_command.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+import { spawn } from "child_process";
+import chokidar from "chokidar";
+import { Worker } from "../src/worker.js";
+export default class SchedulerCommand extends BaseCommand {
+    static commandName = "scheduler:run";
+    static description = "";
+    static aliases = ["scheduler:work", "schedule:work", "schedule:run"];
+    static options = {
+        startApp: true,
+        staysAlive: true,
+    };
+    prepare() {
+        this.app.terminating(async () => {
+            if (this.worker)
+                await this.worker.stop();
+        });
+    }
+    async run() {
+        if (this.watch) {
+            return await this.runAndWatch();
+        }
+        this.worker = new Worker(this.app);
+        await this.worker.start(this.tag);
+    }
+    async runAndWatch() {
+        const logger = await this.app.container.make("logger");
+        let child;
+        const startProcess = () => {
+            if (child)
+                child.kill();
+            child = spawn("node", ["ace.js", "scheduler:run"], { stdio: "inherit" });
+        };
+        const watcher = chokidar.watch([this.app.appRoot.pathname], {
+            //@ts-ignore
+            ignored: (path, stats) => {
+                if (path.includes("node_modules") || path.includes(".git") || path.includes("build")) {
+                    return true;
+                }
+                return stats?.isFile() && !path.endsWith(".ts") && !path.endsWith(".js");
+            },
+            persistent: true,
+            ignoreInitial: true,
+        });
+        let timeoutId;
+        watcher.on("all", (event, path) => {
+            if (typeof path === "string") {
+                logger.info(`File ${path.replace(this.app.appRoot.pathname, "")} changed (${event}), restarting...`);
+            }
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                startProcess();
+            }, 300);
+        });
+        startProcess();
+        this.app.terminating(async () => {
+            if (child)
+                child.kill();
+            process.exit();
+        });
+    }
+}
+__decorate([
+    flags.boolean({ description: "Restart the scheduler on file changes" })
+], SchedulerCommand.prototype, "watch", void 0);
+__decorate([
+    flags.string({ description: "Tag for the scheduler", default: "default" })
+], SchedulerCommand.prototype, "tag", void 0);

package/build/commands/scheduler_list_command.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "@adonisjs/core/ace";
+import { CommandOptions } from "@adonisjs/core/types/ace";
+export default class SchedulerCommand extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    tag?: string;
+    static options: CommandOptions;
+    run(): Promise<void>;
+}

package/build/commands/scheduler_list_command.js

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, cliHelpers, flags } from "@adonisjs/core/ace";
+import { CronExpressionParser } from "cron-parser";
+import { DateTime } from "luxon";
+import stringWidth from "string-width";
+export default class SchedulerCommand extends BaseCommand {
+    static commandName = "scheduler:list";
+    static description = "";
+    static options = {
+        startApp: true,
+    };
+    async run() {
+        const schedule = await this.app.container.make("scheduler");
+        await schedule.boot();
+        const items = [];
+        for (let index = 0; index < schedule.items.length; index++) {
+            const command = schedule.items[index];
+            if (this.tag && command.config.tag !== this.tag) {
+                continue;
+            }
+            const commandName = command.type === "callback"
+                ? `Closure #${index + 1}`
+                : `node ace ${command.commandName}` + (command.commandArgs.length ? ` ${this.ui.colors.cyan(command.commandArgs.join(" "))}` : "");
+            let nextDueDate = null;
+            if (!command.config.enabled) {
+                nextDueDate = "Disabled";
+            }
+            else {
+                const cron = CronExpressionParser.parse(command.expression, {
+                    tz: command.config.timezone,
+                });
+                nextDueDate = DateTime.fromJSDate(cron.next().toDate()).toRelative();
+            }
+            items.push({
+                expression: ` ${this.ui.colors.yellow(command.expression)} `,
+                commandName: ` ${commandName} `,
+                nextDueDate: this.ui.colors.dim(` Next Due: ${nextDueDate}`),
+            });
+        }
+        const expressions = items.map((item) => item.expression);
+        const largestExpressionLength = Math.max(...expressions.map((e) => stringWidth(e)));
+        const formattedExpressions = cliHelpers.justify(expressions, {
+            maxWidth: largestExpressionLength,
+        });
+        const commands = items.map((item) => item.commandName);
+        const largestCommandLength = Math.max(...commands.map((e) => stringWidth(e)));
+        const formattedCommands = cliHelpers.justify(commands, {
+            maxWidth: largestCommandLength,
+            paddingChar: this.ui.colors.dim("."),
+        });
+        const dates = items.map((item) => item.nextDueDate);
+        const largestDateLength = cliHelpers.TERMINAL_SIZE - (largestExpressionLength + largestCommandLength) - 10;
+        const formattedDates = cliHelpers.truncate(cliHelpers.justify(dates, {
+            maxWidth: largestDateLength,
+            align: "right",
+            paddingChar: this.ui.colors.dim("."),
+        }), {
+            maxWidth: largestDateLength,
+        });
+        for (let index = 0; index < formattedExpressions.length; index++) {
+            const expression = formattedExpressions[index];
+            const command = formattedCommands[index];
+            const date = formattedDates[index];
+            this.logger.log(`${expression}${command}${date}`);
+        }
+    }
+}
+__decorate([
+    flags.string({ description: "Filter by tag" })
+], SchedulerCommand.prototype, "tag", void 0);

package/build/configure.d.ts

@@ -0,0 +1,2 @@
+import ConfigureCommand from "@adonisjs/core/commands/configure";
+export declare function configure(command: ConfigureCommand): Promise<void>;

package/build/configure.js

@@ -0,0 +1,23 @@
+/*
+|--------------------------------------------------------------------------
+| Configure hook
+|--------------------------------------------------------------------------
+|
+| The configure hook is called when someone runs "node ace configure <package>"
+| command. You are free to perform any operations inside this function to
+| configure the package.
+|
+| To make things easier, you have access to the underlying "ConfigureCommand"
+| instance and you can use codemods to modify the source files.
+|
+*/
+import { stubsRoot } from "./stubs/main.js";
+export async function configure(command) {
+    const codemods = await command.createCodemods();
+    await codemods.makeUsingStub(stubsRoot, "start/scheduler.stub", {});
+    await codemods.updateRcFile((rcFile) => {
+        rcFile.addProvider("@codenameryuu/adonis-scheduler/scheduler_provider", ["console"]);
+        rcFile.addCommand("@codenameryuu/adonis-scheduler/commands");
+        rcFile.addPreloadFile("#start/scheduler", ["console"]);
+    });
+}

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export { configure } from "./configure.js";
+export { stubsRoot } from "./stubs/main.js";
+export { Scheduler } from "./src/scheduler.js";
+export { Worker } from "./src/worker.js";
+export { schedule } from "./src/decorator.js";

package/build/index.js

@@ -0,0 +1,13 @@
+/*
+|--------------------------------------------------------------------------
+| Package entrypoint
+|--------------------------------------------------------------------------
+|
+| Export values from the package entrypoint as you see fit.
+|
+*/
+export { configure } from "./configure.js";
+export { stubsRoot } from "./stubs/main.js";
+export { Scheduler } from "./src/scheduler.js";
+export { Worker } from "./src/worker.js";
+export { schedule } from "./src/decorator.js";

package/build/providers/scheduler_provider.d.ts

@@ -0,0 +1,12 @@
+import type { ApplicationService } from "@adonisjs/core/types";
+import { Scheduler } from "../src/scheduler.js";
+declare module "@adonisjs/core/types" {
+    interface ContainerBindings {
+        scheduler: Scheduler;
+    }
+}
+export default class SchedulerProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    boot(): void;
+}

package/build/providers/scheduler_provider.js

@@ -0,0 +1,12 @@
+import { Scheduler } from "../src/scheduler.js";
+export default class SchedulerProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    boot() {
+        this.app.container.singleton("scheduler", () => {
+            return new Scheduler(this.app);
+        });
+    }
+}

package/build/services/main.d.ts

@@ -0,0 +1,3 @@
+import type { Scheduler } from "../src/scheduler.js";
+declare let scheduler: Scheduler;
+export { scheduler as default };

package/build/services/main.js

@@ -0,0 +1,6 @@
+import app from "@adonisjs/core/services/app";
+let scheduler;
+await app.booted(async () => {
+    scheduler = await app.container.make("scheduler");
+});
+export { scheduler as default };

package/build/src/decorator.d.ts

@@ -0,0 +1,3 @@
+import type { BaseCommand } from "@adonisjs/core/ace";
+import { ScheduleCommand } from "./scheduler.js";
+export declare function schedule(expression: string | ((s: ScheduleCommand) => ScheduleCommand), args?: string | string[]): <T extends typeof BaseCommand>(target: T) => T;

package/build/src/decorator.js

@@ -0,0 +1,13 @@
+import { ScheduleCommand, Scheduler } from "./scheduler.js";
+import { arrayWrap } from "./utils.js";
+export function schedule(expression, args = []) {
+    return function (target) {
+        if (typeof expression === "string") {
+            Scheduler.__decorator_schedules.push(new ScheduleCommand(target.commandName, arrayWrap(args)).cron(expression));
+        }
+        else {
+            Scheduler.__decorator_schedules.push(expression(new ScheduleCommand(target.commandName, arrayWrap(args))));
+        }
+        return target;
+    };
+}