@supacloud/compiler 0.31.2 → 0.33.0

package/dist/delivery-bundle-protocol.d.ts

@@ -7,6 +7,40 @@ declare const requestSchema: Type.TObject<{
     generatedDirectory: Type.TString;
     options: Type.TObject<{
         version: Type.TLiteral<1>;
+        execution: Type.TOptional<Type.TObject<{
+            groups: Type.TArray<Type.TObject<{
+                name: Type.TString;
+                target: Type.TString;
+                workloadClass: Type.TUnion<[Type.TLiteral<"interactive">, Type.TLiteral<"batch">]>;
+                executor: Type.TLiteral<"pgflow-queue">;
+                runtime: Type.TLiteral<"bun">;
+                queue: Type.TString;
+                taskKey: Type.TString;
+                definitionVersion: Type.TString;
+                replicas: Type.TInteger;
+                maxReplicas: Type.TInteger;
+                concurrencyPerReplica: Type.TInteger;
+                resources: Type.TObject<{
+                    cpuLimit: Type.TNumber;
+                    memoryLimitMiB: Type.TInteger;
+                }>;
+                database: Type.TObject<{
+                    engineConnectionsPerReplica: Type.TInteger;
+                    handlerConnectionsPerReplica: Type.TInteger;
+                }>;
+                lifecycle: Type.TObject<{
+                    executionTimeoutSeconds: Type.TInteger;
+                    visibilityTimeoutSeconds: Type.TInteger;
+                    shutdownGraceSeconds: Type.TInteger;
+                }>;
+                retry: Type.TObject<{
+                    maxAttempts: Type.TInteger;
+                }>;
+                admission: Type.TObject<{
+                    maxOutstandingOperations: Type.TInteger;
+                }>;
+            }>>;
+        }>>;
         targets: Type.TOptional<Type.TArray<Type.TObject<{
             name: Type.TString;
             kind: Type.TUnion<[Type.TLiteral<"api">, Type.TLiteral<"jobs">, Type.TLiteral<"webhook">]>;

package/dist/delivery-bundle-worker.js

@@ -9980,6 +9980,65 @@ var init_build2 = __esm(() => {
   init_types2();
 });
 
+// node_modules/@supacloud/delivery/src/worker-execution.ts
+function parseWorkerExecutionGroup(value) {
+  if (!Check2(WorkerExecutionGroupSchema, value) || value.replicas > value.maxReplicas || !value.queue.endsWith(`_v${value.definitionVersion}`) || value.lifecycle.visibilityTimeoutSeconds < value.lifecycle.executionTimeoutSeconds + value.lifecycle.shutdownGraceSeconds + 30) {
+    throw new Error("WORKER_EXECUTION_INVALID");
+  }
+  return structuredClone(value);
+}
+function validateWorkerExecution(groups) {
+  const names = new Set, targets = new Set, queues = new Set, routes = new Set;
+  for (const candidate of groups) {
+    const group = parseWorkerExecutionGroup(candidate);
+    const route = `${group.taskKey}:${group.definitionVersion}`;
+    if (names.has(group.name) || targets.has(group.target) || queues.has(group.queue) || routes.has(route)) {
+      throw new Error("WORKER_EXECUTION_CONFLICT");
+    }
+    names.add(group.name);
+    targets.add(group.target);
+    queues.add(group.queue);
+    routes.add(route);
+  }
+}
+var closed, positive = (maximum) => Integer({ minimum: 1, maximum }), WorkerExecutionGroupSchema, WorkerExecutionSchema;
+var init_worker_execution = __esm(() => {
+  init_build2();
+  init_value2();
+  closed = { additionalProperties: false };
+  WorkerExecutionGroupSchema = _Object_({
+    name: String2({ pattern: "^[a-z][a-z0-9-]{0,47}$" }),
+    target: String2({ pattern: "^[a-z][a-z0-9-]{0,53}$" }),
+    workloadClass: Union([Literal("interactive"), Literal("batch")]),
+    executor: Literal("pgflow-queue"),
+    runtime: Literal("bun"),
+    queue: String2({ pattern: "^scw_[a-z0-9_]{1,40}$" }),
+    taskKey: String2({ pattern: "^[a-z][a-z0-9_.-]{0,99}$" }),
+    definitionVersion: String2({ pattern: "^[1-9][0-9]{0,8}$" }),
+    replicas: positive(16),
+    maxReplicas: positive(16),
+    concurrencyPerReplica: positive(32),
+    resources: _Object_({
+      cpuLimit: Number2({ minimum: 0.1, maximum: 64, multipleOf: 0.1 }),
+      memoryLimitMiB: Integer({ minimum: 64, maximum: 262144 })
+    }, closed),
+    database: _Object_({
+      engineConnectionsPerReplica: positive(16),
+      handlerConnectionsPerReplica: positive(16)
+    }, closed),
+    lifecycle: _Object_({
+      executionTimeoutSeconds: positive(3500),
+      visibilityTimeoutSeconds: Integer({ minimum: 15, maximum: 3600 }),
+      shutdownGraceSeconds: positive(300)
+    }, closed),
+    retry: _Object_({ maxAttempts: Integer({ minimum: 1, maximum: 10 }) }, closed),
+    admission: _Object_({ maxOutstandingOperations: positive(1e6) }, closed)
+  }, closed);
+  WorkerExecutionSchema = _Object_({
+    groups: _Array_(WorkerExecutionGroupSchema, { minItems: 1, maxItems: 32 })
+  }, closed);
+});
+
 // node_modules/@supacloud/delivery/src/delivery-schema.ts
 function parseDeliveryOptions(value) {
   if (value === undefined)
@@ -9987,6 +10046,11 @@ function parseDeliveryOptions(value) {
   if (!Check2(DeliveryOptionsSchema, value))
     throw new DeliveryConfigurationError;
   const migrations = value.build?.migrations ?? [];
+  try {
+    validateWorkerExecution(value.execution?.groups ?? []);
+  } catch {
+    throw new DeliveryConfigurationError;
+  }
   if (new Set(migrations.map((item) => item.version)).size !== migrations.length || new Set(migrations.map((item) => item.source)).size !== migrations.length || migrations.some((item) => BigInt(item.version) > 9223372036854775807n || !/\.sql$/i.test(item.source) || item.source.split("/").includes("node_modules"))) {
     throw new DeliveryConfigurationError;
   }
@@ -10001,6 +10065,7 @@ var objectOptions, reference, references, kind, isolation, DeliveryFilePathSchem
 var init_delivery_schema = __esm(() => {
   init_build2();
   init_value2();
+  init_worker_execution();
   objectOptions = { additionalProperties: false };
   reference = String2({ minLength: 1, maxLength: 128, pattern: "^[A-Za-z][A-Za-z0-9_.:/-]*$" });
   references = _Array_(reference, { uniqueItems: true });
@@ -10012,6 +10077,7 @@ var init_delivery_schema = __esm(() => {
   });
   DeliveryOptionsSchema = _Object_({
     version: Literal(1),
+    execution: Optional(WorkerExecutionSchema),
     targets: Optional(_Array_(_Object_({
       name: String2({ pattern: "^[a-z][a-z0-9-]{0,62}$" }),
       kind,
@@ -10084,6 +10150,7 @@ var init_delivery_schema = __esm(() => {
     name: String2(),
     kind,
     isolation,
+    execution: Optional(WorkerExecutionGroupSchema),
     roots: _Array_(String2()),
     modules: _Array_(_Object_({
       name: String2(),
@@ -10391,7 +10458,7 @@ init_value2();
 init_delivery_schema();
 
 // src/delivery-bundle-protocol.ts
-var closed = { additionalProperties: false };
+var closed2 = { additionalProperties: false };
 var requestSchema = _Object_({
   parentPid: Integer({ minimum: 1 }),
   name: String2(),
@@ -10399,15 +10466,15 @@ var requestSchema = _Object_({
   project: String2(),
   generatedDirectory: String2(),
   options: DeliveryOptionsSchema
-}, closed);
+}, closed2);
 var responseSchema = Union([
   _Object_({
     ok: Literal(true),
     files: _Array_(Tuple([DeliveryFilePathSchema, String2({ pattern: "^[A-Za-z0-9+/]*={0,2}$" })])),
     inputs: _Array_(Tuple([String2(), String2({ pattern: "^[a-f0-9]{64}$" })])),
     runtimeImports: _Array_(String2())
-  }, closed),
-  _Object_({ ok: Literal(false) }, closed)
+  }, closed2),
+  _Object_({ ok: Literal(false) }, closed2)
 ]);
 function parseDeliveryBundleRequest(input) {
   if (!Check2(requestSchema, input))