@starci/hfs 4.11.21 → 4.12.0

package/runtime/scripts/hfs/architecture/context-map.mjs

@@ -1,149 +1,163 @@
 import path from 'node:path';
 import { pascal } from './machine-ast.mjs';
 import { DATABASE_DIR } from './connection-map.mjs';
-
-const camel = name => { const text = pascal(name); return text[0].toLowerCase() + text.slice(1); };
-
-const unparenWhile = (node, isWrapper) => {
-  let current = node;
-  while (current && isWrapper(current)) current = current.expression;
-  return current;
-};
-
+const camel = (name) => { const text = pascal(name); return text.charAt(0).toLowerCase() + text.slice(1); };
+function unparenWhile(node, isWrapper) {
+    let current = node;
+    while (current && isWrapper(current))
+        current = current.expression;
+    return current;
+}
 const isExpressionWrapper = (ts, node) => ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node);
-
-const unparenRegistration = (ts, node) => unparenWhile(node, current => isExpressionWrapper(ts, current) || ts.isSatisfiesExpression?.(current));
-
+const isRegistrationWrapper = (ts, node) => isExpressionWrapper(ts, node) || Boolean(ts.isSatisfiesExpression?.(node));
+const unparenRegistration = (ts, node) => unparenWhile(node, (current) => isRegistrationWrapper(ts, current));
 const returnedExpression = (ts, declaration) => {
-  const fn = ts.isVariableDeclaration(declaration) && declaration.initializer ? unparenRegistration(ts, declaration.initializer) : declaration;
-  if (!(ts.isArrowFunction(fn) || ts.isFunctionDeclaration(fn) || ts.isFunctionExpression(fn) || ts.isMethodDeclaration(fn)) || !fn.body) return null;
-  if (!ts.isBlock(fn.body)) return fn.body;
-  const statements = fn.body.statements.filter(ts.isReturnStatement);
-  return statements.length === 1 ? statements[0].expression ?? null : null;
+    const fn = ts.isVariableDeclaration(declaration) && declaration.initializer ? unparenRegistration(ts, declaration.initializer) : declaration;
+    if (!(ts.isArrowFunction(fn) || ts.isFunctionDeclaration(fn) || ts.isFunctionExpression(fn) || ts.isMethodDeclaration(fn)) || !fn.body)
+        return null;
+    if (!ts.isBlock(fn.body))
+        return fn.body;
+    const statements = fn.body.statements.filter(ts.isReturnStatement);
+    return statements.length === 1 ? statements[0]?.expression ?? null : null;
 };
-
 /** Every `name:` property assignment of an object literal over the program: [{declaration, initializer, checker}], memoised per name. */
 const assignmentsOf = (ctx, name) => {
-  if (ctx.propertySources.has(name)) return ctx.propertySources.get(name);
-  const { kit } = ctx;
-  const { ts } = kit;
-  const list = [];
-  for (const file of ctx.graph.files.values()) {
-    if (!file.sourceFile.text.includes(name)) continue;
-    const checker = kit.checkerOf(file.sourceFile);
-    kit.walk(file.sourceFile, node => {
-      if (ts.isPropertyAssignment(node) && kit.propertyNameText(node.name) === name && ts.isObjectLiteralExpression(node.parent)) {
-        // the property of the type the literal is checked against, so a typed const and a typed return meet the same declaration
-        const contextual = checker.getContextualType(node.parent)?.getProperty(name);
-        const symbol = contextual ?? checker.getSymbolAtLocation(node.name);
-        list.push({ declaration: symbol?.declarations?.[0] ?? null, initializer: node.initializer, checker });
-      }
-      return true;
-    });
-  }
-  ctx.propertySources.set(name, list);
-  return list;
+    const cached = ctx.propertySources.get(name);
+    if (cached)
+        return cached;
+    const { kit } = ctx;
+    const { ts } = kit;
+    const list = [];
+    for (const file of ctx.graph.files.values()) {
+        if (!file.sourceFile.text.includes(name))
+            continue;
+        const checker = kit.checkerOf(file.sourceFile);
+        kit.walk(file.sourceFile, (node) => {
+            if (ts.isPropertyAssignment(node) && kit.propertyNameText(node.name) === name && ts.isObjectLiteralExpression(node.parent)) {
+                // the property of the type the literal is checked against, so a typed const and a typed return meet the same declaration
+                const contextual = checker.getContextualType(node.parent)?.getProperty(name);
+                const symbol = contextual ?? checker.getSymbolAtLocation(node.name);
+                list.push({ declaration: symbol?.declarations?.[0] ?? null, initializer: node.initializer, checker });
+            }
+            return true;
+        });
+    }
+    ctx.propertySources.set(name, list);
+    return list;
 };
