nuxt-cf-jobs 0.0.2

package/dist/runtime/server/d1.js

@@ -0,0 +1,259 @@
+export const d1DurableJobMigrationSql = [
+  "CREATE TABLE IF NOT EXISTS job_batches (id text PRIMARY KEY, name text, parent_batch_id text, total_jobs integer NOT NULL DEFAULT 0, pending_jobs integer NOT NULL DEFAULT 0, failed_jobs integer NOT NULL DEFAULT 0, on_finish text, handler text, allow_failures integer DEFAULT 0, site_id text, user_id integer, created_at integer NOT NULL DEFAULT (unixepoch()), updated_at integer NOT NULL DEFAULT (unixepoch()), finished_at integer)",
+  "CREATE TABLE IF NOT EXISTS jobs (id text PRIMARY KEY, queue text NOT NULL, job_type text NOT NULL, batch_id text REFERENCES job_batches(id), user_id integer, site_id text, partner_id text, trace_id text, unique_key text, payload text NOT NULL, attempts integer DEFAULT 0, max_attempts integer DEFAULT 3, reserved_at integer, available_at integer NOT NULL, created_at integer NOT NULL DEFAULT (unixepoch()), completed_at integer, failed_at integer, last_error text, retry_reasons text, rows_fetched integer, rows_inserted integer, d1_rows_read integer, d1_rows_written integer, duration_ms integer)",
+  "CREATE TABLE IF NOT EXISTS failed_jobs (id text PRIMARY KEY, queue text NOT NULL, job_type text NOT NULL, batch_id text, user_id integer, site_id text, partner_id text, trace_id text, unique_key text, payload text NOT NULL, exception text NOT NULL, attempts integer NOT NULL, max_attempts integer NOT NULL, failed_at integer NOT NULL)",
+  "CREATE INDEX IF NOT EXISTS idx_job_batches_site ON job_batches (site_id)",
+  "CREATE INDEX IF NOT EXISTS idx_job_batches_pending ON job_batches (pending_jobs)",
+  "CREATE INDEX IF NOT EXISTS idx_job_batches_parent ON job_batches (parent_batch_id)",
+  "CREATE INDEX IF NOT EXISTS idx_job_batches_finished_at ON job_batches (finished_at)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_claimable ON jobs (queue, reserved_at, available_at)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_user ON jobs (user_id)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_site ON jobs (site_id)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_partner ON jobs (partner_id)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_type ON jobs (job_type)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_batch ON jobs (batch_id)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_trace ON jobs (trace_id)",
+  "CREATE INDEX IF NOT EXISTS idx_jobs_sync_dedup ON jobs (site_id, job_type)",
+  "CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_unique_active ON jobs (unique_key) WHERE unique_key IS NOT NULL AND completed_at IS NULL AND failed_at IS NULL",
+  "CREATE INDEX IF NOT EXISTS idx_failed_jobs_queue ON failed_jobs (queue)",
+  "CREATE INDEX IF NOT EXISTS idx_failed_jobs_site ON failed_jobs (site_id)",
+  "CREATE INDEX IF NOT EXISTS idx_failed_jobs_trace ON failed_jobs (trace_id)",
+  "CREATE INDEX IF NOT EXISTS idx_failed_jobs_failed_at ON failed_jobs (failed_at)"
+];
+export function createD1DurableJobRepository(db, opts = {}) {
+  const jobsTable = opts.jobsTable ?? "jobs";
+  const failedJobsTable = opts.failedJobsTable ?? "failed_jobs";
+  const insertJobSql = `
+    INSERT OR IGNORE INTO ${jobsTable} (
+      id, queue, job_type, batch_id, user_id, site_id, partner_id, trace_id, unique_key, payload,
+      attempts, max_attempts, available_at, created_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `;
+  function bindInsertJob(record) {
+    return db.prepare(insertJobSql).bind(
+      record.id,
+      record.queue,
+      record.jobType,
+      record.batchId ?? null,
+      record.userId ?? null,
+      record.siteId ?? null,
+      record.partnerId ?? null,
+      record.traceId,
+      record.uniqueKey ?? null,
+      record.payload,
+      record.attempts,
+      record.maxAttempts,
+      record.availableAt,
+      record.createdAt
+    );
+  }
+  return {
+    async migrate() {
+      for (const statement of d1DurableJobMigrationSql)
+        await db.exec(statement);
+    },
+    async insertJob(record) {
+      const result = await bindInsertJob(record).run();
+      return typeof result.meta?.changes === "number" ? result.meta.changes > 0 : result.success === true;
+    },
+    async insertJobs(records, insertOpts) {
+      if (records.length === 0)
+        return { inserted: [], chunks: [] };
+      const batchSize = Math.max(1, Math.min(insertOpts?.batchSize ?? 90, 100));
+      const chunks = [];
+      const inserted = [];
+      for (let i = 0; i < records.length; i += batchSize) {
+        const slice = records.slice(i, i + batchSize);
+        const stmts = slice.map(bindInsertJob);
+        try {
+          const results = typeof db.batch === "function" ? await db.batch(stmts) : await Promise.all(stmts.map((s) => s.run()));
+          const changes = results.reduce((sum, r) => sum + (r.meta?.changes ?? (r.success ? 1 : 0)), 0);
+          chunks.push({ ok: true, ids: slice.map((r) => r.id), changes });
+          if (changes === slice.length)
+            inserted.push(...slice);
+          else if (changes > 0 && typeof db.batch !== "function") {
+            for (let j = 0; j < slice.length; j++)
+              if ((results[j]?.meta?.changes ?? 0) > 0)
+                inserted.push(slice[j]);
+          }
+        } catch (error) {
+          chunks.push({ ok: false, ids: slice.map((r) => r.id), changes: 0, error });
+        }
+      }
+      if (chunks.length > 0 && chunks.every((c) => !c.ok))
+        throw chunks[0].error ?? new Error("All insertJobs chunks failed");
+      return { inserted, chunks };
+    },
+    async claimJob(id) {
+      const now = currentUnixSeconds();
+      const job = await db.prepare(`
+        UPDATE ${jobsTable}
+        SET reserved_at = ?, attempts = attempts + 1
+        WHERE id = ?
+          AND reserved_at IS NULL
+          AND available_at <= ?
+          AND completed_at IS NULL
+          AND failed_at IS NULL
+        RETURNING *
+      `).bind(now, id, now).first();
+      if (job)
+        fireHook(() => opts.onJobClaimed?.({ job }));
+      return job;
+    },
+    async resolveClaimMiss(id) {
+      const job = await db.prepare(`
+        SELECT reserved_at, completed_at, failed_at
+        FROM ${jobsTable}
+        WHERE id = ?
+      `).bind(id).first();
+      if (!job)
+        return "not-found";
+      if (job.completed_at || job.failed_at)
+        return "already-resolved";
+      return "in-flight";
+    },
+    async completeJob(job, result) {
+      const durationMs = result && typeof result === "object" && "durationMs" in result && typeof result.durationMs === "number" ? result.durationMs : null;
+      await db.prepare(`
+        UPDATE ${jobsTable}
+        SET completed_at = unixepoch(), reserved_at = NULL, duration_ms = COALESCE(?, duration_ms)
+        WHERE id = ?
+      `).bind(durationMs, job.id).run();
+      fireHook(() => opts.onJobCompleted?.({ job, durationMs, result }));
+    },
+    async failJob(job, error) {
+      await db.prepare(`
+        INSERT OR REPLACE INTO ${failedJobsTable} (
+          id, queue, job_type, batch_id, user_id, site_id, partner_id, trace_id, unique_key, payload,
+          exception, attempts, max_attempts, failed_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, unixepoch())
+      `).bind(
+        job.id,
+        job.queue,
+        job.job_type,
+        job.batch_id,
+        job.user_id,
+        job.site_id,
+        job.partner_id,
+        job.trace_id,
+        job.unique_key,
+        job.payload,
+        error,
+        job.attempts,
+        job.max_attempts
+      ).run();
+      await db.prepare(`DELETE FROM ${jobsTable} WHERE id = ?`).bind(job.id).run();
+      fireHook(() => opts.onJobFailed?.({ job, error }));
+    },
+    async releaseJob(job, releaseOpts) {
+      await db.prepare(`
+        UPDATE ${jobsTable}
+        SET reserved_at = NULL, available_at = ?, last_error = COALESCE(?, last_error)
+        WHERE id = ?
+      `).bind(resolveAvailableAt(releaseOpts), releaseOpts?.error ?? null, job.id).run();
+      fireHook(() => opts.onJobReleased?.({ job, opts: releaseOpts }));
+    },
+    async recordFailure(input) {
+      await db.prepare(`
+        INSERT OR REPLACE INTO ${failedJobsTable} (
+          id, queue, job_type, batch_id, user_id, site_id, partner_id, trace_id, unique_key, payload,
+          exception, attempts, max_attempts, failed_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, unixepoch())
+      `).bind(
+        input.id ?? crypto.randomUUID(),
+        input.queue,
+        input.jobType,
+        input.batchId ?? null,
+        input.userId ?? null,
+        input.siteId ?? null,
+        input.partnerId ?? null,
+        input.traceId ?? null,
+        input.uniqueKey ?? null,
+        input.payload,
+        input.exception,
+        input.attempts,
+        input.maxAttempts ?? input.attempts
+      ).run();
+    },
+    async findDispatchableJobs(query = {}) {
+      return await all(db.prepare(`
+        SELECT *
+        FROM ${jobsTable}
+        WHERE reserved_at IS NULL
+          AND available_at <= ?
+          AND completed_at IS NULL
+          AND failed_at IS NULL
+        ORDER BY available_at ASC
+        LIMIT ?
+      `).bind(query.now ?? currentUnixSeconds(), query.limit ?? 100));
+    },
+    async findStaleReservedJobs(query) {
+      return await all(db.prepare(`
+        SELECT *
+        FROM ${jobsTable}
+        WHERE reserved_at IS NOT NULL
+          AND reserved_at <= ?
+          AND completed_at IS NULL
+          AND failed_at IS NULL
+        ORDER BY reserved_at ASC
+        LIMIT ?
+      `).bind(query.staleBefore, query.limit ?? 100));
+    },
+    async releaseStaleReservedJobs(query) {
+      const result = await db.prepare(`
+        UPDATE ${jobsTable}
+        SET reserved_at = NULL, available_at = ?, last_error = COALESCE(?, last_error)
+        WHERE id IN (
+          SELECT id
+          FROM ${jobsTable}
+          WHERE reserved_at IS NOT NULL
+            AND reserved_at <= ?
+            AND completed_at IS NULL
+            AND failed_at IS NULL
+          LIMIT ?
+        )
+      `).bind(
+        query.availableAt ?? query.now ?? currentUnixSeconds(),
+        query.error ?? null,
+        query.staleBefore,
+        query.limit ?? 100
+      ).run();
+      return result.meta?.changes ?? 0;
+    },
+    toDispatchableJob(job) {
+      return {
+        id: job.id,
+        queue: job.queue,
+        payload: JSON.parse(job.payload),
+        attempts: job.attempts,
+        batchId: job.batch_id,
+        siteId: job.site_id,
+        userId: job.user_id
+      };
+    }
+  };
+}
+function currentUnixSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function fireHook(fn) {
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function")
+      result.catch(() => {
+      });
+  } catch {
+  }
+}
+function resolveAvailableAt(opts) {
+  if (typeof opts?.availableAt === "number")
+    return opts.availableAt;
+  return currentUnixSeconds() + (opts?.delaySeconds ?? 0);
+}
+async function all(statement) {
+  const result = await statement.all?.();
+  return result?.results ?? [];
+}

