@aerokit/sdk 14.2.0 → 14.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerokit/sdk",
-  "version": "14.2.0",
+  "version": "14.3.0",
   "description": "Unified TypeScript SDK for modern cloud platforms.",
   "scripts": {
     "clean": "rm -rf dist",

package/test/flows/my.js

@@ -3,6 +3,65 @@ import { expect, test } from '../fixtures.js';
 import { resolveRelationSamples } from '../form.js';
 import { sampleRecord } from '../sample-values.js';
 
+// Wave 2 (UI parity): the personal PAGE renders what the wire serves. Driven by the same
+// own-row lifecycle as the wire test (created through the scoped controller, removed in the
+// finally); skips without an identity mapping, exactly like the wire flow.
+// - layout 'list': every relation column of the own row shows its referenced LABEL - the
+//   raw-FK-id regression class the personal templates fixed;
+// - layout 'calendar'/'slots': the personal route renders the calendar / slot picker, never a
+//   plain form+list downgrade;
+// - layout 'document-chat': the composer accepts a message and the bubble renders (the my
+//   document chat parity class). A plain 'document' asserts the page serves.
+function myUiTest(manifest, entity, mine, buildContext, idProperty) {
+  test(`${entity.name}: the My page renders the own record with resolved labels (UI parity)`, async ({ api, page }) => {
+    const { payload, samples } = await buildContext(api);
+    const createdResponse = await api.post(manifest.restBase + mine.api, { data: payload });
+    test.skip(
+      !createdResponse.ok(),
+      `personal create returned ${createdResponse.status()} - the test user has no identity mapping; ` +
+        `seed the dev identity row (an owner-target record whose identity field equals the login user)`
+    );
+    const created = JSON.parse(await createdResponse.text());
+    const id = created?.[idProperty];
+    const client = makeApi(api, manifest);
+    try {
+      const layout = entity.personal.layout ?? 'list';
+      if (layout === 'calendar' || layout === 'slots') {
+        await page.goto(manifest.standaloneShell + entity.personal.route);
+        await expect(page.locator('[x-h-calendar], [x-h-slot-picker]').first()).toBeVisible();
+        return;
+      }
+      if (layout === 'document-chat' || layout === 'document') {
+        await page.goto(manifest.standaloneShell + entity.personal.route + '/' + id + '/edit');
+        if (layout === 'document-chat') {
+          const message = `UI parity probe ${id}`;
+          const composer = page.getByRole('textbox', { name: /write a message/i }).first();
+          await composer.fill(message);
+          await page.getByRole('button', { name: /send/i }).first().click();
+          await expect(page.getByText(message).first(), 'the sent message must render as a bubble').toBeVisible();
+        } else {
+          await expect(page.locator('[x-h-toolbar-title]').first()).toBeVisible();
+        }
+        return;
+      }
+      // list: the own rows are the only rows - every asserted relation column of the created
+      // row must surface its referenced label somewhere in the table body
+      await page.goto(manifest.standaloneShell + entity.personal.route);
+      await expect(page.locator('tbody tr:visible').first()).toBeVisible();
+      const fkColumns = new Set(entity.personal.fkColumns ?? []);
+      for (const sample of samples) {
+        if (!fkColumns.has(sample.relation.name) || sample.label == null) continue;
+        await expect(
+          page.locator('tbody').getByText(String(sample.label)).first(),
+          `${sample.relation.name} must render its referenced label ("${sample.label}"), not the raw id ${sample.id}`
+        ).toBeVisible();
+      }
+    } finally {
+      await client.remove(mine, id);
+    }
+  });
+}
+
 // The personal (my) surface WIRE contract, driven when the manifest marks an entity `personal`:
 // the scoped <Entity>MyController filters reads to the identity-mapped user, forces the owner FK
 // server-side on create (whatever the client sends is ignored), strips every `sensitive` field
@@ -12,9 +71,8 @@ import { sampleRecord } from '../sample-values.js';
 // Prerequisite: the DEV IDENTITY mapping - a row of the owner relation's target whose identity
 // field equals the test user (e.g. an Employee with email 'admin'). Without it the personal
 // surface is EMPTY by design (never an error), so the flow SKIPS with a pointer instead of
-// failing. The personal UI parity assertions (resolved labels, chat layout, calendar views on
-// the My shell) are deliberately NOT asserted yet - they track the platform's personal-template
-// parity fixes; this flow pins down the wire contract those pages consume.
+// failing. Wave 2 (myUiTest below) walks the personal PAGE over the same own-row lifecycle:
+// resolved relation labels on the list, calendar/slots rendering, the chat composer round-trip.
 export function myFlow(manifest, entity, opts = {}) {
   const cfg = opts.extend?.entities?.[entity.name] ?? {};
   if (!entity.personal || new Set(cfg.skip ?? []).has('my')) return;
@@ -22,14 +80,19 @@ export function myFlow(manifest, entity, opts = {}) {
   // the same entity through the scoped controller
   const mine = { ...entity, api: entity.personal.api };
 
-  async function buildPayload(api) {
+  async function buildContext(api) {
     const payload = sampleRecord(entity);
-    for (const sample of await resolveRelationSamples(api, manifest, entity)) {
+    const samples = await resolveRelationSamples(api, manifest, entity);
+    for (const sample of samples) {
       payload[sample.relation.name] = sample.id;
     }
     // the owner FK is server-forced on the personal surface; sending a value must be pointless
     delete payload[entity.personal.owner];
-    return payload;
+    return { payload, samples };
+  }
+
+  async function buildPayload(api) {
+    return (await buildContext(api)).payload;
   }
 
   test(`${entity.name}: personal (my) surface scopes rows, forces the owner and strips sensitive fields`, async ({ api }) => {
@@ -76,4 +139,10 @@ export function myFlow(manifest, entity, opts = {}) {
     const gone = await api.get(manifest.restBase + mine.api + '/' + id);
     expect(gone.status()).toBe(404);
   });
+
+  // wave 2: the UI-parity walk over the same personal surface (older manifests without the
+  // route/layout metadata regenerate to get it - skip quietly until then)
+  if (entity.personal.route) {
+    myUiTest(manifest, entity, mine, buildContext, idProperty);
+  }
 }