@ogygie/core 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/core",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Ogygie framework core: manifest/spec/error schemas, generic tenancy and gate tooling. Ships TypeScript sources — Ogygie products run tsx/vitest by construction (D1).",
   "license": "MIT",
   "type": "module",

package/src/impact.test.ts

@@ -217,6 +217,31 @@ describe("B5 — les quatre findings, chacun avec sa mutation", () => {
     expect(report.tableReadersOutsideOwner[0]?.feature).toBe("invoices");
   });
 
+  it("MUTATION : le nom d'une table dans une feature FRONT ne compte pas — elle ne parle pas à la base", async () => {
+    // Found on a real repo: widening the scan to other apps turned every
+    // `queryKey: ["orders", "list"]` into a boundary violation — fifteen in one
+    // report. A front feature holds no database client; the string is a query
+    // key or a route, and a rule applied where its premise does not hold makes
+    // noise, which is how a report stops being read.
+    const files = {
+      ...FILES,
+      "apps/web/src/features/orders-screen/queries.ts":
+        'import { ListOrdersOutputSchema } from "@acme/api/features/orders/schemas";\nexport const key = ["orders", "list"];\nexport const s = ListOrdersOutputSchema;\n',
+    };
+    const report = await analyze(files);
+    expect(codesOf(report)).not.toContain("TABLE_REFERENCED_OUTSIDE_OWNER");
+    // …et la dérogation se DIT, elle ne s'applique pas en silence (D12).
+    expect(report.scope.outOfReach.join(" ")).toContain("front/gateway");
+  });
+
+  it("une feature d'API touchant la table d'une autre reste signalée — la règle garde sa portée", async () => {
+    const files = {
+      ...FILES,
+      "apps/api/src/features/invoices/repository.ts": 'export const t = "orders";\n',
+    };
+    expect(codesOf(await analyze(files))).toContain("TABLE_REFERENCED_OUTSIDE_OWNER");
+  });
+
   it("MUTATION : la même table dans un TEST ne compte pas — c'est le patron de fixture", async () => {
     const files = {
       ...FILES,

package/src/impact.ts

@@ -237,6 +237,14 @@ async function buildReport(
       // feature's table as a fixture is the canonical bench pattern, and
       // flagging it would make every run red.
       if (isTest(file.path)) continue;
+      // So is anything that cannot touch a database. A front feature consumes
+      // contracts and a gateway relays — neither holds Drizzle — so the string
+      // a table name in their code is a query key or a route, not a table. Found
+      // on a real repo: widening the scan to other apps turned every
+      // `queryKey: ["orders", "list"]` into a boundary violation (15 of them in
+      // one report). A rule applied where its premise does not hold produces
+      // noise, and noise is how a report stops being read.
+      if (entry.appType === "front" || entry.appType === "gateway") continue;
       for (const table of ownedTables) {
         if (!content.includes(`"${table}"`)) continue;
         tableReadersOutsideOwner.push({ table, feature: entry.name, file: filePath });
@@ -278,7 +286,7 @@ async function buildReport(
     scope: {
       scannedFolders: scannedFolders.sort(),
       coveredKinds: [...new Set(entries.map((entry) => entry.kind))],
-      outOfReach: [...outOfReach, ...outOfReachOf(target)],
+      outOfReach: [...outOfReach, ...outOfReachOf(target, entries)],
     },
   };
   return ImpactReportSchema.parse(report);
@@ -296,11 +304,21 @@ function tablesOf(manifest: OgygieManifest, featureName: string): string[] {
 }
 
 /** What no analysis of this repo can reach, named rather than implied (D12). */
-function outOfReachOf(target: MapEntry): string[] {
+function outOfReachOf(target: MapEntry, entries: readonly MapEntry[]): string[] {
   const limits = [
     "code that no manifest entry declares — the map is the only chart",
     "anything outside this repo: no network, no npm registry",
   ];
+  // Said rather than silently applied: a table rule that skips some folders
+  // has to name them, or its silence reads as "nothing found there".
+  const spared = entries.filter(
+    (entry) => entry.appType === "front" || entry.appType === "gateway",
+  );
+  if (spared.length > 0 && target.kind === "feature") {
+    limits.push(
+      `table ownership was NOT checked in ${spared.length} front/gateway entr${spared.length === 1 ? "y" : "ies"} — that code holds no database client, so a table name there is a query key or a route`,
+    );
+  }
   if (target.kind === "framework-package" || target.kind === "package") {
     limits.unshift(
       `consumers of "${target.name}" OUTSIDE this repo — it is a package, and a published package is imported by projects this analysis cannot see`,

package/src/manifest-owners.test.ts

@@ -234,7 +234,15 @@ describe("declaredEntries — tout ce que la carte déclare, à un seul endroit"
       }),
     );
     expect(entries).toEqual([
-      { kind: "feature", name: "orders", status: "delivered", folder: null, specId: "orders" },
+      {
+        kind: "feature",
+        name: "orders",
+        status: "delivered",
+        folder: null,
+        specId: "orders",
+        // No app carries it, so nothing can be said of what it may touch.
+        appType: null,
+      },
     ]);
   });
 

package/src/manifest-owners.ts

@@ -56,6 +56,16 @@ export interface SpecOwner {
 export interface MapEntry extends SpecOwner {
   /** The spec this entry owns, or null when it owns none. */
   specId: string | null;
+  /**
+   * Type of the app carrying this entry — null for a package, which lives
+   * under no app.
+   *
+   * It answers a question no tool can guess from a folder: WHAT this code is
+   * allowed to touch. A front feature never speaks to the database (it
+   * consumes contracts), a gateway only relays — so a rule about database
+   * tables has no business examining either.
+   */
+  appType: "api" | "front" | "gateway" | null;
 }
 
 /**
@@ -90,6 +100,7 @@ export function declaredEntries(manifest: OgygieManifest): MapEntry[] {
       status: feature.status,
       folder: owningApp === undefined ? null : `${owningApp.path}/${feature.folder}`,
       specId: feature.name,
+      appType: owningApp?.type ?? null,
     });
   }
 
@@ -100,6 +111,7 @@ export function declaredEntries(manifest: OgygieManifest): MapEntry[] {
       status: productPackage.status,
       folder: productPackage.path,
       specId: productPackage.name,
+      appType: null,
     });
   }
 
@@ -111,6 +123,7 @@ export function declaredEntries(manifest: OgygieManifest): MapEntry[] {
       folder: frameworkPackage.path,
       // A published npm name is not a spec id: the link is DECLARED.
       specId: frameworkPackage.spec === null ? null : specIdOf(frameworkPackage.spec),
+      appType: null,
     });
   }