@starci/hfs 4.0.10 → 4.1.0

package/runtime/scripts/hfs/architecture/module-per-transport.mjs

@@ -1,6 +1,8 @@
 import path from 'node:path';
 import { machineKit } from './machine-ast.mjs';
 import { treeOf } from './required-files.mjs';
+import { byCodeUnit } from '../../lib/list.mjs';
+import { trimTrailingSlashes } from '../trailing-slashes.mjs';
 
 /**
  * R45 `module-per-transport` (BE_MODULE_SHAPE, BE-CONVENTION 1.2 and 1.6). A feature has one Nest module for its
@@ -22,48 +24,38 @@ export const MODULE_PER_TRANSPORT_RULE_IDS = ['BE_MODULE_SHAPE'];
 const RULE = 'BE_MODULE_SHAPE';
 const APP_ROOT_FILE = 'app.module.ts';
 
-export function checkModulePerTransport(input) {
-  const { config, graph } = input;
-  const kit = machineKit(input);
-  const { ts, resolver } = kit;
-  const violations = [];
-  const report = (file, node, message, extra = {}) => violations.push({ ruleId: RULE, path: file.rel, ...kit.at(file.rel, file.sourceFile, node), message, ...extra });
-  const plain = (rel, message, extra = {}) => violations.push({ ruleId: RULE, path: rel, line: 1, column: 1, message, ...extra });
+function featureOwnerOf(resolver, rel) {
+  const owner = resolver.ownerOf(rel);
+  return owner && resolver.slot(owner.slot)?.tier === 'feature' ? owner : null;
+}
 
-  const featureOf = rel => {
-    const owner = resolver.ownerOf(rel);
-    return owner && resolver.slot(owner.slot)?.tier === 'feature' ? owner : null;
-  };
-  /**
-   * {feature, root, protocol, composed} of a file inside a feature: protocol is the transport folder, null for the application
-   * side. composed is set for a composed root, an owner slot with `composedBy` (be.cli): an app of those kinds lists its root
-   * module, and every folder of the root holds one static module named after the folder.
-   */
-  const placeOf = rel => {
-    const owner = featureOf(rel);
-    if (!owner) return null;
-    const slot = resolver.slot(owner.slot);
-    const below = rel.slice(owner.root.length + 1).split('/');
-    const feature = path.posix.basename(owner.root);
-    if (slot.composedBy) return { root: owner.root, feature, protocol: null, below, composed: slot };
-    return { root: owner.root, feature, protocol: below[0] === 'transport' && below.length > 2 ? below[1] : null, below, composed: null };
-  };
-  /** The one module file a folder of a composed root may hold: <folder>/<folder>.module.ts. */
-  const composedModuleOf = rel => {
-    const dir = path.posix.dirname(rel);
-    return `${dir}/${path.posix.basename(dir)}.module.ts`;
-  };
+function modulePlaceOf(resolver, rel) {
+  const owner = featureOwnerOf(resolver, rel);
+  if (!owner) return null;
+  const slot = resolver.slot(owner.slot);
+  const below = rel.slice(owner.root.length + 1).split('/');
+  const feature = path.posix.basename(owner.root);
+  if (slot.composedBy) return { root: owner.root, feature, protocol: null, below, composed: slot };
+  return { root: owner.root, feature, protocol: below[0] === 'transport' && below.length > 2 ? below[1] : null, below, composed: null };
+}
 
-  // The transport slots and the app kinds that compose them, by protocol folder name.
+function composedModulePath(rel) {
+  const dir = path.posix.dirname(rel);
+  return `${dir}/${path.posix.basename(dir)}.module.ts`;
+}
+
+function composedByProtocol(resolver) {
   const composedBy = new Map();
   for (const slot of resolver.slots()) {
     if (!slot.composedBy || slot.owner) continue;
-    composedBy.set(path.posix.basename(slot.path.replace(/\/+$/u, '')), slot.composedBy);
+    composedBy.set(path.posix.basename(trimTrailingSlashes(slot.path)), slot.composedBy);
   }
+  return composedBy;
+}
 
