fix(#209): demote a nested INNER view join under a LEFT ancestor (drop-row bug)

Follow-up to 17c26b3. The join type was derived per-hop with no ancestor
propagation, but synthesized joins render flat + left-associative — so a required
belongs-to hop BELOW a LEFT hop emitted e.g.
  FROM orders o
  LEFT OUTER JOIN customers c ON c.id = o.customer_id
  INNER JOIN countries c0 ON c0.id = c.country_id
For an order with no customer, the LEFT yields NULL customer columns, then the
INNER's ON (c0.id = c.country_id) references the NULLed c.country_id → no match →
the base ORDER ROW IS DROPPED, where pre-#209 it survived with NULLs. Same hazard
for a has-many hop followed by a required belongs-to (an aggregate view would drop
zero-children base rows it should COALESCE). The single-hop tests didn't cover it.

Fix: an INNER hop survives only when its ENTIRE ancestor chain is INNER; otherwise
demote to LEFT. Lossless — under a LEFT ancestor, LEFT is the correct type, so
nothing is given up. Single-hop joins are unchanged (empty ancestor chain → the
`every` guard is vacuously true), so the canonical schema.postgres.sql stays
byte-identical.

Verified: new nested-chain regression test (nullable→required chain demotes to LEFT;
all-required chain stays INNER end to end); codegen-ts 957 pass; typecheck exit 0;
canonical schema drift gate byte-identical.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NGQ7oSuNcjhsMHWwZzhBwr

Author: dmealing

server/typescript/packages/codegen-ts/src/projection/extract-view-spec.ts

@@ -525,10 +525,15 @@ function buildJoinTree(
         // FK, or ANY has-many hop (FK on the child — a base row may have zero
         // children), stays LEFT OUTER so no base row is dropped.
         const fkFieldObj = (fkHolder as MetaObject).findField(fkField);
+        const selfInner =
+          referenceHolder === "source" && fkFieldObj !== undefined && isRequired(fkFieldObj);
+        // Nested-chain safety: joins render flat + left-associative, so an INNER hop
+        // BELOW any LEFT ancestor drops the base row (its ON references a column the
+        // LEFT ancestor NULLed). An INNER only survives when the ENTIRE ancestor chain
+        // is INNER; otherwise demote to LEFT (lossless — under a LEFT ancestor, LEFT is
+        // the correct type). `path` holds this chain's ancestor hops accumulated so far.
         const joinType: "inner" | "left" =
-          referenceHolder === "source" && fkFieldObj !== undefined && isRequired(fkFieldObj)
-            ? "inner"
-            : "left";
+          selfInner && path.every((prior) => prior.joinType === "inner") ? "inner" : "left";
 
         path.push({
           entity: currentObj,

server/typescript/packages/codegen-ts/test/projection/join-type-derivation.test.ts

@@ -60,6 +60,63 @@ describe("#209 — belongs-to join type derived from FK optionality", () => {
   });
 });
 
+// A required belongs-to hop must NOT be INNER when an ancestor hop in the same
+// chain is LEFT: joins render flat + left-associative, so an INNER whose ON
+// references a NULLed ancestor column drops the base row (where a LEFT keeps it
+// with NULLs). INNER only survives when the ENTIRE ancestor chain is INNER.
+describe("#209 — nested join chain: an INNER hop under a LEFT ancestor demotes to LEFT", () => {
+  // Order --(customerId)--> Customer --(countryId, required)--> Country.
+  const nestedModel = (orderCustomerIdRequired: boolean) => [
+    { "object.entity": { name: "Country", children: [
+      { "source.rdb": { "@table": "countries" } },
+      { "field.long": { name: "id" } },
+      { "field.string": { name: "name" } },
+      { "identity.primary": { name: "pk", "@fields": "id" } },
+    ] } },
+    { "object.entity": { name: "Customer", children: [
+      { "source.rdb": { "@table": "customers" } },
+      { "field.long": { name: "id" } },
+      { "field.long": { name: "countryId", "@required": true } },
+      { "identity.primary": { name: "pk", "@fields": "id" } },
+      { "identity.reference": { name: "ref_country", "@fields": "countryId", "@references": "Country" } },
+      { "relationship.association": { name: "country", "@objectRef": "Country", "@cardinality": "one" } },
+    ] } },
+    { "object.entity": { name: "Order", children: [
+      { "source.rdb": { "@table": "orders" } },
+      { "field.long": { name: "id" } },
+      { "field.long": { name: "customerId", ...(orderCustomerIdRequired ? { "@required": true } : {}) } },
+      { "identity.primary": { name: "pk", "@fields": "id" } },
+      { "identity.reference": { name: "ref_customer", "@fields": "customerId", "@references": "Customer" } },
+      { "relationship.association": { name: "customer", "@objectRef": "Customer", "@cardinality": "one" } },
+    ] } },
+    { "object.projection": { name: "OrderView", children: [
+      { "source.rdb": { "@kind": "view", "@table": "v_order" } },
+      { "field.long": { name: "id", extends: "Order.id" } },
+      { "field.string": { name: "countryName", children: [{ "origin.passthrough": { "@from": "Country.name", "@via": "Order.customer.country" } }] } },
+      { "identity.primary": { name: "pk", extends: "Order.pk" } },
+    ] } },
+  ];
+
+  test("nullable ancestor (Order→Customer LEFT) forces the required Customer→Country hop to LEFT", async () => {
+    const root = await load(nestedModel(false));
+    const [v] = buildProjectionViews(root, { dialect: "postgres", columnNamingStrategy: "snake_case" });
+    // Both joins LEFT OUTER — an order with no customer must survive with NULLs, not
+    // be dropped by an INNER JOIN countries whose ON references a NULLed customer col.
+    expect(v!.sql).toContain("LEFT OUTER JOIN customers");
+    expect(v!.sql).toContain("LEFT OUTER JOIN countries");
+    expect(v!.sql).not.toContain("INNER JOIN");
+  });
+
+  test("all-required chain stays INNER end to end", async () => {
+    const root = await load(nestedModel(true));
+    const [v] = buildProjectionViews(root, { dialect: "postgres", columnNamingStrategy: "snake_case" });
+    // Order→Customer required + Customer→Country required → both INNER (no base row lost).
+    expect(v!.sql).toContain("INNER JOIN customers");
+    expect(v!.sql).toContain("INNER JOIN countries");
+    expect(v!.sql).not.toContain("LEFT OUTER JOIN");
+  });
+});
+
 describe("#209 — has-many (inverse-FK) join stays LEFT OUTER", () => {
   // Program 1→many Week (FK on Week). Even though Week.programId is required, the
   // Program→weeks join must stay LEFT OUTER: a program with zero weeks must survive