@open-mercato/cli 0.6.6-develop.5586.1.c9ed1d68a8 → 0.6.6-develop.5588.1.a8f6c51d1f

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
-[build:cli] found 89 entry points
+[build:cli] found 90 entry points
 Copied create-app/agentic/ → dist/agentic/
 Discovered 16 standalone guides → dist/agentic/guides/
 [build:cli] built successfully

package/dist/lib/worker-connection-budget.js

@@ -0,0 +1,63 @@
+function toPositiveInt(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  const floored = Math.floor(value);
+  return floored > 0 ? floored : fallback;
+}
+function resolveWorkerConnectionBudget(env, poolMax) {
+  const safePoolMax = toPositiveInt(poolMax, 1);
+  const raw = env.OM_WORKERS_DB_CONNECTION_BUDGET;
+  if (!raw) return safePoolMax;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : safePoolMax;
+}
+function planWorkerConcurrency(queues, budget) {
+  const safeBudget = toPositiveInt(budget, 1);
+  const requested = queues.map((entry) => ({
+    queue: entry.queue,
+    requested: toPositiveInt(entry.concurrency, 1)
+  }));
+  const totalRequested = requested.reduce((sum, entry) => sum + entry.requested, 0);
+  if (totalRequested <= safeBudget) {
+    return {
+      budget: safeBudget,
+      totalRequested,
+      totalEffective: totalRequested,
+      clamped: false,
+      belowQueueFloor: false,
+      entries: requested.map((entry) => ({ ...entry, effective: entry.requested }))
+    };
+  }
+  const effective = requested.map(() => 1);
+  let used = effective.length;
+  while (used < safeBudget) {
+    let bestIndex = -1;
+    let bestDeficit = 0;
+    for (let index = 0; index < requested.length; index += 1) {
+      const deficit = requested[index].requested - effective[index];
+      if (deficit > bestDeficit) {
+        bestDeficit = deficit;
+        bestIndex = index;
+      }
+    }
+    if (bestIndex === -1) break;
+    effective[bestIndex] += 1;
+    used += 1;
+  }
+  const totalEffective = effective.reduce((sum, value) => sum + value, 0);
+  return {
+    budget: safeBudget,
+    totalRequested,
+    totalEffective,
+    clamped: true,
+    belowQueueFloor: requested.length > safeBudget,
+    entries: requested.map((entry, index) => ({
+      ...entry,
+      effective: effective[index]
+    }))
+  };
+}
+export {
+  planWorkerConcurrency,
+  resolveWorkerConnectionBudget
+};
+//# sourceMappingURL=worker-connection-budget.js.map

