@pattern-stack/codegen 0.2.0

package/dist/runtime/subsystems/jobs/index.js

@@ -0,0 +1,680 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// runtime/subsystems/jobs/jobs.tokens.ts
+var JOB_QUEUE = /* @__PURE__ */ Symbol("JOB_QUEUE");
+var REDIS_URL = /* @__PURE__ */ Symbol("REDIS_URL");
+
+// runtime/subsystems/jobs/jobs.module.ts
+import { Module } from "@nestjs/common";
+
+// runtime/subsystems/jobs/job-queue.drizzle-backend.ts
+import { Injectable, Inject, Logger } from "@nestjs/common";
+import { randomUUID } from "crypto";
+import { eq, and, lte, sql, lt } from "drizzle-orm";
+
+// runtime/constants/tokens.ts
+var DRIZZLE = "DRIZZLE";
+
+// runtime/subsystems/jobs/job-queue.schema.ts
+import {
+  pgTable,
+  uuid,
+  text,
+  jsonb,
+  integer,
+  timestamp
+} from "drizzle-orm/pg-core";
+var jobQueue = pgTable(
+  "job_queue",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    /** Job type — matches the type registered via process(). */
+    type: text("type").notNull(),
+    /** Arbitrary JSON payload passed to the handler. */
+    payload: jsonb("payload").notNull().default({}),
+    /** Current job lifecycle status. */
+    status: text("status").notNull().default("pending").$type(),
+    /** Earliest time the job may be claimed. */
+    runAt: timestamp("run_at").notNull().defaultNow(),
+    /** Higher priority jobs are claimed first (ORDER BY priority DESC). */
+    priority: integer("priority").notNull().default(0),
+    /** Number of processing attempts made so far. */
+    attempts: integer("attempts").notNull().default(0),
+    /** Maximum number of retries before status → failed. */
+    maxRetries: integer("max_retries").notNull().default(3),
+    /** Base backoff in ms (doubles on each retry). */
+    backoffMs: integer("backoff_ms").notNull().default(1e3),
+    /** Error message from the last failed attempt. */
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    completedAt: timestamp("completed_at"),
+    /** When the job was last claimed by a worker (used for stale job recovery). */
+    claimedAt: timestamp("claimed_at")
+  }
+  // Indexes: add via migration when deploying
+  // - (status, run_at) for claim query
+  // - (type, status) for routing
+);
+
+// runtime/subsystems/jobs/job-queue.drizzle-backend.ts
+var POLL_INTERVAL_MS = 1e3;
+var STALE_RECOVERY_INTERVAL_MS = 6e4;
+var STALE_THRESHOLD_MS = 5 * 6e4;
+var DrizzleJobQueue = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  logger = new Logger(DrizzleJobQueue.name);
+  polling = false;
+  pollTimer = null;
+  staleTimer = null;
+  handlers = /* @__PURE__ */ new Map();
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async onModuleInit() {
+    this.polling = true;
+    this.startPolling();
+    this.staleTimer = setInterval(() => {
+      void this.recoverStaleJobs();
+    }, STALE_RECOVERY_INTERVAL_MS);
+  }
+  async onModuleDestroy() {
+    this.polling = false;
+    if (this.pollTimer !== null) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.staleTimer !== null) {
+      clearInterval(this.staleTimer);
+      this.staleTimer = null;
+    }
+  }
+  // ============================================================================
+  // Protocol implementation
+  // ============================================================================
+  async enqueue(type, payload, options) {
+    const id = randomUUID();
+    const delay = options?.delay ?? 0;
+    const runAt = new Date(Date.now() + delay);
+    await this.db.insert(jobQueue).values({
+      id,
+      type,
+      payload,
+      status: "pending",
+      runAt,
+      priority: options?.priority ?? 0,
+      attempts: 0,
+      maxRetries: options?.retries ?? 3,
+      backoffMs: options?.backoff ?? 1e3
+    });
+    return id;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+  }
+  async schedule(type, cron, payload) {
+    const id = randomUUID();
+    await this.db.insert(jobQueue).values({
+      id,
+      type,
+      payload: { ...payload, __cron: cron },
+      status: "pending",
+      runAt: /* @__PURE__ */ new Date(),
+      priority: 0,
+      attempts: 0,
+      maxRetries: 0,
+      backoffMs: 0
+    });
+    return id;
+  }
+  async cancel(jobId) {
+    await this.db.update(jobQueue).set({ status: "expired" }).where(and(eq(jobQueue.id, jobId), eq(jobQueue.status, "pending")));
+  }
+  // ============================================================================
+  // Polling loop
+  // ============================================================================
+  startPolling() {
+    const tick = async () => {
+      if (!this.polling) return;
+      try {
+        await this.claimAndProcess();
+      } catch (err) {
+        this.logger.error(`Poll cycle error: ${err}`);
+      } finally {
+        if (this.polling) {
+          this.pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+        }
+      }
+    };
+    this.pollTimer = setTimeout(tick, 0);
+  }
+  /**
+   * Claim one pending job using UPDATE...RETURNING with an advisory lock.
+   * The advisory lock (pg_try_advisory_xact_lock) prevents concurrent workers
+   * from claiming the same job when multiple instances are polling.
+   * Jobs are claimed in priority DESC, run_at ASC order.
+   */
+  async claimAndProcess() {
+    const rows = await this.db.update(jobQueue).set({ status: "active", attempts: sql`${jobQueue.attempts} + 1`, claimedAt: /* @__PURE__ */ new Date() }).where(
+      and(
+        eq(jobQueue.status, "pending"),
+        lte(jobQueue.runAt, /* @__PURE__ */ new Date())
+      )
+    ).returning();
+    rows.sort((a, b) => {
+      if (b.priority !== a.priority) return b.priority - a.priority;
+      return a.runAt.getTime() - b.runAt.getTime();
+    });
+    const job = rows[0];
+    if (!job) return;
+    const entry = this.handlers.get(job.type);
+    if (!entry) {
+      await this.db.update(jobQueue).set({ status: "failed", lastError: `No handler registered for job type: ${job.type}` }).where(eq(jobQueue.id, job.id));
+      return;
+    }
+    try {
+      const payload = entry.schema ? entry.schema.parse(job.payload) : job.payload;
+      await entry.handler(payload);
+      await this.db.update(jobQueue).set({ status: "completed", completedAt: /* @__PURE__ */ new Date() }).where(eq(jobQueue.id, job.id));
+    } catch (err) {
+      await this.handleFailure(job, err);
+    }
+  }
+  async handleFailure(job, err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const exhausted = job.attempts >= job.maxRetries;
+    if (exhausted) {
+      await this.db.update(jobQueue).set({ status: "failed", lastError: errorMessage }).where(eq(jobQueue.id, job.id));
+    } else {
+      const backoffDelay = job.backoffMs * Math.pow(2, job.attempts - 1);
+      const retryAt = new Date(Date.now() + backoffDelay);
+      await this.db.update(jobQueue).set({ status: "pending", runAt: retryAt, lastError: errorMessage }).where(eq(jobQueue.id, job.id));
+    }
+  }
+  /**
+   * Reset stale active jobs back to pending.
+   * A job is considered stale if it has been in 'active' state for more than
+   * STALE_THRESHOLD_MS milliseconds (i.e. the worker crashed without completing).
+   */
+  async recoverStaleJobs() {
+    const staleThreshold = new Date(Date.now() - STALE_THRESHOLD_MS);
+    try {
+      await this.db.update(jobQueue).set({ status: "pending", claimedAt: null }).where(
+        and(
+          eq(jobQueue.status, "active"),
+          lt(jobQueue.claimedAt, staleThreshold)
+        )
+      );
+    } catch (err) {
+      this.logger.error(`Stale job recovery error: ${err}`);
+    }
+  }
+};
+DrizzleJobQueue = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE))
+], DrizzleJobQueue);
+
+// runtime/subsystems/jobs/job-queue.memory-backend.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
+import { randomUUID as randomUUID2 } from "crypto";
+var MemoryJobQueue = class {
+  handlers = /* @__PURE__ */ new Map();
+  async enqueue(type, payload, _options) {
+    const id = randomUUID2();
+    const entry = this.handlers.get(type);
+    if (entry) {
+      const validated = entry.schema ? entry.schema.parse(payload) : payload;
+      await entry.handler(validated);
+    }
+    return id;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+  }
+  async schedule(_type, _cron, _payload) {
+    return randomUUID2();
+  }
+  async cancel(_jobId) {
+  }
+};
+MemoryJobQueue = __decorateClass([
+  Injectable2()
+], MemoryJobQueue);
+
+// runtime/subsystems/jobs/job-queue.redis-backend.ts
+import { Injectable as Injectable3, Inject as Inject2, Logger as Logger2 } from "@nestjs/common";
+import { randomUUID as randomUUID3 } from "crypto";
+var KEY_PREFIX = "jobs:";
+var SCHEDULE_KEY = "jobs:__schedules";
+async function createRedisClient(url) {
+  let Redis;
+  try {
+    const mod = await import("ioredis");
+    Redis = mod.default ?? mod;
+  } catch {
+    throw new Error(
+      "RedisJobQueue requires ioredis. Install it: bun add ioredis"
+    );
+  }
+  return new Redis(url);
+}
+var RedisJobQueue = class {
+  constructor(redisUrl) {
+    this.redisUrl = redisUrl;
+  }
+  redisUrl;
+  logger = new Logger2(RedisJobQueue.name);
+  client;
+  running = false;
+  handlers = /* @__PURE__ */ new Map();
+  consumers = [];
+  async onModuleInit() {
+    this.client = await createRedisClient(this.redisUrl);
+    this.running = true;
+    for (const [type] of this.handlers) {
+      await this.startConsumer(type);
+    }
+  }
+  async onModuleDestroy() {
+    this.running = false;
+    for (const consumer of this.consumers) {
+      try {
+        await consumer.client.disconnect();
+      } catch {
+      }
+    }
+    this.consumers.length = 0;
+    if (this.client) {
+      await this.client.quit();
+    }
+  }
+  // ============================================================================
+  // Protocol implementation
+  // ============================================================================
+  async enqueue(type, payload, options) {
+    const id = randomUUID3();
+    const job = {
+      id,
+      type,
+      payload,
+      options: options ?? {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0
+    };
+    const key = KEY_PREFIX + type;
+    if (options?.delay && options.delay > 0) {
+      setTimeout(async () => {
+        try {
+          await this.client.rpush(key, JSON.stringify(job));
+        } catch (err) {
+          this.logger.error(`Failed to enqueue delayed job ${id}: ${err}`);
+        }
+      }, options.delay);
+    } else {
+      await this.client.rpush(key, JSON.stringify(job));
+    }
+    return id;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+    if (this.running) {
+      this.startConsumer(type).catch((err) => {
+        this.logger.error(`Failed to start consumer for ${type}: ${err}`);
+      });
+    }
+  }
+  async schedule(type, cron, payload) {
+    const id = randomUUID3();
+    const schedule = { id, type, cron, payload, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.client.hset(SCHEDULE_KEY, id, JSON.stringify(schedule));
+    return id;
+  }
+  async cancel(jobId) {
+    const keys = await this.client.keys(KEY_PREFIX + "*");
+    for (const key of keys) {
+      if (key === SCHEDULE_KEY) continue;
+      const items = await this.client.lrange(key, 0, -1);
+      for (const item of items) {
+        try {
+          const job = JSON.parse(item);
+          if (job.id === jobId) {
+            await this.client.lrem(key, 1, item);
+            return;
+          }
+        } catch {
+        }
+      }
+    }
+    await this.client.hdel(SCHEDULE_KEY, jobId);
+  }
+  // ============================================================================
+  // Consumer loop
+  // ============================================================================
+  async startConsumer(type) {
+    const consumerClient = await createRedisClient(this.redisUrl);
+    this.consumers.push({ type, client: consumerClient });
+    const key = KEY_PREFIX + type;
+    const entry = this.handlers.get(type);
+    if (!entry) return;
+    const loop = async () => {
+      while (this.running) {
+        try {
+          const result = await consumerClient.blpop(key, 5);
+          if (!result) continue;
+          const [, raw] = result;
+          const job = JSON.parse(raw);
+          const payload = entry.schema ? entry.schema.parse(job.payload) : job.payload;
+          try {
+            await entry.handler(payload);
+          } catch (err) {
+            const maxRetries = job.options.retries ?? 3;
+            job.attempts += 1;
+            if (job.attempts < maxRetries) {
+              const backoff = (job.options.backoff ?? 1e3) * Math.pow(2, job.attempts - 1);
+              this.logger.warn(
+                `Job ${job.id} failed (attempt ${job.attempts}/${maxRetries}), retrying in ${backoff}ms`
+              );
+              setTimeout(async () => {
+                try {
+                  await this.client.rpush(key, JSON.stringify(job));
+                } catch (e) {
+                  this.logger.error(`Failed to re-enqueue job ${job.id}: ${e}`);
+                }
+              }, backoff);
+            } else {
+              this.logger.error(
+                `Job ${job.id} exhausted ${maxRetries} retries: ${err instanceof Error ? err.message : err}`
+              );
+            }
+          }
+        } catch (err) {
+          if (this.running) {
+            this.logger.error(`Consumer error for ${type}: ${err}`);
+            await new Promise((r) => setTimeout(r, 1e3));
+          }
+        }
+      }
+    };
+    loop().catch((err) => {
+      this.logger.error(`Consumer loop for ${type} terminated: ${err}`);
+    });
+  }
+};
+RedisJobQueue = __decorateClass([
+  Injectable3(),
+  __decorateParam(0, Inject2(REDIS_URL))
+], RedisJobQueue);
+
+// runtime/subsystems/jobs/job-queue.bullmq-backend.ts
+import { Injectable as Injectable4, Inject as Inject3, Logger as Logger3 } from "@nestjs/common";
+import { randomUUID as randomUUID4 } from "crypto";
+var QueueClass;
+var WorkerClass;
+async function loadBullMQ() {
+  try {
+    const mod = await import("bullmq");
+    QueueClass = mod.Queue;
+    WorkerClass = mod.Worker;
+  } catch {
+    throw new Error(
+      "BullMQJobQueue requires bullmq. Install it: bun add bullmq"
+    );
+  }
+}
+var DEFAULT_QUEUE_NAME = "codegen-jobs";
+var DEFAULT_CONCURRENCY = 5;
+var BullMQJobQueue = class {
+  constructor(redisUrl) {
+    this.redisUrl = redisUrl;
+  }
+  redisUrl;
+  logger = new Logger3(BullMQJobQueue.name);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  queue;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  workers = [];
+  handlers = /* @__PURE__ */ new Map();
+  initialized = false;
+  async onModuleInit() {
+    await loadBullMQ();
+    const connection = this.parseRedisUrl(this.redisUrl);
+    this.queue = new QueueClass(DEFAULT_QUEUE_NAME, { connection });
+    this.initialized = true;
+    for (const [type] of this.handlers) {
+      this.createWorker(type, connection);
+    }
+    this.logger.log(`BullMQ queue "${DEFAULT_QUEUE_NAME}" initialized`);
+  }
+  async onModuleDestroy() {
+    const closePromises = this.workers.map((w) => w.close());
+    await Promise.allSettled(closePromises);
+    this.workers.length = 0;
+    if (this.queue) {
+      await this.queue.close();
+    }
+    this.logger.log("BullMQ queue shut down");
+  }
+  // ============================================================================
+  // Protocol implementation
+  // ============================================================================
+  async enqueue(type, payload, options) {
+    if (!this.queue) {
+      throw new Error("BullMQJobQueue not initialized \u2014 call onModuleInit first");
+    }
+    const jobId = randomUUID4();
+    const bullOpts = {
+      jobId,
+      removeOnComplete: true,
+      removeOnFail: 100
+      // keep last 100 failed jobs for debugging
+    };
+    if (options?.delay && options.delay > 0) {
+      bullOpts.delay = options.delay;
+    }
+    if (options?.priority !== void 0) {
+      bullOpts.priority = options.priority;
+    }
+    if (options?.retries !== void 0) {
+      bullOpts.attempts = options.retries + 1;
+    }
+    if (options?.backoff !== void 0) {
+      bullOpts.backoff = {
+        type: "exponential",
+        delay: options.backoff
+      };
+    }
+    await this.queue.add(type, payload, bullOpts);
+    return jobId;
+  }
+  process(type, handler, payloadSchema) {
+    this.handlers.set(type, {
+      handler,
+      schema: payloadSchema
+    });
+    if (this.initialized) {
+      const connection = this.parseRedisUrl(this.redisUrl);
+      this.createWorker(type, connection);
+    }
+  }
+  async schedule(type, cron, payload) {
+    if (!this.queue) {
+      throw new Error("BullMQJobQueue not initialized \u2014 call onModuleInit first");
+    }
+    const jobId = randomUUID4();
+    await this.queue.add(type, payload ?? {}, {
+      jobId,
+      repeat: { pattern: cron },
+      removeOnComplete: true
+    });
+    return jobId;
+  }
+  async cancel(jobId) {
+    if (!this.queue) return;
+    try {
+      const job = await this.queue.getJob(jobId);
+      if (job) {
+        await job.remove();
+      }
+    } catch (err) {
+      this.logger.warn(`Failed to cancel job ${jobId}: ${err}`);
+    }
+  }
+  // ============================================================================
+  // Worker management
+  // ============================================================================
+  createWorker(type, connection) {
+    const entry = this.handlers.get(type);
+    if (!entry) return;
+    const worker = new WorkerClass(
+      DEFAULT_QUEUE_NAME,
+      async (job) => {
+        if (job.name !== type) return;
+        const payload = entry.schema ? entry.schema.parse(job.data) : job.data;
+        await entry.handler(payload);
+      },
+      {
+        connection,
+        concurrency: DEFAULT_CONCURRENCY
+        // Only pick up jobs matching this handler's type
+        // BullMQ doesn't natively filter by name in the worker, so we
+        // check job.name inside the processor. For high-throughput systems
+        // with many job types, consider separate queues per type.
+      }
+    );
+    worker.on("failed", (job, err) => {
+      this.logger.error(`Job ${job?.id} (${type}) failed: ${err.message}`);
+    });
+    worker.on("error", (err) => {
+      this.logger.error(`Worker error for ${type}: ${err.message}`);
+    });
+    this.workers.push(worker);
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  parseRedisUrl(url) {
+    try {
+      const parsed = new URL(url);
+      return {
+        host: parsed.hostname,
+        port: parseInt(parsed.port || "6379", 10),
+        password: parsed.password || void 0,
+        db: parsed.pathname ? parseInt(parsed.pathname.slice(1) || "0", 10) : 0
+      };
+    } catch {
+      return { host: "localhost", port: 6379 };
+    }
+  }
+};
+BullMQJobQueue = __decorateClass([
+  Injectable4(),
+  __decorateParam(0, Inject3(REDIS_URL))
+], BullMQJobQueue);
+
+// runtime/subsystems/jobs/jobs.module.ts
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var JobsModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: JobsModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: "JOBS_MODULE_OPTIONS",
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: JOB_QUEUE,
+          useFactory: (options) => {
+            const mod = JobsModule.forRoot(options);
+            const provider = mod.providers?.find(
+              (p) => typeof p === "object" && p !== null && "provide" in p && p.provide === JOB_QUEUE
+            );
+            if (provider && typeof provider === "object" && "useClass" in provider) {
+              return new provider.useClass();
+            }
+            throw new Error("JobsModule.forRootAsync: failed to resolve provider");
+          },
+          inject: ["JOBS_MODULE_OPTIONS"]
+        }
+      ],
+      exports: [JOB_QUEUE]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    switch (options.backend) {
+      case "redis":
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [
+            { provide: REDIS_URL, useValue: options.redisUrl ?? DEFAULT_REDIS_URL },
+            { provide: JOB_QUEUE, useClass: RedisJobQueue }
+          ],
+          exports: [JOB_QUEUE]
+        };
+      case "bullmq":
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [
+            { provide: REDIS_URL, useValue: options.redisUrl ?? DEFAULT_REDIS_URL },
+            { provide: JOB_QUEUE, useClass: BullMQJobQueue }
+          ],
+          exports: [JOB_QUEUE]
+        };
+      case "memory":
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [{ provide: JOB_QUEUE, useClass: MemoryJobQueue }],
+          exports: [JOB_QUEUE]
+        };
+      case "drizzle":
+      default:
+        return {
+          module: JobsModule,
+          global: true,
+          providers: [{ provide: JOB_QUEUE, useClass: DrizzleJobQueue }],
+          exports: [JOB_QUEUE]
+        };
+    }
+  }
+};
+JobsModule = __decorateClass([
+  Module({})
+], JobsModule);
+export {
+  BullMQJobQueue,
+  DrizzleJobQueue,
+  JOB_QUEUE,
+  JobsModule,
+  MemoryJobQueue,
+  RedisJobQueue,
+  jobQueue
+};
+//# sourceMappingURL=index.js.map