@intentset/architecture 0.2.0 → 0.4.0

package/src/areas.ts

@@ -0,0 +1,233 @@
+/**
+ * Areas (profile §9): a backend split into several Amplify backends, each its
+ * own CloudFormation deployment and source API, behind one AppSync Merged API.
+ * Nothing here runs unless `.intentset/architecture.yaml` declares areas.
+ *
+ *   AMP007  a slice names a declared area as its domain, and its claims stay in that area
+ *   AMP008  no area backend imports another; the shared backend package imports no area
+ *   AMP009  each model, enum and operation is declared in one area's schema (a custom type: a warning)
+ *   AMP010  no relationship or reference names another area's type
+ *   AMP011  only the schema bridge calls generateClient (its schema imports are checked with AMP001)
+ *
+ * AMP012 (cross-area access and an acyclic deploy order) and AMP013 (one
+ * authorizer on the Merged API) are review assertions: neither is visible in
+ * source, so they are listed for review and never reported as passing.
+ */
+import type { AreaConfig } from "./config.ts";
+import { extractSchema, findCalls, type SchemaKind } from "./extract.ts";
+import { type Finding, finding, listSome } from "./finding.ts";
+import type { ImportEdge } from "./imports.ts";
+import { isCode } from "./paths.ts";
+import { compareStrings, matchAny } from "./patterns.ts";
+import type { Model } from "./regions.ts";
+
+export const AREA_REVIEW_REQUIRED = [
+  "AMP012 backend code reaches another area's data through published resource names and the AWS SDK, and deploy-time dependencies between areas are acyclic: deployment wiring, not source",
+  "AMP013 one authorizer on the Merged API decides every request to every area and denies what it does not list: an authorizer's policy, not source",
+];
+
+export interface AreaCheck {
+  findings: Finding[];
+  /** What could not be read: never a pass (invariant 6). */
+  unresolved: string[];
+}
+
+/** The area whose backend holds a path, or null. */
+export function backendAreaOf(areas: readonly AreaConfig[], path: string): AreaConfig | null {
+  return areas.find((area) => matchAny(area.backend, path)) ?? null;
+}
+
+/** The area whose backend or frontend holds a path, or null. */
+export function areaOf(areas: readonly AreaConfig[], path: string): AreaConfig | null {
+  return backendAreaOf(areas, path) ?? areas.find((area) => matchAny(area.frontend, path)) ?? null;
+}
+
+/** True when the path is one of the declared areas' schema files. */
+export function isAreaSchema(areas: readonly AreaConfig[], path: string): boolean {
+  return areas.some((area) => area.schema === path);
+}
+
+const OPERATION_KINDS = new Set<SchemaKind | null>(["model", "enum", "query", "mutation", "subscription", null]);
+
+export function checkAreas(model: Model, edges: readonly ImportEdge[]): AreaCheck {
+  const { areas, sharedBackend, schemaBridge } = model.config;
+  const findings: Finding[] = [];
+  const unresolved: string[] = [];
+  if (areas.length === 0) return { findings, unresolved };
+  const names = areas.map((area) => area.name).join(", ");
+
+  // AMP007: every slice in a declared area, and its claims inside it.
+  for (const slice of model.slices) {
+    const area = areas.find((candidate) => candidate.name === slice.meta.domain);
+    if (area === undefined) {
+      findings.push(
+        finding({
+          code: "AMP007",
+          artifact: slice.id,
+          path: slice.path,
+          field: "/intentset/slice/domain",
+          message: `${slice.id} names the domain "${slice.meta.domain}", which is not a declared area; the areas are ${names}.`,
+          remediation:
+            "Set domain to the area whose backend serves the slice, or declare the area in .intentset/architecture.yaml (profile §9, AMP007).",
+        }),
+      );
+      continue;
+    }
+    slice.meta.claims.forEach((claim, i) => {
+      const foreign = slice.claimFiles[i].filter((file) => {
+        const other = areaOf(areas, file);
+        return other !== null && other.name !== area.name;
+      });
+      if (foreign.length === 0) return;
+      const others = [...new Set(foreign.map((file) => areaOf(areas, file)?.name as string))].sort(compareStrings);
+      findings.push(
+        finding({
+          code: "AMP007",
+          artifact: slice.id,
+          path: slice.path,
+          field: `/intentset/slice/claims/${i}/path`,
+          message: `The ${claim.kind} claim ${claim.path} of ${slice.id}, a slice of area ${area.name}, reaches into area ${others.join(" and ")}: ${listSome(foreign)}.`,
+          remediation:
+            "Narrow the claim to the slice's own area, or move the slice to the area that holds those files (profile §9, AMP007).",
+          paths: foreign,
+        }),
+      );
+    });
+  }
+
+  // AMP008: area backends deploy apart, so neither imports the other; shared backend code imports no area.
+  for (const edge of edges) {
+    if (edge.to === null || !model.inScope(edge.from)) continue;
+    const to = backendAreaOf(areas, edge.to);
+    if (to === null) continue;
+    const from = backendAreaOf(areas, edge.from);
+    const location = { line: edge.line };
+    if (from !== null && from.name !== to.name) {
+      findings.push(
+        finding({
+          code: "AMP008",
+          artifact: null,
+          path: edge.from,
+          location,
+          message: `${edge.from}, in the ${from.name} backend, imports ${edge.to} from the ${to.name} backend, and area backends deploy separately.`,
+          remediation:
+            "Move what both need into the shared backend package, and reach the other area's data through its published resource names (profile §9, AMP008, AMP012).",
+          edges: [{ from: edge.from, to: edge.to }],
+        }),
+      );
+    } else if (from === null && matchAny(sharedBackend, edge.from)) {
+      findings.push(
+        finding({
+          code: "AMP008",
+          artifact: null,
+          path: edge.from,
+          location,
+          message: `${edge.from}, in the shared backend package, imports ${edge.to} from the ${to.name} backend, and the shared package must stay domain-neutral.`,
+          remediation:
+            "Pass what the shared code needs in as a parameter, or move the code into the area that owns it (profile §9, AMP008).",
+          edges: [{ from: edge.from, to: edge.to }],
+        }),
+      );
+    }
+  }
+
+  // AMP009 and AMP010: one owner per name across the areas' schemas, and no reference across them.
+  const declared = new Map<string, { area: string; kind: SchemaKind | null; schema: string; line: number }[]>();
+  const read = new Map<string, ReturnType<typeof extractSchema>>();
+  for (const area of areas) {
+    const text = model.files.get(area.schema);
+    if (text === undefined) {
+      findings.push(
+        finding({
+          code: "AMP009",
+          artifact: null,
+          path: area.schema,
+          message: `The schema of area ${area.name}, ${area.schema}, is not a file in the repository, so its declarations were not checked.`,
+          remediation: "Correct the area's schema path in .intentset/architecture.yaml (profile §9).",
+        }),
+      );
+      continue;
+    }
+    const extraction = extractSchema(area.schema, text);
+    read.set(area.name, extraction);
+    if (!extraction.found) {
+      unresolved.push(
+        `${area.schema}: no <builder>.schema({ ... }) call, so area ${area.name}'s declarations were not read`,
+      );
+    }
+    for (const problem of extraction.problems) unresolved.push(`${area.schema}:${problem.line}: ${problem.message}`);
+    for (const declaration of extraction.declarations) {
+      const list = declared.get(declaration.name) ?? [];
+      list.push({ area: area.name, kind: declaration.kind, schema: area.schema, line: declaration.line });
+      declared.set(declaration.name, list);
+    }
+  }
+  for (const name of [...declared.keys()].sort(compareStrings)) {
+    const owners = declared.get(name) ?? [];
+    const inAreas = [...new Set(owners.map((owner) => owner.area))].sort(compareStrings);
+    if (inAreas.length < 2) continue;
+    const later = owners.find((owner) => owner.area === inAreas[1]) ?? owners[1];
+    const operation = owners.some((owner) => OPERATION_KINDS.has(owner.kind));
+    findings.push(
+      finding({
+        code: "AMP009",
+        ...(operation ? {} : { severity: "warning" as const }),
+        artifact: null,
+        path: later.schema,
+        location: { line: later.line },
+        message: operation
+          ? `${name} is declared in the schemas of areas ${inAreas.join(" and ")}; the Merged API joins every area into one namespace and refuses a field two sources resolve.`
+          : `The custom type ${name} is declared in the schemas of areas ${inAreas.join(" and ")}, which share one type namespace in the Merged API.`,
+        remediation: operation
+          ? `Keep ${name} in the one area whose functions read and write it, and link to it from the others by ID (profile §9, AMP009).`
+          : `Prefix the type with its area's name, or name it after the operation that returns it (profile §9, AMP009).`,
+        paths: [...new Set(owners.map((owner) => owner.schema))].sort(compareStrings),
+      }),
+    );
+  }
+  for (const area of areas) {
+    const extraction = read.get(area.name);
+    if (extraction === undefined) continue;
+    const own = new Set(extraction.declarations.map((declaration) => declaration.name));
+    for (const reference of extraction.references) {
+      if (own.has(reference.target)) continue;
+      const elsewhere = (declared.get(reference.target) ?? []).map((owner) => owner.area);
+      if (elsewhere.length === 0) continue;
+      findings.push(
+        finding({
+          code: "AMP010",
+          artifact: null,
+          path: area.schema,
+          location: { line: reference.line },
+          message: `${area.schema} ${reference.via}("${reference.target}") names a type that area ${elsewhere.sort(compareStrings)[0]} declares; relationships and references do not cross areas.`,
+          remediation:
+            "Store the other area's ID as a plain field and resolve it in a function of this area (profile §9, AMP010).",
+        }),
+      );
+    }
+  }
+
+  // AMP011: one client, on the Merged API, made in one place.
+  for (const [path, text] of model.files) {
+    if (path === schemaBridge || !isCode(path) || model.isTest(path) || !model.inScope(path)) continue;
+    if (model.underBackend(path) || matchAny(sharedBackend, path)) continue;
+    if (!text.includes("generateClient")) continue;
+    const lines = findCalls(path, text, "generateClient");
+    if (lines.length === 0) continue;
+    findings.push(
+      finding({
+        code: "AMP011",
+        artifact: null,
+        path,
+        location: { line: lines[0] },
+        message:
+          schemaBridge === null
+            ? `${path} calls generateClient, and this repository declares no schema bridge to make the one client on the Merged API.`
+            : `${path} calls generateClient; only the schema bridge ${schemaBridge} makes the client, once, on the Merged API.`,
+        remediation:
+          "Declare schemaBridge in .intentset/architecture.yaml and import the client from it everywhere else (profile §9, AMP011).",
+      }),
+    );
+  }
+  return { findings, unresolved };
+}

