@aerokit/sdk 14.62.0 → 14.64.0

package/package.json

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

package/test/api.js

@@ -21,11 +21,19 @@ export function makeApi(request, manifest) {
     getResponse: (entity, id) => request.get(url(entity, '/' + id)),
     create: (entity, data) => request.post(url(entity), { data }).then(asJson),
     update: (entity, id, data) => request.put(url(entity, '/' + id), { data }).then(asJson),
+    // Answers whether the row is gone. A record whose process declares `whenDeleted: refuse` is
+    // REFUSED with 409 while that instance runs (dirigible #7074) - the guard doing its job, not a
+    // failure, so the caller is told rather than thrown at and its cleanup completes either way.
+    // Every other failing status still throws.
     remove: async (entity, id) => {
       const response = await request.delete(url(entity, '/' + id));
+      if (response.status() === 409 && entity.deleteGuardedByProcess?.length) {
+        return false;
+      }
       if (!response.ok()) {
         throw new Error(`DELETE ${response.url()} -> ${response.status()} ${await response.text()}`);
       }
+      return true;
     },
   };
 }

package/test/flows/crud.js

@@ -68,8 +68,10 @@ export function crudFlow(manifest, entity, opts = {}) {
       record[handle.name] = updated;
     }
 
-    // delete (detail pane trash button, then the confirm dialog)
-    if (!skip.has('delete')) {
+    // delete (detail pane trash button, then the confirm dialog). An entity whose process declares
+    // `whenDeleted: refuse` answers the delete with an error toast while its instance runs - the
+    // create above started it - so the walk stops here and the REST flow asserts that refusal.
+    if (!skip.has('delete') && !entity.deleteGuardedByProcess?.length) {
       await dataRow(page, record[handle.name]).click();
       await page.getByRole('button', { name: 'Delete', exact: true }).first().click();
       const dialog = page.locator('[x-h-dialog-overlay][data-open]');

package/test/flows/my.js

@@ -108,6 +108,7 @@ export function myFlow(manifest, entity, opts = {}) {
     const id = created?.[idProperty];
     expect(id, 'personal create carries the generated id').toBeTruthy();
     let foreignId;
+    let deleted;
     try {
       const own = await client.get(mine, id);
       expect(own[entity.personal.owner], 'the owner FK is forced server-side on a personal create').toBeTruthy();
@@ -133,11 +134,14 @@ export function myFlow(manifest, entity, opts = {}) {
         expect(rowsAfter.some((row) => row[idProperty] === foreignId), 'a foreign row must not appear in the personal list').toBe(false);
       }
     } finally {
-      await client.remove(mine, id); // deleting the OWN row through the personal controller works
+      deleted = await client.remove(mine, id); // deleting the OWN row through the personal controller works
       if (foreignId) await client.remove(entity, foreignId);
     }
-    const gone = await api.get(manifest.restBase + mine.api + '/' + id);
-    expect(gone.status()).toBe(404);
+    // ... unless a `whenDeleted: refuse` process guards the record while its instance runs
+    if (deleted) {
+      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

package/test/flows/rest.js

@@ -23,6 +23,7 @@ export function restFlow(manifest, entity, opts = {}) {
     const created = await client.create(entity, payload);
     const id = created?.[idProperty];
     expect(id, 'create response carries the generated id').toBeTruthy();
+    let deleted;
     try {
       const read = await client.get(entity, id);
       expect(read[idProperty]).toBe(id);
@@ -36,7 +37,15 @@ export function restFlow(manifest, entity, opts = {}) {
         expect(reread[handle.name]).toBe(updatedValue);
       }
     } finally {
-      await client.remove(entity, id);
+      deleted = await client.remove(entity, id);
+    }
+    if (!deleted) {
+      // the record's process guard refused the delete (409) - assert the other half of that promise:
+      // the row is still served. A guarded entity can also delete cleanly, when its instance had
+      // already finished, so which outcome is expected is only knowable after the attempt.
+      const kept = await client.get(entity, id);
+      expect(kept[idProperty], `delete refused by ${entity.deleteGuardedByProcess.join(', ')} - the record must survive`).toBe(id);
+      return;
     }
     const gone = await client.getResponse(entity, id);
     expect(gone.status()).toBe(404);

package/test/sample-values.js

@@ -14,8 +14,8 @@ export function sampleValue(field) {
   switch (field.type) {
     case 'string': {
       const len = field.length ?? 64;
-      if (len >= 16) return 'APPTEST-' + rand(ALPHA + DIGITS, 6);
-      return rand(ALPHA, Math.max(1, len - 1)) + rand(DIGITS, 1);
+      const value = len >= 16 ? 'APPTEST-' + rand(ALPHA + DIGITS, 6) : rand(ALPHA, Math.max(1, len - 1)) + rand(DIGITS, 1);
+      return field.pattern ? shaped(field, value) : value;
     }
     case 'integer':
     case 'bigint':
@@ -37,6 +37,31 @@ 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
+// module author needs, and a silent near-miss would not.
+function shaped(field, value) {
+  let regex;
+  try {
+    // anchored like the generated controller's own String.matches, so an unanchored pattern cannot
+    // pass here on a substring and then be refused by the server
+    regex = new RegExp('^(?:' + field.pattern + ')$');
+  } catch {
+    return value; // not a JavaScript-parsable regex - nothing to shape the value to
+  }
+  const token = value.replace(/[^A-Za-z0-9]/g, '');
+  const candidates = [
+    value,
+    `apptest.${token}@apptest.example.com`, // format: email and other address-shaped patterns
+    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;
+}
+
 export function editableFields(entity) {
   return (entity.fields ?? []).filter((f) => !f.readOnly && !f.primaryKey && !f.generated);
 }
@@ -108,11 +133,15 @@ function shifted(value, type, step) {
 }
 
 // The searchable "handle" field: the first long string field shown in the list. Its
-// value identifies the record in the table across the create/edit/delete flow.
+// value identifies the record in the table across the create/edit/delete flow, and the flows
+// flip it by appending a suffix - so a field carrying a `pattern:` cannot be it, the suffix
+// breaking the very shape the controller enforces. Read-only fields are out through
+// editableFields: a `number:` field is the platform's to stamp and preserve, so a write to it
+// reads back unchanged (dirigible #7411).
 // Null when the entity has no such field (all-numeric/date entities) - flows degrade:
 // the UI walk is skipped and the REST flow drops its update-value assertion.
 export function handleField(entity) {
-  return editableFields(entity).find((f) => f.type === 'string' && (f.length ?? 64) >= 16 && f.major !== false) ?? null;
+  return editableFields(entity).find((f) => f.type === 'string' && (f.length ?? 64) >= 16 && f.major !== false && !f.pattern) ?? null;
 }
 
 export function labelOf(field) {