package/dist/runtime/server/dev.d.ts

@@ -0,0 +1,39 @@
+import type { QueueBindingsConfig } from './types.js';
+export interface DevQueueMessage {
+    id?: string;
+    body: Record<string, unknown>;
+    attempts: number;
+    timestamp?: Date | number;
+    ack: () => void;
+    retry: (opts?: {
+        delaySeconds?: number;
+    }) => void;
+}
+export interface DevQueueBatch {
+    queue: string;
+    messages: DevQueueMessage[];
+    ackAll: () => void;
+    retryAll: (opts?: {
+        delaySeconds?: number;
+    }) => void;
+}
+export interface DevQueueHookPayload {
+    batch: DevQueueBatch;
+    env: Record<string, unknown>;
+}
+export interface DevQueueRuntime {
+    env: Record<string, unknown>;
+    enqueue: (binding: string, body: Record<string, unknown>, opts?: {
+        delaySeconds?: number;
+        attempts?: number;
+    }) => void;
+    dispose: () => void;
+}
+export interface DevQueueRuntimeOptions {
+    queues: QueueBindingsConfig;
+    baseEnv?: Record<string, unknown>;
+    onBatch: (payload: DevQueueHookPayload) => Promise<void> | void;
+    onError?: (error: unknown) => void;
+    maxAttempts?: number;
+}
+export declare function createDevQueueRuntime(opts: DevQueueRuntimeOptions): DevQueueRuntime;