-
 const nameOfLiteral = (ctx, checker, literal, depth) => {
-  const { kit } = ctx;
-  const own = kit.propertyOf(literal, 'name');
-  if (own) return kit.stringValue(checker, kit.valueOfProperty(own));
-  for (const property of literal.properties) {
-    if (!kit.ts.isSpreadAssignment(property)) continue;
-    const value = nameOfExpression(ctx, checker, property.expression, depth + 1);
-    if (value) return value;
-  }
-  return null;
+    const { kit } = ctx;
+    const own = kit.propertyOf(literal, 'name');
+    if (own)
+        return kit.stringValue(checker, kit.valueOfProperty(own));
+    for (const property of literal.properties) {
+        if (!kit.ts.isSpreadAssignment(property))
+            continue;
+        const value = nameOfExpression(ctx, checker, property.expression, depth + 1);
+        if (value)
+            return value;
+    }
+    return null;
 };
-
 const nameFromCall = (ctx, checker, node, depth) => {
-  const { kit } = ctx;
-  for (const declaration of kit.declarationsOf(checker, node.expression)) {
-    const body = returnedExpression(kit.ts, declaration);
-    const value = body ? nameOfExpression(ctx, kit.checkerOf(declaration.getSourceFile()), body, depth + 1) : null;
-    if (value) return value;
-  }
-  return null;
+    const { kit } = ctx;
+    const declarations = kit.declarationsOf(checker, node.expression);
+    for (const declaration of declarations) {
+        const body = returnedExpression(kit.ts, declaration);
+        const value = body ? nameOfExpression(ctx, kit.checkerOf(declaration.getSourceFile()), body, depth + 1) : null;
+        if (value)
+            return value;
+    }
+    return null;
 };
-
 const nameFromIdentifier = (ctx, checker, node, depth) => {
-  const { kit } = ctx;
-  const declaration = kit.declarationsOf(checker, node)[0];
-  return declaration && kit.ts.isVariableDeclaration(declaration) && declaration.initializer
-    ? nameOfExpression(ctx, kit.checkerOf(declaration.getSourceFile()), declaration.initializer, depth + 1) : null;
+    const { kit } = ctx;
+    const declaration = kit.declarationsOf(checker, node)[0];
+    return declaration && kit.ts.isVariableDeclaration(declaration) && declaration.initializer
+        ? nameOfExpression(ctx, kit.checkerOf(declaration.getSourceFile()), declaration.initializer, depth + 1) : null;
 };
-
 /** True when `declaration` is a property of the `<app>.env.ts` reader's own interface that sits beside the options file declaring `target`: the reader feeds the options value, so its property is the same slot. */
 const feedsOptions = (declaration, target) => {
-  const home = declaration?.getSourceFile().fileName ?? '';
-  return home.endsWith('.env.ts') && path.posix.dirname(home) === path.posix.dirname(target.getSourceFile().fileName);
+    const home = declaration?.getSourceFile().fileName ?? '';
+    return home.endsWith('.env.ts') && path.posix.dirname(home) === path.posix.dirname(target.getSourceFile().fileName);
 };
