@aerokit/sdk 14.67.0 → 14.69.0

package/package.json

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

package/test/flows/crud.js

@@ -1,7 +1,7 @@
 import { expect, test } from '../fixtures.js';
 import { makeApi } from '../api.js';
 import { fillField, fillForm, resolveRelationSamples } from '../form.js';
-import { handleField, sampleRecord } from '../sample-values.js';
+import { freshUniques, handleField, sampleRecord } from '../sample-values.js';
 
 // Server-side row lookup via the toolbar "Search <Entity>..." box - present on every list
 // layout (manage-list, master-detail, document) and searching the string columns server-side.
@@ -44,7 +44,7 @@ export function crudFlow(manifest, entity, opts = {}) {
   if (!handleField(entity)) return;
 
   test(`${entity.name}: create, edit and delete through the UI`, async ({ page, api }) => {
-    const record = sampleRecord(entity);
+    const record = await freshUniques(makeApi(api, manifest), entity, sampleRecord(entity));
     const handle = handleField(entity);
     const relationSamples = await resolveRelationSamples(api, manifest, entity);
 

package/test/flows/multilingual.js

@@ -1,6 +1,11 @@
 import { expect, test } from '../fixtures.js';
 import { listCrumb } from './list.js';
 
+const LANGUAGE_KEY = 'codbex.harmonia.language';
+// A reload in another language is three round trips on a cold instance - the page, the list's
+// data GET and the translation overlay behind it - so the 5 s default flaked on slower runners.
+const OVERLAY_TIMEOUT = 15_000;
+
 // The read-time translation overlay: switch the shared language key (what the Region &
 // Language setting writes), reload, and a known seed row shows its translated name.
 // Needs a concrete sample in the manifest: { language, base, translated }.
@@ -11,11 +16,45 @@ export function multilingualFlow(manifest, entity) {
   test(`${entity.name}: ${sample.language} translation overlays on read`, async ({ page }) => {
     await page.goto(manifest.standaloneShell + entity.route);
     await expect(listCrumb(page, entity)).toBeVisible();
-    await page.evaluate((lang) => localStorage.setItem('codbex.harmonia.language', lang), sample.language);
-    await page.reload();
-    await expect(page.locator('tbody tr', { hasText: sample.translated }).first()).toBeVisible();
-    await page.evaluate(() => localStorage.setItem('codbex.harmonia.language', 'en'));
-    await page.reload();
-    await expect(page.locator('tbody tr', { hasText: sample.base }).first()).toBeVisible();
+    const translatedRead = await reloadIn(page, manifest, entity, sample.language);
+    await expectRowShowing(page, sample.translated, translatedRead);
+    const baseRead = await reloadIn(page, manifest, entity, 'en');
+    await expectRowShowing(page, sample.base, baseRead);
   });
 }
+
+// Set the language key and reload, waiting for the list's own data GET (the paged getAll on the
+// entity's controller) so the assertion starts once the rows are on their way, and answering what
+// that read asked for and got back - which is what tells a slow render from a missing translation.
+async function reloadIn(page, manifest, entity, language) {
+  await page.evaluate(([key, lang]) => localStorage.setItem(key, lang), [LANGUAGE_KEY, language]);
+  const controllerPath = manifest.restBase + entity.api;
+  const listRead = page.waitForResponse(
+    (response) => response.request().method() === 'GET' && new URL(response.url()).pathname === controllerPath,
+    { timeout: OVERLAY_TIMEOUT },
+  );
+  await page.reload();
+  const response = await listRead;
+  return {
+    language,
+    acceptLanguage: await response.request().headerValue('accept-language'),
+    status: response.status(),
+    body: await response.text(),
+  };
+}
+
+async function expectRowShowing(page, text, read) {
+  const rows = page.locator('tbody tr');
+  try {
+    await expect(rows.filter({ hasText: text }).first()).toBeVisible({ timeout: OVERLAY_TIMEOUT });
+  } catch (error) {
+    const firstRow = (await rows.allInnerTexts())[0]?.replace(/\s+/g, ' ').trim();
+    throw new Error(
+      `no list row shows '${text}' after reloading in '${read.language}': the list GET sent Accept-Language ` +
+        `${read.acceptLanguage ?? '(none)'} and answered ${read.status}, ` +
+        `${read.body.includes(text) ? 'WITH' : 'WITHOUT'} '${text}' in its body; the table's first row reads ` +
+        `${firstRow ? `'${firstRow}'` : '(no rows)'}`,
+      { cause: error },
+    );
+  }
+}

package/test/flows/my.js

@@ -1,7 +1,7 @@
 import { makeApi } from '../api.js';
 import { expect, test } from '../fixtures.js';
 import { resolveRelationSamples } from '../form.js';
-import { sampleRecord } from '../sample-values.js';
+import { freshUniques, 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
@@ -88,6 +88,7 @@ export function myFlow(manifest, entity, opts = {}) {
     }
     // the owner FK is server-forced on the personal surface; sending a value must be pointless
     delete payload[entity.personal.owner];
+    await freshUniques(makeApi(api, manifest), entity, payload);
     return { payload, samples };
   }
 

package/test/flows/rest.js

@@ -1,7 +1,7 @@
 import { makeApi } from '../api.js';
 import { expect, test } from '../fixtures.js';
 import { resolveRelationSamples } from '../form.js';
-import { handleField, sampleRecord } from '../sample-values.js';
+import { freshUniques, handleField, sampleRecord } from '../sample-values.js';
 
 // The same contract over the generated REST controllers, no browser: isolates backend
 // failures from UI failures and verifies the manifest's field names bind.
@@ -19,6 +19,7 @@ export function restFlow(manifest, entity, opts = {}) {
     for (const sample of await resolveRelationSamples(api, manifest, entity)) {
       payload[sample.relation.name] = sample.id;
     }
+    await freshUniques(client, entity, payload);
 
     const created = await client.create(entity, payload);
     const id = created?.[idProperty];

package/test/sample-values.js

@@ -11,6 +11,7 @@ function rand(chars, n) {
 // cleanup marker and the searchable handle); short strings always contain a digit so
 // they can never collide with letter-only nomenclature seeds (ISO codes etc.).
 export function sampleValue(field) {
+  if (field.unique && field.type !== 'string') return uniqueValue(field);
   switch (field.type) {
     case 'string': {
       const len = field.length ?? 64;
@@ -40,8 +41,10 @@ export function sampleValue(field) {
 // A `pattern:` field (an authored regex, or the address regex behind `format: email`) is rejected
 // by the generated controller with 400 unless the value has the declared shape, so the marker value
 // above has to be traded for one that matches: the candidates are tried in order and the first that
-// both matches and fits the declared length wins. A pattern nothing here matches keeps the plain
-// marker - the controller's own 400 then names the field and the pattern, which is the message the
+// both matches and fits the declared length wins. When nothing here matches (an IBAN-shaped regex
+// mixing character classes by position), an optional field is left unset - the record is valid
+// without it, and no flow needs it filled (dirigible #7525) - while a required one keeps the plain
+// marker: the controller's own 400 then names the field and the pattern, which is the message the
 // module author needs, and a silent near-miss would not.
 function shaped(field, value) {
   let regex;
@@ -59,7 +62,60 @@ function shaped(field, value) {
     token, // letters and digits, no separator
     rand(DIGITS, 10), // a numeric code
   ];
-  return candidates.find((candidate) => candidate.length <= (field.length ?? 255) && regex.test(candidate)) ?? value;
+  const match = candidates.find((candidate) => candidate.length <= (field.length ?? 255) && regex.test(candidate));
+  return match ?? (field.required ? value : undefined);
+}
+
+// A `unique:` field refuses a second row carrying its value with 409 - the module's guard doing its
+// job. The per-type constants above are the one value certain to collide: with a seeded row, with
+// the row a parallel flow of the same run is creating, or with one an earlier failed run left
+// behind (dirigible #7530). So a unique field draws a fresh value per record, away from the range
+// an author seeds (a year, a small code): an integer in the hundred-thousands, a date in the 22nd
+// century. Strings need none of this - the marker above is already random.
+function uniqueValue(field) {
+  const n = 100000 + Math.floor(Math.random() * 900000);
+  switch (field.type) {
+    case 'integer':
+    case 'bigint':
+      return n;
+    case 'decimal':
+    case 'double':
+      return n + 0.25;
+    case 'date':
+    case 'timestamp':
+    case 'datetime': {
+      const at = new Date(Date.UTC(2100, 0, 1) + (n % 36500) * 86400000);
+      return field.type === 'date' ? at.toISOString().slice(0, 10) : at.toISOString().replace(/\.\d{3}Z$/, 'Z');
+    }
+    default:
+      return sampleValue({ ...field, unique: false });
+  }
+}
+
+// A drawn value is unlikely to collide, not certain not to - probe the live rows for each unique
+// field of the record through the controller's filtered read and redraw on a hit, so the create the
+// flow is about to send cannot be refused for a value that is already taken. The value goes as a
+// string - the controller coerces it to the property's own type (an Integer would not bind to a Long
+// or BigDecimal column). A probe that fails (an older controller without /search) keeps the value.
+export async function freshUniques(client, entity, record) {
+  let redrawn = false;
+  for (const field of editableFields(entity)) {
+    if (!field.unique || !(field.name in record)) continue;
+    for (let attempt = 0; attempt < 5; attempt++) {
+      let rows;
+      try {
+        rows = await client.search(entity, [{ propertyName: field.name, operator: 'EQ', value: String(record[field.name]) }]);
+      } catch {
+        break;
+      }
+      if (!rows?.length) break;
+      record[field.name] = field.type === 'string' ? sampleValue(field) : uniqueValue(field);
+      redrawn = true;
+    }
+  }
+  // a redrawn field may be the right-hand side of a compare check - re-derive its left operand
+  if (redrawn) steerCompares(entity, record);
+  return record;
 }
 
 export function editableFields(entity) {
@@ -70,17 +126,25 @@ export function editableFields(entity) {
 // against live target rows).
 export function sampleRecord(entity) {
   const record = {};
-  for (const field of editableFields(entity)) record[field.name] = sampleValue(field);
+  for (const field of editableFields(entity)) {
+    const value = sampleValue(field);
+    if (value !== undefined) record[field.name] = value;
+  }
   // an exactlyOne check rejects a record where more than one of the named fields is set -
   // keep only the first of each declared set
   for (const set of entity.exactlyOne ?? []) {
     for (const name of set.slice(1)) delete record[name];
   }
-  // a compare check relates the record's own field to a second value - another of its fields, or a
-  // literal - and the sample values above are per-type constants, so two dates come out EQUAL and a
-  // strict comparison (gt/lt/ne) would be rejected with 400, just as a sample quantity of 7 fails a
-  // `le 5`. Derive the left operand from whichever right-hand side the check names, by the smallest
-  // step that satisfies the declared operator (equality satisfies ge/le/eq).
+  steerCompares(entity, record);
+  return record;
+}
+
+// A compare check relates the record's own field to a second value - another of its fields, or a
+// literal - and the sample values above are per-type constants, so two dates come out EQUAL and a
+// strict comparison (gt/lt/ne) would be rejected with 400, just as a sample quantity of 7 fails a
+// `le 5`. Derive the left operand from whichever right-hand side the check names, by the smallest
+// step that satisfies the declared operator (equality satisfies ge/le/eq).
+function steerCompares(entity, record) {
   for (const check of entity.compare ?? []) {
     if (!(check.field in record)) continue;
     const type = (entity.fields ?? []).find((f) => f.name === check.field)?.type;