@enbox/dwn-sdk-js 0.4.16 → 0.4.18

package/src/handlers/records-subscribe.ts

@@ -1,23 +1,22 @@
-import type { MessageSort } from '../types/message-types.js';
+import type { RecordsCollectionVisibility } from './records-collection.js';
 import type { EventSubscription, ProgressGapInfo, ProgressToken, SubscriptionEvent, SubscriptionListener, SubscriptionMessage } from '../types/subscriptions.js';
 import type { Filter, PaginationCursor } from '../types/query-types.js';
 import type { HandlerDependencies, MethodHandler } from '../types/method-handler.js';
 import type { RecordsQueryReplyEntry, RecordsSubscribeMessage, RecordsSubscribeReply } from '../types/records-types.js';
 
 import { attachInitialWrites } from '../utils/initial-write-attachment.js';
-import { authenticate } from '../core/auth.js';
-import { DateSort } from '../types/records-types.js';
 import { EncryptionControl } from '../core/encryption-control.js';
+import { isRecordLimitOccupant } from '../utils/record-limit-occupancy.js';
 import { Message } from '../core/message.js';
 import { messageReplyFromError } from '../core/message-reply.js';
-import { ProtocolAuthorization } from '../core/protocol-authorization.js';
 import { Records } from '../utils/records.js';
-import { RecordsGrantAuthorization } from '../core/records-grant-authorization.js';
 import { RecordsSubscribe } from '../interfaces/records-subscribe.js';
-import { SortDirection } from '../types/query-types.js';
+import {
+  buildRecordsEventFilters,
+  queryVisibleRecordsPage,
+  resolveRecordsCollectionVisibility,
+} from './records-collection.js';
 import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