-
 const nameFromProperty = (ctx, checker, node, depth) => {
-  const target = ctx.kit.declarationsOf(checker, node.name)[0];
-  if (!target) return null;
-  const names = new Set(assignmentsOf(ctx, node.name.text).filter(item => item.declaration === target || feedsOptions(item.declaration, target))
-    .map(item => nameOfExpression(ctx, item.checker, item.initializer, depth + 1)).filter(Boolean));
-  return names.size === 1 ? [...names][0] : null;
+    const target = ctx.kit.declarationsOf(checker, node.name)[0];
+    if (!target)
+        return null;
+    const names = new Set(assignmentsOf(ctx, node.name.text).filter(item => item.declaration === target || feedsOptions(item.declaration, target))
+        .map(item => nameOfExpression(ctx, item.checker, item.initializer, depth + 1)).filter(Boolean));
+    return names.size === 1 ? [...names][0] ?? null : null;
 };
-
 function nameOfExpression(ctx, checker, expression, depth) {
-  const { ts } = ctx.kit;
-  const node = unparenRegistration(ts, expression);
-  if (!node || depth > 5) return null;
-  if (ts.isObjectLiteralExpression(node)) return nameOfLiteral(ctx, checker, node, depth);
-  if (ts.isCallExpression(node)) return nameFromCall(ctx, checker, node, depth);
-  if (ts.isIdentifier(node)) return nameFromIdentifier(ctx, checker, node, depth);
-  if (ts.isPropertyAccessExpression(node)) return nameFromProperty(ctx, checker, node, depth);
-  return null;
+    const { ts } = ctx.kit;
+    const node = unparenRegistration(ts, expression);
+    if (!node || depth > 5)
+        return null;
+    if (ts.isObjectLiteralExpression(node))
+        return nameOfLiteral(ctx, checker, node, depth);
+    if (ts.isCallExpression(node))
+        return nameFromCall(ctx, checker, node, depth);
+    if (ts.isIdentifier(node))
+        return nameFromIdentifier(ctx, checker, node, depth);
+    if (ts.isPropertyAccessExpression(node))
+        return nameFromProperty(ctx, checker, node, depth);
+    return null;
 }
-
 const isCapabilityArray = (owner, name) => owner?.below.length === 1 && owner.below[0] === 'connection.ts' && [`${camel(owner.capability)}Entities`, `${camel(owner.capability)}Migrations`].includes(name);
-
 const arrayDeclarationOf = (kit, checker, node) => {
-  const { ts } = kit;
-  const declaration = kit.declarationsOf(checker, ts.isPropertyAccessExpression(node) ? node.name : node)[0];
-  return declaration && ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) ? declaration : null;
+    const { ts } = kit;
+    const declaration = kit.declarationsOf(checker, ts.isPropertyAccessExpression(node) ? node.name : node)[0];
+    // the identifier name was just checked, so the declaration is a named variable
+    return declaration && ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) ? declaration : null;
 };