package/dist/lib/worker-connection-budget.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/worker-connection-budget.ts"],
+  "sourcesContent": ["/**\n * Bound the DB-connection demand of background queue workers.\n *\n * Since #2970/#3011 each worker job builds its own request container, so its own\n * `EntityManager` checks out a dedicated pooled DB connection for the job's\n * duration. The peak connection demand of `worker --all` is therefore the sum of\n * every queue's concurrency. Nothing previously bounded that sum against the DB\n * pool (`DB_POOL_MAX`) or the database's global `max_connections`, so a storm of\n * slow/failing jobs could over-subscribe connections \u2014 thrashing on the worker's\n * own acquire timeout and, across the worker + web processes, starving the\n * request/onboarding path that shares the same database.\n *\n * These helpers derive a per-queue effective-concurrency plan whose total never\n * exceeds a connection budget (defaulting to the resolved pool max), while\n * guaranteeing every queue keeps at least one worker.\n */\n\nexport type WorkerQueueConcurrency = {\n  queue: string\n  concurrency: number\n}\n\nexport type WorkerConcurrencyPlanEntry = {\n  queue: string\n  requested: number\n  effective: number\n}\n\nexport type WorkerConcurrencyPlan = {\n  /** Connection budget the plan was fitted to. */\n  budget: number\n  /** Sum of requested concurrency across all queues. */\n  totalRequested: number\n  /** Sum of effective concurrency the plan grants. */\n  totalEffective: number\n  /** True when any queue's concurrency was reduced to fit the budget. */\n  clamped: boolean\n  /**\n   * True when the budget is smaller than the number of queues, so the per-queue\n   * floor of 1 forces the total above the budget. The caller should surface this\n   * as a misconfiguration (raise `DB_POOL_MAX` or the budget).\n   */\n  belowQueueFloor: boolean\n  entries: WorkerConcurrencyPlanEntry[]\n}\n\nfunction toPositiveInt(value: number | undefined, fallback: number): number {\n  if (value === undefined || !Number.isFinite(value)) return fallback\n  const floored = Math.floor(value)\n  return floored > 0 ? floored : fallback\n}\n\n/**\n * Resolve the connection budget for background workers. Defaults to the resolved\n * DB pool max so the worker never tries to use more connections than its own pool\n * can hand out; override with `OM_WORKERS_DB_CONNECTION_BUDGET` (positive int).\n */\nexport function resolveWorkerConnectionBudget(\n  env: NodeJS.ProcessEnv,\n  poolMax: number,\n): number {\n  const safePoolMax = toPositiveInt(poolMax, 1)\n  const raw = env.OM_WORKERS_DB_CONNECTION_BUDGET\n  if (!raw) return safePoolMax\n  const parsed = Number.parseInt(raw, 10)\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : safePoolMax\n}\n\n/**\n * Fit per-queue concurrency to a connection budget.\n *\n * - Every queue keeps a floor of 1 worker (no queue is starved).\n * - No queue exceeds its requested concurrency.\n * - When the sum exceeds the budget, leftover capacity is distributed greedily to\n *   the queues furthest below their request, so the total matches the budget\n *   exactly (when `budget >= queueCount`) and the allocation is deterministic.\n */\nexport function planWorkerConcurrency(\n  queues: WorkerQueueConcurrency[],\n  budget: number,\n): WorkerConcurrencyPlan {\n  const safeBudget = toPositiveInt(budget, 1)\n  const requested = queues.map((entry) => ({\n    queue: entry.queue,\n    requested: toPositiveInt(entry.concurrency, 1),\n  }))\n  const totalRequested = requested.reduce((sum, entry) => sum + entry.requested, 0)\n\n  if (totalRequested <= safeBudget) {\n    return {\n      budget: safeBudget,\n      totalRequested,\n      totalEffective: totalRequested,\n      clamped: false,\n      belowQueueFloor: false,\n      entries: requested.map((entry) => ({ ...entry, effective: entry.requested })),\n    }\n  }\n\n  // Floor every queue at 1, then water-fill the remaining budget to the queues\n  // with the largest unmet request first.\n  const effective = requested.map(() => 1)\n  let used = effective.length\n  while (used < safeBudget) {\n    let bestIndex = -1\n    let bestDeficit = 0\n    for (let index = 0; index < requested.length; index += 1) {\n      const deficit = requested[index].requested - effective[index]\n      if (deficit > bestDeficit) {\n        bestDeficit = deficit\n        bestIndex = index\n      }\n    }\n    if (bestIndex === -1) break\n    effective[bestIndex] += 1\n    used += 1\n  }\n\n  const totalEffective = effective.reduce((sum, value) => sum + value, 0)\n  return {\n    budget: safeBudget,\n    totalRequested,\n    totalEffective,\n    clamped: true,\n    belowQueueFloor: requested.length > safeBudget,\n    entries: requested.map((entry, index) => ({\n      ...entry,\n      effective: effective[index],\n    })),\n  }\n}\n"],
+  "mappings": "AA8CA,SAAS,cAAc,OAA2B,UAA0B;AAC1E,MAAI,UAAU,UAAa,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AAC3D,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,SAAO,UAAU,IAAI,UAAU;AACjC;AAOO,SAAS,8BACd,KACA,SACQ;AACR,QAAM,cAAc,cAAc,SAAS,CAAC;AAC5C,QAAM,MAAM,IAAI;AAChB,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,SAAS,OAAO,SAAS,KAAK,EAAE;AACtC,SAAO,OAAO,SAAS,MAAM,KAAK,SAAS,IAAI,SAAS;AAC1D;AAWO,SAAS,sBACd,QACA,QACuB;AACvB,QAAM,aAAa,cAAc,QAAQ,CAAC;AAC1C,QAAM,YAAY,OAAO,IAAI,CAAC,WAAW;AAAA,IACvC,OAAO,MAAM;AAAA,IACb,WAAW,cAAc,MAAM,aAAa,CAAC;AAAA,EAC/C,EAAE;AACF,QAAM,iBAAiB,UAAU,OAAO,CAAC,KAAK,UAAU,MAAM,MAAM,WAAW,CAAC;AAEhF,MAAI,kBAAkB,YAAY;AAChC,WAAO;AAAA,MACL,QAAQ;AAAA,MACR;AAAA,MACA,gBAAgB;AAAA,MAChB,SAAS;AAAA,MACT,iBAAiB;AAAA,MACjB,SAAS,UAAU,IAAI,CAAC,WAAW,EAAE,GAAG,OAAO,WAAW,MAAM,UAAU,EAAE;AAAA,IAC9E;AAAA,EACF;AAIA,QAAM,YAAY,UAAU,IAAI,MAAM,CAAC;AACvC,MAAI,OAAO,UAAU;AACrB,SAAO,OAAO,YAAY;AACxB,QAAI,YAAY;AAChB,QAAI,cAAc;AAClB,aAAS,QAAQ,GAAG,QAAQ,UAAU,QAAQ,SAAS,GAAG;AACxD,YAAM,UAAU,UAAU,KAAK,EAAE,YAAY,UAAU,KAAK;AAC5D,UAAI,UAAU,aAAa;AACzB,sBAAc;AACd,oBAAY;AAAA,MACd;AAAA,IACF;AACA,QAAI,cAAc,GAAI;AACtB,cAAU,SAAS,KAAK;AACxB,YAAQ;AAAA,EACV;AAEA,QAAM,iBAAiB,UAAU,OAAO,CAAC,KAAK,UAAU,MAAM,OAAO,CAAC;AACtE,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT,iBAAiB,UAAU,SAAS;AAAA,IACpC,SAAS,UAAU,IAAI,CAAC,OAAO,WAAW;AAAA,MACxC,GAAG;AAAA,MACH,WAAW,UAAU,KAAK;AAAA,IAC5B,EAAE;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/mercato.js

