@starci/hfs 4.0.9 → 4.1.0

package/runtime/scripts/hfs/architecture/sql-owner.mjs

@@ -31,64 +31,98 @@ const literalStrings = (ts, node) => {
   return null;
 };
 
-export function entitiesOf(kit, graph) {
+function isTypeormDecorator(kit, checker, node, ...names) {
+  const call = kit.ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+  const binding = kit.importBinding(checker, call);
+  return binding?.module === TYPEORM && names.includes(binding.name);
+}
+
+function entityTableInfo(kit, checker, statement) {
+  const { ts } = kit;
+  const entity = kit.decorators(statement).find(decorator => isTypeormDecorator(kit, checker, decorator, 'Entity'));
+  if (!entity) return null;
+  const argument = ts.isCallExpression(entity.expression) ? entity.expression.arguments[0] : null;
+  let table = argument && ts.isStringLiteralLike(argument) ? argument.text : null;
+  if (table === null && argument && ts.isObjectLiteralExpression(argument)) {
+    const property = kit.propertyOf(argument, 'name');
+    if (property && ts.isStringLiteralLike(kit.valueOfProperty(property))) table = kit.valueOfProperty(property).text;
+  }
+  return { table };
+}
+
+function mappedColumnName(kit, member, property) {
+  const { ts } = kit;
+  let column = property;
+  for (const decorator of kit.decorators(member)) {
+    const args = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
+    for (const item of args) if (ts.isObjectLiteralExpression(item)) {
+      const named = kit.propertyOf(item, 'name');
+      if (named && ts.isStringLiteralLike(kit.valueOfProperty(named))) column = kit.valueOfProperty(named).text;
+    }
+  }
+  return column;
+}
+
+function addUniqueColumnSet(kit, checker, decorator, column, primary, sets) {
   const { ts } = kit;
+  const args = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
+  const uniqueOption = args.some(item => ts.isObjectLiteralExpression(item) && kit.propertyOf(item, 'unique')
+    && kit.valueOfProperty(kit.propertyOf(item, 'unique')).kind === ts.SyntaxKind.TrueKeyword);
+  if (isTypeormDecorator(kit, checker, decorator, 'PrimaryColumn', 'PrimaryGeneratedColumn')) primary.push(column.toLowerCase());
+  else if (isTypeormDecorator(kit, checker, decorator, 'Column', 'Index') && uniqueOption) sets.push([column.toLowerCase()]);
+}
+
+function entityColumnSets(kit, checker, statement) {
+  const { ts } = kit;
+  const dbName = new Map();
+  const primary = [];
+  const sets = [];
+  for (const member of statement.members) {
+    if (!ts.isPropertyDeclaration(member) || !member.name || !ts.isIdentifier(member.name)) continue;
+    const property = member.name.text;
+    const column = mappedColumnName(kit, member, property);
+    dbName.set(property, column.toLowerCase());
+    for (const decorator of kit.decorators(member)) addUniqueColumnSet(kit, checker, decorator, column, primary, sets);
+  }
+  if (primary.length) sets.push(primary);
+  return { dbName, sets };
+}
+
+function addEntityUniqueSets(kit, checker, statement, dbName, sets) {
+  const { ts } = kit;
+  for (const decorator of kit.decorators(statement)) {
+    const args = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
+    const list = args.find(item => ts.isArrayLiteralExpression(item) && literalStrings(ts, item));
+    const columns = list ? literalStrings(ts, list) : null;
+    const unique = isTypeormDecorator(kit, checker, decorator, 'Unique') || (isTypeormDecorator(kit, checker, decorator, 'Index') && args.some(item => ts.isObjectLiteralExpression(item) && kit.propertyOf(item, 'unique')
+      && kit.valueOfProperty(kit.propertyOf(item, 'unique')).kind === ts.SyntaxKind.TrueKeyword));
+    if (unique && columns) sets.push(columns.map(column => (dbName.get(column) ?? column).toLowerCase()));
+  }
+}
+
+/** Records the entities one `.entity.ts` file declares into `tables`; returns how many of its entities have no readable table name. */
+function addFileEntities(kit, file, tables) {
+  const checker = kit.checkerOf(file.sourceFile);
+  let unreadable = 0;
+  for (const statement of file.sourceFile.statements) {
+    if (!kit.ts.isClassDeclaration(statement)) continue;
+    const entity = entityTableInfo(kit, checker, statement);
+    if (!entity) continue;
+    if (entity.table === null) { unreadable += 1; continue; }
+    const { dbName, sets } = entityColumnSets(kit, checker, statement);
+    addEntityUniqueSets(kit, checker, statement, dbName, sets);
+    const key = entity.table.toLowerCase();
+    if (!tables.has(key)) tables.set(key, { table: entity.table, owner: file.owner.root, rel: file.rel, uniqueSets: sets });
+  }
+  return unreadable;
+}
+
+export function entitiesOf(kit, graph) {
   const tables = new Map();
   let unreadable = 0;
   for (const file of graph.files.values()) {
     if (file.slot !== 'be.persistence' || !path.posix.basename(file.rel).endsWith('.entity.ts') || !file.owner) continue;
-    const checker = kit.checkerOf(file.sourceFile);
-    const typeorm = (node, ...names) => {
-      const call = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
-      const binding = kit.importBinding(checker, call);
-      return binding?.module === TYPEORM && names.includes(binding.name);
-    };
-    for (const statement of file.sourceFile.statements) {
-      if (!ts.isClassDeclaration(statement)) continue;
-      const entity = kit.decorators(statement).find(decorator => typeorm(decorator, 'Entity'));
-      if (!entity) continue;
-      const argument = ts.isCallExpression(entity.expression) ? entity.expression.arguments[0] : null;
-      let table = argument && ts.isStringLiteralLike(argument) ? argument.text : null;
-      if (table === null && argument && ts.isObjectLiteralExpression(argument)) {
-        const property = kit.propertyOf(argument, 'name');
-        if (property && ts.isStringLiteralLike(kit.valueOfProperty(property))) table = kit.valueOfProperty(property).text;
-      }
-      if (table === null) { unreadable += 1; continue; }
-      const dbName = new Map();
-      const primary = [];
-      const sets = [];
-      for (const member of statement.members) {
-        if (!ts.isPropertyDeclaration(member) || !member.name || !ts.isIdentifier(member.name)) continue;
-        const property = member.name.text;
-        let column = property;
-        for (const decorator of kit.decorators(member)) {
-          const args = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
-          for (const item of args) if (ts.isObjectLiteralExpression(item)) {
-            const named = kit.propertyOf(item, 'name');
-            if (named && ts.isStringLiteralLike(kit.valueOfProperty(named))) column = kit.valueOfProperty(named).text;
-          }
-        }
-        dbName.set(property, column.toLowerCase());
-        for (const decorator of kit.decorators(member)) {
-          const args = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
-          const uniqueOption = args.some(item => ts.isObjectLiteralExpression(item) && kit.propertyOf(item, 'unique')
-            && kit.valueOfProperty(kit.propertyOf(item, 'unique')).kind === ts.SyntaxKind.TrueKeyword);
-          if (typeorm(decorator, 'PrimaryColumn', 'PrimaryGeneratedColumn')) primary.push(column.toLowerCase());
-          else if (typeorm(decorator, 'Column', 'Index') && uniqueOption) sets.push([column.toLowerCase()]);
-        }
-      }
-      if (primary.length) sets.push(primary);
-      for (const decorator of kit.decorators(statement)) {
-        const args = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
-        const list = args.find(item => ts.isArrayLiteralExpression(item) && literalStrings(ts, item));
-        const columns = list ? literalStrings(ts, list) : null;
-        const unique = typeorm(decorator, 'Unique') || (typeorm(decorator, 'Index') && args.some(item => ts.isObjectLiteralExpression(item) && kit.propertyOf(item, 'unique')
-          && kit.valueOfProperty(kit.propertyOf(item, 'unique')).kind === ts.SyntaxKind.TrueKeyword));
-        if (unique && columns) sets.push(columns.map(column => (dbName.get(column) ?? column).toLowerCase()));
-      }
-      const key = table.toLowerCase();
-      if (!tables.has(key)) tables.set(key, { table, owner: file.owner.root, rel: file.rel, uniqueSets: sets });
-    }
+    unreadable += addFileEntities(kit, file, tables);
   }
   return { tables, unreadable };
 }
@@ -103,11 +137,93 @@ function supabaseDeclarations(graph, appRoot, ts) {
     if (file.slot !== 'be.persistence' || !file.owner) continue;
     const key = capabilityTable(file.owner.root);
     const declaration = tables.get(key);
-    if (declaration && declaration.owner === null) tables.set(key, { ...declaration, owner: file.owner.root, rel: file.rel });
+    if (declaration?.owner === null) tables.set(key, { ...declaration, owner: file.owner.root, rel: file.rel });
   }
   return tables;
 }
 
