@enbox/dwn-sdk-js 0.3.4 → 0.3.5

package/src/store/storage-controller.ts

@@ -30,10 +30,10 @@ export type ResumableRecordsSquashData = {
  */
 export class StorageController {
 
-  private messageStore: MessageStore;
-  private dataStore: DataStore;
-  private stateIndex: StateIndex;
-  private eventLog?: EventLog;
+  private readonly messageStore: MessageStore;
+  private readonly dataStore: DataStore;
+  private readonly stateIndex: StateIndex;
+  private readonly eventLog?: EventLog;
 
   public constructor({ messageStore, dataStore, stateIndex, eventLog }: {
     messageStore : MessageStore,
@@ -79,8 +79,13 @@ export class StorageController {
     }
 
     if (message.descriptor.prune) {
-      // purge/hard-delete all descendent records
-      await StorageController.purgeRecordDescendants(tenant, message.descriptor.recordId, this.messageStore, this.dataStore, this.stateIndex);
+      // purge/hard-delete all descendant records. Cascade is intentionally protocol-agnostic:
+      // `parentContextId` is a structural link, and a prune removes the whole subtree regardless
+      // of which protocol a descendant lives in. Cross-protocol composing children (linked via
+      // `$ref`/`uses`) participate in the cascade. See issue #298 for the design discussion.
+      await StorageController.purgeRecordDescendants(
+        tenant, message.descriptor.recordId, this.messageStore, this.dataStore, this.stateIndex
+      );
     }
 
     // delete all existing messages that are not newest, except for the initial write
@@ -131,10 +136,10 @@ export class StorageController {
       }
 
       const existing = recordIdToMessages.get(recordId);
-      if (existing !== undefined) {
-        existing.push(msg);
-      } else {
+      if (existing === undefined) {
         recordIdToMessages.set(recordId, [msg]);
+      } else {
+        existing.push(msg);
       }
     }
 
@@ -191,7 +196,21 @@ export class StorageController {
   }
 
   /**
-   * Purges (permanent hard-delete) all descendant's data of the given `recordId`.
+   * Purges (permanent hard-delete) all descendants of the given `recordId`, recursively.
+   *
+   * The cascade is intentionally protocol-agnostic: `parentContextId` is a structural link,
+   * so pruning a parent removes every record hanging off it regardless of which protocol a
+   * descendant lives in. Cross-protocol composing children (records in a different protocol
+   * that reference the parent via `$ref` / `uses`) are included in the cascade.
+   *
+   * Rationale (closes #298 as working-as-intended):
+   * - A DWN is tenant-owned storage. The tenant's prune authority extends across the whole
+   *   subtree they rooted, regardless of which protocol a descendant declares itself under.
+   * - Preserving cross-protocol orphans creates a half-alive state (readable but not
+   *   updatable, since `validateReferentialIntegrity` requires the pruned parent) that is
+   *   worse for callers than simply cascading.
+   * - Same-protocol cascade is already protocol-agnostic at every hop via `parentId`,
+   *   so treating cross-protocol boundaries differently was inconsistent.
    */
   public static async purgeRecordDescendants(
     tenant: string,
@@ -200,16 +219,15 @@ export class StorageController {
     dataStore: DataStore,
     stateIndex: StateIndex
   ): Promise<void> {
-    const filter = {
+    const filter: Filter = {
       interface : DwnInterfaceName.Records,
-      parentId  : recordId
+      parentId  : recordId,
     };
     const { messages: childMessages } = await messageStore.query(tenant, [filter]);
 
     // group the child messages by `recordId`
     const recordIdToMessagesMap = new Map<string, GenericMessage[]>();
     for (const message of childMessages) {
-      // get the recordId
       let recordId;
       if (Records.isRecordsWrite(message)) {
         recordId = message.recordId;
@@ -225,13 +243,10 @@ export class StorageController {
       }
     }
 
-    // purge all child's descendants first
     for (const childRecordId of recordIdToMessagesMap.keys()) {
-      // purge the child's descendent messages first
       await StorageController.purgeRecordDescendants(tenant, childRecordId, messageStore, dataStore, stateIndex);
     }
 
-    // then purge the child messages themselves
     for (const childRecordId of recordIdToMessagesMap.keys()) {
       await StorageController.purgeRecordMessages(tenant, recordIdToMessagesMap.get(childRecordId)!, messageStore, dataStore, stateIndex);
     }

package/src/types/permission-types.ts

@@ -89,13 +89,12 @@ export type ProtocolPermissionScope = {
 /**
  * Permission scope for the Messages interface.
  *
- * A `Read` scope is a unified scope that authorizes `MessagesRead`, `MessagesSubscribe`, and `MessagesSync` operations.
- * The `Subscribe` and `Sync` method values are retained for backward compatibility with existing grants but are
- * functionally equivalent to `Read` — new grants SHOULD use `Read` exclusively.
+ * `Read` is the only valid method and acts as a unified scope that authorizes
+ * `MessagesRead`, `MessagesSubscribe`, and `MessagesSync` operations.
  */
 export type MessagesPermissionScope = {
   interface: DwnInterfaceName.Messages;
-  method: DwnMethodName.Read | DwnMethodName.Subscribe | DwnMethodName.Sync;
+  method: DwnMethodName.Read;
   protocol?: string;
 };
 

package/src/utils/memory-cache.ts

@@ -5,12 +5,12 @@ import { LRUCache } from 'lru-cache';
  * A cache using local memory.
  */
 export class MemoryCache implements Cache {
-  private cache: LRUCache<string, any>;
+  private readonly cache: LRUCache<string, any>;
 
   /**
    * @param timeToLiveInSeconds time-to-live for every key-value pair set in the cache
    */
-  public constructor (private timeToLiveInSeconds: number) {
+  public constructor (private readonly timeToLiveInSeconds: number) {
     this.cache = new LRUCache({
       max : 100_000,
       ttl : timeToLiveInSeconds * 1000

package/src/utils/messages.ts

@@ -21,7 +21,7 @@ export class Messages {
     // normalize each filter, and only add non-empty filters to the returned array
     for (const filter of filters) {
       // normalize the protocol URL if it exists
-      const protocol = filter.protocol !== undefined ? normalizeProtocolUrl(filter.protocol) : undefined;
+      const protocol = filter.protocol === undefined ? undefined : normalizeProtocolUrl(filter.protocol);
 
       const messagesFilter = {
         ...filter,
@@ -130,6 +130,6 @@ export class Messages {
       };
     }
 
-    return filterCopy as Filter;
+    return filterCopy;
   }
 }

package/src/utils/object.ts

@@ -6,11 +6,7 @@ export function isEmptyObject(obj: unknown): boolean {
     return false;
   }
 
-  for (const _ in obj) {
-    return false;
-  }
-
-  return true;
+  return Object.keys(obj as object).length === 0;
 }
 
 /**

package/src/utils/private-key-signer.ts

@@ -30,8 +30,8 @@ export type PrivateKeySignerOptions = {
 export class PrivateKeySigner implements MessageSigner {
   public keyId;
   public algorithm;
-  private privateJwk: PrivateKeyJwk;
-  private signatureAlgorithm;
+  private readonly privateJwk: PrivateKeyJwk;
+  private readonly signatureAlgorithm;
 
   public constructor(options: PrivateKeySignerOptions) {
     if (options.keyId === undefined && options.privateJwk.kid === undefined) {

package/src/utils/records.ts

@@ -375,7 +375,7 @@ export class Records {
       delete filterCopy.recipient;
     }
 
-    return filterCopy as Filter;
+    return filterCopy;
   }
 
   /**