-
 /** The capability arrays (`<c>Entities` / `<c>Migrations` of persistence/connection.ts) an expression lists. */
 function arraysIn(ctx, checker, expression, out, depth) {
-  const { kit } = ctx;
-  const { ts } = kit;
-  const node = unparenRegistration(ts, expression);
-  if (!node || depth > 6) return;
-  if (ts.isArrayLiteralExpression(node)) {
-    for (const element of node.elements) { arraysIn(ctx, checker, ts.isSpreadElement(element) ? element.expression : element, out, depth + 1); }
-    return;
-  }
-  if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node)) return;
-  const declaration = arrayDeclarationOf(kit, checker, node);
-  if (!declaration) return;
-  const rel = kit.graphPath(declaration);
-  const owner = rel ? ctx.persistenceOf(rel) : null;
-  if (isCapabilityArray(owner, declaration.name.text)) {
-    out.push({ key: path.posix.dirname(owner.root), name: owner.capability });
-  } else if (declaration.initializer) arraysIn(ctx, kit.checkerOf(declaration.getSourceFile()), declaration.initializer, out, depth + 1);
+    const { kit } = ctx;
+    const { ts } = kit;
+    const node = unparenRegistration(ts, expression);
+    if (!node || depth > 6)
+        return;
+    if (ts.isArrayLiteralExpression(node)) {
+        for (const element of node.elements) {
+            arraysIn(ctx, checker, ts.isSpreadElement(element) ? element.expression : element, out, depth + 1);
+        }
+        return;
+    }
+    if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node))
+        return;
+    const declaration = arrayDeclarationOf(kit, checker, node);
+    if (!declaration)
+        return;
+    const rel = kit.graphPath(declaration);
+    const owner = rel ? ctx.persistenceOf(rel) : null;
+    if (isCapabilityArray(owner, declaration.name.text)) {
+        out.push({ key: path.posix.dirname(owner.root), name: owner.capability });
+    }
+    else if (declaration.initializer)
+        arraysIn(ctx, kit.checkerOf(declaration.getSourceFile()), declaration.initializer, out, depth + 1);
 }
-
 const registrationArrays = (ctx, checker, literal) => {
-  const arrays = [];
-  for (const key of ['entities', 'migrations']) {
-    const property = ctx.kit.propertyOf(literal, key);
-    if (property) arraysIn(ctx, checker, ctx.kit.valueOfProperty(property), arrays, 0);
-  }
-  return arrays;
+    const arrays = [];
+    for (const key of ['entities', 'migrations']) {
+        const property = ctx.kit.propertyOf(literal, key);
+        if (property)
+            arraysIn(ctx, checker, ctx.kit.valueOfProperty(property), arrays, 0);
+    }
+    return arrays;
 };
-
 const recordRegistration = (registered, arrays, connection, site) => {
-  for (const { key, name } of new Map(arrays.map(item => [item.key, item])).values()) {
-    if (!registered.has(key)) registered.set(key, { name, connections: new Map() });
-    const sites = registered.get(key).connections;
-    if (!sites.has(connection)) sites.set(connection, site);
-  }
+    for (const { key, name } of new Map(arrays.map((item) => [item.key, item])).values()) {
+        let entry = registered.get(key);
+        if (!entry) {
+            entry = { name, connections: new Map() };
+            registered.set(key, entry);
+        }
+        const sites = entry.connections;
+        if (!sites.has(connection))
+            sites.set(connection, site);
+    }
 };
-
 /**
  * Where the persistence arrays of every capability are registered: the object literals (`DatabaseModule.register` connections and the
  * migrate/cli app's) that list `<c>Entities` / `<c>Migrations` of a capability's `persistence/connection.ts` under a connection `name`.
@@ -154,92 +168,98 @@ const recordRegistration = (registered, arrays, connection, site) => {
  *   `registered`: capability root -> its name and the connections it is registered on (first site each).
  */
 export function collectRegistrations({ kit, graph, persistenceOf }) {
-  const { ts } = kit;
-  const ctx = { kit, graph, persistenceOf, propertySources: new Map() }; // property name -> [{declaration, initializer, checker}] over the program
-  const all = []; // every registration literal: {file, node, connection | null when the name cannot be resolved}
-  const registered = new Map(); // capability root -> {name, connections: Map(connection -> first site)}
-  let registrations = 0;
-  for (const file of graph.files.values()) {
-    const checker = kit.checkerOf(file.sourceFile);
-    kit.walk(file.sourceFile, node => {
-      if (!ts.isObjectLiteralExpression(node)) return;
-      const arrays = registrationArrays(ctx, checker, node);
-      if (!arrays.length) return;
-      registrations += 1;
-      const connection = nameOfLiteral(ctx, checker, node, 0);
-      all.push({ file, node, connection });
-      if (connection !== null) recordRegistration(registered, arrays, connection, { file, node });
-    });
-  }
-  return { registered, registrations, all };
+    const { ts } = kit;
+    const ctx = { kit, graph, persistenceOf, propertySources: new Map() }; // property name -> [{declaration, initializer, checker}] over the program
+    const all = []; // every registration literal: {file, node, connection | null when the name cannot be resolved}
+    const registered = new Map(); // capability root -> {name, connections: Map(connection -> first site)}
+    let registrations = 0;
+    for (const file of graph.files.values()) {
+        const checker = kit.checkerOf(file.sourceFile);
+        kit.walk(file.sourceFile, (node) => {
+            if (!ts.isObjectLiteralExpression(node))
+                return;
+            const arrays = registrationArrays(ctx, checker, node);
+            if (!arrays.length)
+                return;
+            registrations += 1;
+            const connection = nameOfLiteral(ctx, checker, node, 0);
+            all.push({ file, node, connection });
+            if (connection !== null)
+                recordRegistration(registered, arrays, connection, { file, node });
+        });
+    }
+    return { registered, registrations, all };
 }
