@outloud/adonis-scheduler 1.0.6 → 1.1.0

package/build/src/scheduler.d.ts

@@ -0,0 +1,36 @@
+import { ErrorHandler, Factory, SchedulerConfig, TaskRegisterOptions } from "./types.js";
+import { Task } from "./task.js";
+import { ContainerResolver } from "@adonisjs/core/container";
+import { ContainerBindings } from "@adonisjs/core/types";
+import { LockService } from "@adonisjs/lock/types";
+import { Logger } from "@adonisjs/core/logger";
+import { Emitter } from "@adonisjs/core/events";
+
+//#region src/scheduler.d.ts
+declare class Scheduler {
+  private config;
+  private resolver;
+  private logger;
+  private emitter;
+  private locks?;
+  private definitions;
+  private state;
+  private errorHandler?;
+  constructor(config: SchedulerConfig, resolver: ContainerResolver<ContainerBindings>, logger: Logger, emitter: Emitter<any>, locks?: LockService);
+  register(options: TaskRegisterOptions | typeof Task | Factory<typeof Task>): this;
+  start(wait?: boolean): Promise<void>;
+  stop(): Promise<void>;
+  onError(callback: ErrorHandler): this;
+  private registerFromGlob;
+  private load;
+  private make;
+  private run;
+  private hasState;
+  private setState;
+  private handleError;
+  private cancel;
+  private terminate;
+  private schedule;
+}
+//#endregion
+export { Scheduler };

package/build/src/scheduler.js

@@ -0,0 +1,147 @@
+import { Task } from "./task.js";
+import { waitUntil } from "./helpers.js";
+import { glob } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Cron } from "croner";
+
+//#region src/scheduler.ts
+var Scheduler = class {
+	definitions = [];
+	state = "created";
+	errorHandler;
+	constructor(config, resolver, logger, emitter, locks) {
+		this.config = config;
+		this.resolver = resolver;
+		this.logger = logger;
+		this.emitter = emitter;
+		this.locks = locks;
+	}
+	register(options) {
+		const definition = {
+			schedule: "* * * * *",
+			state: "created",
+			jobs: []
+		};
+		if (typeof options === "object") {
+			const command = Array.isArray(options.command) ? options.command : [options.command];
+			Object.assign(definition, options);
+			definition.loader = () => import("./command.task.js").then((module) => {
+				return class extends module.CommandTask {
+					static command = command;
+				};
+			});
+		} else if (Task.isTask(options)) {
+			definition.task = options;
+			Object.assign(definition, options.options ?? {});
+		} else definition.loader = options;
+		if (!definition.task && !definition.loader) throw new Error("Task definition must have either a command or a task defined.");
+		this.definitions.push(definition);
+		if (this.hasState(["starting", "running"])) this.schedule(definition);
+		return this;
+	}
+	async start(wait = false) {
+		if (!this.hasState(["created", "stopped"])) {
+			this.logger.warn("Scheduler is already running");
+			return;
+		}
+		this.setState("starting");
+		if (this.config.locations) await Promise.all(this.config.locations.map((location) => this.registerFromGlob(location)));
+		await Promise.all(this.definitions.map((definition) => this.schedule(definition)));
+		if (!this.definitions.length) this.logger.warn("No tasks registered, scheduler will not run any jobs.");
+		this.setState("running");
+		if (wait) return waitUntil(() => this.state === "stopped");
+	}
+	async stop() {
+		if (this.state === "starting") await waitUntil(() => this.state !== "starting");
+		if (this.state !== "running") {
+			this.logger.warn("Scheduler is not running");
+			return;
+		}
+		this.setState("stopping");
+		await Promise.all(this.definitions.map((definition) => this.terminate(definition)));
+		this.setState("stopped");
+	}
+	onError(callback) {
+		this.errorHandler = callback;
+		return this;
+	}
+	async registerFromGlob(pattern) {
+		const normalizedPattern = pattern.replace(/\.(?:js|ts)$/, ".{js,ts}");
+		for await (const file of glob(normalizedPattern)) try {
+			const module = await import(`file://${resolve(file)}`);
+			if (Task.isTask(module.default)) this.register(module.default);
+		} catch (error) {
+			console.warn(`Failed to load task from ${file}:`, error);
+		}
+	}
+	async load(definition) {
+		if (definition.loader) {
+			const module = await definition.loader();
+			definition.task = "default" in module ? module.default : module;
+		}
+		if (!definition.task) throw new Error("Failed to load task, no loader or task provided.");
+		Object.assign(definition, definition.task.options ?? {});
+	}
+	async make(definition) {
+		return await this.resolver.make(definition.task);
+	}
+	async run(definition) {
+		const task = await this.make(definition);
+		const lockDuration = definition.lock && typeof definition.lock !== "boolean" ? definition.lock : this.config.lockDuration;
+		const lock = definition.lock ? this.locks?.createLock(`scheduler:${task.name}`, lockDuration) : void 0;
+		if (definition.lock && !this.locks) this.logger.warn("Lock is not available, install @adonisjs/lock to use task locking.");
+		if (lock) {
+			if (!await lock.acquireImmediately()) {
+				this.config.warnWhenLocked && this.logger.warn(`Task "${definition.task?.name}" is locked and cannot be run.`);
+				return;
+			}
+		}
+		try {
+			definition.jobs.push(task);
+			const promise = this.resolver.call(task, "run").finally(() => lock?.release());
+			task.promise = promise.catch(() => {});
+			await promise;
+		} catch (error) {
+			await this.handleError(error, definition, task);
+		} finally {
+			definition.jobs.splice(definition.jobs.indexOf(task), 1);
+		}
+	}
+	hasState(state) {
+		return (Array.isArray(state) ? state : [state]).includes(this.state);
+	}
+	setState(state) {
+		if (this.state === state) return;
+		this.state = state;
+		this.logger.info(`Scheduler: ${state}`);
+	}
+	async handleError(error, _, task) {
+		await task.onError?.(error);
+		this.emitter.emit("scheduler:error", {
+			error,
+			task
+		});
+		await this.errorHandler?.(error, task);
+		if (!this.emitter.hasListeners("scheduler:error") && !this.errorHandler) throw error;
+	}
+	async cancel(job) {
+		await job.cancel();
+	}
+	async terminate(definition) {
+		definition.cron?.stop();
+		definition.cron = void 0;
+		await Promise.all(definition.jobs.map((job) => this.cancel(job)));
+		definition.state = "created";
+	}
+	async schedule(definition) {
+		if (definition.state !== "created") return;
+		definition.state = "preparing";
+		if (!definition.task) await this.load(definition);
+		definition.cron = new Cron(definition.schedule, { timezone: definition.timeZone }, () => this.run(definition));
+		definition.state = "ready";
+		this.logger.debug(`Scheduler: Task "${definition.task?.name}" scheduled with "${definition.schedule}"`);
+	}
+};
+
+//#endregion
+export { Scheduler };

