@supacloud/compiler 0.58.0 → 0.60.0

package/dist/database-governance-worker.js

@@ -3,6 +3,7 @@ import { readFile, realpath } from "node:fs/promises";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
+  checkRpcBoundary,
   lintModule,
   readCatalog,
   reconcileModule
@@ -34,13 +35,31 @@ function governanceDiagnostic(message, code = "database-governance") {
     suggestion: "Fix the database source contract, module manifest or live catalog before compiling."
   };
 }
-async function enforceDatabaseGovernance(options) {
+async function enforceDatabaseGovernance(options, rpcCapabilities = []) {
   const projectRoot = await realpath(options.projectRoot ?? ".");
   const sourceReport = await databaseSources(projectRoot, "check");
   const diagnostics = sourceReport.findings.map((finding) => governanceDiagnostic(`${finding.file}: ${finding.message}`, "database-source-contract"));
   if (!sourceReport.ok && diagnostics.length === 0) {
     diagnostics.push(governanceDiagnostic("Database source contract check failed without findings."));
   }
+  if (diagnostics.length > 0)
+    return { diagnostics };
+  if (options.rpcBoundary) {
+    try {
+      const readJson = async (path) => path === undefined ? undefined : JSON.parse(await readFile(await withinRoot(projectRoot, path), "utf8"));
+      const report = checkRpcBoundary({
+        capabilities: rpcCapabilities,
+        registry: await readJson(options.rpcBoundary.registry),
+        catalog: await readJson(options.rpcBoundary.catalog),
+        legacy: await readJson(options.rpcBoundary.legacy)
+      });
+      if (!report.ok) {
+        diagnostics.push(governanceDiagnostic(`RPC capabilities have no registry/catalog source or historical entry: ${report.missing.join(", ")}`, "database-rpc-boundary"));
+      }
+    } catch {
+      diagnostics.push(governanceDiagnostic("RPC boundary artifacts could not be read or parsed.", "database-rpc-boundary"));
+    }
+  }
   if (diagnostics.length > 0)
     return { diagnostics };
   if (options.mode === "check")
@@ -107,11 +126,13 @@ function assertDatabaseGovernance(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error("Invalid databaseGovernance configuration.");
   const entry = value;
-  if (entry["mode"] !== "off" && entry["mode"] !== "check" && entry["mode"] !== "enforce" || Object.keys(entry).some((key) => !["mode", "projectRoot", "moduleFile", "databaseUrl", "databaseUrlEnv", "schemas"].includes(key)) || ["projectRoot", "moduleFile", "databaseUrl", "databaseUrlEnv"].some((key) => entry[key] !== undefined && (typeof entry[key] !== "string" || !entry[key].trim())) || entry["databaseUrlEnv"] !== undefined && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(String(entry["databaseUrlEnv"])) || entry["schemas"] !== undefined && (!Array.isArray(entry["schemas"]) || !entry["schemas"].length || !entry["schemas"].every((schema) => typeof schema === "string" && schema.trim()))) {
+  const rpcBoundary = entry["rpcBoundary"];
+  const validRpcBoundary = rpcBoundary === undefined || rpcBoundary !== null && typeof rpcBoundary === "object" && !Array.isArray(rpcBoundary) && Object.keys(rpcBoundary).every((key) => ["registry", "catalog", "legacy"].includes(key)) && Object.values(rpcBoundary).length > 0 && Object.values(rpcBoundary).every((path) => typeof path === "string" && path.trim() !== "" && !path.includes("\\") && !path.startsWith("/"));
+  if (entry["mode"] !== "off" && entry["mode"] !== "check" && entry["mode"] !== "enforce" || Object.keys(entry).some((key) => !["mode", "projectRoot", "moduleFile", "databaseUrl", "databaseUrlEnv", "schemas", "rpcBoundary"].includes(key)) || ["projectRoot", "moduleFile", "databaseUrl", "databaseUrlEnv"].some((key) => entry[key] !== undefined && (typeof entry[key] !== "string" || !entry[key].trim())) || entry["databaseUrlEnv"] !== undefined && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(String(entry["databaseUrlEnv"])) || entry["schemas"] !== undefined && (!Array.isArray(entry["schemas"]) || !entry["schemas"].length || !entry["schemas"].every((schema) => typeof schema === "string" && schema.trim())) || !validRpcBoundary) {
     throw new Error("Invalid databaseGovernance mode, paths, connection or schemas.");
   }
 }
-async function checkDatabaseGovernance(rootDir, value) {
+async function checkDatabaseGovernance(rootDir, value, rpcCapabilities = []) {
   if (value === undefined)
     return [];
   const failure = () => [{
@@ -128,7 +149,7 @@ async function checkDatabaseGovernance(rootDir, value) {
     const output = await new Promise((accept, reject) => {
       const child = execFile(process.versions.bun ? process.execPath : "bun", ["--no-env-file", worker], { timeout: 30000, killSignal: "SIGKILL", maxBuffer: 1024 * 1024 }, (error, stdout) => error ? reject(error) : accept(stdout));
       child.stdin?.on("error", reject);
-      child.stdin?.end(JSON.stringify(options));
+      child.stdin?.end(JSON.stringify({ options, rpcCapabilities }));
     });
     const report = JSON.parse(output);
     if (!report || typeof report !== "object" || !("diagnostics" in report) || !Array.isArray(report.diagnostics))
@@ -147,9 +168,11 @@ async function checkDatabaseGovernance(rootDir, value) {
 
 // src/database-governance-worker.ts
 try {
-  const options = JSON.parse(await Bun.stdin.text());
+  const payload = JSON.parse(await Bun.stdin.text());
+  const options = payload && typeof payload === "object" && !Array.isArray(payload) && "options" in payload ? payload.options : payload;
+  const rpcCapabilities = payload && typeof payload === "object" && !Array.isArray(payload) && "rpcCapabilities" in payload && Array.isArray(payload.rpcCapabilities) ? payload.rpcCapabilities : [];
   assertDatabaseGovernance(options);
-  process.stdout.write(JSON.stringify(await enforceDatabaseGovernance(options)));
+  process.stdout.write(JSON.stringify(await enforceDatabaseGovernance(options, rpcCapabilities)));
 } catch {
   process.stdout.write(JSON.stringify({ diagnostics: [{
     severity: "error",

package/dist/database-governance.d.ts

@@ -1,4 +1,4 @@
 import type { DatabaseGovernanceOptions, Diagnostic } from "./types";
 export declare function assertDatabaseGovernance(value: unknown): asserts value is DatabaseGovernanceOptions;
 /** A fresh, bounded process avoids stale module imports during incremental compilation. */
-export declare function checkDatabaseGovernance(rootDir: string, value: DatabaseGovernanceOptions | undefined): Promise<Diagnostic[]>;
+export declare function checkDatabaseGovernance(rootDir: string, value: DatabaseGovernanceOptions | undefined, rpcCapabilities?: readonly string[]): Promise<Diagnostic[]>;

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

@@ -19,6 +19,7 @@ declare const requestSchema: Type.TObject<{
                 definitionVersion: Type.TString;
                 replicas: Type.TInteger;
                 maxReplicas: Type.TInteger;
+                shardCount: Type.TOptional<Type.TInteger>;
                 concurrencyPerReplica: Type.TInteger;
                 resources: Type.TObject<{
                     cpuLimit: Type.TNumber;

package/dist/delivery-bundle-worker.js

@@ -10103,23 +10103,49 @@ var init_build2 = __esm(() => {
 });
 
 // node_modules/@supacloud/delivery/src/worker-execution.ts
+function workerShardCount(group) {
+  return group.shardCount ?? 1;
+}
+function shardSuffix(shard) {
+  if (!Number.isSafeInteger(shard) || shard < 0 || shard >= 64) {
+    throw new Error("WORKER_SHARD_INVALID");
+  }
+  return `s${shard.toString(36).padStart(2, "0")}`;
+}
+function workerShardQueue(group, shard) {
+  const count = workerShardCount(group);
+  if (!Number.isSafeInteger(shard) || shard < 0 || shard >= count) {
+    throw new Error("WORKER_SHARD_INVALID");
+  }
+  if (count === 1)
+    return group.queue;
+  const queue = `${group.queue}_${shardSuffix(shard)}`;
+  if (!/^scw_[a-z0-9_]{1,40}$/.test(queue))
+    throw new Error("WORKER_QUEUE_INVALID");
+  return queue;
+}
 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);
+  const group = structuredClone(value);
+  for (let shard = 0;shard < workerShardCount(group); shard += 1)
+    workerShardQueue(group, shard);
+  return group;
 }
 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)) {
+    const physicalQueues = Array.from({ length: workerShardCount(group) }, (_, shard) => workerShardQueue(group, shard));
+    if (names.has(group.name) || targets.has(group.target) || queues.has(group.queue) || physicalQueues.some((queue) => queues.has(queue)) || routes.has(route)) {
       throw new Error("WORKER_EXECUTION_CONFLICT");
     }
     names.add(group.name);
     targets.add(group.target);
     queues.add(group.queue);
+    physicalQueues.forEach((queue) => queues.add(queue));
     routes.add(route);
   }
 }
@@ -10143,6 +10169,7 @@ var init_worker_execution = __esm(() => {
     definitionVersion: String2({ pattern: "^[1-9][0-9]{0,8}$" }),
     replicas: positive(16),
     maxReplicas: positive(16),
+    shardCount: Optional(positive(64)),
     concurrencyPerReplica: positive(32),
     resources: ComputeResourcesSchema,
     database: _Object_({

package/dist/execution-snapshot.d.ts

@@ -8,6 +8,7 @@ declare const SnapshotSchema: Type.TObject<{
         name: Type.TString;
         command: Type.TOptional<Type.TString>;
         stages: Type.TArray<Type.TString>;
+        stagePaths: Type.TOptional<Type.TArray<Type.TArray<Type.TString>>>;
     }>>;
     commandAliases: Type.TArray<Type.TObject<{
         module: Type.TString;