fix: Scalar reversion

Author: ntucker

docs/rest/api/Scalar.md

@@ -183,11 +183,13 @@ method only supplies the `entityPk` piece.
 
 By default `entityPk()`:
 
-- returns the surrounding map `key` when present (authoritative for
-  `Values(Scalar)`, where the cell may not carry the pk fields), then
+- returns the surrounding map `key` when it authoritatively addresses the
+  cell — i.e. `parent[key] === input`, as in `Values(Scalar)` where the map
+  key is the entity pk and the cell may not carry the pk fields — then
 - delegates to the bound `Entity.pk(input, parent, key, args)` static so
-  `[Scalar]` and `Collection([Scalar])` array responses — including custom or
-  composite Entity pks — work out of the box.
+  `[Scalar]` and `Collection([Scalar])` array responses — including arrays
+  nested under a parent object schema like `{ stock: [Scalar] }`, and
+  custom or composite Entity pks — work out of the box.
 
 Override `entityPk()` in a subclass only when the response uses an id field the
 `Entity.pk()` does not read:

packages/endpoint/src/schemas/Scalar.ts

@@ -68,8 +68,13 @@ export default class Scalar implements Mergeable {
   /**
    * The bound Entity's pk for a standalone scalar cell.
    *
-   * Prefers the surrounding map key (authoritative for `Values(Scalar)`),
-   * then falls back to the bound `Entity.pk(...)`.
+   * Prefers the surrounding map key (authoritative for `Values(Scalar)`,
+   * where `parent[key] === input`), then falls back to the bound
+   * `Entity.pk(...)`. Other shapes — `[Scalar]` top-level (where `key` is
+   * `undefined`) or nested under a plain object schema like
+   * `{ stock: [Scalar] }` (where `Array.normalize` forwards the parent
+   * object's field name as `key`, but `parent[key]` is the enclosing array,
+   * not the item) — must derive pk from the item itself.
    *
    * @see https://dataclient.io/rest/api/Scalar#entityPk
    * @param [input] the scalar cell input
@@ -83,7 +88,14 @@ export default class Scalar implements Mergeable {
     key: string | undefined,
     args: readonly any[],
   ): string | number | undefined {
-    if (key !== undefined) return key;
+    // Only trust `key` when the enclosing container literally maps it to this
+    // cell — i.e. `Values(Scalar)`, where the map key is the entity pk by
+    // construction. `Array.normalize` forwards the *outer* object's field name
+    // as `key` for every element (see Array.ts), so `key !== undefined` alone
+    // would collapse every item onto the same compound pk.
+    if (key !== undefined && parent != null && parent[key] === input) {
+      return key;
+    }
     return this.entity?.pk?.(input, parent, key, args);
   }
 

packages/endpoint/src/schemas/__tests__/Scalar.test.ts

@@ -437,6 +437,82 @@ describe('Scalar', () => {
     });
   });
 
+  describe('nested array-of-records under a plain object schema (regression)', () => {
+    // `[Scalar]` (or `Collection([Scalar])`) nested inside a plain object schema
+    // — `{ stock: [Scalar] }` — must derive each item's entity pk from the item
+    // itself, not from the parent's field name. Previously `Array.normalize`
+    // forwarded its enclosing field name (e.g. `'stock'`) as `key` to each
+    // child; `Scalar.entityPk` returned that key (since it was non-undefined),
+    // collapsing every cell onto compound pk `Company|stock|<lens>` and
+    // silently corrupting the data.
+    it('keys cells by item id, not by parent field name', () => {
+      const objSchema = { stock: [PortfolioScalar] };
+      const state = normalize(
+        objSchema,
+        {
+          stock: [
+            { id: '1', pct_equity: 0.7, shares: 555 },
+            { id: '2', pct_equity: 0.1, shares: 999 },
+          ],
+        },
+        [{ portfolio: 'portfolioB' }],
+      );
+
+      expect(state.result).toEqual({
+        stock: ['Company|1|portfolioB', 'Company|2|portfolioB'],
+      });
+      expect(state.entities['Scalar(portfolio)']).toMatchObject({
+        'Company|1|portfolioB': {
+          id: '1',
+          pct_equity: 0.7,
+          shares: 555,
+        },
+        'Company|2|portfolioB': {
+          id: '2',
+          pct_equity: 0.1,
+          shares: 999,
+        },
+      });
+      // Must not key any cell by the parent field name.
+      expect(
+        Object.keys(state.entities['Scalar(portfolio)'] ?? {}).some(k =>
+          k.includes('|stock|'),
+        ),
+      ).toBe(false);
+    });
+
+    it('keys cells by item id when nested as Collection([Scalar])', () => {
+      const columns = new Collection([PortfolioScalar], {
+        nestKey: (parent: any, key: string) => ({ portfolio: key }),
+      });
+      const objSchema = { stock: columns };
+      const state = normalize(
+        objSchema,
+        {
+          stock: [
+            { id: '1', pct_equity: 0.7, shares: 555 },
+            { id: '2', pct_equity: 0.1, shares: 999 },
+          ],
+        },
+        [{ portfolio: 'portfolioB' }],
+      );
+
+      // Cells are keyed by item id, not by the parent field name.
+      expect(state.entities['Scalar(portfolio)']).toMatchObject({
+        'Company|1|portfolioB': {
+          id: '1',
+          pct_equity: 0.7,
+          shares: 555,
+        },
+        'Company|2|portfolioB': {
+          id: '2',
+          pct_equity: 0.1,
+          shares: 999,
+        },
+      });
+    });
+  });
+
   describe('composite primary keys containing "|"', () => {
     class CompositeCompany extends IDEntity {
       type = '';