package/build/src/task.d.ts

@@ -0,0 +1,19 @@
+import { TaskOptions } from "./types.js";
+
+//#region src/task.d.ts
+declare abstract class Task {
+  isCanceled: boolean;
+  promise?: Promise<any>;
+  static options: TaskOptions;
+  static isTask(obj: unknown): obj is typeof Task;
+  constructor(..._: any[]);
+  get name(): string;
+  abstract run(...args: any[]): Promise<void>;
+  cancel(): Promise<void>;
+}
+interface Task {
+  onCancel?(): Promise<void>;
+  onError?(error: Error): Promise<void>;
+}
+//#endregion
+export { Task };

package/build/src/task.js

@@ -0,0 +1,22 @@
+//#region src/task.ts
+var Task = class Task {
+	isCanceled = false;
+	promise;
+	static options;
+	static isTask(obj) {
+		return typeof obj === "function" && obj.prototype instanceof Task;
+	}
+	constructor(..._) {}
+	get name() {
+		const Ctor = this.constructor;
+		return Ctor.options.name ?? Ctor.name;
+	}
+	async cancel() {
+		this.isCanceled = true;
+		await this.onCancel?.();
+		await this.promise;
+	}
+};
+
+//#endregion
+export { Task };

package/build/src/types.d.ts