-
 const PERSISTENCE_SLOT = 'be.persistence';
 /** The slot tiers whose capabilities belong to a bounded context: the domain and the projections (a projection is owned by the context whose connection holds its tables). */
 const CONTEXT_TIERS = new Set(['domain', 'projections']);
-
 /** True for a platform capability the manifest lists as `perConnection` (its tables exist on every connection that uses it); `root` is the capability root. */
 export const isPerConnection = (resolver, root, name) => root.split('/').includes('platform') && (resolver.slot(PERSISTENCE_SLOT)?.perConnection ?? []).includes(name);
-
 /**
  * `persistenceOf(rel)`: {root, capability, folder, below} of a be.persistence file (`folder` the directory below persistence/, '' at its root),
  * null for any other file. `root` is the persistence root, its dirname the capability root.
  */
-export const persistenceOfFactory = resolver => rel => {
-  const classified = resolver.classifyPath(rel);
-  if (classified.slot !== PERSISTENCE_SLOT) return null;
-  const below = rel.slice(classified.root.length + 1).split('/');
-  return { root: classified.root, capability: path.posix.basename(path.posix.dirname(classified.root)), folder: below.length > 1 ? below[0] : '', below };
+export const persistenceOfFactory = (resolver) => (rel) => {
+    const classified = resolver.classifyPath(rel);
+    if (classified.slot !== PERSISTENCE_SLOT)
+        return null;
+    const below = rel.slice(classified.root.length + 1).split('/');
+    return { root: classified.root, capability: path.posix.basename(path.posix.dirname(classified.root)), folder: below.length > 1 ? below[0] ?? '' : '', below };
 };
-
 /** The declared connection named by a decorator whose callee is declared in src/modules/platform/database/<conn>.decorators.ts, else null. */
 const connectionOfDecorators = (kit, declared, checker, declaration) => {
-  const { ts } = kit;
-  for (const decorator of kit.decorators(declaration)) {
-    const callee = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
-    for (const target of kit.declarationsOf(checker, callee)) {
-      const rel = kit.graphPath(target);
-      const name = rel ? [...declared.keys()].find(connection => rel === `${DATABASE_DIR}/${connection}.decorators.ts`) : null;
-      if (name) return name;
+    const { ts } = kit;
+    const decorators = kit.decorators(declaration);
+    for (const decorator of decorators) {
+        const callee = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
+        const targets = kit.declarationsOf(checker, callee);
+        for (const target of targets) {
+            const rel = kit.graphPath(target);
+            const name = rel ? [...declared.keys()].find(connection => rel === `${DATABASE_DIR}/${connection}.decorators.ts`) : null;
+            if (name)
+                return name;
+        }
     }
-  }
-  return null;
+    return null;
 };
-
 const managerTarget = (ts, node) => {
-  if (ts.isPropertyAccessExpression(node)) return node.name;
-  return ts.isIdentifier(node) ? node : null;
+    if (ts.isPropertyAccessExpression(node))
+        return node.name;
+    return ts.isIdentifier(node) ? node : null;
 };
-
 /** The receiver expression of the `.transaction(callback)` call whose first callback parameter is `declaration`, else null. */
 const transactionReceiver = (ts, declaration) => {
-  const callback = declaration.parent;
-  if (!ts.isParameter(declaration) || !(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) || callback.parameters[0] !== declaration) return null;
-  const call = callback.parent;
-  if (!ts.isCallExpression(call) || !call.arguments.includes(callback) || !ts.isPropertyAccessExpression(call.expression) || call.expression.name.text !== 'transaction') return null;
-  return call.expression.expression;
+    const callback = declaration.parent;
+    if (!ts.isParameter(declaration) || !(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) || callback.parameters[0] !== declaration)
+        return null;
+    const call = callback.parent;
+    if (!ts.isCallExpression(call) || !call.arguments.includes(callback) || !ts.isPropertyAccessExpression(call.expression) || call.expression.name.text !== 'transaction')
+        return null;
+    return call.expression.expression;
 };
-
 /**
  * The declared connection whose entity manager `expression` is: a property or parameter injected with `Inject<Conn>EntityManager`, or the
  * manager parameter of the callback of a `.transaction(...)` on such a manager. Null when the origin cannot be proven (never guessed).
  */
 function connectionOfManagerIn(kit, declared, checker, expression, depth = 0) {
-  const { ts } = kit;
-  const node = unparenWhile(expression, current => isExpressionWrapper(ts, current));
-  if (!node || depth > 4) return null;
-  const target = managerTarget(ts, node);
-  if (!target) return null;
-  const declaration = kit.declarationsOf(checker, target)[0];
-  if (!declaration) return null;
-  if (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration)) {
-    const direct = connectionOfDecorators(kit, declared, checker, declaration);
-    if (direct) return direct;
-  }
-  const receiver = transactionReceiver(ts, declaration);
-  return receiver ? connectionOfManagerIn(kit, declared, checker, receiver, depth + 1) : null;
+    const { ts } = kit;
+    const node = unparenWhile(expression, (current) => isExpressionWrapper(ts, current));
+    if (!node || depth > 4)
+        return null;
+    const target = managerTarget(ts, node);
+    if (!target)
+        return null;
+    const declaration = kit.declarationsOf(checker, target)[0];
+    if (!declaration)
+        return null;
+    if (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration)) {
+        const direct = connectionOfDecorators(kit, declared, checker, declaration);
+        if (direct)
+            return direct;
+    }
+    const receiver = transactionReceiver(ts, declaration);
+    return receiver ? connectionOfManagerIn(kit, declared, checker, receiver, depth + 1) : null;
 }
