@aerokit/test 15.14.0 → 15.15.0

package/README.md

@@ -89,14 +89,24 @@ picked in the UI. A relation fixed after create (`fixedAfterCreate: true`) carri
 picked on create and never changed by an edit, which the generated app answers with a 409. A field declaring a
 `pattern:` gets a value of that shape rather than the marker string. An optional `pattern:` field
 whose shape none of the sample candidates has (an IBAN, say) is left empty; a required one keeps the
-marker, so the controller's 400 names the field. Relations an `agree` check names are picked so
+marker, so the controller's 400 names the field. A `dependsOn` relation is sampled to match its
+trigger, as the form narrows it: with `filterBy` alone the trigger is the row the dependent's `filterBy`
+names; with `valueFrom` the dependent is the row whose `filterBy` (or key) equals the trigger row's
+`valueFrom`. Relations an `agree` check names are picked so
 their targets agree; a composite `uniqueKeys` entry is given a relation combination no live row
 carries, and the rest and crud flows skip with the key named when every combination tried is taken.
+A slots entity's start (the manifest's `slots` window) is a random grid start inside the hours, on
+an open weekday of a far-future day, so the server's slot rules (a 400 off the window, a 409 for a
+booked slot) never refuse it; the REST requests name `UTC` as their `X-Time-Zone`, the zone it is
+computed in.
 A relation carrying `pickable` is sampled only from the rows its rule admits — the chooser offers no
 other, so a record built from one would never save — and one carrying `forbiddenTarget` only from
 rows the record's own `forbidWhen` does not refuse, which is what the REST flow needs, having no
 picker to read. When no row is left, a required relation fails naming the rule's own message rather
-than "no rows".
+than "no rows". A relation whose target is labelled by a `stampOn: issue` number carries
+`labelDocumentNumber`: the picker shows every row not issued yet as the same "(draft)", so the sample
+is a stamped row, picked by its number; with none stamped yet an optional relation is left unset and
+a required one picks "(draft)".
 
 ## Custom UI hooks
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerokit/test",
-  "version": "15.14.0",
+  "version": "15.15.0",
   "description": "Generic Playwright runner that executes an intent module's generated <name>.test manifest against a running Eclipse Dirigible instance",
   "license": "EPL-2.0",
   "type": "module",

package/src/api.js

