@manablox/jobs 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,18 @@
+# `@manablox/jobs`
+
+Background work on BullMQ: webhook delivery with retries, image derivatives, scheduled publishing, key pruning. Without Redis the jobs run inline, which is correct for a single-node install.
+
+## Exports
+
+- `createJobRunner`, `JobRunner`, `JobPayloads`
+- `attachWebhooks` — turns content hooks into `webhook:deliver` jobs
+
+## Depends on
+
+@manablox/db, bullmq
+
+## Check
+
+```sh
+pnpm --filter @manablox/jobs typecheck
+```

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { Database, Repositories } from "@manablox/db";
+import { JobsOptions } from "bullmq";
+import { Manablox } from "@manablox/core";
+//#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,82 @@
+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 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 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": await db.delete(schema.apikeys).where(sql`${schema.apikeys.expiresAt} is not null and ${schema.apikeys.expiresAt} < now()`);
+	}
+}
+//#endregion
+export { createJobRunner };

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@manablox/jobs",
-  "version": "0.1.0",
+  "version": "0.3.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.1.0",
-    "@manablox/db": "0.1.0",
+    "@manablox/core": "0.3.0",
+    "@manablox/db": "0.3.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,231 +0,0 @@
-import { createHmac } from 'node:crypto';
-import type { Manablox } from '@manablox/core';
-import { type Database, type Repositories, schema } from '@manablox/db';
-import { type JobsOptions, Queue, Worker } from 'bullmq';
-import { and, eq, 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 };
-  '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>;
-}
-
-export interface JobHandlers {
-  derive?: (assetId: string, preset: string, format: string) => Promise<void>;
-  publish?: (contentId: string) => 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 {
-      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 {
-    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 deliverWebhook(db, data, manablox);
-      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 'maintenance:pruneApiKeys': {
-      await db
-        .delete(schema.apikeys)
-        .where(
-          sql`${schema.apikeys.expiresAt} is not null and ${schema.apikeys.expiresAt} < now()`,
-        );
-      break;
-    }
-  }
-  void repos;
-}
-
-async function deliverWebhook(
-  db: Database,
-  data: JobPayloads['webhook:deliver'],
-  manablox: Manablox,
-): Promise<void> {
-  const rows = await db
-    .select()
-    .from(schema.webhooks)
-    .where(and(eq(schema.webhooks.id, data.webhookId), eq(schema.webhooks.enabled, true)))
-    .limit(1);
-
-  const webhook = rows[0];
-  if (!webhook) return;
-
-  const body = JSON.stringify({
-    event: data.event,
-    payload: data.payload,
-    at: new Date().toISOString(),
-  });
-
-  const headers: Record<string, string> = {
-    'content-type': 'application/json',
-    'x-manablox-event': data.event,
-  };
-
-  // Signed so a receiver can verify the payload actually came from this instance.
-  if (webhook.secret) {
-    headers['x-manablox-signature'] = createHmac('sha256', webhook.secret)
-      .update(body)
-      .digest('hex');
-  }
-
-  let status: number | null = null;
-  let error: string | null = null;
-
-  try {
-    const response = await fetch(webhook.url, {
-      method: 'POST',
-      headers,
-      body,
-      signal: AbortSignal.timeout(10_000),
-    });
-    status = response.status;
-    if (!response.ok) error = `HTTP ${response.status}`;
-  } catch (cause) {
-    error = cause instanceof Error ? cause.message : String(cause);
-  }
-
-  await db.insert(schema.webhookDeliveries).values({
-    webhookId: webhook.id,
-    event: data.event,
-    payload: data.payload,
-    status,
-    error,
-  });
-
-  // Throwing hands the retry decision back to BullMQ's backoff policy.
-  if (error) {
-    manablox.logger.warn({ webhook: webhook.id, status, error }, 'webhook delivery failed');
-    throw new Error(error);
-  }
-}
-
-/** Fans content lifecycle events out to the space's webhooks. */
-export function attachWebhooks(manablox: Manablox, db: Database, jobs: JobRunner): void {
-  const dispatch = async (event: string, spaceId: string, payload: Record<string, unknown>) => {
-    const hooks = await db
-      .select({ id: schema.webhooks.id, events: schema.webhooks.events })
-      .from(schema.webhooks)
-      .where(and(eq(schema.webhooks.spaceId, spaceId), eq(schema.webhooks.enabled, true)));
-
-    for (const hook of hooks) {
-      if (hook.events.length > 0 && !hook.events.includes(event)) continue;
-      await jobs.enqueue('webhook:deliver', { webhookId: hook.id, event, payload });
-    }
-  };
-
-  manablox.hooks.on(
-    'content:afterPublish',
-    async (row) => {
-      await dispatch('content.published', row.spaceId, { id: row.id, permalink: row.permalink });
-    },
-    { source: '@manablox/jobs' },
-  );
-
-  manablox.hooks.on(
-    'content:afterUpdate',
-    async (row) => {
-      await dispatch('content.updated', row.spaceId, { id: row.id });
-    },
-    { source: '@manablox/jobs' },
-  );
-
-  manablox.hooks.on(
-    'content:afterDelete',
-    async (payload, context) => {
-      if (context.spaceId) await dispatch('content.deleted', context.spaceId, { id: payload.id });
-    },
-    { source: '@manablox/jobs' },
-  );
-}

package/tsconfig.json

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