-
 /**
  * The bounded-context model of a program: which context (declared connection) each capability belongs to, and which connection an expression's
  * entity manager is. A context is a connection; a capability belongs to the one declared connection its persistence arrays are registered on
@@ -248,75 +268,88 @@ function connectionOfManagerIn(kit, declared, checker, expression, depth = 0) {
  * transaction callback parameter's receiver. Nothing is matched by a variable name.
  */
 const MODELS = new WeakMap();
-
 export function contextModelOf(kit, graph) {
-  if (MODELS.has(graph)) return MODELS.get(graph);
-  const { ts, resolver } = kit;
-  const persistenceOf = persistenceOfFactory(resolver);
-  const declared = new Map(resolver.repo.connections.map(connection => [connection.name, connection]));
-  const { registered, all } = collectRegistrations({ kit, graph, persistenceOf });
-  const perConnection = new Set();
-  const contextOfRoot = new Map(); // capability root -> declared connection name (single registration only)
-  for (const [root, { name, connections }] of registered) {
-    if (isPerConnection(resolver, root, name)) { perConnection.add(root); continue; }
-    const names = [...connections.keys()].filter(connection => declared.has(connection));
-    if (names.length === 1) contextOfRoot.set(root, names[0]);
-  }
-  /** The declared connection a capability root belongs to, or null (no registration, several, or a per-connection platform capability). */
-  const contextOfCapability = root => contextOfRoot.get(root) ?? null;
-  /** The context of the capability owning `rel` when that capability is of a context tier (domain, projections), else null: only these are bounded contexts. */
-  const contextOfFile = rel => {
-    const file = graph.files.get(rel);
-    if (!file?.owner || !CONTEXT_TIERS.has(file.tier)) return null;
-    return contextOfCapability(file.owner.root);
-  };
-  const model = {
-    declared, registered, registrations: all, perConnection, contextOfCapability, contextOfFile,
-    connectionOfManager: (checker, expression) => connectionOfManagerIn(kit, declared, checker, expression),
-    unparen: node => unparenWhile(node, current => isExpressionWrapper(ts, current)),
-  };
-  MODELS.set(graph, model);
-  return model;
+    const cached = MODELS.get(graph);
+    if (cached)
+        return cached;
+    const { ts, resolver } = kit;
+    const persistenceOf = persistenceOfFactory(resolver);
+    const connections = resolver.repo.connections;
+    const declared = new Map(connections.map((connection) => [connection.name, connection]));
+    const { registered, all } = collectRegistrations({ kit, graph, persistenceOf });
+    const perConnection = new Set();
+    const contextOfRoot = new Map(); // capability root -> declared connection name (single registration only)
+    for (const [root, { name, connections: sites }] of registered) {
+        if (isPerConnection(resolver, root, name)) {
+            perConnection.add(root);
+            continue;
+        }
+        const names = [...sites.keys()].filter(connection => declared.has(connection));
+        const [only] = names;
+        if (names.length === 1 && only !== undefined)
+            contextOfRoot.set(root, only);
+    }
+    /** The declared connection a capability root belongs to, or null (no registration, several, or a per-connection platform capability). */
+    const contextOfCapability = (root) => contextOfRoot.get(root) ?? null;
+    /** The context of the capability owning `rel` when that capability is of a context tier (domain, projections), else null: only these are bounded contexts. */
+    const contextOfFile = (rel) => {
+        const file = graph.files.get(rel);
+        if (!file?.owner || !CONTEXT_TIERS.has(file.tier ?? ''))
+            return null;
+        return contextOfCapability(file.owner.root);
+    };
+    const model = {
+        declared, registered, registrations: all, perConnection, contextOfCapability, contextOfFile,
+        connectionOfManager: (checker, expression) => connectionOfManagerIn(kit, declared, checker, expression),
+        unparen: node => unparenWhile(node, (current) => isExpressionWrapper(ts, current)),
+    };
+    MODELS.set(graph, model);
+    return model;
 }