package/src/boundaries.ts

@@ -38,6 +38,7 @@
  * so a narrow scope cannot hide its consumers and they do not fail it
  * (VSA §9). They count toward no edge total and no slice dependency.
  */
+import { isAreaSchema } from "./areas.ts";
 import { type Finding, finding, listSome } from "./finding.ts";
 import type { ImportEdge } from "./imports.ts";
 import { inSeam, isPure, knownLayer, layerAllows, layerOf } from "./layers.ts";
@@ -281,9 +282,27 @@ export function checkBoundaries(model: Model, edges: readonly ImportEdge[], reso
     if (!model.inScope(to) && target === undefined) continue;
     const subject = { edges: [{ from, to }, ...(source && target ? [{ from: source.id, to: target.id }] : [])] };
 
-    // 1. AMP001
-    if (model.underBackend(to) && !model.underBackend(from)) {
+    // 1. AMP001, and AMP011 for an area repository's schema bridge (profile §9). The shared backend
+    // package is backend code: what it may import is AMP008's question.
+    if (model.underBackend(to) && !model.underBackend(from) && !matchAny(config.sharedBackend, from)) {
       const seam = source !== undefined && inSeam(source, from);
+      if (edge.typeOnly && isAreaSchema(config.areas, to)) {
+        if (from !== config.schemaBridge) {
+          findings.push(
+            finding({
+              code: "AMP011",
+              artifact,
+              path: from,
+              location,
+              message: `${from} ${how(edge)}, the schema of an area, and only the schema bridge${config.schemaBridge === null ? ", which this repository has not declared," : ` ${config.schemaBridge}`} may.`,
+              remediation:
+                "Import the client and its types from the schema bridge, which joins every area's schema into one type (profile §9, AMP011).",
+              ...subject,
+            }),
+          );
+        }
+        continue;
+      }
       if (!(seam && matchAny(config.responseParserModules, to))) {
         findings.push(
           finding({

package/src/check.ts

@@ -20,6 +20,7 @@ import {
   type Registries,
   sortDiagnostics,
 } from "@intentset/core";
+import { AREA_REVIEW_REQUIRED, checkAreas } from "./areas.ts";
 import { applyBaseline, type BaselineEntry, type Mode } from "./baseline.ts";
 import { checkBoundaries, checkUnclassified } from "./boundaries.ts";
 import { checkClaims } from "./claims.ts";
@@ -165,6 +166,9 @@ export function checkArchitecture(
   const boundaries = checkBoundaries(model, imports.edges, resolver);
   findings.push(...boundaries.findings);
   findings.push(...checkUnclassified(model));
+  const areaCheck = checkAreas(model, imports.edges);
+  findings.push(...areaCheck.findings);
+  unresolved.push(...areaCheck.unresolved);
   const dependencies = checkDependencies(model, graph, boundaries.sliceEdges);
   findings.push(...dependencies.findings);
 
@@ -207,7 +211,7 @@ export function checkArchitecture(
     baselined: baseline.baselined,
     baselineStale: baseline.stale.length,
     unresolved: [...new Set(unresolved)].sort(compareStrings),
-    reviewRequired: [...REVIEW_REQUIRED],
+    reviewRequired: [...REVIEW_REQUIRED, ...(config.areas.length > 0 ? AREA_REVIEW_REQUIRED : [])],
   };
   const ownership: OwnershipEntry[] = [];
   for (const path of model.files.keys()) {

package/src/config.ts

@@ -11,6 +11,21 @@ import { compareStrings, validatePattern } from "./patterns.ts";
 
 export const ARCHITECTURE_CONFIG_PATH = ".intentset/architecture.yaml";
 
+/** One area (profile §9): an Amplify backend of its own and the frontend slices it serves. */
+export interface AreaConfig {
+  /** Lowercase name; a slice names its area in `domain`. */
+  name: string;
+  /** Patterns for the area's backend: its own CloudFormation deployment and source API. */
+  backend: string[];
+  /** The area's schema file, `data/resource.ts`: the one place its models and operations are declared (AMP009). */
+  schema: string;
+  /** Patterns for the area's frontend slices, such as src/features/<area>/**. May be empty. */
+  frontend: string[];
+}
+
+/** AppSync joins at most this many source APIs into one Merged API. */
+export const MAX_AREAS = 10;
+
 export interface ArchitectureConfig {
   /** Declared scope (VSA §9, Core §11): files outside it are counted, never reported one by one. */
   scope: string[];
@@ -40,6 +55,12 @@ export interface ArchitectureConfig {
   layerMatrix: Record<string, string[]>;
   /** Export conditions tried first when resolving a workspace package's entry, before types, import and default. */
   conditions: string[];
+  /** Areas (profile §9). Empty for a repository with one backend, which none of AMP007 to AMP013 concern. */
+  areas: AreaConfig[];
+  /** Domain-neutral backend code every area may import, which imports no area (AMP008). */
+  sharedBackend: string[];
+  /** The one frontend file that may import area schemas, type-only, and call generateClient (AMP011). */
+  schemaBridge: string | null;
 }
 
 export const DEFAULT_ARCHITECTURE_CONFIG: ArchitectureConfig = {
@@ -63,6 +84,9 @@ export const DEFAULT_ARCHITECTURE_CONFIG: ArchitectureConfig = {
     external: ["external", "model"],
   },
   conditions: [],
+  areas: [],
+  sharedBackend: [],
+  schemaBridge: null,
 };
 
 const LIST_KEYS = [
@@ -78,6 +102,7 @@ const LIST_KEYS = [
   "tests",
   "backendSdks",
   "conditions",
+  "sharedBackend",
 ] as const;
 
 /** Keys whose entries are path patterns and must pass validatePattern. */
@@ -93,9 +118,10 @@ const PATTERN_KEYS = new Set<string>([
   "ignore",
   "tests",
   "screensGlob",
+  "sharedBackend",
 ]);
 
-const KNOWN_KEYS = [...LIST_KEYS, "screensGlob", "layerMatrix"].sort(compareStrings);
+const KNOWN_KEYS = [...LIST_KEYS, "screensGlob", "layerMatrix", "areas", "schemaBridge"].sort(compareStrings);
 
 /** The defaults with a partial configuration laid over them; a key given replaces the default whole. */
 export function resolveConfig(...layers: (Partial<ArchitectureConfig> | undefined)[]): ArchitectureConfig {
@@ -166,6 +192,25 @@ export function readArchitectureConfig(
       } else config.screensGlob = value as string;
       continue;
     }
+    if (key === "schemaBridge") {
+      const why = typeof value === "string" ? literalPath(value) : "is not a string";
+      if (why !== null) {
+        report(
+          field,
+          at(field),
+          `schemaBridge ${why}.`,
+          "Name the one file, such as src/infrastructure/amplify/client.ts.",
+        );
+      } else config.schemaBridge = value as string;
+      continue;
+    }
+    if (key === "areas") {
+      const read = readAreas(value);
+      if (typeof read === "string") {
+        report(field, at(field), `areas ${read}.`, AREAS_REMEDIATION);
+      } else config.areas = read;
+      continue;
+    }
     if (key === "layerMatrix") {
       const matrix = readMatrix(value);
       if (matrix === null) {
@@ -210,3 +255,49 @@ function readMatrix(value: unknown): Record<string, string[]> | null {
   }
   return matrix;
 }
+
+const AREAS_REMEDIATION =
+  "Write each area as a mapping of name, backend (a list of patterns), schema (one file) and frontend (a list of patterns), as profile §9 shows.";
+const AREA_NAME = /^[a-z][a-z0-9-]*$/;
+
+/** `areas` as a list of AreaConfig, or why it is not one. */
+function readAreas(value: unknown): AreaConfig[] | string {
+  if (!Array.isArray(value)) return "must be a list of areas";
+  if (value.length > MAX_AREAS) {
+    return `names ${value.length} areas, and an AppSync Merged API joins at most ${MAX_AREAS} source APIs`;
+  }
+  const areas: AreaConfig[] = [];
+  for (const [i, entry] of value.entries()) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return `entry ${i} is not a mapping`;
+    const record = entry as Record<string, unknown>;
+    const unknown = Object.keys(record).filter((key) => !["name", "backend", "schema", "frontend"].includes(key));
+    if (unknown.length > 0) return `entry ${i} has the unknown key \`${unknown[0]}\``;
+    const { name, backend, schema, frontend = [] } = record;
+    if (typeof name !== "string" || !AREA_NAME.test(name)) return `entry ${i} needs a lowercase name such as platform`;
+    if (areas.some((area) => area.name === name)) return `name the area ${name} twice`;
+    const patterns = (list: unknown, what: string, required: boolean): string[] | string => {
+      if (!Array.isArray(list) || !list.every((item) => typeof item === "string" && item !== "")) {
+        return `entry ${name} needs ${what} as a list of patterns`;
+      }
+      if (required && list.length === 0) return `entry ${name} needs at least one ${what} pattern`;
+      const bad = (list as string[]).find((pattern) => validatePattern(pattern) !== null);
+      return bad === undefined
+        ? [...(list as string[])]
+        : `entry ${name}: the ${what} pattern ${bad} ${validatePattern(bad)}`;
+    };
+    const backendList = patterns(backend, "backend", true);
+    if (typeof backendList === "string") return backendList;
+    const frontendList = patterns(frontend, "frontend", false);
+    if (typeof frontendList === "string") return frontendList;
+    const why = typeof schema === "string" ? literalPath(schema) : "is missing";
+    if (why !== null) return `entry ${name}: schema ${why}`;
+    areas.push({ name, backend: backendList, schema: schema as string, frontend: frontendList });
+  }
+  return areas;
+}
+
+/** Null for one repository-relative file path with no wildcard, or why it is not one. */
+function literalPath(value: string): string | null {
+  if (value.includes("*")) return "must name one file, not a pattern";
+  return validatePattern(value);
+}

package/src/extract.ts

@@ -342,3 +342,153 @@ export function extractImports(path: string, text: string): Extraction {
 
   return { imports, problems };
 }
+
+/** What an Amplify schema declares at its top level (profile §9, AMP009). */
+export const SCHEMA_KINDS = ["model", "enum", "query", "mutation", "subscription", "customType"] as const;
+export type SchemaKind = (typeof SCHEMA_KINDS)[number];
+
+export interface SchemaDeclaration {
+  name: string;
+  /** Null when the value is not a builder call this reader recognizes, such as a variable defined elsewhere. */
+  kind: SchemaKind | null;
+  line: number;
+}
+
+/** A relationship or reference by name inside a schema (AMP010): `belongsTo("X")`, `hasMany`, `hasOne`, `ref`. */
+export interface SchemaReference {
+  target: string;
+  via: "belongsTo" | "hasMany" | "hasOne" | "ref";
+  line: number;
+}
+
+export interface SchemaExtraction {
+  /** False when the file holds no `<builder>.schema({ ... })` call at all. */
+  found: boolean;
+  declarations: SchemaDeclaration[];
+  references: SchemaReference[];
+  problems: ExtractProblem[];
+}
+
+const REFERENCE_CALLS = new Set(["belongsTo", "hasMany", "hasOne", "ref"]);
+const OPENERS = new Set<SyntaxKind>([
+  SyntaxKind.OpenBraceToken,
+  SyntaxKind.OpenParenToken,
+  SyntaxKind.OpenBracketToken,
+]);
+const CLOSERS = new Set<SyntaxKind>([
+  SyntaxKind.CloseBraceToken,
+  SyntaxKind.CloseParenToken,
+  SyntaxKind.CloseBracketToken,
+]);
+
+/**
+ * The top-level names an Amplify Gen 2 schema file declares, and the names its
+ * relationships and references point at, read from TypeScript's tokens as
+ * imports are. Every `<builder>.schema({ ... })` object literal counts: each
+ * key at its top level is a declaration, its kind read from a `<builder>.<kind>(`
+ * value or from a `const Name = <builder>.<kind>(` elsewhere in the file. A
+ * spread, or a value that is neither, is a problem rather than a guess.
+ */
+export function extractSchema(path: string, text: string): SchemaExtraction {
+  const { tokens, problems } = tokenize(path, text);
+  const declarations: SchemaDeclaration[] = [];
+  const references: SchemaReference[] = [];
+  const word = (i: number, value?: string): boolean => {
+    const token = tokens[i];
+    return (
+      token !== undefined && tokenIsIdentifierOrKeyword(token.kind) && (value === undefined || token.text === value)
+    );
+  };
+  const is = (i: number, kind: SyntaxKind): boolean => tokens[i]?.kind === kind;
+  /** `<builder>.<kind>(` starting at i, as the kind, or null. */
+  const builderCall = (i: number): SchemaKind | null => {
+    if (!word(i) || !is(i + 1, SyntaxKind.DotToken) || !word(i + 2) || !is(i + 3, SyntaxKind.OpenParenToken))
+      return null;
+    const kind = tokens[i + 2].text;
+    return (SCHEMA_KINDS as readonly string[]).includes(kind) ? (kind as SchemaKind) : null;
+  };
+  const bound = new Map<string, SchemaKind>();
+  for (let i = 0; i + 3 < tokens.length; i++) {
+    if ((word(i, "const") || word(i, "let")) && word(i + 1) && is(i + 2, SyntaxKind.EqualsToken)) {
+      const kind = builderCall(i + 3);
+      if (kind !== null) bound.set(tokens[i + 1].text, kind);
+    }
+  }
+
+  let found = false;
+  for (let i = 0; i + 4 < tokens.length; i++) {
+    if (!(word(i) && is(i + 1, SyntaxKind.DotToken) && word(i + 2, "schema"))) continue;
+    if (!(is(i + 3, SyntaxKind.OpenParenToken) && is(i + 4, SyntaxKind.OpenBraceToken))) continue;
+    found = true;
+    let depth = 0;
+    let k = i + 5;
+    for (; k < tokens.length; k++) {
+      const token = tokens[k];
+      if (CLOSERS.has(token.kind)) {
+        if (depth === 0) break;
+        depth--;
+        continue;
+      }
+      if (OPENERS.has(token.kind)) {
+        depth++;
+        continue;
+      }
+      if (
+        word(k) &&
+        REFERENCE_CALLS.has(token.text) &&
+        is(k - 1, SyntaxKind.DotToken) &&
+        is(k + 1, SyntaxKind.OpenParenToken)
+      ) {
+        if (is(k + 2, SyntaxKind.StringLiteral)) {
+          references.push({ target: tokens[k + 2].value, via: token.text as SchemaReference["via"], line: token.line });
+        }
+        continue;
+      }
+      if (depth !== 0) continue;
+      const startsMember = is(k - 1, SyntaxKind.OpenBraceToken) || is(k - 1, SyntaxKind.CommaToken);
+      if (!startsMember) continue;
+      if (is(k, SyntaxKind.DotDotDotToken)) {
+        problems.push({
+          line: token.line,
+          message: "the schema spreads another object in, and its members were not read",
+        });
+        continue;
+      }
+      const isKey = word(k) || is(k, SyntaxKind.StringLiteral);
+      if (!isKey) continue;
+      const name = is(k, SyntaxKind.StringLiteral) ? token.value : token.text;
+      if (is(k + 1, SyntaxKind.ColonToken)) {
+        const direct = builderCall(k + 2);
+        const named = word(k + 2) && !is(k + 3, SyntaxKind.DotToken) ? (bound.get(tokens[k + 2].text) ?? null) : null;
+        const kind = direct ?? named;
+        if (kind === null) {
+          problems.push({ line: token.line, message: `the kind of the schema member ${name} could not be read` });
+        }
+        declarations.push({ name, kind, line: token.line });
+      } else if (is(k + 1, SyntaxKind.CommaToken) || is(k + 1, SyntaxKind.CloseBraceToken)) {
+        const kind = bound.get(name) ?? null;
+        if (kind === null) {
+          problems.push({ line: token.line, message: `the kind of the schema member ${name} could not be read` });
+        }
+        declarations.push({ name, kind, line: token.line });
+      }
+    }
+    i = k;
+  }
+  return { found, declarations, references, problems };
+}
+
+/** 1-based lines where `name` is called, as `name(` or `name<T>(`, not as a method and not where it is declared. */
+export function findCalls(path: string, text: string, name: string): number[] {
+  const { tokens } = tokenize(path, text);
+  const lines: number[] = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!tokenIsIdentifierOrKeyword(token.kind) || token.text !== name) continue;
+    const before = tokens[i - 1];
+    if (before !== undefined && (before.kind === SyntaxKind.DotToken || before.text === "function")) continue;
+    const next = tokens[i + 1]?.kind;
+    if (next === SyntaxKind.OpenParenToken || next === SyntaxKind.LessThanToken) lines.push(token.line);
+  }
+  return lines;
+}

package/src/index.ts

@@ -4,6 +4,7 @@
  * (spec/profile-typescript-amplify-gen2-0.1.md). `checkArchitecture` is the
  * whole check; the rest is exported for reports, tools and tests.
  */
+export { AREA_REVIEW_REQUIRED, areaOf, backendAreaOf, checkAreas, isAreaSchema } from "./areas.ts";
 export {
   applyBaseline,
   type BaselineEntry,
@@ -25,8 +26,10 @@ export {
 export { checkClaims } from "./claims.ts";
 export {
   ARCHITECTURE_CONFIG_PATH,
+  type AreaConfig,
   type ArchitectureConfig,
   DEFAULT_ARCHITECTURE_CONFIG,
+  MAX_AREAS,
   readArchitectureConfig,
   resolveConfig,
 } from "./config.ts";
@@ -40,7 +43,18 @@ export {
   readExceptionRecord,
   readExceptions,
 } from "./exceptions.ts";
-export { type Extraction, extractImports, type RawImport } from "./extract.ts";
+export {
+  type Extraction,
+  extractImports,
+  extractSchema,
+  findCalls,
+  type RawImport,
+  SCHEMA_KINDS,
+  type SchemaDeclaration,
+  type SchemaExtraction,
+  type SchemaKind,
+  type SchemaReference,
+} from "./extract.ts";
 export type { Finding, SubjectEdge } from "./finding.ts";
 export { buildImportGraph, type ImportEdge, type ImportGraph, type UnresolvedImport } from "./imports.ts";
 export { inSeam, isPure, layerAllows, layerOf, purePatterns, seamPatterns } from "./layers.ts";

package/src/regions.ts

@@ -171,7 +171,9 @@ export function buildModel(
       validatePattern(resource.path) === null ? production.filter((file) => matchPattern(resource.path, file)) : [],
   }));
 
-  const underBackend = (path: string) => matchAny(config.backendRoots, path);
+  // An area's backend is backend for AMP001, AMP002 and AMP004 as the unified one is (profile §9).
+  const backendPatterns = [...config.backendRoots, ...config.areas.flatMap((area) => area.backend)];
+  const underBackend = (path: string) => matchAny(backendPatterns, path);
   const regions = new Map<string, Region>();
   const regionOf = (path: string): Region => {
     const cached = regions.get(path);