@manablox/jobs 0.1.0

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@manablox/jobs",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "dependencies": {
+    "@manablox/core": "0.1.0",
+    "@manablox/db": "0.1.0",
+    "bullmq": "^6.3.4",
+    "ioredis": "^6.0.0",
+    "drizzle-orm": "^0.45.2"
+  },
+  "devDependencies": {
+    "@manablox/config-typescript": "0.0.0",
+    "@types/node": "^26.4.1",
+    "typescript": "^7.0.2"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,231 @@
+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

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