@@ -11,6 +11,10 @@ import {
 } from "./lib/auto-spawn-workers.js";
 import { startLazyWorkerSupervisor } from "./lib/queue-worker-supervisor.js";
 import { createPerJobWorkerHandler } from "./lib/worker-job-handler.js";
+import {
+  planWorkerConcurrency,
+  resolveWorkerConnectionBudget
+} from "./lib/worker-connection-budget.js";
 import {
   resolveAutoSpawnSchedulerMode,
   resolveLazySchedulerPollMs,
@@ -379,6 +383,27 @@ function formatQueueWorkerLabel(queueNames) {
   const preview = sorted.length > 4 ? `${sorted.slice(0, 4).join(", ")}, +${sorted.length - 4} more` : sorted.join(", ");
   return `Queue worker (${preview})`;
 }
+async function resolveWorkerBudgetPlan(requestedByQueue) {
+  const { resolvePoolConfig } = await import("@open-mercato/shared/lib/db/mikro");
+  const poolMax = resolvePoolConfig(process.env).poolMax;
+  const budget = resolveWorkerConnectionBudget(process.env, poolMax);
+  const plan = planWorkerConcurrency(requestedByQueue, budget);
+  console.log(
+    `[worker] DB connection budget: ${plan.budget} (pool max ${poolMax}); requested \u03A3concurrency ${plan.totalRequested}, effective ${plan.totalEffective}`
+  );
+  if (plan.clamped) {
+    const perQueue = plan.entries.map((entry) => `${entry.queue}=${entry.effective}/${entry.requested}`).join(", ");
+    console.warn(
+      `[worker] Worker concurrency clamped to fit the DB connection budget (${plan.budget}): ${perQueue}. Raise DB_POOL_MAX or set OM_WORKERS_DB_CONNECTION_BUDGET to change this. Keep web_pool_max + worker_pool_max + overhead <= Postgres max_connections.`
+    );
+  }
+  if (plan.belowQueueFloor) {
+    console.warn(
+      `[worker] DB connection budget (${plan.budget}) is smaller than the number of queues (${requestedByQueue.length}); every queue runs at concurrency 1 and total demand (${plan.totalEffective}) still exceeds the budget. Raise DB_POOL_MAX.`
+    );
+  }
+  return plan;
+}
 function lookupModuleCommand(allModules, moduleName, commandName) {
   const mod = allModules.find((entry) => entry.id === moduleName);
   if (!mod) {
@@ -1226,10 +1251,21 @@ async function run(argv = process.argv) {
               return;
             }
             const { createRequestContainer } = await import("@open-mercato/shared/lib/di/container");
+            const requestedByQueue = discoveredQueues.map((queue) => {
+              const queueWorkers = allWorkers.filter((w) => w.queue === queue);
+              return {
+                queue,
+                concurrency: concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1)
+              };
+            });
+            const budgetPlan = await resolveWorkerBudgetPlan(requestedByQueue);
+            const effectiveByQueue = new Map(
+              budgetPlan.entries.map((entry) => [entry.queue, entry.effective])
+            );
             console.log(`[worker] Starting workers for all queues: ${discoveredQueues.join(", ")}`);
             const workerPromises = discoveredQueues.map(async (queue) => {
               const queueWorkers = allWorkers.filter((w) => w.queue === queue);
-              const concurrency = concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1);
+              const concurrency = effectiveByQueue.get(queue) ?? concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1);
               console.log(`[worker] Starting "${queue}" with ${queueWorkers.length} handler(s), concurrency: ${concurrency}`);
               const queueRedisUrl = getRedisUrl("QUEUE");
               await runWorker({
@@ -1248,7 +1284,9 @@ async function run(argv = process.argv) {
             const queueWorkers = allWorkers.filter((w) => w.queue === queueName);
             if (queueWorkers.length > 0) {
               const { createRequestContainer } = await import("@open-mercato/shared/lib/di/container");
-              const concurrency = concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1);
+              const requested = concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1);
+              const budgetPlan = await resolveWorkerBudgetPlan([{ queue: queueName, concurrency: requested }]);
+              const concurrency = budgetPlan.entries[0]?.effective ?? requested;
               console.log(`[worker] Found ${queueWorkers.length} worker(s) for queue "${queueName}"`);
               const queueRedisUrl = getRedisUrl("QUEUE");
               await runWorker({