-import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
-import { isRecordLimitOccupant, queryRecordsWithRecordLimitOccupancy } from '../utils/record-limit-occupancy.js';
 
 type ProjectedRecordsSubscriptionHandler = {
   listener: SubscriptionListener;
@@ -47,16 +46,15 @@ export class RecordsSubscribeHandler implements MethodHandler {
     let recordsSubscribe: RecordsSubscribe;
     try {
       recordsSubscribe = await RecordsSubscribe.parse(message);
-    } catch (e) {
-      return messageReplyFromError(e, 400);
+    } catch (error) {
+      return messageReplyFromError(error, 400);
     }
 
-    const requester = Message.getRequester(recordsSubscribe.message);
     const filterResolution = await this.resolveSubscriptionFilters(tenant, message, recordsSubscribe);
     if ('errorReply' in filterResolution) {
       return filterResolution.errorReply;
     }
-    const { eventFilters, queryFilters } = filterResolution;
+    const { eventFilters, visibility } = filterResolution;
 
     const messageCid = await Message.getCid(message);
     const { cursor: eventLogCursor } = recordsSubscribe.message.descriptor;
@@ -78,12 +76,12 @@ export class RecordsSubscribeHandler implements MethodHandler {
 
     // ---- No cursor: existing behavior (initial snapshot from MessageStore) ----
     return this.handleSnapshotSubscription(
-      tenant, messageCid, recordsSubscribe, requester, eventFilters, queryFilters, projectedSubscriptionHandler
+      tenant, messageCid, recordsSubscribe, eventFilters, visibility, projectedSubscriptionHandler
     );
   }
 
   /**
-   * Resolves the event/query filters for the subscription, performing authentication and
+   * Resolves the event filters and visibility for the subscription, performing authentication and
    * authorization when the request is not an anonymous published-records-only subscribe.
    * Returns the resolved filters, or an `errorReply` if authentication/authorization failed.
    */
@@ -91,35 +89,21 @@ export class RecordsSubscribeHandler implements MethodHandler {
     tenant: string,
     message: RecordsSubscribeMessage,
     recordsSubscribe: RecordsSubscribe,
-  ): Promise<{ eventFilters: Filter[]; queryFilters: Filter[] } | { errorReply: RecordsSubscribeReply }> {
-    // if this is an anonymous subscribe and the filter supports published records, subscribe to only published records
-    if (Records.filterIncludesPublishedRecords(recordsSubscribe.message.descriptor.filter) && recordsSubscribe.author === undefined) {
-      const eventFilters = [RecordsSubscribeHandler.buildPublishedEventFilter(recordsSubscribe)];
-      const queryFilters = [RecordsSubscribeHandler.buildPublishedQueryFilter(recordsSubscribe)];
-      // delete the undefined authorization property else the code will encounter the following IPLD issue when attempting to generate CID:
-      // Error: `undefined` is not supported by the IPLD Data Model and cannot be encoded
-      delete message.authorization;
-      return { eventFilters, queryFilters };
-    }
-
-    // authentication and authorization
+  ): Promise<{ eventFilters: Filter[]; visibility: RecordsCollectionVisibility } | { errorReply: RecordsSubscribeReply }> {
+    let visibility: RecordsCollectionVisibility;
     try {
-      await authenticate(message.authorization!, this.deps.didResolver);
-      await RecordsSubscribeHandler.authorizeRecordsSubscribe(tenant, recordsSubscribe, this.deps);
+      visibility = await resolveRecordsCollectionVisibility(tenant, recordsSubscribe, this.deps);
     } catch (error) {
       return { errorReply: messageReplyFromError(error, 401) };
     }
 
-    if (recordsSubscribe.author === tenant) {
-      return {
-        eventFilters : RecordsSubscribeHandler.buildOwnerEventFilters(recordsSubscribe),
-        queryFilters : RecordsSubscribeHandler.buildOwnerQueryFilters(recordsSubscribe),
-      };
+    if (visibility === 'published') {
+      // Remove the undefined property before computing the subscription CID because IPLD cannot encode it.
+      delete message.authorization;
     }
-
     return {
-      eventFilters : RecordsSubscribeHandler.buildNonOwnerEventFilters(recordsSubscribe),
-      queryFilters : RecordsSubscribeHandler.buildNonOwnerQueryFilters(recordsSubscribe),
+      eventFilters: buildRecordsEventFilters(recordsSubscribe, visibility),
+      visibility,
     };
   }
 
@@ -167,9 +151,8 @@ export class RecordsSubscribeHandler implements MethodHandler {
     tenant: string,
     messageCid: string,
     recordsSubscribe: RecordsSubscribe,
-    requester: string | undefined,
     eventFilters: Filter[],
-    queryFilters: Filter[],
+    visibility: RecordsCollectionVisibility,
     projectedSubscriptionHandler: ProjectedRecordsSubscriptionHandler,
   ): Promise<RecordsSubscribeReply> {
     // Step 1: Register event listener FIRST to ensure no events are missed between query and subscribe
@@ -182,16 +165,12 @@ export class RecordsSubscribeHandler implements MethodHandler {
     let entries: RecordsQueryReplyEntry[];
     let paginationCursor: PaginationCursor | undefined;
     try {
-      const { dateSort, pagination } = recordsSubscribe.message.descriptor;
-      const messageSort = RecordsSubscribeHandler.convertDateSort(dateSort);
-      const queryResult = await this.queryRecordsWithVisibleControlFiltering(
+      const queryResult = await queryVisibleRecordsPage({
+        deps    : this.deps,
         tenant,
-        recordsSubscribe,
-        requester,
-        queryFilters,
-        messageSort,
-        pagination,
-      );
+        request : recordsSubscribe,
+        visibility,
+      });
 
       // attach the retained initial write to every entry that is not itself an initial write
       entries = await attachInitialWrites({
@@ -216,29 +195,6 @@ export class RecordsSubscribeHandler implements MethodHandler {
     };
   }
 
-  /**
-   * Convert an incoming DateSort to a sort type accepted by MessageStore.
-   * Defaults to `dateCreated` ascending if no sort is supplied.
-   */
-  private static convertDateSort(dateSort?: DateSort): MessageSort {
-    switch (dateSort) {
-    case DateSort.CreatedAscending:
-      return { dateCreated: SortDirection.Ascending };
-    case DateSort.CreatedDescending:
-      return { dateCreated: SortDirection.Descending };
-    case DateSort.PublishedAscending:
-      return { datePublished: SortDirection.Ascending };
-    case DateSort.PublishedDescending:
-      return { datePublished: SortDirection.Descending };
-    case DateSort.UpdatedAscending:
-      return { messageTimestamp: SortDirection.Ascending };
-    case DateSort.UpdatedDescending:
-      return { messageTimestamp: SortDirection.Descending };
-    default:
-      return { dateCreated: SortDirection.Ascending };
-    }
-  }
-
   private static createRecordLimitOccupancyGuard(input: {
     deps: HandlerDependencies;
     eventFilters: Filter[];
@@ -357,331 +313,4 @@ export class RecordsSubscribeHandler implements MethodHandler {
     };
   }
 
-  // =============================================
-  // Event filters (for live subscription)
-  // These match Write+Delete and do NOT use isLatestBaseState
-  // =============================================
-
-  /**
-   * Build event filters for owner: all matching Write+Delete events.
-   */
-  private static buildOwnerEventFilters(recordsSubscribe: RecordsSubscribe): Filter[] {
-    const { filter } = recordsSubscribe.message.descriptor;
-    return [{
-      ...Records.convertFilter(filter),
-      interface : DwnInterfaceName.Records,
-      method    : [DwnMethodName.Write, DwnMethodName.Delete],
-    }];
-  }
-
-  /**
-   * Build event filters for non-owner with visibility rules.
-   */
-  private static buildNonOwnerEventFilters(recordsSubscribe: RecordsSubscribe): Filter[] {
-    const filters: Filter[] = [];
-    const { filter } = recordsSubscribe.message.descriptor;
-    if (Records.filterIncludesPublishedRecords(filter)) {
-      filters.push(RecordsSubscribeHandler.buildPublishedEventFilter(recordsSubscribe));
-    }
-
-    if (Records.filterIncludesUnpublishedRecords(filter)) {
-      if (EncryptionControl.isExactAudienceFilter(filter)) {
-        filters.push({
-          ...Records.convertFilter(filter),
-          interface : DwnInterfaceName.Records,
-          method    : [DwnMethodName.Write, DwnMethodName.Delete],
-          published : false,
-        });
-      }
-
-      if (Records.shouldBuildUnpublishedAuthorFilter(filter, recordsSubscribe.author!)) {
-        filters.push({
-          ...Records.convertFilter(filter),
-          author    : recordsSubscribe.author!,
-          interface : DwnInterfaceName.Records,
-          method    : [DwnMethodName.Write, DwnMethodName.Delete],
-          published : false,
-        });
-      }
-
-      if (Records.shouldProtocolAuthorize(recordsSubscribe.signaturePayload!)) {
-        filters.push({
-          ...Records.convertFilter(filter),
-          interface : DwnInterfaceName.Records,
-          method    : [DwnMethodName.Write, DwnMethodName.Delete],
-          published : false,
-        });
-      }
-
-      if (Message.getPermissionGrantId(recordsSubscribe.signaturePayload!) !== undefined) {
-        filters.push({
-          ...Records.convertFilter(filter),
-          interface : DwnInterfaceName.Records,
-          method    : [DwnMethodName.Write, DwnMethodName.Delete],
-          published : false,
-        });
-      }
-
-      if (Records.shouldBuildUnpublishedRecipientFilter(filter, recordsSubscribe.author!)) {
-        filters.push({
-          ...Records.convertFilter(filter),
-          interface : DwnInterfaceName.Records,
-          method    : [DwnMethodName.Write, DwnMethodName.Delete],
-          recipient : recordsSubscribe.author!,
-          published : false,
-        });
-      }
-    }
-    return filters;
-  }
-
-  /**
-   * Build a published-only event filter (Write+Delete).
-   */
-  private static buildPublishedEventFilter(recordsSubscribe: RecordsSubscribe): Filter {
-    return {
-      ...Records.convertFilter(recordsSubscribe.message.descriptor.filter),
-      interface : DwnInterfaceName.Records,
-      method    : [DwnMethodName.Write, DwnMethodName.Delete],
-      published : true,
-    };
-  }
-
-  // =============================================
-  // Query filters (for initial snapshot)
-  // These match Write only and use isLatestBaseState: true
-  // =============================================
-
-  /**
-   * Build query filters for owner: latest writes matching the filter.
-   */
-  private static buildOwnerQueryFilters(recordsSubscribe: RecordsSubscribe): Filter[] {
-    const { dateSort, filter } = recordsSubscribe.message.descriptor;
-    return [{
-      ...Records.convertFilter(filter, dateSort),
-      interface         : DwnInterfaceName.Records,
-      method            : DwnMethodName.Write,
-      isLatestBaseState : true,
-    }];
-  }
-
-  /**
-   * Build query filters for non-owner with visibility rules.
-   */
-  private static buildNonOwnerQueryFilters(recordsSubscribe: RecordsSubscribe): Filter[] {
-    const filters: Filter[] = [];
-    const { dateSort, filter } = recordsSubscribe.message.descriptor;
-    if (Records.filterIncludesPublishedRecords(filter)) {
-      filters.push(RecordsSubscribeHandler.buildPublishedQueryFilter(recordsSubscribe));
-    }
-
-    if (Records.filterIncludesUnpublishedRecords(filter)) {
-      if (EncryptionControl.isExactAudienceFilter(filter)) {
-        filters.push(Records.buildUnpublishedControlRecordsFilter(filter, dateSort));
-      }
-
-      if (Records.shouldBuildUnpublishedAuthorFilter(filter, recordsSubscribe.author!)) {
-        filters.push({
-          ...Records.convertFilter(filter, dateSort),
-          author            : recordsSubscribe.author!,
-          interface         : DwnInterfaceName.Records,
-          method            : DwnMethodName.Write,
-          isLatestBaseState : true,
-          published         : false,
-        });
-      }
-
-      if (Records.shouldProtocolAuthorize(recordsSubscribe.signaturePayload!)) {
-        filters.push({
-          ...Records.convertFilter(filter, dateSort),
-          interface         : DwnInterfaceName.Records,
-          method            : DwnMethodName.Write,
-          isLatestBaseState : true,
-          published         : false,
-        });
-      }
-
-      if (Message.getPermissionGrantId(recordsSubscribe.signaturePayload!) !== undefined) {
-        filters.push({
-          ...Records.convertFilter(filter, dateSort),
-          interface         : DwnInterfaceName.Records,
-          method            : DwnMethodName.Write,
-          isLatestBaseState : true,
-          published         : false,
-        });
-      }
-
-      if (Records.shouldBuildUnpublishedRecipientFilter(filter, recordsSubscribe.author!)) {
-        filters.push({
-          ...Records.convertFilter(filter, dateSort),
-          interface         : DwnInterfaceName.Records,
-          method            : DwnMethodName.Write,
-          recipient         : recordsSubscribe.author!,
-          isLatestBaseState : true,
-          published         : false,
-        });
-      }
-    }
-    return filters;
-  }
-
-  /**
-   * Build a published-only query filter (latest writes).
-   */
-  private static buildPublishedQueryFilter(recordsSubscribe: RecordsSubscribe): Filter {
-    const { dateSort, filter } = recordsSubscribe.message.descriptor;
-    return {
-      ...Records.convertFilter(filter, dateSort),
-      interface         : DwnInterfaceName.Records,
-      method            : DwnMethodName.Write,
-      published         : true,
-      isLatestBaseState : true,
-    };
-  }
-
-  /**
-   * @param messageStore Used to check if the grant has been revoked.
-   */
-  public static async authorizeRecordsSubscribe(
-    tenant: string,
-    recordsSubscribe: RecordsSubscribe,
-    deps: HandlerDependencies,
-  ): Promise<void> {
-
-    if (Message.isSignedByAuthorDelegate(recordsSubscribe.message) &&
-        !EncryptionControl.filterTargetsOnlyControlRecords(recordsSubscribe.message.descriptor.filter)) {
-      await recordsSubscribe.authorizeDelegate(deps.validationStateReader);
-    } else if (EncryptionControl.filterTargetsOnlyControlRecords(recordsSubscribe.message.descriptor.filter)) {
-      await EncryptionControl.authorizeControlReadRequest({
-        tenant,
-        incomingMessage       : recordsSubscribe.message,
-        requester             : Message.getRequester(recordsSubscribe.message),
-        validationStateReader : deps.validationStateReader,
-      });
-    }
-
-    const permissionGrantId = Message.getPermissionGrantId(recordsSubscribe.signaturePayload!);
-    if (permissionGrantId !== undefined) {
-      const permissionGrant = await deps.validationStateReader.fetchGrant(tenant, permissionGrantId);
-      await RecordsGrantAuthorization.authorizeQueryOrSubscribe({
-        incomingMessage       : recordsSubscribe.message,
-        expectedGrantor       : tenant,
-        expectedGrantee       : recordsSubscribe.author!,
-        permissionGrant,
-        validationStateReader : deps.validationStateReader,
-      });
-      return;
-    }
-
-    // NOTE: not all RecordsSubscribe messages require protocol authorization even if the filter includes protocol-related fields,
-    // this is because we dynamically filter out records that the caller is not authorized to see.
-    // Currently only run protocol authorization if message deliberately invokes a protocol role.
-    if (Records.shouldProtocolAuthorize(recordsSubscribe.signaturePayload!)) {
-      await ProtocolAuthorization.authorizeQueryOrSubscribe(tenant, recordsSubscribe, deps.validationStateReader);
-    }
-  }
-
-  private async filterControlRecordsForNonOwner(
-    tenant: string,
-    recordsSubscribe: RecordsSubscribe,
-    requester: string | undefined,
-    recordsWrites: RecordsQueryReplyEntry[],
-  ): Promise<RecordsQueryReplyEntry[]> {
-    return EncryptionControl.filterVisibleControlRecords({
-      tenant,
-      incomingMessage       : recordsSubscribe.message,
-      requester,
-      recordsWriteMessages  : recordsWrites,
-      validationStateReader : this.deps.validationStateReader,
-    });
-  }
-
-  private async queryRecordsWithVisibleControlFiltering(
-    tenant: string,
-    recordsSubscribe: RecordsSubscribe,
-    requester: string | undefined,
-    filters: Filter[],
-    messageSort: MessageSort,
-    pagination: { cursor?: PaginationCursor; limit?: number } | undefined,
-  ): Promise<{ messages: RecordsQueryReplyEntry[], cursor?: PaginationCursor }> {
-    const controlFilters = Records.buildControlRecordsFilters(filters);
-    const currentAudienceRecordIdCache = new Map<string, string | undefined>();
-    if (controlFilters.length === 0) {
-      const result = await queryRecordsWithRecordLimitOccupancy({
-        messageStore          : this.deps.messageStore,
-        validationStateReader : this.deps.validationStateReader,
-        tenant,
-        filters,
-        messageSort,
-        pagination,
-        messageTimestamp      : recordsSubscribe.message.descriptor.messageTimestamp,
-      });
-      return EncryptionControl.projectCurrentAudienceRecordPage({
-        messageStore: this.deps.messageStore,
-        tenant,
-        filters,
-        currentAudienceRecordIdCache,
-        result,
-      });
-    }
-
-    if (pagination?.limit === undefined || pagination.limit <= 0) {
-      const result = await queryRecordsWithRecordLimitOccupancy({
-        messageStore          : this.deps.messageStore,
-        validationStateReader : this.deps.validationStateReader,
-        tenant,
-        filters,
-        messageSort,
-        pagination,
-        messageTimestamp      : recordsSubscribe.message.descriptor.messageTimestamp,
-      });
-      const projectedResult = await EncryptionControl.projectCurrentAudienceRecordPage({
-        messageStore: this.deps.messageStore,
-        tenant,
-        filters,
-        currentAudienceRecordIdCache,
-        result,
-      });
-      return {
-        messages : await this.filterControlRecordsForNonOwner(tenant, recordsSubscribe, requester, projectedResult.messages),
-        cursor   : projectedResult.cursor,
-      };
-    }
-
-    const visibleMessages: RecordsQueryReplyEntry[] = [];
-    let cursor = pagination.cursor;
-    let nextCursor: PaginationCursor | undefined;
-    // Keeps visible-page pagination stable until #1100 moves control visibility into indexed store filters.
-    do {
-      const remainingLimit = pagination.limit - visibleMessages.length;
-      const result = await queryRecordsWithRecordLimitOccupancy({
-        messageStore          : this.deps.messageStore,
-        validationStateReader : this.deps.validationStateReader,
-        tenant,
-        filters,
-        messageSort,
-        pagination            : { ...pagination, cursor, limit: remainingLimit },
-        messageTimestamp      : recordsSubscribe.message.descriptor.messageTimestamp,
-      });
-      const projectedResult = await EncryptionControl.projectCurrentAudienceRecordPage({
-        messageStore: this.deps.messageStore,
-        tenant,
-        filters,
-        currentAudienceRecordIdCache,
-        result,
-      });
-      const filteredMessages = await this.filterControlRecordsForNonOwner(
-        tenant,
-        recordsSubscribe,
-        requester,
-        projectedResult.messages,
-      );
-      visibleMessages.push(...filteredMessages);
-      nextCursor = projectedResult.cursor;
-      cursor = projectedResult.cursor;
-    } while (visibleMessages.length < pagination.limit && cursor !== undefined);
-
-    return { messages: visibleMessages, cursor: nextCursor };
-  }
-
 }

package/src/handlers/records-write.ts

@@ -1,5 +1,6 @@
 import type { CoreProtocol } from '../core/core-protocol.js';
 import type { ProgressToken } from '../types/subscriptions.js';
+import type { ProtocolRuleSet } from '../types/protocols-types.js';
 import type { GenericMessage, GenericMessageReply } from '../types/message-types.js';
 import type { HandlerDependencies, MethodHandler } from '../types/method-handler.js';
 import type { RecordsQueryReplyEntry, RecordsWriteMessage } from '../types/records-types.js';
@@ -64,8 +65,13 @@ export class RecordsWriteHandler implements MethodHandler {
       return messageReplyFromError(e, 400);
     }
 
+    let protocolRuleSet: ProtocolRuleSet;
     try {
-      await ProtocolAuthorization.validateReferentialIntegrity(tenant, recordsWrite, this.deps.validationStateReader);
+      protocolRuleSet = await ProtocolAuthorization.validateReferentialIntegrity(
+        tenant,
+        recordsWrite,
+        this.deps.validationStateReader,
+      );
     } catch (e) {
       return messageReplyFromError(e, 400);
     }
@@ -87,7 +93,7 @@ export class RecordsWriteHandler implements MethodHandler {
     // messageTimestamp is <= the most recent squash record at the same path and parent context.
     // The squash record acts as a temporal floor — no record older than the latest squash can exist.
     try {
-      await this.enforceSquashBackstop(tenant, message);
+      await this.enforceSquashBackstop(tenant, message, protocolRuleSet);
     } catch (e) {
       return messageReplyFromError(e, 409);
     }
@@ -445,38 +451,17 @@ export class RecordsWriteHandler implements MethodHandler {
    * and there exists a squash record at the same protocol path and parent context whose
    * `messageTimestamp` is >= the incoming message's `messageTimestamp`, reject with 409.
    *
+   * The rule set is the exact policy already resolved by referential-integrity validation. Reusing
+   * it prevents a second store lookup from observing different state or failing open.
+   *
    * This check only applies to protocol-based records at `$squash: true` paths.
    */
-  private async enforceSquashBackstop(tenant: string, message: RecordsWriteMessage): Promise<void> {
-    // Only applies to protocol-based records
-    if (message.descriptor.protocol === undefined || message.descriptor.protocolPath === undefined) {
-      return;
-    }
-
-    // Fetch the protocol definition active at the incoming message timestamp to check if $squash is enabled at this path.
-    // The reader resolves core protocols (e.g. permissions) from the registry.
-    let protocolDefinition;
-    try {
-      protocolDefinition = await this.deps.validationStateReader.fetchProtocolDefinition(
-        tenant,
-        message.descriptor.protocol,
-        message.descriptor.messageTimestamp,
-      );
-    } catch (error) {
-      // If the protocol definition can't be found, skip the backstop check.
-      // Authorization will handle the missing protocol error later.
-      console.warn(`enforceSquashBackstop: failed to fetch protocol definition for '${message.descriptor.protocol}':`, error);
-      return;
-    }
-
-    // Walk the structure to find the rule set for this protocol path
-    const pathSegments = message.descriptor.protocolPath.split('/');
-    let ruleSet = protocolDefinition.structure[pathSegments[0]];
-    for (let i = 1; i < pathSegments.length && ruleSet !== undefined; i++) {
-      ruleSet = ruleSet[pathSegments[i]] as typeof ruleSet;
-    }
-
-    if (ruleSet?.$squash !== true) {
+  private async enforceSquashBackstop(
+    tenant: string,
+    message: RecordsWriteMessage,
+    ruleSet: ProtocolRuleSet,
+  ): Promise<void> {
+    if (ruleSet.$squash !== true) {
       return;
     }
 

package/src/index.ts

@@ -9,9 +9,8 @@ export { StoreValidationStateReader } from './core/validation-state-reader.js';
 export type { RecordedValidationRead } from './core/recording-validation-state-reader.js';
 export { RecordingValidationStateReader } from './core/recording-validation-state-reader.js';
 export type { MessagesFilter, MessagesQueryDescriptor, MessagesQueryMessage, MessagesQueryReply, MessagesQueryReplyEntry, MessagesReadMessage, MessagesReadReply, MessagesReadReplyEntry, MessagesReadDescriptor, MessagesSubscribeDescriptor, MessagesSubscribeMessage, MessagesSubscribeReply, MessagesSubscribeMessageOptions } from './types/messages-types.js';
-export type { GT, LT, Filter, FilterValue, KeyValues, EqualFilter, OneOfFilter, RangeFilter, RangeCriterion, PaginationCursor, QueryOptions, RangeValue, StartsWithFilter } from './types/query-types.js';
+export type { GT, LT, Filter, FilterValue, KeyValues, EqualFilter, OneOfFilter, RangeFilter, RangeCriterion, PaginationCursor, QueryOptions, RangeValue, StartsWithFilter, SubtreeFilter } from './types/query-types.js';
 export type { ProtocolsConfigureDescriptor, ProtocolDefinition, ProtocolTypes, ProtocolRuleSet, ProtocolsQueryFilter, ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply, ProtocolActionRule, ProtocolDeliveryStrategy, ProtocolKeyAgreement, ProtocolsQueryDescriptor, ProtocolRecordLimitDefinition, ProtocolSizeDefinition, ProtocolTagsDefinition, ProtocolTagSchema, ProtocolType, ProtocolUses } from './types/protocols-types.js';
-export { ProtocolRecordLimitStrategy } from './types/protocols-types.js';
 export type { DataEncodedRecordsWriteMessage, RecordsCountDescriptor, RecordsCountMessage, RecordsCountReply, RecordsDeleteMessage, RecordsFilter, RecordsQueryMessage, RecordsQueryReply, RecordsQueryReplyEntry, RecordsReadMessage, RecordsReadReply, RecordsSubscribeDescriptor, RecordsSubscribeMessage, RecordsSubscribeReply, RecordsWriteDescriptor, RecordsWriteTags, RecordsWriteTagValue, RecordsWriteMessage, RecordsWriteSignaturePayload, RecordsDeleteDescriptor, RecordsQueryDescriptor, RecordsReadDescriptor, RecordsSubscribeMessageOptions, RecordsWriteMessageOptions, InternalRecordsWriteMessage, RecordEvent, RecordsWriteTagsFilter } from './types/records-types.js';
 export type { GeneralJws, SignatureEntry } from './types/jws-types.js';
 export { authenticate } from './core/auth.js';
@@ -53,6 +52,7 @@ export { DwnError, DwnErrorCode } from './core/dwn-error.js';
 export type { DwnErrorInfo } from './core/dwn-error.js';
 export { DwnInterfaceName, DwnMethodName } from './enums/dwn-interface-method.js';
 export { Encoder } from './utils/encoder.js';
+export { assertValidSubtreeFilters, isSubtreeFilter } from './utils/filter.js';
 export { MessagesSubscribe } from './interfaces/messages-subscribe.js';
 export type { MessagesSubscribeOptions } from './interfaces/messages-subscribe.js';
 export { Encryption, ContentEncryptionAlgorithm, KeyAgreementAlgorithm, ROLE_AUDIENCE_DERIVATION_SCHEME, SEAL_DERIVATION_SCHEME } from './utils/encryption.js';
@@ -82,7 +82,7 @@ export type { MessagesReadOptions } from './interfaces/messages-read.js';
 export { MessagesQuery } from './interfaces/messages-query.js';
 export type { MessagesQueryOptions } from './interfaces/messages-query.js';
 export type { UnionMessageReply } from './core/message-reply.js';
-export type { MessageStore, MessageStoreLatestStateTransition, MessageStoreOptions, MessageStorePutResult } from './types/message-store.js';
+export type { MessageStore, MessageStoreLatestStateTransition, MessageStoreOptions, MessageStorePutResult, MessageStoreQueryOptions, RecordLimitOccupancy } from './types/message-store.js';
 export { Replication } from './utils/replication.js';
 export type { MessageInterface } from './types/message-interface.js';
 export { PermissionGrant } from './protocols/permission-grant.js';

package/src/interfaces/protocols-configure.ts

@@ -9,6 +9,7 @@ import type {
 
 import { AbstractMessage } from '../core/abstract-message.js';
 import { DwnConstant } from '../core/dwn-constant.js';
+import { FilterUtility } from '../utils/filter.js';
 import { Message } from '../core/message.js';
 import { PermissionGrant } from '../protocols/permission-grant.js';
 import { ProtocolsGrantAuthorization } from '../core/protocols-grant-authorization.js';
@@ -18,7 +19,7 @@ import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
 import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
 import { getRoleAudienceContextId, getRuleSetAtPath, isCrossProtocolRef, parseCrossProtocolRef } from '../utils/protocols.js';
 import { normalizeProtocolUrl, normalizeSchemaUrl, validateProtocolUrlNormalized, validateSchemaUrlNormalized } from '../utils/url.js';
-import { ProtocolAction, ProtocolActor, ProtocolRecordLimitStrategy } from '../types/protocols-types.js';
+import { ProtocolAction, ProtocolActor } from '../types/protocols-types.js';
 
 export type ProtocolsConfigureOptions = {
   messageTimestamp?: string;
@@ -300,7 +301,7 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
 
     // Validate $recordLimit
     if (ruleSet.$recordLimit !== undefined) {
-      const { max, strategy } = ruleSet.$recordLimit;
+      const { max } = ruleSet.$recordLimit;
 
       if (!Number.isInteger(max) || max < 1) {
         throw new DwnError(
@@ -315,15 +316,6 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
           `Invalid $recordLimit.max value ${max} at protocol path '${ruleSetProtocolPath}': must be <= ${DwnConstant.maxRecordLimit}.`
         );
       }
-
-      const validStrategies = Object.values(ProtocolRecordLimitStrategy) as string[];
-      if (!validStrategies.includes(strategy as string)) {
-        throw new DwnError(
-          DwnErrorCode.ProtocolsConfigureInvalidRecordLimit,
-          `Invalid $recordLimit.strategy '${strategy}' at protocol path '${ruleSetProtocolPath}': ` +
-          `must be one of ${validStrategies.join(', ')}.`
-        );
-      }
     }
 
     if (ruleSet.$tags !== undefined) {
@@ -412,8 +404,7 @@ export class ProtocolsConfigure extends AbstractMessage<ProtocolsConfigureMessag
           ProtocolsConfigure.validateCrossProtocolAlias(actionRule.of, uses, ruleSetProtocolPath, 'of');
         } else {
           // Local `of`: must be self or ancestor
-          const isSelfOrAncestor = ruleSetProtocolPath === actionRule.of
-            || ruleSetProtocolPath.startsWith(actionRule.of + '/');
+          const isSelfOrAncestor = FilterUtility.matchesSubtree(actionRule.of, ruleSetProtocolPath);
           if (!isSelfOrAncestor) {
             throw new DwnError(
               DwnErrorCode.ProtocolsConfigureInvalidActionOfNotAnAncestor,

package/src/interfaces/records-count.ts

@@ -38,7 +38,7 @@ export class RecordsCount extends AbstractMessage<RecordsCountMessage> {
     }
 
     await Records.validateDelegatedGrantReferentialIntegrity(message, signaturePayload);
-    Records.validateNestedProtocolPathQueryScope(
+    Records.validateNestedProtocolPathScope(
       message.descriptor.filter,
       DwnErrorCode.RecordsCountNestedProtocolPathContextIdInvalid,
       'RecordsCount'