@manablox/jobs 0.1.0 → 0.2.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manablox/jobs",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "exports": {
     ".": {
@@ -11,8 +11,8 @@
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "dependencies": {
-    "@manablox/core": "0.1.0",
-    "@manablox/db": "0.1.0",
+    "@manablox/core": "0.2.0",
+    "@manablox/db": "0.2.0",
     "bullmq": "^6.3.4",
     "ioredis": "^6.0.0",
     "drizzle-orm": "^0.45.2"

package/src/index.ts

@@ -1,14 +1,14 @@
-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 { 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>;
 }
 
@@ -21,11 +21,17 @@ export interface JobRunner {
     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. */
@@ -41,6 +47,7 @@ export function createJobRunner(
   // call sites identical either way.
   if (!redisUrl) {
     return {
+      inline: true,
       async enqueue(name, payload) {
         await runJob(name, payload as never, db, repos, handlers, manablox);
       },
@@ -76,6 +83,7 @@ export function createJobRunner(
   });
 
   return {
+    inline: false,
     async enqueue(name, payload, options) {
       await queue.add(name, payload, {
         attempts: 5,
@@ -103,7 +111,7 @@ async function runJob(
   switch (name) {
     case 'webhook:deliver': {
       const data = payload as JobPayloads['webhook:deliver'];
-      await deliverWebhook(db, data, manablox);
+      await handlers.webhookDeliver?.(data);
       break;
     }
     case 'media:derive': {
@@ -116,6 +124,11 @@ async function runJob(
       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)
@@ -126,106 +139,5 @@ async function runJob(
     }
   }
   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' },
-  );
+  void manablox;
 }