@manablox/jobs 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { Manablox } from "@manablox/core";
+import { Database, Repositories } from "@manablox/db";
+import { JobsOptions } from "bullmq";
+//#region src/index.d.ts
+export interface JobPayloads {
+  'webhook:deliver': {
+    webhookId: string;
+    event: string;
+    payload: Record<string, unknown>;
+  };
+  'media:derive': {
+    assetId: string;
+    preset: string;
+    format: string;
+  };
+  'content:scheduledPublish': {
+    contentId: string;
+  };
+  'workflow:run': {
+    runId: string;
+  };
+  'maintenance:pruneApiKeys': Record<string, never>;
+}
+export type JobName = keyof JobPayloads;
+export interface JobRunner {
+  enqueue<K extends JobName>(name: K, payload: JobPayloads[K], options?: JobsOptions): Promise<void>;
+  close(): Promise<void>;
+  /** True when there is no queue and `enqueue` runs the job before returning. */
+  inline: boolean;
+}
+export interface JobHandlers {
+  derive?: (assetId: string, preset: string, format: string) => Promise<void>;
+  publish?: (contentId: string) => Promise<void>;
+  /** Executes a queued workflow run; set by the host once the engine exists. */
+  workflowRun?: (runId: string) => Promise<void>;
+  /** Sends one webhook delivery; set by the host once the webhook service exists. */
+  webhookDeliver?: (data: JobPayloads['webhook:deliver']) => Promise<void>;
+}
+/** Background work: webhook delivery with retries, image derivatives, scheduled publish. */
+export declare function createJobRunner(manablox: Manablox, db: Database, repos: Repositories, handlers?: JobHandlers): JobRunner;
+//#endregion

package/dist/index.js

@@ -0,0 +1,94 @@
+import { runAsActor, systemActor } from "@manablox/core";
+import { schema } from "@manablox/db";
+import { Queue, Worker } from "bullmq";
+import { sql } from "drizzle-orm";
+import { Redis } from "ioredis";
+//#region src/index.ts
+/** Background work: webhook delivery with retries, image derivatives, scheduled publish. */
+function createJobRunner(manablox, db, repos, handlers = {}) {
+	const redisUrl = manablox.config.cache.redisUrl;
+	if (!redisUrl) return {
+		inline: true,
+		async enqueue(name, payload) {
+			await runAsActor(systemActor(`job:${name}`), () => runJob(name, payload, db, repos, handlers, manablox));
+		},
+		async close() {}
+	};
+	const connection = new Redis(redisUrl, { maxRetriesPerRequest: null });
+	const queue = new Queue("manablox", { connection });
+	const worker = new Worker("manablox", async (job) => {
+		await runAsActor(systemActor(`job:${job.name}`), () => runJob(job.name, job.data, db, repos, handlers, manablox));
+	}, {
+		connection,
+		concurrency: 8,
+		autorun: true
+	});
+	worker.on("failed", (job, error) => {
+		manablox.logger.warn({
+			job: job?.name,
+			err: error
+		}, "job failed");
+	});
+	manablox.onDispose(async () => {
+		await worker.close();
+		await queue.close();
+		connection.disconnect();
+	});
+	return {
+		inline: false,
+		async enqueue(name, payload, options) {
+			await queue.add(name, payload, {
+				attempts: 5,
+				backoff: {
+					type: "exponential",
+					delay: 2e3
+				},
+				removeOnComplete: 500,
+				removeOnFail: 1e3,
+				...options
+			});
+		},
+		async close() {
+			await worker.close();
+			await queue.close();
+		}
+	};
+}
+async function runJob(name, payload, db, repos, handlers, manablox) {
+	switch (name) {
+		case "webhook:deliver": {
+			const data = payload;
+			await handlers.webhookDeliver?.(data);
+			break;
+		}
+		case "media:derive": {
+			const data = payload;
+			await handlers.derive?.(data.assetId, data.preset, data.format);
+			break;
+		}
+		case "content:scheduledPublish": {
+			const data = payload;
+			await handlers.publish?.(data.contentId);
+			break;
+		}
+		case "workflow:run": {
+			const data = payload;
+			await handlers.workflowRun?.(data.runId);
+			break;
+		}
+		case "maintenance:pruneApiKeys": {
+			const deleted = await db.delete(schema.apikeys).where(sql`${schema.apikeys.expiresAt} is not null and ${schema.apikeys.expiresAt} < now()`).returning({
+				id: schema.apikeys.id,
+				name: schema.apikeys.name
+			});
+			if (deleted.length) await repos.audit.record({
+				action: "apiKey.prune",
+				targetKind: "apiKey",
+				meta: { removed: deleted }
+			});
+			break;
+		}
+	}
+}
+//#endregion
+export { createJobRunner };

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@manablox/jobs",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@manablox/core": "0.2.0",
-    "@manablox/db": "0.2.0",
+    "@manablox/core": "0.4.0",
+    "@manablox/db": "0.4.0",
     "bullmq": "^6.3.4",
     "ioredis": "^6.0.0",
     "drizzle-orm": "^0.45.2"