+function reportSqlWrite({ tables, supabase, file, ownTable, report }, write) {
+  const declaration = tables.get(write.table.toLowerCase());
+  if (!declaration) {
+    report(supabase
+      ? `SQL writes table ${write.table}, which Database['public']['Tables'] does not declare; regenerate supabase/types/database.types.ts from the migrations.`
+      : `SQL writes table ${write.table}, which no @Entity declares; declare the entity in the owning capability's persistence/entities.`, { table: write.table });
+  } else if (supabase) {
+    if (write.table.toLowerCase() === ownTable) return;
+    const ownerNote = declaration.owner ? `, owned by ${declaration.owner}` : '';
+    report(`SQL in ${file.owner.root} writes table ${write.table}${ownerNote}; under Supabase schema authority a capability writes only its own table (${ownTable}), named for that capability.`, { table: write.table, ...(declaration.owner ? { tableOwner: declaration.owner } : {}) });
+  } else if (declaration.owner !== file.owner.root) {
+    report(`SQL in ${file.owner.root} writes table ${write.table}, owned by ${declaration.owner}; a capability writes only the tables of its own entities, call the owner's public API instead.`, { table: write.table, tableOwner: declaration.owner });
+  }
+}
+
+function reportSqlWrites(input) {
+  for (const write of input.result.writes) reportSqlWrite(input, write);
+}
+
+function reportSqlRead(tables, supabase, file, model, resolver, report, read) {
+  const declaration = tables.get(read.table.toLowerCase());
+  if (!declaration) {
+    report(supabase
+      ? `SQL reads table ${read.table}, which Database['public']['Tables'] does not declare; regenerate supabase/types/database.types.ts from the migrations.`
+      : `SQL reads table ${read.table}, which no @Entity declares; declare the entity in the owning capability's persistence/entities.`, { table: read.table });
+    return;
+  }
+  if (!declaration.owner || declaration.owner === file.owner.root) return;
+  const ownContext = model.contextOfCapability(file.owner.root);
+  const tableContext = model.contextOfCapability(declaration.owner);
+  if (ownContext && tableContext && ownContext !== tableContext) {
+    report(`SQL in ${file.owner.root} (context ${ownContext}) reads table ${read.table}, owned by ${declaration.owner} (context ${tableContext}); a context reads and writes only its own context's tables, so a cross-context JOIN or subquery is refused. Keep a local copy fed by the other context's events (a reactor), or read a projection.`, { table: read.table, tableOwner: declaration.owner, context: ownContext, tableContext });
+    return;
+  }
+  const verdict = resolver.importAllowed(file.rel, `${declaration.owner}/index.ts`);
+  if (!verdict.allowed) report(`SQL in ${file.owner.root} reads table ${read.table}, owned by ${declaration.owner}, which ${file.owner.root} may not import (${verdict.reason}); read it through the owner's public API.`, { table: read.table, tableOwner: declaration.owner, reason: verdict.reason });
+}
+
+function reportSqlReads({ result, tables, supabase, file, model, resolver, report }) {
+  for (const read of result.reads) reportSqlRead(tables, supabase, file, model, resolver, report, read);
+}
+
+function reportSqlSelects({ result, tables, report }) {
+  for (const select of result.selects) {
+    if (select.bounded || (select.table && !tables.has(select.table.toLowerCase()))) continue;
+    const tableNote = select.table ? `on ${select.table} ` : '';
+    report(`SELECT ${tableNote}has no LIMIT and does not constrain a primary key or unique column with =; bound it with LIMIT (PAGE_SIZE_MAX, LIST_ROWS_MAX or BATCH_ROWS from platform/database), filter by key, or select only aggregates.`, { table: select.table ?? undefined });
+  }
+}
+
+function inspectSqlTag(input, state, file, checker, node) {
+  const { kit, ts, tables, supabase, model, resolver } = input;
+  if (!ts.isTaggedTemplateExpression(node)) return true;
+  const home = kit.declarationsOf(checker, node.tag).map(kit.ownerOfDeclaration).find(Boolean);
+  if (home?.tier !== 'platform' || home?.name !== 'database') { state.foreignTags += 1; return true; }
+  state.templates += 1;
+  const template = node.template;
+  const text = ts.isNoSubstitutionTemplateLiteral(template) ? template.text
+    : template.head.text + template.templateSpans.map(span => HOLE + span.literal.text).join('');
+  const seen = new Set();
+  const report = (message, extra = {}) => {
+    const key = `${message}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    state.violations.push({ ruleId: RULE, path: file.rel, ...kit.at(file.rel, file.sourceFile, node), message, ...extra });
+  };
+  const result = analyzeSql(text, { uniqueSetsOf: table => tables.get(table.toLowerCase())?.uniqueSets ?? null });
+  state.dynamic += result.dynamic;
+  const ownTable = capabilityTable(file.owner.root);
+  reportSqlWrites({ result, tables, supabase, file, ownTable, report });
+  reportSqlReads({ result, tables, supabase, file, model, resolver, report });
+  reportSqlSelects({ result, tables, report });
+  return true;
+}
+
+function inspectSqlFile(input, state, file) {
+  const { kit } = input;
+  if (file.slot !== 'be.persistence' || !path.posix.basename(file.rel).endsWith('.sql.ts') || !file.owner) return;
+  const checker = kit.checkerOf(file.sourceFile);
+  kit.walk(file.sourceFile, node => inspectSqlTag(input, state, file, checker, node));
+}
+
 export function checkSqlOwner(input) {
   const { config, graph } = input;
   const kit = machineKit(input);
@@ -116,68 +232,9 @@ export function checkSqlOwner(input) {
   const entityDeclarations = supabase ? { tables: new Map(), unreadable: 0 } : entitiesOf(kit, graph);
   const tables = supabase ? supabaseDeclarations(graph, config.packageRoot, ts) : entityDeclarations.tables;
   const model = contextModelOf(kit, graph);
-  const violations = [];
-  let templates = 0;
-  let dynamic = 0;
-  let foreignTags = 0;
-  for (const file of graph.files.values()) {
-    if (file.slot !== 'be.persistence' || !path.posix.basename(file.rel).endsWith('.sql.ts') || !file.owner) continue;
-    const checker = kit.checkerOf(file.sourceFile);
-    kit.walk(file.sourceFile, node => {
-      if (!ts.isTaggedTemplateExpression(node)) return true;
-      const home = kit.declarationsOf(checker, node.tag).map(kit.ownerOfDeclaration).find(Boolean);
-      if (!home || home.tier !== 'platform' || home.name !== 'database') { foreignTags += 1; return true; }
-      templates += 1;
-      const template = node.template;
-      const text = ts.isNoSubstitutionTemplateLiteral(template) ? template.text
-        : template.head.text + template.templateSpans.map(span => HOLE + span.literal.text).join('');
-      const seen = new Set();
-      const report = (message, extra = {}) => {
-        const key = `${message}`;
-        if (seen.has(key)) return;
-        seen.add(key);
-        violations.push({ ruleId: RULE, path: file.rel, ...kit.at(file.rel, file.sourceFile, node), message, ...extra });
-      };
-      const result = analyzeSql(text, { uniqueSetsOf: table => tables.get(table.toLowerCase())?.uniqueSets ?? null });
-      dynamic += result.dynamic;
-      const ownTable = capabilityTable(file.owner.root);
-      for (const write of result.writes) {
-        const declaration = tables.get(write.table.toLowerCase());
-        if (!declaration) {
-          report(supabase
-            ? `SQL writes table ${write.table}, which Database['public']['Tables'] does not declare; regenerate supabase/types/database.types.ts from the migrations.`
-            : `SQL writes table ${write.table}, which no @Entity declares; declare the entity in the owning capability's persistence/entities.`, { table: write.table });
-        } else if (supabase && write.table.toLowerCase() !== ownTable) {
-          report(`SQL in ${file.owner.root} writes table ${write.table}${declaration.owner ? `, owned by ${declaration.owner}` : ''}; under Supabase schema authority a capability writes only its own table (${ownTable}), named for that capability.`, { table: write.table, ...(declaration.owner ? { tableOwner: declaration.owner } : {}) });
-        } else if (!supabase && declaration.owner !== file.owner.root) {
-          report(`SQL in ${file.owner.root} writes table ${write.table}, owned by ${declaration.owner}; a capability writes only the tables of its own entities, call the owner's public API instead.`, { table: write.table, tableOwner: declaration.owner });
-        }
-      }
-      for (const read of result.reads) {
-        const declaration = tables.get(read.table.toLowerCase());
-        if (!declaration) {
-          report(supabase
-            ? `SQL reads table ${read.table}, which Database['public']['Tables'] does not declare; regenerate supabase/types/database.types.ts from the migrations.`
-            : `SQL reads table ${read.table}, which no @Entity declares; declare the entity in the owning capability's persistence/entities.`, { table: read.table });
-          continue;
-        }
-        if (!declaration.owner || declaration.owner === file.owner.root) continue;
-        const ownContext = model.contextOfCapability(file.owner.root);
-        const tableContext = model.contextOfCapability(declaration.owner);
-        if (ownContext && tableContext && ownContext !== tableContext) {
-          report(`SQL in ${file.owner.root} (context ${ownContext}) reads table ${read.table}, owned by ${declaration.owner} (context ${tableContext}); a context reads and writes only its own context's tables, so a cross-context JOIN or subquery is refused. Keep a local copy fed by the other context's events (a reactor), or read a projection.`, { table: read.table, tableOwner: declaration.owner, context: ownContext, tableContext });
-          continue;
-        }
-        const verdict = resolver.importAllowed(file.rel, `${declaration.owner}/index.ts`);
-        if (!verdict.allowed) report(`SQL in ${file.owner.root} reads table ${read.table}, owned by ${declaration.owner}, which ${file.owner.root} may not import (${verdict.reason}); read it through the owner's public API.`, { table: read.table, tableOwner: declaration.owner, reason: verdict.reason });
-      }
-      for (const select of result.selects) {
-        if (select.bounded || (select.table && !tables.has(select.table.toLowerCase()))) continue;
-        report(`SELECT ${select.table ? `on ${select.table} ` : ''}has no LIMIT and does not constrain a primary key or unique column with =; bound it with LIMIT (PAGE_SIZE_MAX, LIST_ROWS_MAX or BATCH_ROWS from platform/database), filter by key, or select only aggregates.`, { table: select.table ?? undefined });
-      }
-      return true;
-    });
-  }
-  return { violations, coverage: { status: 'checked', entities: entityDeclarations.tables.size, unreadableEntities: entityDeclarations.unreadable,
-    ...(supabase ? { supabaseTables: tables.size } : {}), templates, dynamicIdentifiers: dynamic, foreignTags } };
+  const state = { violations: [], templates: 0, dynamic: 0, foreignTags: 0 };
+  const inspection = { kit, ts, tables, supabase, model, resolver };
+  for (const file of graph.files.values()) inspectSqlFile(inspection, state, file);
+  return { violations: state.violations, coverage: { status: 'checked', entities: entityDeclarations.tables.size, unreadableEntities: entityDeclarations.unreadable,
+    ...(supabase ? { supabaseTables: tables.size } : {}), templates: state.templates, dynamicIdentifiers: state.dynamic, foreignTags: state.foreignTags } };
 }