@@ -16,6 +16,7 @@ export function makeApi(request, manifest) {
     // absolute controller path (a cross-model relation target owned by another module)
     listPath: (path, limit = 20) => request.get(`${path}?$limit=${limit}`).then(asJson),
     getPath: (path) => request.get(path).then(asJson),
+    searchPath: (path, conditions) => request.post(`${path}/search`, { data: { conditions } }).then(asJson),
     count: (entity) => request.get(url(entity, '/count')).then(asJson).then((body) => (typeof body === 'number' ? body : body.count)),
     get: (entity, id) => request.get(url(entity, '/' + id)).then(asJson),
     getResponse: (entity, id) => request.get(url(entity, '/' + id)),

package/src/fixtures.js

@@ -5,7 +5,8 @@ import { login } from './session.js';
 // Pre-authenticated Playwright test:
 // - authState: worker-scoped form login, one session per worker
 // - storageState: every page starts logged in
-// - api: an APIRequestContext carrying the same session, for REST-level checks
+// - api: an APIRequestContext carrying the same session, for REST-level checks; its writes name UTC as
+//   their zone, the one a sample slot start is computed in (dirigible #8097)
 export const test = base.extend({
   authState: [
     async ({ browser }, use) => {
@@ -20,6 +21,7 @@ export const test = base.extend({
     const request = await playwright.request.newContext({
       baseURL: BASE_URL,
       storageState: authState,
+      extraHTTPHeaders: { 'X-Time-Zone': 'UTC' },
     });
     await use(request);
     await request.dispose();

package/src/form.js

@@ -66,8 +66,11 @@ export async function pickDropdown(page, relation, optionText) {
 // - a dependsOn cascade forces CONSISTENT samples: the dependent row is chosen first and
 //   its filterBy FK becomes the trigger sibling's sample (independent first rows would
 //   pick e.g. Country=Afghanistan + City=Sofia, and the cascade then offers no options);
+//   a valueFrom dependent is the row the form narrows it to once the trigger is picked;
 // - a relation an agree check or a composite unique key names keeps a page of candidate rows, so
-//   agreeing rows can be chosen here and a free key combination by freshUniqueKeys.
+//   agreeing rows can be chosen here and a free key combination by freshUniqueKeys;
+// - a target labelled by a stampOn: issue number (labelDocumentNumber) prefers a stamped row: the
+//   picker shows every unstamped one as the same draft marker (#7722, #7823).
 export async function resolveRelationSamples(request, manifest, entity) {
   const api = makeApi(request, manifest);
   const idProperty = manifest.idProperty ?? 'Id';
@@ -87,7 +90,12 @@ export async function resolveRelationSamples(request, manifest, entity) {
     // a filtered picker needs a matching candidate, so fetch a page and filter client-side; a
     // constrained relation needs alternatives to choose from
     const wide =
-      relation.where || relation.leafOnly || relation.pickable || relation.forbiddenTarget || constrained.has(relation.name);
+      relation.where ||
+      relation.leafOnly ||
+      relation.pickable ||
+      relation.forbiddenTarget ||
+      relation.labelDocumentNumber ||
+      constrained.has(relation.name);
     const { rows: fetched, labelFrom } = await fetchRows(relation, wide ? 200 : 1);
     let rows = relation.where ? fetched?.filter((r) => String(r[relation.where.by]) === String(relation.where.value)) : fetched;
     // A picker rule narrows what the chooser OFFERS (dirigible #7663) and the child's own
@@ -106,6 +114,12 @@ export async function resolveRelationSamples(request, manifest, entity) {
       const idProp = manifest.idProperty ?? 'Id';
       rows = rows.filter((row) => !fetched.some((other) => other[prop] === row[idProp]));
     }
+    if (rows?.length && relation.labelDocumentNumber) {
+      // an optional relation with no stamped row is left unset; a required one picks "(draft)"
+      const stamped = rows.filter((row) => !isDraftNumber(row[labelFrom]));
+      if (stamped.length) rows = stamped;
+      else if (!relation.required) continue;
+    }
     if (!rows?.length) {
       // a required FK cannot be satisfied - fail loudly; an optional one is simply left unset
       if (relation.required) throw new Error(`Relation ${entity.name}.${relation.name}: ${noCandidateReason(relation)}`);
@@ -124,7 +138,8 @@ export async function resolveRelationSamples(request, manifest, entity) {
       use(row) {
         this.row = row;
         this.id = row[idProperty];
-        this.label = row[labelFrom] ?? String(row[idProperty]);
+        this.label =
+          relation.labelDocumentNumber && isDraftNumber(row[labelFrom]) ? DRAFT_MARKER : (row[labelFrom] ?? String(row[idProperty]));
       },
     };
     sample.use(rows[0]);
@@ -134,6 +149,20 @@ export async function resolveRelationSamples(request, manifest, entity) {
   // cascade consistency: re-point each dependsOn trigger at the row the dependent's choice implies
   for (const sample of samples) {
     const dependsOn = sample.relation.dependsOn;
+    if (dependsOn?.valueFrom) {
+      // The form copies the trigger row's valueFrom and offers only the rows whose filterBy (default:
+      // the key) holds it, so the dependent is that row, not its own first one (#7957).
+      const trigger = samples.find((s) => s.relation.name === dependsOn.relation);
+      const value = trigger?.row[dependsOn.valueFrom];
+      const path = sample.relation.apiAbsolute ?? (sample.relation.api ? manifest.restBase + sample.relation.api : null);
+      if (value == null || !path) continue; // nothing copied: the picker offers every row
+      const [row] = (await api.searchPath(path, [{ propertyName: dependsOn.filterBy ?? idProperty, operator: 'EQ', value }])) ?? [];
+      if (!row) continue;
+      sample.use(row);
+      sample.rows = [row];
+      trigger.rows = [trigger.row];
+      continue;
+    }
     if (!dependsOn?.filterBy) continue;
     const trigger = samples.find((s) => s.relation.name === dependsOn.relation);
     // a cascade pair is chosen together - neither side may be swapped for a candidate later
@@ -145,10 +174,8 @@ export async function resolveRelationSamples(request, manifest, entity) {
     if (!path) continue;
     const row = await api.getPath(`${path}/${impliedId}`);
     if (!row) continue;
-    trigger.row = row;
+    trigger.use(row);
     trigger.rows = [row];
-    trigger.id = impliedId;
-    trigger.label = row[trigger.relation.labelFrom ?? 'Name'];
   }
   alignAgreeing(entity, samples);
   return samples;
@@ -190,6 +217,14 @@ export async function fillForm(page, manifest, entity, record, relationSamples,
   for (const sample of [...triggers, ...dependents]) await pickDropdown(page, sample.relation, sample.label);
 }
 
+// The option text the picker gives a stampOn: issue number (HarmoniaFormat.documentNumber): a UUID
+// placeholder - a document not issued yet - reads as the draft marker, any other value as itself.
+// The marker is the English default; a walk in another UI language would need the translated one.
+const DRAFT_MARKER = '(draft)';
+function isDraftNumber(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(String(value));
+}
+
 // One term of a picker rule or of a forbidWhen reaching through a relation, as the manifest writes
 // it: `{ by, op, value }` with `op` one of eq / ne / present / absent, a presence test carrying no
 // value. Compared as strings, because an id arrives as a number from REST and as text from a

package/src/sample-values.js

@@ -210,9 +210,24 @@ export function sampleRecord(entity) {
     for (const name of set.slice(1)) delete record[name];
   }
   steerCompares(entity, record);
+  if (entity.slots) record[entity.slots.start] = slotSample(entity.slots);
   return record;
 }
 
+// A slots entity's start (dirigible #8097): the server refuses one on a closed day, outside the
+// hours or off the grid, and a second booking of a slot. A random free-looking slot - an open day of
+// a far-future century, a grid start inside the hours - read in UTC, the zone the api fixture names.
+function slotSample({ open, close, step, disabledDays = [] }) {
+  const minutes = (hhmm) => hhmm.split(':').reduce((h, m) => Number(h) * 60 + Number(m));
+  const from = minutes(open);
+  const slots = Math.max(1, Math.ceil((minutes(close) - from) / step));
+  let day = new Date(Date.UTC(2100, 0, 1) + Math.floor(Math.random() * 36500) * 86400000);
+  while (disabledDays.includes(day.getUTCDay())) day = new Date(day.getTime() + 86400000);
+  const at = from + step * Math.floor(Math.random() * slots);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${day.toISOString().slice(0, 10)}T${pad(Math.floor(at / 60))}:${pad(at % 60)}:00Z`;
+}
+
 // 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