@contractspec/lib.jobs 1.57.0 → 1.58.0

package/dist/node/queue/memory-queue.js

@@ -0,0 +1,160 @@
+// src/queue/types.ts
+export * from "@contractspec/lib.contracts/jobs/queue";
+import {
+  calculateBackoff,
+  DEFAULT_RETRY_POLICY
+} from "@contractspec/lib.contracts/jobs/queue";
+
+// src/queue/memory-queue.ts
+import { randomUUID } from "node:crypto";
+class MemoryJobQueue {
+  jobs = new Map;
+  handlers = new Map;
+  timer;
+  activeCount = 0;
+  pollIntervalMs;
+  concurrency;
+  retryPolicy;
+  constructor(options = {}) {
+    this.pollIntervalMs = options.pollIntervalMs ?? 200;
+    this.concurrency = options.concurrency ?? 5;
+    this.retryPolicy = options.retryPolicy ?? DEFAULT_RETRY_POLICY;
+  }
+  async enqueue(jobType, payload, options = {}) {
+    if (options.dedupeKey) {
+      const existing = Array.from(this.jobs.values()).find((j) => j.dedupeKey === options.dedupeKey && j.status === "pending");
+      if (existing) {
+        return existing;
+      }
+    }
+    const now = new Date;
+    const scheduledAt = options.delaySeconds ? new Date(now.getTime() + options.delaySeconds * 1000) : now;
+    const job = {
+      id: randomUUID(),
+      type: jobType,
+      version: "1.0.0",
+      payload,
+      status: "pending",
+      priority: options.priority ?? 0,
+      attempts: 0,
+      maxRetries: options.maxRetries ?? this.retryPolicy.maxRetries,
+      createdAt: now,
+      updatedAt: now,
+      scheduledAt,
+      dedupeKey: options.dedupeKey,
+      tenantId: options.tenantId,
+      userId: options.userId,
+      traceId: options.traceId,
+      metadata: options.metadata
+    };
+    if (options.timeoutMs) {
+      job.timeoutAt = new Date(now.getTime() + options.timeoutMs);
+    }
+    this.jobs.set(job.id, job);
+    return job;
+  }
+  register(jobType, handler) {
+    this.handlers.set(jobType, handler);
+  }
+  start() {
+    if (this.timer)
+      return;
+    this.timer = setInterval(() => {
+      this.processNext();
+    }, this.pollIntervalMs);
+  }
+  async stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+    while (this.activeCount > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+  async getJob(jobId) {
+    return this.jobs.get(jobId) ?? null;
+  }
+  async cancelJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "pending") {
+      return false;
+    }
+    job.status = "cancelled";
+    job.updatedAt = new Date;
+    return true;
+  }
+  async getStats() {
+    const stats = {
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+      deadLetter: 0
+    };
+    for (const job of this.jobs.values()) {
+      switch (job.status) {
+        case "pending":
+          stats.pending++;
+          break;
+        case "running":
+          stats.running++;
+          break;
+        case "completed":
+          stats.completed++;
+          break;
+        case "failed":
+          stats.failed++;
+          break;
+        case "dead_letter":
+          stats.deadLetter++;
+          break;
+      }
+    }
+    return stats;
+  }
+  async processNext() {
+    if (this.activeCount >= this.concurrency)
+      return;
+    const now = new Date;
+    const pendingJobs = Array.from(this.jobs.values()).filter((j) => j.status === "pending" && (!j.scheduledAt || j.scheduledAt <= now)).sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return (a.scheduledAt?.getTime() ?? 0) - (b.scheduledAt?.getTime() ?? 0);
+    });
+    const job = pendingJobs[0];
+    if (!job)
+      return;
+    const handler = this.handlers.get(job.type);
+    if (!handler)
+      return;
+    this.activeCount++;
+    job.status = "running";
+    job.startedAt = new Date;
+    job.updatedAt = new Date;
+    job.attempts += 1;
+    try {
+      const result = await handler(job);
+      job.status = "completed";
+      job.completedAt = new Date;
+      job.result = result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      job.lastError = errorMessage;
+      if (job.attempts >= job.maxRetries) {
+        job.status = "dead_letter";
+      } else {
+        const backoff = calculateBackoff(job.attempts, this.retryPolicy);
+        job.status = "pending";
+        job.scheduledAt = new Date(Date.now() + backoff);
+      }
+    } finally {
+      job.updatedAt = new Date;
+      this.activeCount--;
+    }
+  }
+}
+export {
+  MemoryJobQueue
+};