package/runtime/scripts/hfs/architecture/sql-returning.mjs

@@ -15,28 +15,47 @@ export const SQL_RETURNING_RULE_IDS = ['BE_SQL_RETURNING_SHAPE'];
 
 const RULE = 'BE_SQL_RETURNING_SHAPE';
 
+/** Ends the statement in progress, recording its leading verb when it carried RETURNING. */
+function closeStatement(state) {
+  if (state.verb && state.returning) state.found.push(state.verb);
+  state.verb = null;
+  state.returning = false;
+}
+
+/** Folds one token into the statement state: parenthesis depth, statement ends and the top-level words. */
+function readToken(state, token) {
+  if (token.t === 'punct') {
+    if (token.v === '(') state.depth += 1;
+    else if (token.v === ')') state.depth = Math.max(0, state.depth - 1);
+    else if (token.v === ';' && state.depth === 0) closeStatement(state);
+    return;
+  }
+  if (state.depth !== 0 || token.t !== 'word') return;
+  if (state.verb === null) state.verb = token.up;
+  else if (token.up === 'RETURNING') state.returning = true;
+}
+
 /** The leading verbs of the top-level statements of `text` that RETURN from an UPDATE or DELETE without a wrapping SELECT. */
 function unwrappedReturning(text) {
-  const found = [];
-  let depth = 0;
-  let verb = null;
-  let returning = false;
-  const close = () => { if (verb && returning) found.push(verb); verb = null; returning = false; };
-  for (const token of tokenizeSql(text)) {
-    if (token.t === 'punct') {
-      if (token.v === '(') depth += 1;
-      else if (token.v === ')') depth = Math.max(0, depth - 1);
-      else if (token.v === ';' && depth === 0) close();
-      continue;
-    }
-    if (depth !== 0 || token.t !== 'word') continue;
-    if (verb === null) verb = token.up;
-    else if (token.up === 'RETURNING') returning = true;
-  }
-  close();
-  return found.filter(verb => verb === 'UPDATE' || verb === 'DELETE');
+  const state = { found: [], depth: 0, verb: null, returning: false };
+  for (const token of tokenizeSql(text)) readToken(state, token);
+  closeStatement(state);
+  return state.found.filter(verb => verb === 'UPDATE' || verb === 'DELETE');
+}
+
+/** The SQL text of a tagged template, each substitution replaced by a HOLE marker. */
+function templateText(ts, template) {
+  return ts.isNoSubstitutionTemplateLiteral(template) ? template.text
+    : template.head.text + template.templateSpans.map(span => HOLE + span.literal.text).join('');
 }
 