@@ -20,9 +20,16 @@
   "devDependencies": {
     "@manablox/config-typescript": "0.0.0",
     "@types/node": "^26.4.1",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2"
   },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md"
+  ],
   "scripts": {
+    "build": "tsdown",
     "typecheck": "tsc --noEmit"
   }
 }

package/src/index.ts

@@ -1,143 +0,0 @@
-import type { Manablox } from '@manablox/core';
-import { type Database, type Repositories, schema } from '@manablox/db';
-import { type JobsOptions, Queue, Worker } from 'bullmq';
-import { sql } from 'drizzle-orm';
-import { Redis } from 'ioredis';
-
-export interface JobPayloads {
-  'webhook:deliver': { webhookId: string; event: string; payload: Record<string, unknown> };
-  'media:derive': { assetId: string; preset: string; format: string };
-  'content:scheduledPublish': { contentId: string };
-  'workflow:run': { runId: string };
-  'maintenance:pruneApiKeys': Record<string, never>;
-}
-
-export type JobName = keyof JobPayloads;
-
-export interface JobRunner {
-  enqueue<K extends JobName>(
-    name: K,
-    payload: JobPayloads[K],
-    options?: JobsOptions,
-  ): Promise<void>;
-  close(): Promise<void>;
-  /** True when there is no queue and `enqueue` runs the job before returning. */
-  inline: boolean;
-}
-
-export interface JobHandlers {
-  derive?: (assetId: string, preset: string, format: string) => Promise<void>;
-  publish?: (contentId: string) => Promise<void>;
-  /** Executes a queued workflow run; set by the host once the engine exists. */
-  workflowRun?: (runId: string) => Promise<void>;
-  /** Sends one webhook delivery; set by the host once the webhook service exists. */
-  webhookDeliver?: (data: JobPayloads['webhook:deliver']) => Promise<void>;
-}
-
-/** Background work: webhook delivery with retries, image derivatives, scheduled publish. */
-export function createJobRunner(
-  manablox: Manablox,
-  db: Database,
-  repos: Repositories,
-  handlers: JobHandlers = {},
-): JobRunner {
-  const redisUrl = manablox.config.cache.redisUrl;
-
-  // Without Redis, jobs run inline. Correct for a single-node install, and it keeps the
-  // call sites identical either way.
-  if (!redisUrl) {
-    return {
-      inline: true,
-      async enqueue(name, payload) {
-        await runJob(name, payload as never, db, repos, handlers, manablox);
-      },
-      async close() {},
-    };
-  }
-
-  const connection = new Redis(redisUrl, { maxRetriesPerRequest: null });
-  const queue = new Queue('manablox', { connection });
-
-  const worker = new Worker(
-    'manablox',
-    async (job) => {
-      await runJob(job.name as JobName, job.data, db, repos, handlers, manablox);
-    },
-    {
-      connection,
-      concurrency: 8,
-      // Exponential backoff so a webhook endpoint that is briefly down is retried
-      // rather than dropped, and a permanently dead one stops being hammered.
-      autorun: true,
-    },
-  );
-
-  worker.on('failed', (job, error) => {
-    manablox.logger.warn({ job: job?.name, err: error }, 'job failed');
-  });
-
-  manablox.onDispose(async () => {
-    await worker.close();
-    await queue.close();
-    connection.disconnect();
-  });
-
-  return {
-    inline: false,
-    async enqueue(name, payload, options) {
-      await queue.add(name, payload, {
-        attempts: 5,
-        backoff: { type: 'exponential', delay: 2000 },
-        removeOnComplete: 500,
-        removeOnFail: 1000,
-        ...options,
-      });
-    },
-    async close() {
-      await worker.close();
-      await queue.close();
-    },
-  };
-}
-
-async function runJob(
-  name: JobName,
-  payload: JobPayloads[JobName],
-  db: Database,
-  repos: Repositories,
-  handlers: JobHandlers,
-  manablox: Manablox,
-): Promise<void> {
-  switch (name) {
-    case 'webhook:deliver': {
-      const data = payload as JobPayloads['webhook:deliver'];
-      await handlers.webhookDeliver?.(data);
-      break;
-    }
-    case 'media:derive': {
-      const data = payload as JobPayloads['media:derive'];
-      await handlers.derive?.(data.assetId, data.preset, data.format);
-      break;
-    }
-    case 'content:scheduledPublish': {
-      const data = payload as JobPayloads['content:scheduledPublish'];
-      await handlers.publish?.(data.contentId);
-      break;
-    }
-    case 'workflow:run': {
-      const data = payload as JobPayloads['workflow:run'];
-      await handlers.workflowRun?.(data.runId);
-      break;
-    }
-    case 'maintenance:pruneApiKeys': {
-      await db
-        .delete(schema.apikeys)
-        .where(
-          sql`${schema.apikeys.expiresAt} is not null and ${schema.apikeys.expiresAt} < now()`,
-        );
-      break;
-    }
-  }
-  void repos;
-  void manablox;
-}

package/tsconfig.json

@@ -1 +0,0 @@
-{ "extends": "@manablox/config-typescript/library.json", "include": ["src"] }