-
 const composedConnection = (kit, declared, checker, inner) => {
-  const { ts } = kit;
-  const parent = inner.parent;
-  if (parent?.name === inner && (ts.isPropertyAssignment(parent) || ts.isPropertyAccessExpression(parent))) return null;
-  if (!(ts.isIdentifier(inner) || ts.isStringLiteralLike(inner) || ts.isPropertyAccessExpression(inner))) return null;
-  const value = kit.stringValue(checker, inner);
-  return value !== null && declared.has(value) ? value : null;
+    const { ts } = kit;
+    const parent = inner.parent;
+    if ((ts.isPropertyAssignment(parent) || ts.isPropertyAccessExpression(parent)) && parent.name === inner)
+        return null;
+    if (!(ts.isIdentifier(inner) || ts.isStringLiteralLike(inner) || ts.isPropertyAccessExpression(inner)))
+        return null;
+    const value = kit.stringValue(checker, inner);
+    return value !== null && declared.has(value) ? value : null;
 };
-
 const collectComposedConnections = (kit, declared, checker, call, file, items) => {
-  for (const argument of call.arguments) {
-    kit.walk(argument, inner => {
-      const value = composedConnection(kit, declared, checker, inner);
-      if (value === null) return true;
-      items.push({ connection: value, node: inner, file });
-      return false;
-    });
-  }
+    for (const argument of call.arguments) {
+        kit.walk(argument, (inner) => {
+            const value = composedConnection(kit, declared, checker, inner);
+            if (value === null)
+                return true;
+            items.push({ connection: value, node: inner, file });
+            return false;
+        });
+    }
 };