package/dist/runtime/server/dev.js

@@ -0,0 +1,93 @@
+import { resolveCloudflareQueueName } from "./queue.js";
+export function createDevQueueRuntime(opts) {
+  const env = { ...opts.baseEnv ?? {} };
+  const bindingToLogical = /* @__PURE__ */ new Map();
+  const timers = /* @__PURE__ */ new Set();
+  const maxAttempts = opts.maxAttempts ?? 10;
+  let disposed = false;
+  for (const [logicalName, config] of Object.entries(opts.queues)) {
+    const binding = typeof config === "string" ? config : config?.binding;
+    if (!binding)
+      continue;
+    bindingToLogical.set(binding, logicalName);
+    const queue = {
+      async send(message, sendOpts) {
+        enqueue(binding, message, { delaySeconds: sendOpts?.delaySeconds });
+      },
+      async sendBatch(messages, sendOpts) {
+        for (const message of messages) {
+          enqueue(binding, message.body, {
+            delaySeconds: message.delaySeconds ?? sendOpts?.delaySeconds
+          });
+        }
+      }
+    };
+    env[binding] = queue;
+  }
+  function enqueue(binding, body, eopts) {
+    if (disposed)
+      return;
+    const logical = bindingToLogical.get(binding);
+    if (!logical)
+      return;
+    const cfQueueName = resolveCloudflareQueueName(opts.queues, logical);
+    const attempts = (eopts?.attempts ?? 0) + 1;
+    const delayMs = Math.max(0, (eopts?.delaySeconds ?? 0) * 1e3);
+    const id = eopts?.id ?? (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`);
+    const fire = () => {
+      let settled = false;
+      const message = {
+        id,
+        body,
+        attempts,
+        timestamp: /* @__PURE__ */ new Date(),
+        ack() {
+          settled = true;
+        },
+        retry(retryOpts) {
+          if (settled)
+            return;
+          settled = true;
+          if (attempts >= maxAttempts)
+            return;
+          enqueue(binding, body, { delaySeconds: retryOpts?.delaySeconds, attempts, id });
+        }
+      };
+      const batch = {
+        queue: cfQueueName,
+        messages: [message],
+        ackAll() {
+          settled = true;
+        },
+        retryAll(retryOpts) {
+          if (settled)
+            return;
+          settled = true;
+          if (attempts >= maxAttempts)
+            return;
+          enqueue(binding, body, { delaySeconds: retryOpts?.delaySeconds, attempts, id });
+        }
+      };
+      Promise.resolve().then(() => opts.onBatch({ batch, env })).catch((error) => opts.onError?.(error));
+    };
+    if (delayMs === 0) {
+      queueMicrotask(fire);
+      return;
+    }
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      fire();
+    }, delayMs);
+    timers.add(timer);
+  }
+  return {
+    env,
+    enqueue,
+    dispose() {
+      disposed = true;
+      for (const timer of timers)
+        clearTimeout(timer);
+      timers.clear();
+    }
+  };
+}

package/dist/runtime/server/dispatch.d.ts

@@ -0,0 +1,25 @@
+import type { DispatchableJob, DispatchResult, JobContext, JobControlResult, JobDefinition, JobHandler, JobMiddleware } from './types.js';
+export interface JobRegistryLike<Env, Db, Logger> {
+    getHandler: (name: string) => JobHandler<unknown, Env, Db, Logger> | undefined;
+    getJobDefinition?: (name: string) => JobDefinition<string, unknown, string, Env, Db, Logger> | undefined;
+}
+export interface DispatchContextInput<Job extends DispatchableJob> {
+    job: Job;
+    taskName: string;
+    payload: Record<string, unknown>;
+    control: JobControlResult;
+}
+export interface DispatchRegisteredJobOptions<Job extends DispatchableJob, Env, Db, Logger> {
+    registry: JobRegistryLike<Env, Db, Logger>;
+    job: Job;
+    createContext: (input: DispatchContextInput<Job>) => JobContext<Env, Db, Logger> | Promise<JobContext<Env, Db, Logger>>;
+    onHandledThrow?: (input: DispatchContextInput<Job> & {
+        error: unknown;
+    }) => void | Promise<void>;
+    onUnhandledThrow?: (input: DispatchContextInput<Job> & {
+        error: unknown;
+    }) => void | Promise<void>;
+    onComplete?: (input: DispatchContextInput<Job>) => void | Promise<void>;
+}
+export declare function dispatchRegisteredJob<Job extends DispatchableJob, Env, Db, Logger>(opts: DispatchRegisteredJobOptions<Job, Env, Db, Logger>): Promise<DispatchResult>;
+export declare function runJobThroughMiddleware<Payload, Env, Db, Logger>(payload: Payload, ctx: JobContext<Env, Db, Logger>, middleware: Array<JobMiddleware<Payload, Env, Db, Logger>>, destination: () => Promise<void>): Promise<void>;

package/dist/runtime/server/dispatch.js

@@ -0,0 +1,66 @@
+import { parseJobInput } from "./registry.js";
+export async function dispatchRegisteredJob(opts) {
+  const payload = opts.job.payload;
+  const taskName = payload._task;
+  if (typeof taskName !== "string" || taskName.length === 0) {
+    return { success: false, error: "No _task in payload", handlerNotFound: true };
+  }
+  const definition = opts.registry.getJobDefinition?.(taskName);
+  const handler = definition?.handle ?? opts.registry.getHandler(taskName);
+  if (!handler) {
+    return { success: false, error: `No handler for task: ${taskName}`, handlerNotFound: true };
+  }
+  const { _task, _continuations, ...cleanPayload } = payload;
+  const parsedPayload = parseJobInput(definition, cleanPayload);
+  if (!parsedPayload.success) {
+    return {
+      success: false,
+      error: `Invalid payload for task: ${taskName}`,
+      invalidPayload: true,
+      validationError: parsedPayload.error
+    };
+  }
+  const control = { handled: false };
+  const input = {
+    job: opts.job,
+    taskName,
+    payload: parsedPayload.data,
+    control
+  };
+  const ctx = await opts.createContext(input);
+  try {
+    await runJobThroughMiddleware(
+      parsedPayload.data,
+      ctx,
+      definition?.middleware ?? [],
+      () => handler(parsedPayload.data, ctx)
+    );
+  } catch (error) {
+    if (control.handled) {
+      await opts.onHandledThrow?.({ ...input, error });
+      return { success: true, control };
+    }
+    if (definition?.failed) {
+      await Promise.resolve(definition.failed(parsedPayload.data, ctx, error)).catch((failedError) => {
+        opts.onUnhandledThrow?.({ ...input, error: failedError });
+      });
+    }
+    await opts.onUnhandledThrow?.({ ...input, error });
+    throw error;
+  }
+  await opts.onComplete?.(input);
+  return { success: true, control: control.handled ? control : void 0 };
+}
+export async function runJobThroughMiddleware(payload, ctx, middleware, destination) {
+  let index = -1;
+  async function run(i) {
+    if (i <= index)
+      throw new Error("Job middleware called next() multiple times");
+    index = i;
+    const layer = middleware[i];
+    if (!layer)
+      return destination();
+    await layer(payload, ctx, () => run(i + 1));
+  }
+  await run(0);
+}

package/dist/runtime/server/index.d.ts

@@ -0,0 +1,12 @@
+export * from './app.js';
+export * from './d1.js';
+export * from './dev.js';
+export * from './dispatch.js';
+export * from './outbox.js';
+export * from './payload.js';
+export * from './policy.js';
+export * from './queue.js';
+export * from './registry.js';
+export * from './schema.js';
+export * from './testing.js';
+export * from './types.js';

package/dist/runtime/server/index.js

@@ -0,0 +1,12 @@
+export * from "./app.js";
+export * from "./d1.js";
+export * from "./dev.js";
+export * from "./dispatch.js";
+export * from "./outbox.js";
+export * from "./payload.js";
+export * from "./policy.js";
+export * from "./queue.js";
+export * from "./registry.js";
+export * from "./schema.js";
+export * from "./testing.js";
+export * from "./types.js";