+function reportTransportFileShapes(tree, placeOf, plain) {
   let transportModules = 0;
-  const tree = treeOf(config.root);
-  for (const rel of [...tree.files].sort()) {
+  for (const rel of [...tree.files].sort(byCodeUnit)) {
     const place = placeOf(rel);
     if (!place) continue;
     const base = path.posix.basename(rel);
@@ -74,81 +66,138 @@ export function checkModulePerTransport(input) {
       else transportModules += 1;
     }
   }
+  return transportModules;
+}
+
+function isNestModuleClass(ts, kit, checker, statement) {
+  return kit.decorators(statement).some(decorator => {
+    const call = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
+    return kit.isImportOf(checker, call, 'Module', '@nestjs/common');
+  });
+}
+
+function reportModuleClassLocation(file, statement, place, composedModuleOf, report) {
+  if (place.composed) {
+    const own = composedModuleOf(file.rel);
+    if (file.rel !== own) report(file, statement.name, `${statement.name.text} is a Nest module declared in ${file.rel}; every folder of ${place.root} holds exactly one static module named after it (${own}), never a module per command.`, { feature: place.feature });
+    return;
+  }
+  const own = place.protocol === null
+    ? `${place.root}/${place.feature}.module.ts`
+    : `${place.root}/transport/${place.protocol}/${place.feature}-${place.protocol}.module.ts`;
+  if (file.rel !== own) report(file, statement.name, `${statement.name.text} is a Nest module declared in ${file.rel}; a feature declares exactly its application module (${place.feature}.module.ts) and one module per transport folder (${place.feature}-<protocol>.module.ts), never a module per operation.`, { feature: place.feature });
+}
 
-  // @Module classes of the program: where they live, and the feature classes among them.
+function reportConfigurableModuleUses(file, checker, kit, ts, place, report) {
+  kit.walk(file.sourceFile, node => {
+    if (ts.isNewExpression(node) && kit.isImportOf(checker, node.expression, 'ConfigurableModuleBuilder', '@nestjs/common')) {
+      report(file, node, `ConfigurableModuleBuilder builds a capability's module definition; feature ${place.feature} has static modules only, so declare the providers in its @Module.`, { feature: place.feature });
+    } else if (ts.isHeritageClause(node)) {
+      for (const type of node.types) if (kit.isImportOf(checker, type.expression, 'ConfigurableModuleClass', '@nestjs/common')) {
+        report(file, type, `A feature module never extends ConfigurableModuleClass; feature ${place.feature} has static modules only.`, { feature: place.feature });
+      }
+    }
+    return true;
+  });
+}
+
+function moduleClassesInFile(file, checker, place, modules, env) {
+  const { kit, ts, composedModuleOf, report } = env;
+  for (const statement of file.sourceFile.statements) {
+    if (!ts.isClassDeclaration(statement) || !statement.name) continue;
+    if (!isNestModuleClass(ts, kit, checker, statement)) continue;
+    modules.set(statement, { name: statement.name.text, file });
+    if (place) reportModuleClassLocation(file, statement, place, composedModuleOf, report);
+  }
+}
+
+function collectFeatureModules(graph, kit, ts, placeOf, composedModuleOf, report) {
   const modules = new Map(); // class declaration -> {name, file}
+  const env = { kit, ts, composedModuleOf, report };
   for (const file of graph.files.values()) {
     const checker = kit.checkerOf(file.sourceFile);
     const place = placeOf(file.rel);
-    for (const statement of file.sourceFile.statements) {
-      if (!ts.isClassDeclaration(statement) || !statement.name) continue;
-      const isModule = kit.decorators(statement).some(decorator => {
-        const call = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
-        return kit.isImportOf(checker, call, 'Module', '@nestjs/common');
-      });
-      if (!isModule) continue;
-      modules.set(statement, { name: statement.name.text, file });
-      if (!place) continue;
-      if (place.composed) {
-        const own = composedModuleOf(file.rel);
-        if (file.rel !== own) report(file, statement.name, `${statement.name.text} is a Nest module declared in ${file.rel}; every folder of ${place.root} holds exactly one static module named after it (${own}), never a module per command.`, { feature: place.feature });
-        continue;
-      }
-      const own = place.protocol === null
-        ? `${place.root}/${place.feature}.module.ts`
-        : `${place.root}/transport/${place.protocol}/${place.feature}-${place.protocol}.module.ts`;
-      if (file.rel !== own) report(file, statement.name, `${statement.name.text} is a Nest module declared in ${file.rel}; a feature declares exactly its application module (${place.feature}.module.ts) and one module per transport folder (${place.feature}-<protocol>.module.ts), never a module per operation.`, { feature: place.feature });
-    }
-    if (place) {
-      kit.walk(file.sourceFile, node => {
-        if (ts.isNewExpression(node) && kit.isImportOf(checker, node.expression, 'ConfigurableModuleBuilder', '@nestjs/common')) {
-          report(file, node, `ConfigurableModuleBuilder builds a capability's module definition; feature ${place.feature} has static modules only, so declare the providers in its @Module.`, { feature: place.feature });
-        } else if (ts.isHeritageClause(node)) {
-          for (const type of node.types) if (kit.isImportOf(checker, type.expression, 'ConfigurableModuleClass', '@nestjs/common')) {
-            report(file, type, `A feature module never extends ConfigurableModuleClass; feature ${place.feature} has static modules only.`, { feature: place.feature });
-          }
-        }
-        return true;
-      });
-    }
+    moduleClassesInFile(file, checker, place, modules, env);
+    if (place) reportConfigurableModuleUses(file, checker, kit, ts, place, report);
+  }
+  return modules;
+}
+
+function reportModuleReference(root, node, app, module, place, composedBy, report) {
+  if (place.composed) {
+    const rootModule = `${place.root}/${place.feature}.module.ts`;
+    if (!place.composed.composedBy.includes(app.kind)) report(root, node, `App ${app.name} is of kind ${app.kind} and lists ${module.name} from ${place.root}; only an app of kind ${place.composed.composedBy.join(', ')} composes that root.`, { app: app.name, module: module.name });
+    else if (module.file.rel !== rootModule) report(root, node, `App ${app.name} lists ${module.name}, a group module inside ${place.root}; the app lists the root module (${rootModule}), which imports every group module.`, { app: app.name, module: module.name });
+  } else if (place.protocol === null) {
+    report(root, node, `App ${app.name} lists ${module.name}, the application module of feature ${place.feature}; apps import only transport modules (${place.feature}-<protocol>.module.ts), which import the application module themselves.`, { app: app.name, module: module.name });
+  } else if (!(composedBy.get(place.protocol) ?? []).includes(app.kind)) {
+    const allowed = [...composedBy].filter(([, kinds]) => kinds.includes(app.kind)).map(([protocol]) => protocol).sort(byCodeUnit);
+    const transports = allowed.length ? `${allowed.join(', ')} transports only` : 'no transport module';
+    report(root, node, `App ${app.name} is of kind ${app.kind} and lists ${module.name}, a ${place.protocol} transport module; an app of kind ${app.kind} composes ${transports}.`, { app: app.name, module: module.name, protocol: place.protocol });
   }
+}
 
-  // What each app root lists: a feature module must be a transport module of a kind the app kind composes.
+function inspectModuleDeclarations(checker, target, node, root, app, scan, seen) {
+  const { moduleMap, kit, placeOf, composedBy, report } = scan;
   let references = 0;
-  for (const app of resolver.repo.apps) {
-    const root = graph.files.get(`apps/${app.name}/src/${APP_ROOT_FILE}`);
-    if (!root) continue;
-    const checker = kit.checkerOf(root.sourceFile);
-    const seen = new Set();
-    const judge = node => {
-      const call = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register';
-      if (ts.isCallExpression(node) && !call) return;
-      const target = call ? node.expression.expression : node;
-      for (const declaration of kit.declarationsOf(checker, target)) {
-        const module = modules.get(declaration);
-        if (!module) continue;
-        const place = placeOf(module.file.rel);
-        if (!place || seen.has(node)) continue;
-        seen.add(node);
-        references += 1;
-        if (place.composed) {
-          const rootModule = `${place.root}/${place.feature}.module.ts`;
-          if (!place.composed.composedBy.includes(app.kind)) report(root, node, `App ${app.name} is of kind ${app.kind} and lists ${module.name} from ${place.root}; only an app of kind ${place.composed.composedBy.join(', ')} composes that root.`, { app: app.name, module: module.name });
-          else if (module.file.rel !== rootModule) report(root, node, `App ${app.name} lists ${module.name}, a group module inside ${place.root}; the app lists the root module (${rootModule}), which imports every group module.`, { app: app.name, module: module.name });
-        } else if (place.protocol === null) {
-          report(root, node, `App ${app.name} lists ${module.name}, the application module of feature ${place.feature}; apps import only transport modules (${place.feature}-<protocol>.module.ts), which import the application module themselves.`, { app: app.name, module: module.name });
-        } else if (!(composedBy.get(place.protocol) ?? []).includes(app.kind)) {
-          const allowed = [...composedBy].filter(([, kinds]) => kinds.includes(app.kind)).map(([protocol]) => protocol).sort();
-          report(root, node, `App ${app.name} is of kind ${app.kind} and lists ${module.name}, a ${place.protocol} transport module; an app of kind ${app.kind} composes ${allowed.length ? `${allowed.join(', ')} transports only` : 'no transport module'}.`, { app: app.name, module: module.name, protocol: place.protocol });
-        }
-      }
-    };
-    kit.walk(root.sourceFile, node => {
-      if (ts.isPropertyAssignment(node) && kit.propertyNameText(node.name) === 'imports' && ts.isArrayLiteralExpression(node.initializer)) {
-        for (const element of node.initializer.elements) judge(element);
-      } else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register') judge(node);
-      return true;
-    });
+  for (const declaration of kit.declarationsOf(checker, target)) {
+    const module = moduleMap.get(declaration);
+    if (!module) continue;
+    const place = placeOf(module.file.rel);
+    if (!place || seen.has(node)) continue;
+    seen.add(node);
+    references += 1;
+    reportModuleReference(root, node, app, module, place, composedBy, report);
   }
+  return references;
+}
+
+function inspectAppRoot(app, scan) {
+  const { graph, kit, ts } = scan;
+  const root = graph.files.get(`apps/${app.name}/src/${APP_ROOT_FILE}`);
+  if (!root) return 0;
+  const checker = kit.checkerOf(root.sourceFile);
+  const seen = new Set();
+  let references = 0;
+  const judge = node => {
+    const call = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register';
+    if (ts.isCallExpression(node) && !call) return;
+    const target = call ? node.expression.expression : node;
+    references += inspectModuleDeclarations(checker, target, node, root, app, scan, seen);
+  };
+  kit.walk(root.sourceFile, node => {
+    if (ts.isPropertyAssignment(node) && kit.propertyNameText(node.name) === 'imports' && ts.isArrayLiteralExpression(node.initializer)) {
+      for (const element of node.initializer.elements) judge(element);
+    } else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register') judge(node);
+    return true;
+  });
+  return references;
+}
+
+function appModuleReferences(apps, scan) {
+  let references = 0;
+  for (const app of apps) references += inspectAppRoot(app, scan);
+  return references;
+}
+
+export function checkModulePerTransport(input) {
+  const { config, graph } = input;
+  const kit = machineKit(input);
+  const { ts, resolver } = kit;
+  const violations = [];
+  const report = (file, node, message, extra = {}) => violations.push({ ruleId: RULE, path: file.rel, ...kit.at(file.rel, file.sourceFile, node), message, ...extra });
+  const plain = (rel, message, extra = {}) => violations.push({ ruleId: RULE, path: rel, line: 1, column: 1, message, ...extra });
+
+  const placeOf = rel => modulePlaceOf(resolver, rel);
+  const composedModuleOf = composedModulePath;
+
+  const composedBy = composedByProtocol(resolver);
+
+  const tree = treeOf(config.root);
+  const transportModules = reportTransportFileShapes(tree, placeOf, plain);
+
+  const modules = collectFeatureModules(graph, kit, ts, placeOf, composedModuleOf, report);
+
+  const references = appModuleReferences(resolver.repo.apps, { graph, kit, ts, moduleMap: modules, placeOf, composedBy, report });
   return { violations, coverage: { status: 'checked', modules: modules.size, transportModules, appReferences: references } };
 }

package/runtime/scripts/hfs/architecture/next-data-contract.mjs

@@ -13,64 +13,72 @@ const HOOK_KEYS = new Set(['id', 'path', 'export', 'kind', 'resultBinding', 'ide
 const IDENTITY_KEYS = new Set(['id', 'binding', 'gatesRequest', 'resource']);
 function relativeSource(repository, value, label) {
   repository = path.resolve(repository);
-  if (typeof value !== 'string' || !value.trim() || path.isAbsolute(value)) throw Error(`${label} must be a non-empty repository-relative source path.`);
+  if (typeof value !== 'string' || !value.trim() || path.isAbsolute(value)) throw new Error(`${label} must be a non-empty repository-relative source path.`);
   const relative = slash(value.trim()).replace(/^\.\//, '');
   if (relative.split('/').includes('..') || !SOURCE.test(relative) || /\.d\.[cm]?[jt]s$/i.test(relative)) {
-    throw Error(`${label} must be a production TypeScript or JavaScript source path.`);
+    throw new Error(`${label} must be a production TypeScript or JavaScript source path.`);
   }
   const absolute = path.resolve(repository, ...relative.split('/'));
-  if (!isInside(repository, absolute)) throw Error(`${label} must stay inside the repository.`);
+  if (!isInside(repository, absolute)) throw new Error(`${label} must stay inside the repository.`);
   for (let current = absolute; current !== repository; current = path.dirname(current)) {
     const stat = fs.lstatSync(current);
-    if (stat.isSymbolicLink()) throw Error(`${label} must not cross a symbolic-link or junction ancestor.`);
+    if (stat.isSymbolicLink()) throw new Error(`${label} must not cross a symbolic-link or junction ancestor.`);
   }
   const stat = fs.lstatSync(absolute);
-  if (!stat.isFile() || !isInside(canonical(repository), canonical(absolute))) throw Error(`${label} must be a regular source file inside the repository.`);
+  if (!stat.isFile() || !isInside(canonical(repository), canonical(absolute))) throw new Error(`${label} must be a regular source file inside the repository.`);
   return relative;
 }
 
+const CONTRACT_LABEL = 'package.json#starci.codePatterns.next.dataLifecycle';
+
+function parseSwr(swr) {
+  exactKeys(swr, SWR_KEYS, 'dataLifecycle.swr');
+  if (swr.package !== 'swr' || !Number.isInteger(swr.major) || swr.major < 1) {
+    throw new Error('dataLifecycle.swr must bind package swr and one positive integer major version.');
+  }
+}
+
+function parseIdentity(identity, identityLabel, seen) {
+  exactKeys(identity, IDENTITY_KEYS, identityLabel);
+  if (typeof identity.id !== 'string' || !identity.id.trim() || seen.ids.has(identity.id.trim())) throw new Error(`${identityLabel}.id must be unique and non-empty.`);
+  if (typeof identity.binding !== 'string' || !BINDING.test(identity.binding) || seen.bindings.has(identity.binding)) throw new Error(`${identityLabel}.binding must be a unique identifier or property path.`);
+  if (typeof identity.gatesRequest !== 'boolean' || typeof identity.resource !== 'boolean') throw new Error(`${identityLabel} must explicitly declare gatesRequest and resource booleans.`);
+  seen.ids.add(identity.id.trim());
+  seen.bindings.add(identity.binding);
+  return { id: identity.id.trim(), binding: identity.binding, gatesRequest: identity.gatesRequest, resource: identity.resource };
+}
+
+function parseHook(config, hook, label, ids) {
+  exactKeys(hook, HOOK_KEYS, label);
+  if (typeof hook.id !== 'string' || !hook.id.trim() || ids.has(hook.id.trim())) throw new Error(`${label}.id must be unique and non-empty.`);
+  ids.add(hook.id.trim());
+  const source = relativeSource(config.root, hook.path, `${label}.path`);
+  if (typeof hook.export !== 'string' || !/^use[A-Z0-9_$][\w$]*$/.test(hook.export)) throw new Error(`${label}.export must name one exported use* hook.`);
+  if (!['query', 'mutation'].includes(hook.kind)) throw new Error(`${label}.kind must be query or mutation.`);
+  if (hook.resultBinding !== undefined && (typeof hook.resultBinding !== 'string' || !IDENTIFIER.test(hook.resultBinding))) {
+    throw new Error(`${label}.resultBinding must be one local identifier.`);
+  }
+  if (!Array.isArray(hook.identities)) throw new Error(`${label}.identities must be an array.`);
+  const seen = { ids: new Set(), bindings: new Set() };
+  const identities = hook.identities.map((identity, identityIndex) => parseIdentity(identity, `${label}.identities[${identityIndex}]`, seen));
+  if (hook.kind === 'mutation' && !identities.some(identity => identity.resource)) throw new Error(`${label} mutation must declare at least one resource identity.`);
+  return { id: hook.id.trim(), path: source, export: hook.export, kind: hook.kind,
+    ...(hook.resultBinding === undefined ? {} : { resultBinding: hook.resultBinding }), identities };
+}
+
 export function parseContract(config) {
   // The contract is declared in the app's one package.json (the app root; config.root is the fe side folder).
   const manifest = JSON.parse(fs.readFileSync(path.join(config.packageRoot ?? config.root, 'package.json'), 'utf8'));
   const next = manifest?.starci?.codePatterns?.next;
   const value = next?.dataLifecycle;
   if (value === undefined) return null;
-  if (next.schema !== 'starci/next-code-pattern-contract@1') throw Error('package.json#starci.codePatterns.next must use starci/next-code-pattern-contract@1.');
-  exactKeys(value, TOP_KEYS, 'package.json#starci.codePatterns.next.dataLifecycle');
-  if (value.schema !== CONTRACT_SCHEMA) throw Error(`dataLifecycle.schema must be ${CONTRACT_SCHEMA}.`);
-  exactKeys(value.swr, SWR_KEYS, 'dataLifecycle.swr');
-  if (value.swr.package !== 'swr' || !Number.isInteger(value.swr.major) || value.swr.major < 1) {
-    throw Error('dataLifecycle.swr must bind package swr and one positive integer major version.');
-  }
-  if (!Array.isArray(value.hooks) || value.hooks.length === 0) throw Error('dataLifecycle.hooks must contain at least one declared lifecycle call.');
+  if (next.schema !== 'starci/next-code-pattern-contract@1') throw new Error('package.json#starci.codePatterns.next must use starci/next-code-pattern-contract@1.');
+  exactKeys(value, TOP_KEYS, CONTRACT_LABEL);
+  if (value.schema !== CONTRACT_SCHEMA) throw new Error(`dataLifecycle.schema must be ${CONTRACT_SCHEMA}.`);
+  parseSwr(value.swr);
+  if (!Array.isArray(value.hooks) || value.hooks.length === 0) throw new Error('dataLifecycle.hooks must contain at least one declared lifecycle call.');
   const ids = new Set();
-  const hooks = value.hooks.map((hook, index) => {
-    const label = `dataLifecycle.hooks[${index}]`;
-    exactKeys(hook, HOOK_KEYS, label);
-    if (typeof hook.id !== 'string' || !hook.id.trim() || ids.has(hook.id.trim())) throw Error(`${label}.id must be unique and non-empty.`);
-    ids.add(hook.id.trim());
-    const source = relativeSource(config.root, hook.path, `${label}.path`);
-    if (typeof hook.export !== 'string' || !/^use[A-Z0-9_$][\w$]*$/.test(hook.export)) throw Error(`${label}.export must name one exported use* hook.`);
-    if (!['query', 'mutation'].includes(hook.kind)) throw Error(`${label}.kind must be query or mutation.`);
-    if (hook.resultBinding !== undefined && (typeof hook.resultBinding !== 'string' || !IDENTIFIER.test(hook.resultBinding))) {
-      throw Error(`${label}.resultBinding must be one local identifier.`);
-    }
-    if (!Array.isArray(hook.identities)) throw Error(`${label}.identities must be an array.`);
-    const identityIds = new Set(), bindings = new Set();
-    const identities = hook.identities.map((identity, identityIndex) => {
-      const identityLabel = `${label}.identities[${identityIndex}]`;
-      exactKeys(identity, IDENTITY_KEYS, identityLabel);
-      if (typeof identity.id !== 'string' || !identity.id.trim() || identityIds.has(identity.id.trim())) throw Error(`${identityLabel}.id must be unique and non-empty.`);
-      if (typeof identity.binding !== 'string' || !BINDING.test(identity.binding) || bindings.has(identity.binding)) throw Error(`${identityLabel}.binding must be a unique identifier or property path.`);
-      if (typeof identity.gatesRequest !== 'boolean' || typeof identity.resource !== 'boolean') throw Error(`${identityLabel} must explicitly declare gatesRequest and resource booleans.`);
-      identityIds.add(identity.id.trim());
-      bindings.add(identity.binding);
-      return { id: identity.id.trim(), binding: identity.binding, gatesRequest: identity.gatesRequest, resource: identity.resource };
-    });
-    if (hook.kind === 'mutation' && !identities.some(identity => identity.resource)) throw Error(`${label} mutation must declare at least one resource identity.`);
-    return { id: hook.id.trim(), path: source, export: hook.export, kind: hook.kind,
-      ...(hook.resultBinding === undefined ? {} : { resultBinding: hook.resultBinding }), identities };
-  });
+  const hooks = value.hooks.map((hook, index) => parseHook(config, hook, `dataLifecycle.hooks[${index}]`, ids));
   return { schema: value.schema, swr: { package: 'swr', major: value.swr.major }, hooks };
 }
 
@@ -79,7 +87,7 @@ export function installedSWR(repository) {
   let manifest;
   try { manifest = require.resolve('swr/package.json'); } catch {
     let entry;
-    try { entry = require.resolve('swr'); } catch { throw Error('Installed swr package is unavailable.'); }
+    try { entry = require.resolve('swr'); } catch { throw new Error('Installed swr package is unavailable.'); }
     let current = path.dirname(entry);
     while (isInside(repository, current) && current !== repository) {
       const candidate = path.join(current, 'package.json');
@@ -87,10 +95,10 @@ export function installedSWR(repository) {
       current = path.dirname(current);
     }
   }
-  if (!manifest) throw Error('Installed swr package.json is unavailable.');
+  if (!manifest) throw new Error('Installed swr package.json is unavailable.');
   const actualManifest = canonical(manifest);
   const parsed = JSON.parse(fs.readFileSync(actualManifest, 'utf8'));
   const major = Number.parseInt(String(parsed.version ?? '').split('.')[0], 10);
-  if (parsed.name !== 'swr' || !Number.isInteger(major)) throw Error('Installed swr package identity or version is invalid.');
+  if (parsed.name !== 'swr' || !Number.isInteger(major)) throw new Error('Installed swr package identity or version is invalid.');
   return { name: parsed.name, version: parsed.version, major, root: canonical(path.dirname(actualManifest)) };
 }