@@ -0,0 +1,60 @@
+import { Task } from "./task.js";
+import { Cron } from "croner";
+
+//#region src/types.d.ts
+interface SchedulerConfig {
+  /**
+   * Should the scheduler start with HTTP server?
+   */
+  httpServer: boolean;
+  /**
+   * Warn when a task is locked and cannot be run
+   */
+  warnWhenLocked: boolean;
+  /**
+   * The default ttl for the lock.
+   */
+  lockDuration: number | string;
+  /** Locations for task auto-discovery */
+  locations?: string[];
+}
+interface TaskOptions {
+  /**
+   * A unique name for the task.
+   */
+  name?: string;
+  /**
+   * The pattern to when the task should run.
+   *
+   * See https://croner.56k.guru/usage/pattern/ for more information.
+   */
+  schedule: string;
+  /**
+   * Time zone to use for the task.
+   */
+  timeZone?: string;
+  /**
+   * Lock the task to prevent it from running concurrently.
+   *
+   * If a string or number is provided, it will be as ttl.
+   *
+   * @default false
+   */
+  lock?: boolean | number | string;
+}
+interface TaskRegisterOptions extends TaskOptions {
+  command: string | string[];
+}
+type ErrorHandler = (error: Error, task: Task) => (void | Promise<void>);
+interface SchedulerEvents {
+  'scheduler:error': {
+    error: Error;
+    task: Task;
+  };
+}
+type MaybePromise<T> = T | Promise<T>;
+type Factory<T> = () => MaybePromise<{
+  default: T;
+} | T>;
+//#endregion
+export { ErrorHandler, Factory, SchedulerConfig, SchedulerEvents, TaskOptions, TaskRegisterOptions };

package/build/stubs/config/scheduler.stub

@@ -9,6 +9,7 @@ const schedulerConfig = defineConfig({
   httpServer: env.get('SCHEDULER_HTTP_SERVER', false),
   warnWhenLocked: false,
   lockDuration: '10m',
+  locations: ['./app/**/*.task.js'],
 })
 
 export default schedulerConfig

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@outloud/adonis-scheduler",
   "type": "module",
-  "version": "1.0.6",
-  "description": "Schedule cron jobs in AdonisJS.",
+  "version": "1.1.0",
+  "description": "Schedule cron jobs in AdonisJS 6/7.",
   "author": "Outloud <hello@outloud.co>",
   "contributors": [
     "Andrej Adamcik"
@@ -13,22 +13,20 @@
     "type": "git",
     "url": "git+https://github.com/madebyoutloud/adonis-scheduler.git"
   },
-  "publishConfig": {
-    "tag": "latest",
-    "access": "public"
-  },
   "files": [
     "build"
   ],
   "exports": {
-    ".": "./build/index.js",
+    ".": "./build/src/index.js",
     "./provider": "./build/providers/scheduler.provider.js",
     "./commands": "./build/commands/main.js",
+    "./service": "./build/services/main.js",
     "./services/*": "./build/services/*.js"
   },
+  "sideEffects": false,
   "peerDependencies": {
-    "@adonisjs/core": "^6",
-    "@adonisjs/lock": "^1"
+    "@adonisjs/core": "^6 || ^7",
+    "@adonisjs/lock": "^1 || ^2"
   },
   "peerDependenciesMeta": {
     "@adonisjs/lock": {
@@ -36,17 +34,18 @@
     }
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^7.8.2",
-    "@adonisjs/core": "~6.19.0",
-    "@adonisjs/lock": "^1.1.1",
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/core": "~7.0.0",
+    "@adonisjs/lock": "^2.1.0",
     "@adonisjs/tsconfig": "^1.4.1",
-    "@outloud/eslint-config": "^2.0.5",
+    "@outloud/eslint-config": "^2.1.3",
     "@swc/core": "^1.13.3",
     "@types/node": "^24.2.1",
     "copyfiles": "^2.4.1",
     "eslint": "^9.33.0",
     "reflect-metadata": "^0.2.2",
     "release-it": "^19.0.4",
+    "tsdown": "0.21.0-beta.2",
     "tsup": "~8.5.0",
     "typescript": "~5.9.2"
   },
@@ -61,12 +60,8 @@
     "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
     "pretest": "pnpm run lint",
     "test": "c8 pnpm run quick:test",
-    "precompile": "pnpm run lint && rm -rf build",
-    "compile": "tsup-node",
-    "postcompile": "pnpm run copy:templates && pnpm run index:commands",
-    "build": "rm -rf build && pnpm run compile",
+    "build": "tsdown && pnpm run copy:templates && pnpm run index:commands",
     "release": "release-it",
-    "index:commands": "adonis-kit index build/commands",
-    "version": "pnpm run build"
+    "index:commands": "NODE_OPTIONS='--import=reflect-metadata' adonis-kit index build/commands"
   }
 }

package/build/chunk-7P6J5U6O.js

