@modelprofile.com/flexharness 10.23.0 → 10.24.1

package/ts_stores_nosqldb/classes.recordstore.ts

@@ -318,13 +318,13 @@ export class FlexRecordStore {
     );
   }
 
-  /** Deletes every record and chunk of one domain in a storage namespace. */
-  public async purgeNamespace(storageKey: string, domain: TFlexRecordDomain): Promise<void> {
+  /** Deletes every record and chunk of a storage namespace, in one domain or in every domain. */
+  public async purgeNamespace(storageKey: string, domain?: TFlexRecordDomain): Promise<void> {
     await this.prepare();
     const namespaceKey = digest(storageKey);
     await this.deleteInTransaction(
-      `${FLEX_RECORD_COLLECTION}/${domain}/namespace/${namespaceKey}`,
-      { namespaceKey, domain },
+      `${FLEX_RECORD_COLLECTION}/${domain ?? 'all'}/namespace/${namespaceKey}`,
+      domain ? { namespaceKey, domain } : { namespaceKey },
     );
   }
 
@@ -333,7 +333,7 @@ export class FlexRecordStore {
     selector:
       | { recordId: string; domain: TFlexRecordDomain }
       | { ownerKey: string; domain: { $in: TFlexRecordDomain[] } }
-      | { namespaceKey: string; domain: TFlexRecordDomain },
+      | { namespaceKey: string; domain?: TFlexRecordDomain },
   ): Promise<void> {
     const session = this.db.createSession();
     try {

package/ts_stores_nosqldb/readme.md

@@ -23,6 +23,13 @@ The database is the application's. The stores never close it, and they need NoSQ
 
 A snapshot of up to `FLEX_RECORD_CHUNK_CODE_UNITS` UTF-16 code units of JSON is stored inside its record. A longer one is split into chunks of that size, each below 3 MiB of UTF-8, so a snapshot may exceed the 16 MiB document limit of NoSQLDB and MongoDB. Chunks are written before the record swaps to them. The chunks a record no longer references are removed by a later write of that record, in a transaction that also touches the record, and deleting a session or purging a namespace removes its records and chunks in one transaction. A writer that crashes between writing its chunks and swapping the record leaves only unreferenced chunks, never a record that points at missing ones. They are written against the record's current write token, which a concurrent writer may still win with, so the write after the next one removes them, or the deletion of the session or namespace does.
 
+`stores.purgeNamespace(storageKey)` is the durable deletion of a scope: it removes every record and chunk of that storage namespace in every domain, including the scope snapshot and the project-management tombstones that deleting its sessions keeps, in one transaction. Deleting every session alone leaves those records, keyed by the storage key. Call it only after stopping new admission for every alias of the scope and awaiting `harness.retireScope()` on every harness that owns it:
+
+```typescript
+await harness.retireScope(scopeId);
+await stores.purgeNamespace(storageKey);
+```
+
 A record swap that loses to a concurrent writer is decided again against the newer record, up to eight times, with a bounded exponential backoff between attempts; a writer that still loses gets the domain's conflict error.
 
 A save that may have reached the database without a confirmation, such as a timed-out or interrupted record write or a deletion transaction with an unknown commit outcome, rejects with `FlexHarnessStoreCommitUncertainError` (operation `write` or `delete`). FlexHarness then fences the namespace, as it does for the JSON file stores.