+const isDatabaseTag = (kit, checker, node) => {
+  const home = kit.declarationsOf(checker, node.tag).map(kit.ownerOfDeclaration).find(Boolean);
+  return home?.tier === 'platform' && home?.name === 'database';
+};
+
+const returningViolation = (kit, file, node, verb) => ({ ruleId: RULE, path: file.rel, ...kit.at(file.rel, file.sourceFile, node), message: `${verb} ... RETURNING in ${file.rel} is returned by EntityManager.query as [rows, affectedCount], not as rows, so a caller reading rows reads the wrong value. Wrap it: WITH changed AS (${verb} ... RETURNING ...) SELECT ... FROM changed.`, verb });
+
 export function checkSqlReturning(input) {
   const { graph } = input;
   const kit = machineKit(input);
@@ -47,17 +66,9 @@ export function checkSqlReturning(input) {
     if (file.slot !== 'be.persistence' || !path.posix.basename(file.rel).endsWith('.sql.ts') || !file.owner) continue;
     const checker = kit.checkerOf(file.sourceFile);
     kit.walk(file.sourceFile, node => {
-      if (!ts.isTaggedTemplateExpression(node)) return true;
-      const home = kit.declarationsOf(checker, node.tag).map(kit.ownerOfDeclaration).find(Boolean);
-      if (!home || home.tier !== 'platform' || home.name !== 'database') return true;
+      if (!ts.isTaggedTemplateExpression(node) || !isDatabaseTag(kit, checker, node)) return;
       templates += 1;
-      const template = node.template;
-      const text = ts.isNoSubstitutionTemplateLiteral(template) ? template.text
-        : template.head.text + template.templateSpans.map(span => HOLE + span.literal.text).join('');
-      for (const verb of unwrappedReturning(text)) {
-        violations.push({ ruleId: RULE, path: file.rel, ...kit.at(file.rel, file.sourceFile, node), message: `${verb} ... RETURNING in ${file.rel} is returned by EntityManager.query as [rows, affectedCount], not as rows, so a caller reading rows reads the wrong value. Wrap it: WITH changed AS (${verb} ... RETURNING ...) SELECT ... FROM changed.`, verb });
-      }
-      return true;
+      for (const verb of unwrappedReturning(templateText(ts, node.template))) violations.push(returningViolation(kit, file, node, verb));
     });
   }
   return { violations, coverage: { status: 'checked', templates } };