@@ -1,25 +0,0 @@
-import { __name } from './chunk-SHUYVCID.js';
-
-// src/task.ts
-var Task = class {
-  static {
-    __name(this, "Task");
-  }
-  isCanceled = false;
-  promise;
-  static options;
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  constructor(..._) {
-  }
-  get name() {
-    const Ctor = this.constructor;
-    return Ctor.options.name ?? Ctor.name;
-  }
-  async $cancel() {
-    this.isCanceled = true;
-    await this.onCancel?.();
-    await this.promise;
-  }
-};
-
-export { Task };

package/build/chunk-FOVOD6FP.js

@@ -1,185 +0,0 @@
-import { __name } from './chunk-SHUYVCID.js';
-import { Cron } from 'croner';
-import timers from 'timers/promises';
-
-async function waitUntil(callback, interval = 50) {
-  while (!callback()) {
-    await timers.setTimeout(interval);
-  }
-}
-__name(waitUntil, "waitUntil");
-
-// src/scheduler.ts
-var Scheduler = class {
-  static {
-    __name(this, "Scheduler");
-  }
-  config;
-  resolver;
-  logger;
-  emitter;
-  locks;
-  definitions = [];
-  state = "created";
-  errorHandler;
-  constructor(config, resolver, logger, emitter, locks) {
-    this.config = config;
-    this.resolver = resolver;
-    this.logger = logger;
-    this.emitter = emitter;
-    this.locks = locks;
-  }
-  register(options) {
-    const definition = {
-      schedule: "* * * * *",
-      state: "created",
-      jobs: []
-    };
-    if (typeof options === "object") {
-      const command = Array.isArray(options.command) ? options.command : [
-        options.command
-      ];
-      Object.assign(definition, options);
-      definition.loader = () => import('./command.task-GUNK3QFY.js').then((module) => {
-        return class extends module.CommandTask {
-          static command = command;
-        };
-      });
-    } else {
-      definition.loader = options;
-    }
-    if (!definition.loader) {
-      throw new Error("Task definition must have either a command or a task defined.");
-    }
-    this.definitions.push(definition);
-    if (this.hasState([
-      "starting",
-      "running"
-    ])) {
-      this.schedule(definition);
-    }
-    return this;
-  }
-  async start(wait = false) {
-    if (!this.hasState([
-      "created",
-      "stopped"
-    ])) {
-      this.logger.warn("Scheduler is already running");
-      return;
-    }
-    this.setState("starting");
-    await Promise.all(this.definitions.map((definition) => this.schedule(definition)));
-    if (!this.definitions.length) {
-      this.logger.warn("No tasks registered, scheduler will not run any jobs.");
-    }
-    this.setState("running");
-    if (wait) {
-      return waitUntil(() => this.state === "stopped");
-    }
-  }
-  async stop() {
-    if (this.state === "starting") {
-      await waitUntil(() => this.state !== "starting");
-    }
-    if (this.state !== "running") {
-      this.logger.warn("Scheduler is not running");
-      return;
-    }
-    this.setState("stopping");
-    await Promise.all(this.definitions.map((definition) => this.terminate(definition)));
-    this.setState("stopped");
-  }
-  onError(callback) {
-    this.errorHandler = callback;
-    return this;
-  }
-  async load(definition) {
-    if (definition.loader) {
-      const module = await definition.loader();
-      definition.task = "default" in module ? module.default : module;
-    }
-    if (!definition.task) {
-      throw new Error("Failed to load task, no loader or task provided.");
-    }
-    Object.assign(definition, definition.task.options ?? {});
-  }
-  async make(definition) {
-    return await this.resolver.make(definition.task);
-  }
-  async run(definition) {
-    const task = await this.make(definition);
-    const lockDuration = definition.lock && typeof definition.lock !== "boolean" ? definition.lock : this.config.lockDuration;
-    const lock = definition.lock ? this.locks?.createLock(`scheduler:${task.name}`, lockDuration) : void 0;
-    if (definition.lock && !this.locks) {
-      this.logger.warn("Lock is not available, install @adonisjs/lock to use task locking.");
-    }
-    if (lock) {
-      const acquired = await lock.acquireImmediately();
-      if (!acquired) {
-        this.config.warnWhenLocked && this.logger.warn(`Task "${definition.task?.name}" is locked and cannot be run.`);
-        return;
-      }
-    }
-    try {
-      definition.jobs.push(task);
-      const promise = this.resolver.call(task, "run").finally(() => lock?.release());
-      task.promise = promise.catch(() => {
-      });
-      await promise;
-    } catch (error) {
-      await this.handleError(error, definition, task);
-    } finally {
-      definition.jobs.splice(definition.jobs.indexOf(task), 1);
-    }
-  }
-  hasState(state) {
-    const states = Array.isArray(state) ? state : [
-      state
-    ];
-    return states.includes(this.state);
-  }
-  setState(state) {
-    if (this.state === state) {
-      return;
-    }
-    this.state = state;
-    this.logger.info(`Scheduler: ${state}`);
-  }
-  async handleError(error, _, task) {
-    await task.onError?.(error);
-    this.emitter.emit("scheduler:error", {
-      error,
-      task
-    });
-    await this.errorHandler?.(error, task);
-    if (!this.emitter.hasListeners("scheduler:error") && !this.errorHandler) {
-      throw error;
-    }
-  }
-  async cancel(job) {
-    await job.$cancel();
-  }
-  async terminate(definition) {
-    definition.cron?.stop();
-    definition.cron = void 0;
-    await Promise.all(definition.jobs.map((job) => this.cancel(job)));
-    definition.state = "created";
-  }
-  async schedule(definition) {
-    if (definition.state !== "created") {
-      return;
-    }
-    definition.state = "preparing";
-    if (!definition.task) {
-      await this.load(definition);
-    }
-    definition.cron = new Cron(definition.schedule, {
-      timezone: definition.timeZone
-    }, () => this.run(definition));
-    definition.state = "ready";
-    this.logger.debug(`Scheduler: Task "${definition.task?.name}" scheduled with "${definition.schedule}"`);
-  }
-};
-
-export { Scheduler };