-
 /**
  * The declared connection names the composition of `app` (its root app.module.ts and the composition groups of compose/) passes to
  * the database module registration, as [{connection, node, file}] in path then source order.
  */
 export function connectionsComposedBy(kit, app) {
-  const { ts } = kit;
-  const files = kit.appCompositionFiles(app);
-  if (!files.length) return { root: null, items: [] };
-  const declared = new Set(kit.resolver.repo.connections.map(connection => connection.name));
-  const items = [];
-  for (const file of files) {
-    const checker = kit.checkerOf(file.sourceFile);
-    kit.walk(file.sourceFile, node => {
-      if (!(ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register')) return;
-      const owner = kit.declarationsOf(checker, node.expression.expression).map(kit.ownerOfDeclaration).find(Boolean);
-      if (owner?.tier !== 'platform' || owner.name !== 'database') return;
-      collectComposedConnections(kit, declared, checker, node, file, items);
-    });
-  }
-  return { root: files[0], items };
+    const { ts } = kit;
+    const files = kit.appCompositionFiles(app);
+    if (!files.length)
+        return { root: null, items: [] };
+    const connections = kit.resolver.repo.connections;
+    const declared = new Set(connections.map(connection => connection.name));
+    const items = [];
+    for (const file of files) {
+        const checker = kit.checkerOf(file.sourceFile);
+        kit.walk(file.sourceFile, (node) => {
+            if (!(ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register'))
+                return;
+            const declarations = kit.declarationsOf(checker, node.expression.expression);
+            const owner = declarations.map(kit.ownerOfDeclaration).find(Boolean);
+            if (owner?.tier !== 'platform' || owner.name !== 'database')
+                return;
+            collectComposedConnections(kit, declared, checker, node, file, items);
+        });
+    }
+    return { root: files[0] ?? null, items };
 }

package/runtime/scripts/hfs/architecture/context-owner.d.mts

@@ -0,0 +1,15 @@
+import type { CheckResult, HfsCheckInput } from './context-map.mjs';
+/**
+ * R174 `context-owner` (BE_CONTEXT_OWNER). A connection of hfs.json IS a bounded context, and its `owner` is the one service app that composes it:
+ *   - an api or worker app passes to the database module registration (or lists in its options) only the connections it owns (a monolith's one
+ *     app owns them all);
+ *   - an api or worker app imports no domain or projection capability of a context it does not own: it composes only its own contexts;
+ *   - the cli app is the migration runner and composes every declared connection
+ *     that holds registered tables (migrations run only through it, once per connection).
+ * Which connection an app composes is read from two typed origins in its own files: the connection passed to the database module registration
+ * and the connection literal that lists a capability's `<c>Entities` / `<c>Migrations`. Which context a capability belongs to is the connection
+ * its arrays are registered on (context-map.mjs); an import is judged by the owner graph edge and the target's slot tier, never by a path or
+ * name pattern. A runner app with a registration whose connection name cannot be resolved is not judged for missing connections.
+ */
+export declare const CONTEXT_OWNER_RULE_IDS: string[];
+export declare function checkContextOwner(input: HfsCheckInput): CheckResult;