@outloud/adonis-scheduler 1.1.0 → 1.1.1

package/README.md

@@ -56,9 +56,16 @@ export default class TestTask extends Task {
 ### Register a task
 For task to run it must be registered in the scheduler.
 
-> [!NOTE]
-> By default tasks are auto-discovered using the locations defined in config.
+#### Auto-discovery (recommended)
+By default tasks are auto-discovered using the locations defined in `config/scheduler.ts`.
+
+```ts
+const schedulerConfig = defineConfig({
+  locations: ['./app/**/*.task.js'],
+})
+```
 
+#### Manual registration
 If you want to register tasks manually, you can register tasks in two ways: using the `start/scheduler.ts` preloaded file or in a provider's `start` method.
 
 Using `start/scheduler.ts` file.
@@ -69,7 +76,7 @@ import scheduler from '@outloud/adonis-scheduler/services/main'
 scheduler.register(() => import('../app/tasks/test.task.js'))
 ```
 
-Or using a provider.
+Or in a any provider's `start` method.
 
 ```ts
 import type { ApplicationService } from '@adonisjs/core/types'
@@ -117,11 +124,9 @@ You can also create a custom worker command that runs the scheduler. This is use
 ```ts [commands/worker.ts]
 import { createServer, type Server as HttpServer } from 'node:http'
 import { BaseCommand } from '@adonisjs/core/ace'
-import { Server } from '@adonisjs/core/http'
 import type { CommandOptions } from '@adonisjs/core/types/ace'
 import { inject } from '@adonisjs/core'
 import { Scheduler } from '@outloud/adonis-scheduler'
-import type { ApplicationService } from '@adonisjs/core/types'
 
 export default class extends BaseCommand {
   static commandName = 'worker'
@@ -136,7 +141,9 @@ export default class extends BaseCommand {
   private scheduler?: Scheduler
 
   prepare() {
-    this.app.terminating(() => this.server?.close())
+    this.app.terminating(() => {
+      this.server?.close()
+    })
     this.app.terminating(() => this.scheduler?.stop())
   }
 
@@ -152,14 +159,14 @@ export default class extends BaseCommand {
 
   private async startServer() {
     const server = await this.makeServer()
-    const httpServer = createServer(server.handle.bind(server))
-    this.server = httpServer
     await server.boot()
 
+    const httpServer = createServer(server.handle.bind(server))
     server.setNodeServer(httpServer)
+    this.server = httpServer
 
     const host = process.env.HOST || '0.0.0.0'
-    const port = Number(process.env.PORT || '3000')
+    const port = Number(process.env.PORT || 3000)
 
     httpServer.once('listening', () => this.logger.info(`listening to http server, host: ${host}, port: ${port}`))
 
@@ -167,15 +174,9 @@ export default class extends BaseCommand {
   }
 
   private async makeServer() {
-    const server = new Server(
-      this.app,
-      await this.app.container.make('encryption'),
-      await this.app.container.make('emitter'),
-      await this.app.container.make('logger'),
-      this.app.config.get<any>('app.http'),
-    )
-
+    const server = await this.app.container.make('server')
     const router = server.getRouter()
+    
     router.get('/health', () => ({ status: 'ok' }))
 
     return server

package/build/src/scheduler.d.ts

@@ -24,6 +24,7 @@ declare class Scheduler {
   private registerFromGlob;
   private load;
   private make;
+  private resolveLock;
   private run;
   private hasState;
   private setState;

package/build/src/scheduler.js

@@ -22,7 +22,11 @@ var Scheduler = class {
 			state: "created",
 			jobs: []
 		};
-		if (typeof options === "object") {
+		if (Task.isTask(options)) {
+			definition.task = options;
+			Object.assign(definition, options.options ?? {});
+		} else if (typeof options === "function") definition.loader = options;
+		else {
 			const command = Array.isArray(options.command) ? options.command : [options.command];
 			Object.assign(definition, options);
 			definition.loader = () => import("./command.task.js").then((module) => {
@@ -30,10 +34,7 @@ var Scheduler = class {
 					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);
@@ -85,19 +86,25 @@ var Scheduler = class {
 	async make(definition) {
 		return await this.resolver.make(definition.task);
 	}
+	resolveLock(task, definition) {
+		if (!definition.lock) return;
+		if (!this.locks) {
+			this.logger.warn("Lock is not available, install @adonisjs/lock to use task locking.");
+			return;
+		}
+		const lockDuration = definition.lock && typeof definition.lock !== "boolean" ? definition.lock : this.config.lockDuration;
+		return this.locks.createLock(`scheduler:${task.name}`, lockDuration);
+	}
 	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()) {
+		const lock = this.resolveLock(task, definition);
+		try {
+			definition.jobs.push(task);
+			if (lock && !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);
+			if (task.isCanceled) return;
 			const promise = this.resolver.call(task, "run").finally(() => lock?.release());
 			task.promise = promise.catch(() => {});
 			await promise;
@@ -117,12 +124,12 @@ var Scheduler = class {
 	}
 	async handleError(error, _, task) {
 		await task.onError?.(error);
-		this.emitter.emit("scheduler:error", {
+		await this.emitter.emit("scheduler:error", {
 			error,
 			task
 		});
 		await this.errorHandler?.(error, task);
-		if (!this.emitter.hasListeners("scheduler:error") && !this.errorHandler) throw error;
+		if (!(task.onError || this.emitter.hasListeners("scheduler:error") || this.errorHandler)) throw error;
 	}
 	async cancel(job) {
 		await job.cancel();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@outloud/adonis-scheduler",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Schedule cron jobs in AdonisJS 6/7.",
   "author": "Outloud <hello@outloud.co>",
   "contributors": [