package/build/chunk-SHUYVCID.js

@@ -1,4 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-export { __name };

package/build/command.task-GUNK3QFY.js

@@ -1,22 +0,0 @@
-import { Task } from './chunk-7P6J5U6O.js';
-import { __name } from './chunk-SHUYVCID.js';
-import ace from '@adonisjs/core/services/ace';
-
-var CommandTask = class extends Task {
-  static {
-    __name(this, "CommandTask");
-  }
-  static command = [];
-  get name() {
-    return this.constructor.command.join(",");
-  }
-  async run() {
-    const [name, ...args] = this.constructor.command;
-    if (!name) {
-      throw new Error("No command name provided.");
-    }
-    await ace.exec(name, args);
-  }
-};
-
-export { CommandTask };

package/build/index.d.ts

@@ -1,14 +0,0 @@
-import { S as SchedulerConfig } from './scheduler-DO35E0Fu.js';
-export { a as Scheduler, T as Task, b as TaskOptions } from './scheduler-DO35E0Fu.js';
-import Configure from '@adonisjs/core/commands/configure';
-import '@adonisjs/core/container';
-import '@adonisjs/core/types';
-import '@adonisjs/lock/types';
-import '@adonisjs/core/logger';
-import '@adonisjs/core/events';
-
-declare function configure(command: Configure): Promise<void>;
-
-declare function defineConfig<T extends SchedulerConfig>(config: T): T;
-
-export { SchedulerConfig, configure, defineConfig };

package/build/index.js

@@ -1,29 +0,0 @@
-export { Scheduler } from './chunk-FOVOD6FP.js';
-export { Task } from './chunk-7P6J5U6O.js';
-import { __name } from './chunk-SHUYVCID.js';
-
-// configure.ts
-async function configure(command) {
-  const codemods = await command.createCodemods();
-  await codemods.makeUsingStub(import.meta.dirname + "/stubs", "config/scheduler.stub", {});
-  await codemods.defineEnvVariables({
-    SCHEDULER_HTTP_SERVER: false
-  });
-  await codemods.defineEnvValidations({
-    variables: {
-      SCHEDULER_HTTP_SERVER: `Env.schema.boolean.optional()`
-    }
-  });
-  await codemods.updateRcFile((rcFile) => {
-    rcFile.addProvider("@outloud/adonis-scheduler/provider").addCommand("@outloud/adonis-scheduler/commands");
-  });
-}
-__name(configure, "configure");
-
-// src/config.ts
-function defineConfig(config) {
-  return config;
-}
-__name(defineConfig, "defineConfig");
-
-export { configure, defineConfig };