@crvouga/mockingbird-service-postgres 3.7.0 → 3.8.0

package/dist/wire/cli.js

@@ -161,6 +161,16 @@ var Timeline = class {
   }
 };
 
+// ../core/dist/ids.js
+var normalizeIdBase = (value, label = "idBase", wallNow = Date.now) => {
+  if (value === "boot")
+    return wallNow();
+  const base = typeof value === "string" && /^\d+$/.test(value.trim()) ? Number(value.trim()) : typeof value === "number" ? value : Number.NaN;
+  if (!Number.isSafeInteger(base) || base < 0)
+    throw new RangeError(`${label} must be a non-negative integer or "boot" (got ${JSON.stringify(value)})`);
+  return base;
+};
+
 // ../core/dist/clock.js
 var createClock = (source = Date.now) => {
   let offsetMs = 0;
@@ -746,6 +756,19 @@ function ownedTransport(policy) {
 import { readFile as readFile5 } from "node:fs/promises";
 import { parseArgs } from "node:util";
 
+// ../../adapters/node/dist/boot-settings.js
+var checkSettings = (target, settings, label) => {
+  if (!target.parseSettings)
+    throw new Error(`${label}: ${target.name} takes no boot settings`);
+  try {
+    return target.parseSettings(settings);
+  } catch (error) {
+    throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`, {
+      cause: error
+    });
+  }
+};
+
 // ../../adapters/node/dist/fleet.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
@@ -3395,6 +3418,9 @@ var fleet_config_schema_default = {
     adminControls: {
       $ref: "#/$defs/controls"
     },
+    idBase: {
+      $ref: "#/$defs/idBase"
+    },
     namespace: {
       type: "string",
       pattern: "^[A-Za-z0-9_.-]{1,64}$"
@@ -3484,6 +3510,12 @@ var fleet_config_schema_default = {
         adminControls: {
           $ref: "#/$defs/controls"
         },
+        idBase: {
+          $ref: "#/$defs/idBase"
+        },
+        settings: {
+          type: "object"
+        },
         fixtures: {
           type: "object"
         },
@@ -3530,6 +3562,18 @@ var fleet_config_schema_default = {
         }
       }
     },
+    idBase: {
+      anyOf: [
+        {
+          type: "integer",
+          minimum: 0
+        },
+        {
+          type: "string",
+          pattern: "^(boot|[0-9]+)$"
+        }
+      ]
+    },
     controls: {
       type: "object",
       additionalProperties: false,
@@ -3679,6 +3723,8 @@ async function preflightFleet(config, options2) {
     throw new Error("protected archive policy requires a protected repository; configure its protector before startup");
   resolveAdminPrefix(config.adminPrefix);
   normalizeBootControls(config.adminControls);
+  if (config.idBase !== void 0)
+    normalizeIdBase(config.idBase, "idBase");
   const targets = /* @__PURE__ */ new Map();
   const ports = /* @__PURE__ */ new Set();
   for (const [name2, entry] of Object.entries(config.services)) {
@@ -3710,6 +3756,13 @@ async function preflightFleet(config, options2) {
             throw new Error("invalid protocol namespace selector");
         }
       }
+      if (entry.idBase !== void 0)
+        normalizeIdBase(entry.idBase, "idBase");
+      if (entry.settings !== void 0) {
+        if (protocol !== "http" || !("create" in target))
+          throw new Error("settings: only HTTP services take boot settings");
+        checkSettings(target, entry.settings, "settings");
+      }
       const port = entry.port ?? target.defaultPort;
       if (port !== 0) {
         const key = `${entry.host ?? "127.0.0.1"}:${port}`;
@@ -3745,7 +3798,7 @@ async function preflightFleet(config, options2) {
             break;
         }
       }
-      targets.set(name2, { ...target, packageVersion: packageVersion ?? "3.7.0" });
+      targets.set(name2, { ...target, packageVersion: packageVersion ?? "3.8.0" });
     } catch (error) {
       throw new Error(`service ${name2}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -4065,6 +4118,7 @@ var httpChild = async (target, entry, options2, admission, generation, privateAc
       options2.onLog?.(entry2);
     },
     ...entry.adminControls !== void 0 ? { adminControls: entry.adminControls } : {},
+    ...entry.settings !== void 0 ? { settings: checkSettings(target, entry.settings, "settings") } : {},
     ...entry.fixtures !== void 0 ? { fixtures: entry.fixtures } : {},
     ...(advertisedHttpBase(entry) ?? entry.baseUrl) !== void 0 ? { baseUrl: advertisedHttpBase(entry) ?? entry.baseUrl } : {}
   });
@@ -4083,6 +4137,8 @@ var httpChild = async (target, entry, options2, admission, generation, privateAc
   ].some((method) => typeof created[method] !== "function"))
     throw new Error("HTTP target does not implement the fleet runtime protocol; build/install matching supported service versions");
   const runtime = created;
+  if (entry.idBase !== void 0)
+    runtime.setIdBase?.(entry.idBase);
   const unobserve = runtime.webhooks?.observeDeliveries(observer.delivery);
   if (options2.outbound && runtime.webhooks)
     runtime.webhooks.setTransportPolicy(ownedTransport(options2.outbound));
@@ -4681,6 +4737,7 @@ async function startFleet(config, options2) {
           ...entry,
           adminPrefix: resolveAdminPrefix(entry.adminPrefix ?? adminPrefix),
           ...adminKey !== void 0 ? { adminKey } : {},
+          ...(entry.idBase ?? config.idBase) !== void 0 ? { idBase: entry.idBase ?? config.idBase } : {},
           // Fleet-wide controls, with the service's own keys replacing them.
           ...config.adminControls !== void 0 || entry.adminControls !== void 0 ? { adminControls: { ...config.adminControls, ...entry.adminControls } } : {}
         }, options2, (namespace, request) => management?.admit(namespace, request), (namespace) => management?.generation(namespace), (namespace, request) => management?.privateRequest(namespace, request) ?? false, {
@@ -5365,6 +5422,16 @@ var COMMON_SERVE_OPTIONS = {
     value: "<seed>",
     description: "Seed for every random choice (env MOCKINGBIRD_SEED)"
   },
+  "id-base": {
+    type: "string",
+    value: "<n|boot>",
+    description: "Start generated ids at this base so a restart does not reissue the last boot's ids; boot derives one from the clock (env MOCKINGBIRD_ID_BASE; default 0, the same ids every boot)"
+  },
+  settings: {
+    type: "string",
+    value: "<json|file>",
+    description: "Service settings to boot with, as JSON or a JSON file; every namespace starts from them (env MOCKINGBIRD_SETTINGS; only for services that declare settings)"
+  },
   "admin-controls": {
     type: "string",
     value: "<json|file>",
@@ -5459,19 +5526,40 @@ var readJsonFile = async (path, label) => {
   }
 };
 var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJsonOption = async (source, label) => {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      throw new Error(`${label}: not valid JSON`);
+    }
+  }
+  return readJsonFile(source, label);
+};
+var resolveServeIdBase = (values, env = process.env) => {
+  const source = asString(values["id-base"]) ?? env.MOCKINGBIRD_ID_BASE;
+  if (source === void 0 || source.trim() === "")
+    return void 0;
+  normalizeIdBase(source.trim(), "--id-base");
+  return source.trim();
+};
+var resolveServeSettings = async (target, values, env = process.env) => {
+  const flag2 = asString(values.settings);
+  const source = flag2 ?? env.MOCKINGBIRD_SETTINGS;
+  if (source === void 0 || source.trim() === "")
+    return void 0;
+  const label = flag2 !== void 0 ? "--settings" : "MOCKINGBIRD_SETTINGS";
+  const parsed = await readJsonOption(source, label);
+  if (!isObject2(parsed))
+    throw new Error(`${label}: expected a JSON object`);
+  return checkSettings(target, parsed, label);
+};
 var resolveServeControls = async (values, env = process.env, base) => {
   const source = asString(values["admin-controls"]) ?? env.MOCKINGBIRD_ADMIN_CONTROLS;
   let document = isObject2(base) ? { ...base } : {};
   if (source !== void 0 && source.trim() !== "") {
-    let parsed;
-    if (source.trim().startsWith("{")) {
-      try {
-        parsed = JSON.parse(source);
-      } catch {
-        throw new Error("--admin-controls: not valid JSON");
-      }
-    } else
-      parsed = await readJsonFile(source, "--admin-controls");
+    const parsed = source.trim().startsWith("{") ? await readJsonOption(source, "--admin-controls") : await readJsonFile(source, "--admin-controls");
     if (!isObject2(parsed))
       throw new Error("--admin-controls: expected a JSON object");
     document = { ...document, ...parsed };
@@ -5521,8 +5609,11 @@ var start = async (target, values, config) => {
     adminKey: config.adminKey,
     seed: config.seed,
     onLog: formatLog(config.log),
+    ...config.settings !== void 0 ? { settings: config.settings } : {},
     ...config.adminControls !== void 0 ? { adminControls: config.adminControls } : {}
   });
+  if (config.idBase !== void 0)
+    runtime.setIdBase?.(config.idBase);
   const listening = await listen(runtime, { port: config.port, host: config.host });
   target.listening?.(listening);
   console.log(`${target.name} emulator listening on ${listening.url}`);
@@ -5568,6 +5659,11 @@ var serveCommand = (target) => ({
         const adminControls = await resolveServeControls(values, process.env, config.adminControls);
         if (adminControls !== void 0)
           config.adminControls = adminControls;
+        if (values.settings !== void 0)
+          throw new Error("--settings serves a single service; give each service its own `settings` in the config");
+        const idBase = config.idBase ?? resolveServeIdBase(values);
+        if (idBase !== void 0)
+          config.idBase = idBase;
         const fleet = await startFleet(config, {
           load: (name2) => loadTarget(name2, target),
           onLog: formatLog(config.log ?? log2),
@@ -5597,8 +5693,12 @@ var serveCommand = (target) => ({
     let listening;
     try {
       const adminControls = await resolveServeControls(values);
+      const idBase = resolveServeIdBase(values);
+      const settings = await resolveServeSettings(target, values);
       listening = await start(target, values, {
         ...adminControls !== void 0 ? { adminControls } : {},
+        ...idBase !== void 0 ? { idBase } : {},
+        ...settings !== void 0 ? { settings } : {},
         adminPrefix: resolveAdminPrefix(asString(values["admin-prefix"]) ?? process.env.MOCKINGBIRD_ADMIN_PREFIX),
         port: port === void 0 ? target.defaultPort : Number.parseInt(port, 10),
         host: asString(values.host) ?? "127.0.0.1",
@@ -15420,7 +15520,7 @@ function evalTrgmWordSimilar(ctx, left, right) {
   const score = wordSimilarity(a.v, b.v);
   return tv("bool", score >= WORD_SIMILARITY_THRESHOLD);
 }
-function assertGinTrgmIndex(state, table, stmt) {
+function assertGinTrgmIndex(state, table, stmt, expressionType) {
   const trgmCols = stmt.columns.filter((col2) => isGinTrgmOpclass(col2.opclass));
   if (trgmCols.length === 0) return;
   if (trgmCols.length !== stmt.columns.length || stmt.columns.length !== 1) {
@@ -15440,11 +15540,7 @@ function assertGinTrgmIndex(state, table, stmt) {
   if (stmt.unique) {
     throw pgError("feature_not_supported", `access method "gin" does not support unique indexes`, "0A000");
   }
-  if (col.expr.type !== "colref" || col.expr.parts.length !== 1) {
-    throw unsupported("expression gin_trgm_ops");
-  }
-  const index = table.columnIndex(col.expr.parts[0]);
-  const typeId = table.columns[index].type.id;
+  const typeId = col.expr.type === "colref" && col.expr.parts.length === 1 ? table.columns[table.columnIndex(col.expr.parts[0])].type.id : expressionType(col.expr);
   if (!GIN_TRGM_TYPES.has(typeId)) {
     throw pgError(
       "datatype_mismatch",
@@ -19082,6 +19178,17 @@ function tableScope(table, row) {
   const cols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: table.name }));
   return new RowScope(cols, row, null, /* @__PURE__ */ new Set([table.name]));
 }
+function expressionTypeOf(env, table, expr) {
+  const scope = makeEvalScope(
+    env,
+    tableScope(
+      table,
+      table.columns.map(() => null)
+    )
+  );
+  const v = evalExpr(env.ctx, scope, expr);
+  return v.t === "unknown" ? "text" : v.t;
+}
 function checkNotNull(env, table, row) {
   void env;
   for (let i = 0; i < table.columns.length; i++) {
@@ -22004,7 +22111,6 @@ var Parser = class {
     } while (this.eatKw("or"));
     this.expectKw("on");
     const table = this.qualifiedName();
-    if (this.eatKw("referencing")) throw unsupported("trigger transition tables");
     let deferrable = false;
     let initiallyDeferred = false;
     if (this.eatKw("not")) this.expectKw("deferrable");
@@ -22017,6 +22123,23 @@ var Parser = class {
       this.errorAt(this.peek(), "only constraint triggers can be deferred");
     if (initiallyDeferred && !deferrable)
       this.errorAt(this.peek(), "constraint declared INITIALLY DEFERRED must be DEFERRABLE");
+    const transitions = [];
+    if (!constraint && this.eatKw("referencing")) {
+      do {
+        const isNew = this.eatKw("new");
+        if (!isNew) this.expectKw("old");
+        if (this.eatKw("row")) {
+          throw pgError(
+            "feature_not_supported",
+            "ROW variable naming in the REFERENCING clause is not supported",
+            "0A000"
+          );
+        }
+        this.expectKw("table");
+        this.eatKw("as");
+        transitions.push({ isNew, name: this.ident() });
+      } while (this.atKw("new") || this.atKw("old"));
+    }
     let forEachRow = false;
     if (this.eatKw("for")) {
       this.eatKw("each");
@@ -22054,7 +22177,8 @@ var Parser = class {
       forEachRow,
       when,
       funcName,
-      funcArgs
+      funcArgs,
+      ...transitions.length > 0 ? { transitions } : {}
     };
   }
   // --- ALTER --------------------------------------------------------------------
@@ -26600,6 +26724,29 @@ function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   }
   return { row };
 }
+function transitionRelation(table, name2, rows) {
+  return {
+    columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: name2 })),
+    rows
+  };
+}
+function fireStatementTriggers(env, table, timing, event, transitions) {
+  const fired = table.triggers.filter((t) => !t.forEachRow && t.timing === timing && matches(t, event)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const t of fired) {
+    if (!executor) throw unsupported(`trigger "${t.name}" execution`);
+    const ctes = /* @__PURE__ */ new Map();
+    if (t.oldTable !== void 0)
+      ctes.set(t.oldTable, transitionRelation(table, t.oldTable, transitions?.oldRows ?? []));
+    if (t.newTable !== void 0)
+      ctes.set(t.newTable, transitionRelation(table, t.newTable, transitions?.newRows ?? []));
+    const changes = env.ctx.state.changes;
+    try {
+      executor({ ctx: env.ctx, params: null, ctes, outer: null }, table, t, event, null, null);
+    } finally {
+      env.ctx.state.changes = changes;
+    }
+  }
+}
 var keyOf = (schema, name2) => JSON.stringify([schema, name2]);
 function flushConstraintTriggers(state, all = false) {
   const env = { ctx: new EngineCtx(state), params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
@@ -26983,7 +27130,13 @@ function executeInsert(env0, stmt) {
   const sourceRows = insertSourceRows(env, stmt, colIdxs);
   const insertedRows = [];
   let insertedCount = 0;
+  const addedRows = [];
+  const conflictOldRows = [];
+  const conflictNewRows = [];
+  const updatesOnConflict = stmt.onConflict !== null && stmt.onConflict.action !== "nothing";
   return withStatementRollback(env, () => {
+    fireStatementTriggers(env, table, "before", "insert");
+    if (updatesOnConflict) fireStatementTriggers(env, table, "before", "update");
     for (const srcRow of sourceRows) {
       const row = table.columns.map(() => null);
       const provided = /* @__PURE__ */ new Set();
@@ -27029,6 +27182,7 @@ function executeInsert(env0, stmt) {
         }
         if (conflictIdx !== null && conflictWhereOk) {
           if (stmt.onConflict.action === "nothing") continue;
+          const replaced = rows[conflictIdx];
           const did = applyOnConflictUpdate(
             env,
             table,
@@ -27041,6 +27195,8 @@ function executeInsert(env0, stmt) {
           if (did) {
             insertedCount++;
             insertedRows.push(rows[conflictIdx]);
+            conflictOldRows.push(replaced);
+            conflictNewRows.push(rows[conflictIdx]);
             fireRowTriggers(env, table, "after", "update", null, rows[conflictIdx]);
           }
           continue;
@@ -27055,8 +27211,13 @@ function executeInsert(env0, stmt) {
       indexInsertRow(env, table, rows.length - 1, newRow);
       insertedCount++;
       insertedRows.push(newRow);
+      addedRows.push(newRow);
       fireRowTriggers(env, table, "after", "insert", null, newRow);
     }
+    fireStatementTriggers(env, table, "after", "insert", { oldRows: [], newRows: addedRows });
+    if (updatesOnConflict) {
+      fireStatementTriggers(env, table, "after", "update", { oldRows: conflictOldRows, newRows: conflictNewRows });
+    }
     env.ctx.state.changes = insertedCount;
     if (stmt.returning) {
       const res = evalReturning(env, table, label, stmt.returning, insertedRows, "INSERT");
@@ -27137,10 +27298,12 @@ function executeUpdate(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "update");
   const label = stmt.alias ?? table.name;
+  fireStatementTriggers(env, table, "before", "update");
   const fromSource = stmt.from.length > 0 ? buildFrom(env, stmt.from) : null;
   const rows = table.mutableRows();
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
   const updatedRows = [];
+  const replacedRows = [];
   let updateCount = 0;
   for (let ri = 0; ri < rows.length; ri++) {
     const oldRow = rows[ri];
@@ -27183,8 +27346,10 @@ function executeUpdate(env0, stmt) {
     handleReferencedUpdate(env, table, [oldRow], [finalRow]);
     updateCount++;
     updatedRows.push(finalRow);
+    replacedRows.push(oldRow);
     fireRowTriggers(env, table, "after", "update", oldRow, finalRow);
   }
+  fireStatementTriggers(env, table, "after", "update", { oldRows: replacedRows, newRows: updatedRows });
   env.ctx.state.changes = updateCount;
   if (stmt.returning) {
     const res = evalReturning(env, table, label, stmt.returning, updatedRows, "UPDATE");
@@ -27196,6 +27361,7 @@ function executeDelete(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "delete from");
   const label = stmt.alias ?? table.name;
+  fireStatementTriggers(env, table, "before", "delete");
   const rows = table.mutableRows();
   const usingSource = stmt.using.length > 0 ? buildFrom(env, stmt.using) : null;
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
@@ -27233,6 +27399,7 @@ function executeDelete(env0, stmt) {
     fireRowTriggers(env, table, "after", "delete", row, null);
   }
   if (deletedRows.length > 0) rebuildTableIndexes(env, table);
+  fireStatementTriggers(env, table, "after", "delete", { oldRows: deletedRows, newRows: [] });
   env.ctx.state.changes = deletedRows.length;
   if (stmt.returning) {
     const res = evalReturning(env, table, label, stmt.returning, deletedRows, "DELETE");
@@ -29375,7 +29542,7 @@ function pgTrigger(ctx) {
   let oid = 4e4;
   for (const t of allTables(ctx.state)) {
     for (const tr of t.triggers) {
-      rows.push([oid++, tr.name, t.oid, !tr.forEachRow]);
+      rows.push([oid++, tr.name, t.oid, !tr.forEachRow, tr.oldTable ?? null, tr.newTable ?? null]);
     }
   }
   return rel2(
@@ -29383,7 +29550,9 @@ function pgTrigger(ctx) {
       ["oid", "oid"],
       ["tgname", "name"],
       ["tgrelid", "oid"],
-      ["tgisinternal", "bool"]
+      ["tgisinternal", "bool"],
+      ["tgoldtable", "name"],
+      ["tgnewtable", "name"]
     ],
     rows,
     "pg_trigger"
@@ -30810,7 +30979,7 @@ function executeCreateIndex(env, stmt) {
       }
     }
   }
-  assertGinTrgmIndex(state, table, stmt);
+  assertGinTrgmIndex(state, table, stmt, (expr) => expressionTypeOf(env, table, expr));
   const method = stmt.using ?? "btree";
   if (!ACCESS_METHODS.has(method) || method === "heap") {
     throw pgError("undefined_object", `access method "${method}" does not exist`, "42704");
@@ -31065,6 +31234,50 @@ function executeCreateFunction(env, stmt) {
   schema.functions.set(name2, existing);
   return commandResult("CREATE FUNCTION", 0);
 }
+function validateTransitionTables(stmt) {
+  const transitions = stmt.transitions ?? [];
+  if (transitions.length === 0) return {};
+  const invalid = (message2) => pgError("invalid_table_definition", message2, "42P17");
+  const unsupportedClause = (message2) => pgError("feature_not_supported", message2, "0A000");
+  if (stmt.timing !== "after") throw invalid("transition table name can only be specified for an AFTER trigger");
+  if (stmt.events.some((e) => e.event === "truncate")) {
+    throw unsupportedClause("TRUNCATE triggers with transition tables are not supported");
+  }
+  if (stmt.events.some((e) => e.columns !== null)) {
+    throw unsupportedClause("transition tables cannot be specified for triggers with column lists");
+  }
+  if (stmt.events.length > 1) {
+    throw unsupportedClause("transition tables cannot be specified for triggers with more than one event");
+  }
+  const event = stmt.events[0].event;
+  let oldTable;
+  let newTable;
+  for (const transition of transitions) {
+    if (transition.isNew) {
+      if (event !== "insert" && event !== "update") {
+        throw invalid("NEW TABLE can only be specified for an INSERT or UPDATE trigger");
+      }
+      if (newTable !== void 0) throw invalid("NEW TABLE cannot be specified multiple times");
+      newTable = transition.name;
+    } else {
+      if (event !== "delete" && event !== "update") {
+        throw invalid("OLD TABLE can only be specified for a DELETE or UPDATE trigger");
+      }
+      if (oldTable !== void 0) throw invalid("OLD TABLE cannot be specified multiple times");
+      oldTable = transition.name;
+    }
+  }
+  if (oldTable !== void 0 && oldTable === newTable) {
+    throw invalid("OLD TABLE name and NEW TABLE name cannot be the same");
+  }
+  if (stmt.forEachRow) {
+    throw pgError("unsupported", "transition tables on FOR EACH ROW triggers are not supported", "0A000");
+  }
+  return {
+    ...oldTable !== void 0 ? { oldTable } : {},
+    ...newTable !== void 0 ? { newTable } : {}
+  };
+}
 function executeCreateTrigger(env, stmt) {
   if (stmt.constraint && (stmt.timing !== "after" || !stmt.forEachRow))
     throw pgError("syntax", "constraint triggers must be AFTER ROW triggers", "42601");
@@ -31074,6 +31287,7 @@ function executeCreateTrigger(env, stmt) {
     throw pgError("undefined_table", `relation "${stmt.table.join(".")}" does not exist`, "42P01");
   }
   const table = state.ensureWritableTable(found);
+  const transitionTables = validateTransitionTables(stmt);
   const fnSchema = stmt.funcName.length >= 2 ? stmt.funcName[stmt.funcName.length - 2] : null;
   const fnName = stmt.funcName[stmt.funcName.length - 1];
   const fns = state.findFunctions(stmt.funcName);
@@ -31092,6 +31306,7 @@ function executeCreateTrigger(env, stmt) {
     timing: stmt.timing,
     events: stmt.events,
     forEachRow: stmt.forEachRow,
+    ...transitionTables,
     when: stmt.when,
     funcSchema: fnSchema ?? fns[0].schema,
     funcName: fnName,