package/dist/node/queue/register-defined-job.js

@@ -0,0 +1,15 @@
+// src/queue/register-defined-job.ts
+function registerDefinedJob(queue, def) {
+  const wrapped = async (job) => {
+    const payload = def.schema.parse(job.payload);
+    const typedJob = {
+      ...job,
+      payload
+    };
+    await def.handler(payload, typedJob);
+  };
+  queue.register(def.type, wrapped);
+}
+export {
+  registerDefinedJob
+};

package/dist/node/queue/scaleway-sqs-queue.js

@@ -0,0 +1,206 @@
+// src/queue/types.ts
+export * from "@contractspec/lib.contracts/jobs/queue";
+import {
+  calculateBackoff,
+  DEFAULT_RETRY_POLICY
+} from "@contractspec/lib.contracts/jobs/queue";
+
+// src/queue/scaleway-sqs-queue.ts
+import { randomUUID } from "node:crypto";
+import {
+  DeleteMessageCommand,
+  ReceiveMessageCommand,
+  SendMessageCommand,
+  SQSClient
+} from "@aws-sdk/client-sqs";
+class ScalewaySqsJobQueue {
+  sqs;
+  queueUrl;
+  waitTimeSeconds;
+  maxNumberOfMessages;
+  visibilityTimeoutSeconds;
+  handlers = new Map;
+  logger;
+  running = false;
+  constructor(config) {
+    this.logger = config.logger;
+    const accessKeyId = config.credentials?.accessKeyId ?? process.env.SCALEWAY_ACCESS_KEY_QUEUE;
+    const secretAccessKey = config.credentials?.secretAccessKey ?? process.env.SCALEWAY_SECRET_KEY_QUEUE;
+    if (!accessKeyId || !secretAccessKey) {
+      throw new Error("Missing SCALEWAY_ACCESS_KEY_QUEUE / SCALEWAY_SECRET_KEY_QUEUE in env");
+    }
+    const region = config.region ?? process.env.SCALEWAY_REGION ?? "par";
+    const endpoint = config.endpoint ?? "https://sqs.mnq.fr-par.scaleway.com";
+    this.sqs = new SQSClient({
+      region,
+      endpoint,
+      credentials: {
+        accessKeyId,
+        secretAccessKey
+      }
+    });
+    this.queueUrl = config.queueUrl;
+    this.waitTimeSeconds = config.waitTimeSeconds ?? 20;
+    this.maxNumberOfMessages = config.maxNumberOfMessages ?? 5;
+    this.visibilityTimeoutSeconds = config.visibilityTimeoutSeconds ?? 60;
+  }
+  async enqueue(jobType, payload, options = {}) {
+    const id = randomUUID();
+    const now = new Date;
+    const scheduledAt = options.delaySeconds ? new Date(now.getTime() + options.delaySeconds * 1000) : now;
+    const envelope = {
+      id,
+      type: jobType,
+      payload
+    };
+    await this.sqs.send(new SendMessageCommand({
+      QueueUrl: this.queueUrl,
+      MessageBody: JSON.stringify(envelope),
+      DelaySeconds: options.delaySeconds ?? 0
+    }));
+    return {
+      id,
+      type: jobType,
+      version: "1.0.0",
+      payload,
+      status: "pending",
+      priority: options.priority ?? 0,
+      attempts: 0,
+      maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+      createdAt: now,
+      updatedAt: now,
+      scheduledAt,
+      dedupeKey: options.dedupeKey,
+      tenantId: options.tenantId,
+      userId: options.userId,
+      traceId: options.traceId,
+      metadata: options.metadata
+    };
+  }
+  register(jobType, handler) {
+    if (this.handlers.has(jobType)) {
+      throw new Error(`Handler already registered for job type "${jobType}"`);
+    }
+    this.handlers.set(jobType, handler);
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.pollLoop().catch((error) => {
+      this.logger?.error?.("jobs.queue.scaleway_sqs.poll_loop_fatal", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.running = false;
+    });
+  }
+  async stop() {
+    this.running = false;
+  }
+  async pollLoop() {
+    this.logger?.info?.("jobs.queue.scaleway_sqs.started", {
+      queueUrl: this.queueUrl
+    });
+    while (this.running) {
+      try {
+        const res = await this.sqs.send(new ReceiveMessageCommand({
+          QueueUrl: this.queueUrl,
+          MaxNumberOfMessages: this.maxNumberOfMessages,
+          WaitTimeSeconds: this.waitTimeSeconds,
+          VisibilityTimeout: this.visibilityTimeoutSeconds,
+          MessageSystemAttributeNames: ["ApproximateReceiveCount"]
+        }));
+        const messages = res.Messages ?? [];
+        if (messages.length === 0) {
+          continue;
+        }
+        for (const msg of messages) {
+          if (!msg.Body || !msg.ReceiptHandle) {
+            this.logger?.warn?.("jobs.queue.scaleway_sqs.invalid_message", {
+              messageId: msg.MessageId,
+              reason: "missing_body_or_receipt"
+            });
+            continue;
+          }
+          let envelope;
+          try {
+            envelope = JSON.parse(msg.Body);
+          } catch (err) {
+            this.logger?.warn?.("jobs.queue.scaleway_sqs.parse_failed", {
+              messageId: msg.MessageId,
+              error: err instanceof Error ? err.message : String(err)
+            });
+            await this.deleteMessage(msg.ReceiptHandle);
+            continue;
+          }
+          const handler = this.handlers.get(envelope.type);
+          if (!handler) {
+            this.logger?.warn?.("jobs.queue.scaleway_sqs.missing_handler", {
+              jobType: envelope.type,
+              messageId: msg.MessageId
+            });
+            await this.deleteMessage(msg.ReceiptHandle);
+            continue;
+          }
+          const now = new Date;
+          const attempts = parseInt(msg.Attributes?.ApproximateReceiveCount ?? "1", 10);
+          const job = {
+            id: envelope.id,
+            type: envelope.type,
+            version: "1.0.0",
+            payload: envelope.payload,
+            status: "pending",
+            priority: 0,
+            attempts,
+            maxRetries: DEFAULT_RETRY_POLICY.maxRetries,
+            createdAt: now,
+            updatedAt: now
+          };
+          job.status = "running";
+          job.updatedAt = new Date;
+          try {
+            await handler(job);
+            job.status = "completed";
+            job.updatedAt = new Date;
+            await this.deleteMessage(msg.ReceiptHandle);
+          } catch (err) {
+            job.status = "failed";
+            job.lastError = err instanceof Error ? err.message : "Unknown job error";
+            job.updatedAt = new Date;
+            this.logger?.error?.("jobs.queue.scaleway_sqs.job_failed", {
+              jobType: job.type,
+              jobId: job.id,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      } catch (err) {
+        this.logger?.error?.("jobs.queue.scaleway_sqs.poll_error", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        await this.sleep(5000);
+      }
+    }
+    this.logger?.info?.("jobs.queue.scaleway_sqs.stopped", {
+      queueUrl: this.queueUrl
+    });
+  }
+  async deleteMessage(receiptHandle) {
+    try {
+      await this.sqs.send(new DeleteMessageCommand({
+        QueueUrl: this.queueUrl,
+        ReceiptHandle: receiptHandle
+      }));
+    } catch (err) {
+      this.logger?.warn?.("jobs.queue.scaleway_sqs.delete_failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  async sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+export {
+  ScalewaySqsJobQueue
+};

package/dist/node/queue/types.js

@@ -0,0 +1,10 @@
+// src/queue/types.ts
+export * from "@contractspec/lib.contracts/jobs/queue";
+import {
+  calculateBackoff,
+  DEFAULT_RETRY_POLICY
+} from "@contractspec/lib.contracts/jobs/queue";
+export {
+  calculateBackoff,
+  DEFAULT_RETRY_POLICY
+};

package/dist/node/scheduler/index.js

@@ -0,0 +1,117 @@
+// src/scheduler/index.ts
+function getNextCronRun(cronExpression, after = new Date) {
+  try {
+    const parts = cronExpression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+      console.warn(`Invalid cron expression: ${cronExpression}`);
+      return null;
+    }
+    const minute = parts[0];
+    const hour = parts[1];
+    const dayOfMonth = parts[2];
+    const month = parts[3];
+    const next = new Date(after);
+    next.setSeconds(0);
+    next.setMilliseconds(0);
+    if (minute && hour && minute !== "*" && hour !== "*" && dayOfMonth === "*" && month === "*") {
+      const targetMinute = Number.parseInt(minute, 10);
+      const targetHour = Number.parseInt(hour, 10);
+      next.setHours(targetHour, targetMinute, 0, 0);
+      if (next <= after) {
+        next.setDate(next.getDate() + 1);
+      }
+      return next;
+    }
+    next.setMinutes(next.getMinutes() + 1);
+    return next;
+  } catch {
+    return null;
+  }
+}
+
+class JobScheduler {
+  queue;
+  schedules = new Map;
+  timer;
+  checkIntervalMs;
+  constructor(queue, options = {}) {
+    this.queue = queue;
+    this.checkIntervalMs = options.checkIntervalMs ?? 60000;
+  }
+  schedule(config) {
+    const nextRun = config.enabled !== false ? getNextCronRun(config.cronExpression) : null;
+    this.schedules.set(config.name, {
+      ...config,
+      enabled: config.enabled ?? true,
+      nextRun,
+      lastRun: null
+    });
+  }
+  unschedule(name) {
+    return this.schedules.delete(name);
+  }
+  enable(name) {
+    const schedule = this.schedules.get(name);
+    if (!schedule)
+      return false;
+    schedule.enabled = true;
+    schedule.nextRun = getNextCronRun(schedule.cronExpression);
+    return true;
+  }
+  disable(name) {
+    const schedule = this.schedules.get(name);
+    if (!schedule)
+      return false;
+    schedule.enabled = false;
+    schedule.nextRun = null;
+    return true;
+  }
+  getSchedules() {
+    return Array.from(this.schedules.values());
+  }
+  getSchedule(name) {
+    return this.schedules.get(name);
+  }
+  start() {
+    if (this.timer)
+      return;
+    this.checkSchedules();
+    this.timer = setInterval(() => {
+      this.checkSchedules();
+    }, this.checkIntervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+  async checkSchedules() {
+    const now = new Date;
+    for (const schedule of this.schedules.values()) {
+      if (!schedule.enabled || !schedule.nextRun)
+        continue;
+      if (schedule.nextRun <= now) {
+        try {
+          const payload = typeof schedule.payload === "function" ? await schedule.payload() : schedule.payload;
+          await this.queue.enqueue(schedule.jobType, payload, schedule.options);
+          schedule.lastRun = now;
+          schedule.nextRun = getNextCronRun(schedule.cronExpression, now);
+        } catch (error) {
+          console.error(`Failed to enqueue scheduled job ${schedule.name}:`, error);
+        }
+      }
+    }
+  }
+}
+function createScheduler(queue, options) {
+  return new JobScheduler(queue, options);
+}
+function defineSchedule(config) {
+  return config;
+}
+export {
+  defineSchedule,
+  createScheduler,
+  JobScheduler
+};

package/dist/queue/gcp-cloud-tasks.d.ts

@@ -1,42 +1,39 @@
-import { types_d_exports } from "./types.js";
-
-//#region src/queue/gcp-cloud-tasks.d.ts
+import { type EnqueueOptions, type Job, type JobHandler, type JobQueue } from './types';
 interface CloudTasksClientLike {
-  createTask(request: {
-    parent: string;
-    task: {
-      httpRequest: {
-        httpMethod: number | string;
-        url: string;
-        body: Buffer;
-        headers?: Record<string, string>;
-        oidcToken?: {
-          serviceAccountEmail: string;
+    createTask(request: {
+        parent: string;
+        task: {
+            httpRequest: {
+                httpMethod: number | string;
+                url: string;
+                body: Buffer;
+                headers?: Record<string, string>;
+                oidcToken?: {
+                    serviceAccountEmail: string;
+                };
+            };
+            scheduleTime?: {
+                seconds: number;
+            };
         };
-      };
-      scheduleTime?: {
-        seconds: number;
-      };
-    };
-  }): Promise<unknown>;
+    }): Promise<unknown>;
 }
-interface GcpCloudTasksQueueOptions {
-  client: CloudTasksClientLike;
-  projectId: string;
-  location: string;
-  queue: string;
-  resolveUrl(jobType: string): string;
-  serviceAccountEmail?: string;
+export interface GcpCloudTasksQueueOptions {
+    client: CloudTasksClientLike;
+    projectId: string;
+    location: string;
+    queue: string;
+    resolveUrl(jobType: string): string;
+    serviceAccountEmail?: string;
 }
-declare class GcpCloudTasksQueue implements types_d_exports.JobQueue {
-  private readonly options;
-  private readonly handlers;
-  constructor(options: GcpCloudTasksQueueOptions);
-  enqueue<TPayload>(jobType: string, payload: TPayload, options?: types_d_exports.EnqueueOptions): Promise<types_d_exports.Job<TPayload>>;
-  register<TPayload, TResult = void>(jobType: string, handler: types_d_exports.JobHandler<TPayload, TResult>): void;
-  start(): void;
-  stop(): Promise<void>;
+export declare class GcpCloudTasksQueue implements JobQueue {
+    private readonly options;
+    private readonly handlers;
+    constructor(options: GcpCloudTasksQueueOptions);
+    enqueue<TPayload>(jobType: string, payload: TPayload, options?: EnqueueOptions): Promise<Job<TPayload>>;
+    register<TPayload, TResult = void>(jobType: string, handler: JobHandler<TPayload, TResult>): void;
+    start(): void;
+    stop(): Promise<void>;
 }
-//#endregion
-export { GcpCloudTasksQueue, GcpCloudTasksQueueOptions };
+export {};
 //# sourceMappingURL=gcp-cloud-tasks.d.ts.map

package/dist/queue/gcp-cloud-tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gcp-cloud-tasks.d.ts","names":[],"sources":["../../src/queue/gcp-cloud-tasks.ts"],"mappings":";;;UAUU,oBAAA;EACR,UAAA,CAAW,OAAA;IACT,MAAA;IACA,IAAA;MACE,WAAA;QACE,UAAA;QACA,GAAA;QACA,IAAA,EAAM,MAAA;QACN,OAAA,GAAU,MAAA;QACV,SAAA;UAAc,mBAAA;QAAA;MAAA;MAEhB,YAAA;QAAiB,OAAA;MAAA;IAAA;EAAA,IAEjB,OAAA;AAAA;AAAA,UAGW,yBAAA;EACf,MAAA,EAAQ,oBAAA;EACR,SAAA;EACA,QAAA;EACA,KAAA;EACA,UAAA,CAAW,OAAA;EACX,mBAAA;AAAA;AAAA,cAGW,kBAAA,YAA8B,eAAA,CAAA,QAAA;EAAA,iBAGZ,OAAA;EAAA,iBAFZ,QAAA;cAEY,OAAA,EAAS,yBAAA;EAEhC,OAAA,UAAA,CACJ,OAAA,UACA,OAAA,EAAS,QAAA,EACT,OAAA,GAAS,eAAA,CAAA,cAAA,GACR,OAAA,CAAQ,eAAA,CAAA,GAAA,CAAI,QAAA;EAoDf,QAAA,0BAAA,CACE,OAAA,UACA,OAAA,EAAS,eAAA,CAAA,UAAA,CAAW,QAAA,EAAU,OAAA;EAKhC,KAAA,CAAA;EAIM,IAAA,CAAA,GAAQ,OAAA;AAAA"}
+{"version":3,"file":"gcp-cloud-tasks.d.ts","sourceRoot":"","sources":["../../src/queue/gcp-cloud-tasks.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,GAAG,EACR,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,SAAS,CAAC;AAEjB,UAAU,oBAAoB;IAC5B,UAAU,CAAC,OAAO,EAAE;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE;YACJ,WAAW,EAAE;gBACX,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;gBAC5B,GAAG,EAAE,MAAM,CAAC;gBACZ,IAAI,EAAE,MAAM,CAAC;gBACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBACjC,SAAS,CAAC,EAAE;oBAAE,mBAAmB,EAAE,MAAM,CAAA;iBAAE,CAAC;aAC7C,CAAC;YACF,YAAY,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAA;aAAE,CAAC;SACpC,CAAC;KACH,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,qBAAa,kBAAmB,YAAW,QAAQ;IAGrC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiC;gBAE7B,OAAO,EAAE,yBAAyB;IAEzD,OAAO,CAAC,QAAQ,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,QAAQ,EACjB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAoDzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,EAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,GACrC,IAAI;IAIP,KAAK,IAAI,IAAI;IAIP,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}