@adobe/spacecat-shared-data-access 2.88.9 → 2.90.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [@adobe/spacecat-shared-data-access-v2.90.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v2.89.0...@adobe/spacecat-shared-data-access-v2.90.0) (2025-12-08)
+
+
+### Features
+
+* **data-access:** handle configuration via s3 ([#1216](https://github.com/adobe/spacecat-shared/issues/1216)) ([ef03ab7](https://github.com/adobe/spacecat-shared/commit/ef03ab705bae8653162de12405bcbc65c32bb5a8))
+
+# [@adobe/spacecat-shared-data-access-v2.89.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v2.88.9...@adobe/spacecat-shared-data-access-v2.89.0) (2025-12-08)
+
+
+### Features
+
+* **audit-url:** add URL store data model and data access ([#1211](https://github.com/adobe/spacecat-shared/issues/1211)) ([a7e458e](https://github.com/adobe/spacecat-shared/commit/a7e458e91d4f1aa93b7243cea5361f028ef2b7db))
+
 # [@adobe/spacecat-shared-data-access-v2.88.9](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-data-access-v2.88.8...@adobe/spacecat-shared-data-access-v2.88.9) (2025-12-04)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-data-access",
-  "version": "2.88.9",
+  "version": "2.90.0",
   "description": "Shared modules of the Spacecat Services - Data Access",
   "type": "module",
   "engines": {
@@ -40,6 +40,7 @@
   "dependencies": {
     "@adobe/spacecat-shared-utils": "1.81.1",
     "@aws-sdk/client-dynamodb": "3.940.0",
+    "@aws-sdk/client-s3": "^3.940.0",
     "@aws-sdk/lib-dynamodb": "3.940.0",
     "@types/joi": "17.2.3",
     "aws-xray-sdk": "3.12.0",

package/src/index.js

@@ -26,6 +26,7 @@ export default function dataAccessWrapper(fn) {
    * Wrapper for data access layer. This wrapper will create a data access layer if it is not
    * already created. It requires the context to have a log object. It will also use the
    * DYNAMO_TABLE_NAME_DATA environment variable to create the data access layer.
+   * Optionally, it will use the ENV and AWS_REGION environment variables
    *
    * @param {object} request - The request object
    * @param {object} context - The context object
@@ -37,10 +38,14 @@ export default function dataAccessWrapper(fn) {
 
       const {
         DYNAMO_TABLE_NAME_DATA = TABLE_NAME_DATA,
+        S3_CONFIG_BUCKET: s3Bucket,
+        AWS_REGION: region,
       } = context.env;
 
       context.dataAccess = createDataAccess({
         tableNameData: DYNAMO_TABLE_NAME_DATA,
+        s3Bucket,
+        region,
       }, log);
     }
 

package/src/models/audit-url/audit-url.collection.js

@@ -0,0 +1,285 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { hasText } from '@adobe/spacecat-shared-utils';
+
+import BaseCollection from '../base/base.collection.js';
+
+/**
+ * AuditUrlCollection - A collection class responsible for managing AuditUrl entities.
+ * Extends the BaseCollection to provide specific methods for interacting with AuditUrl records.
+ *
+ * @class AuditUrlCollection
+ * @extends BaseCollection
+ */
+class AuditUrlCollection extends BaseCollection {
+  static COLLECTION_NAME = 'AuditUrlCollection';
+
+  /**
+   * Sorts audit URLs by a specified field.
+   * @param {Array} auditUrls - Array of AuditUrl objects to sort.
+   * @param {string} sortBy - Field to sort by ('url', 'createdAt', 'updatedAt').
+   * @param {string} sortOrder - Sort order ('asc' or 'desc'). Default: 'asc'.
+   * @returns {Array} Sorted array of AuditUrl objects.
+   * @private
+   */
+  static sortAuditUrls(auditUrls, sortBy = 'createdAt', sortOrder = 'asc') {
+    if (!auditUrls || auditUrls.length === 0) {
+      return auditUrls;
+    }
+
+    const sorted = [...auditUrls].sort((a, b) => {
+      let aValue;
+      let bValue;
+
+      // Get values using getter methods if available (with optional chaining)
+      switch (sortBy) {
+        case 'url':
+          aValue = a.getUrl?.() ?? a.url;
+          bValue = b.getUrl?.() ?? b.url;
+          break;
+        case 'createdAt':
+          aValue = a.getCreatedAt?.() ?? a.createdAt;
+          bValue = b.getCreatedAt?.() ?? b.createdAt;
+          break;
+        case 'updatedAt':
+          aValue = a.getUpdatedAt?.() ?? a.updatedAt;
+          bValue = b.getUpdatedAt?.() ?? b.updatedAt;
+          break;
+        default:
+          return 0;
+      }
+
+      // Handle null/undefined values (push to end)
+      if (aValue == null && bValue == null) return 0;
+      if (aValue == null) return 1;
+      if (bValue == null) return -1;
+
+      // Compare values
+      let comparison = 0;
+      if (typeof aValue === 'string' && typeof bValue === 'string') {
+        comparison = aValue.localeCompare(bValue);
+        /* c8 ignore start */
+        // Defensive: all current sort fields return strings,
+        // but keep numeric comparison for future extensibility
+      } else if (aValue < bValue) {
+        comparison = -1;
+      } else if (aValue > bValue) {
+        comparison = 1;
+      } else {
+        comparison = 0;
+      }
+      /* c8 ignore stop */
+
+      return sortOrder === 'desc' ? -comparison : comparison;
+    });
+
+    return sorted;
+  }
+
+  /**
+   * Finds an audit URL by its composite primary key (siteId + url).
+   * This is the primary lookup method, similar to LatestAudit.findById(siteId, auditType).
+   *
+   * @param {string} siteId - The site ID (partition key).
+   * @param {string} url - The URL (sort key).
+   * @returns {Promise<AuditUrl|null>} The found AuditUrl or null.
+   */
+  async findById(siteId, url) {
+    if (!hasText(siteId) || !hasText(url)) {
+      throw new Error('Both siteId and url are required');
+    }
+
+    return this.findByIndexKeys({ siteId, url });
+  }
+
+  /**
+   * Convenience alias for findById.
+   * @param {string} siteId - The site ID (partition key).
+   * @param {string} url - The URL (sort key).
+   * @returns {Promise<AuditUrl|null>} The found AuditUrl or null.
+   */
+  async findBySiteIdAndUrl(siteId, url) {
+    return this.findById(siteId, url);
+  }
+
+  /**
+   * Gets all audit URLs for a site that have a specific audit type enabled.
+   * Uses DynamoDB FilterExpression to filter at the database level.
+   *
+   * @param {string} siteId - The site ID.
+   * @param {string} auditType - The audit type to filter by.
+   * @param {object} [options={}] - Query options (limit, cursor, sortBy, sortOrder).
+   * @returns {Promise<{data: AuditUrl[], cursor: string|null}>} Paginated results.
+   */
+  async allBySiteIdAndAuditType(siteId, auditType, options = {}) {
+    if (!hasText(siteId) || !hasText(auditType)) {
+      throw new Error('Both siteId and auditType are required');
+    }
+
+    const { sortBy, sortOrder, ...queryOptions } = options;
+
+    // Use FilterExpression to filter at DynamoDB level (reduces network transfer)
+    const result = await this.allByIndexKeys(
+      { siteId },
+      {
+        ...queryOptions,
+        returnCursor: true,
+        where: (attr, op) => op.contains(attr.audits, auditType),
+      },
+    );
+
+    // Handle result format
+    const data = result.data || [];
+    const { cursor } = result;
+
+    // Apply sorting if requested
+    const sortedData = sortBy
+      ? AuditUrlCollection.sortAuditUrls(data, sortBy, sortOrder)
+      : data;
+
+    return {
+      data: sortedData,
+      cursor,
+    };
+  }
+
+  /**
+   * Gets all audit URLs for a site with sorting support.
+   * @param {string} siteId - The site ID.
+   * @param {object} [options={}] - Query options (limit, cursor, sortBy, sortOrder).
+   * @returns {Promise<{data: AuditUrl[], cursor: string|null}>} Paginated and sorted results.
+   */
+  async allBySiteIdSorted(siteId, options = {}) {
+    if (!hasText(siteId)) {
+      throw new Error('SiteId is required');
+    }
+
+    const { sortBy, sortOrder, ...queryOptions } = options;
+
+    // Get all URLs for the site with pagination metadata
+    const result = await this.allByIndexKeys(
+      { siteId },
+      { ...queryOptions, returnCursor: true },
+    );
+
+    // Handle result format
+    const data = result.data || [];
+    const { cursor } = result;
+
+    // Apply sorting if requested
+    const sortedData = sortBy
+      ? AuditUrlCollection.sortAuditUrls(data, sortBy, sortOrder)
+      : data;
+
+    return {
+      data: sortedData,
+      cursor,
+    };
+  }
+
+  /**
+   * Gets all audit URLs for a site by byCustomer flag with sorting support.
+   * Uses GSI (spacecat-data-gsi2pk-gsi2sk) for efficient querying.
+   * @param {string} siteId - The site ID.
+   * @param {boolean} byCustomer - True for customer-added, false for system-added.
+   * @param {object} [options={}] - Query options (limit, cursor, sortBy, sortOrder).
+   * @returns {Promise<{data: AuditUrl[], cursor: string|null}>} Paginated and sorted results.
+   */
+  async allBySiteIdByCustomerSorted(siteId, byCustomer, options = {}) {
+    if (!hasText(siteId) || typeof byCustomer !== 'boolean') {
+      throw new Error('SiteId is required and byCustomer must be a boolean');
+    }
+
+    const { sortBy, sortOrder, ...queryOptions } = options;
+
+    // Use GSI for efficient querying by siteId + byCustomer with pagination metadata
+    const result = await this.allByIndexKeys(
+      { siteId, byCustomer },
+      {
+        ...queryOptions,
+        returnCursor: true,
+        index: 'spacecat-data-gsi2pk-gsi2sk',
+      },
+    );
+
+    // Handle result format
+    const data = result.data || [];
+    const { cursor } = result;
+
+    // Apply sorting if requested
+    const sortedData = sortBy
+      ? AuditUrlCollection.sortAuditUrls(data, sortBy, sortOrder)
+      : data;
+
+    return {
+      data: sortedData,
+      cursor,
+    };
+  }
+
+  /**
+   * Removes all audit URLs for a specific site.
+   * Useful for cleanup operations.
+   *
+   * @param {string} siteId - The site ID.
+   * @returns {Promise<void>}
+   */
+  async removeForSiteId(siteId) {
+    if (!hasText(siteId)) {
+      throw new Error('SiteId is required');
+    }
+
+    const urlsToRemove = await this.allBySiteId(siteId);
+
+    if (urlsToRemove.length > 0) {
+      // Use composite keys (siteId + url) for deletion
+      const keysToRemove = urlsToRemove.map((auditUrl) => ({
+        siteId,
+        url: auditUrl.getUrl?.() ?? auditUrl.url,
+      }));
+      await this.removeByIndexKeys(keysToRemove);
+    }
+  }
+
+  /**
+   * Removes audit URLs by byCustomer flag for a specific site.
+   * For example, remove all customer-added or all system-added URLs.
+   * Uses GSI (spacecat-data-gsi2pk-gsi2sk) for efficient querying.
+   *
+   * @param {string} siteId - The site ID.
+   * @param {boolean} byCustomer - True for customer-added, false for system-added.
+   * @returns {Promise<void>}
+   */
+  async removeForSiteIdByCustomer(siteId, byCustomer) {
+    if (!hasText(siteId) || typeof byCustomer !== 'boolean') {
+      throw new Error('SiteId is required and byCustomer must be a boolean');
+    }
+
+    // Use GSI for efficient querying by siteId + byCustomer
+    const urlsToRemove = await this.allByIndexKeys(
+      { siteId, byCustomer },
+      { index: 'spacecat-data-gsi2pk-gsi2sk' },
+    );
+
+    if (urlsToRemove.length > 0) {
+      // Use composite keys (siteId + url) for deletion
+      const keysToRemove = urlsToRemove.map((auditUrl) => ({
+        siteId,
+        url: auditUrl.getUrl?.() ?? auditUrl.url,
+      }));
+      await this.removeByIndexKeys(keysToRemove);
+    }
+  }
+}
+
+export default AuditUrlCollection;

package/src/models/audit-url/audit-url.model.js

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import BaseModel from '../base/base.model.js';
+
+/**
+ * AuditUrl - A class representing an AuditUrl entity.
+ * Provides methods to access and manipulate AuditUrl-specific data.
+ *
+ * @class AuditUrl
+ * @extends BaseModel
+ */
+class AuditUrl extends BaseModel {
+  static ENTITY_NAME = 'AuditUrl';
+
+  /**
+   * Checks if this URL is enabled for a specific audit type.
+   * @param {string} auditType - The audit type to check.
+   * @returns {boolean} True if the audit is enabled for this URL.
+   */
+  isAuditEnabled(auditType) {
+    const audits = this.getAudits?.() ?? this.audits ?? [];
+    return audits.includes(auditType);
+  }
+
+  /**
+   * Adds an audit type to the audits array if not already present.
+   * @param {string} auditType - The audit type to add.
+   * @returns {this} The current instance for chaining.
+   */
+  enableAudit(auditType) {
+    const audits = this.getAudits?.() ?? this.audits ?? [];
+    if (!audits.includes(auditType)) {
+      // Create a new array instead of mutating the existing one
+      const updatedAudits = [...audits, auditType];
+      if (this.setAudits) {
+        this.setAudits(updatedAudits);
+      } else {
+        this.audits = updatedAudits;
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Removes an audit type from the audits array.
+   * @param {string} auditType - The audit type to remove.
+   * @returns {this} The current instance for chaining.
+   */
+  disableAudit(auditType) {
+    const audits = this.getAudits?.() ?? this.audits ?? [];
+    // filter() already creates a new array
+    const filtered = audits.filter((a) => a !== auditType);
+    if (this.setAudits) {
+      this.setAudits(filtered);
+    } else {
+      this.audits = filtered;
+    }
+    return this;
+  }
+
+  /**
+   * Checks if this URL was added by a customer.
+   * @returns {boolean} True if the URL was added by a customer.
+   */
+  isCustomerUrl() {
+    const byCustomer = this.getByCustomer?.() ?? this.byCustomer;
+    return byCustomer === true;
+  }
+
+  /**
+   * Generates the composite keys for the AuditUrl model.
+   * Required for ElectroDB operations with composite primary key (siteId + url).
+   * @returns {Object} - The composite keys.
+   */
+  generateCompositeKeys() {
+    return {
+      siteId: this.getSiteId(),
+      url: this.getUrl(),
+    };
+  }
+}
+
+export default AuditUrl;

package/src/models/audit-url/audit-url.schema.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/* c8 ignore start */
+
+import { isValidUrl } from '@adobe/spacecat-shared-utils';
+
+import SchemaBuilder from '../base/schema.builder.js';
+import AuditUrl from './audit-url.model.js';
+import AuditUrlCollection from './audit-url.collection.js';
+
+/*
+Schema Doc: https://electrodb.dev/en/modeling/schema/
+Attribute Doc: https://electrodb.dev/en/modeling/attributes/
+Indexes Doc: https://electrodb.dev/en/modeling/indexes/
+
+Data Access Patterns:
+1. Get all URLs for a site: allBySiteId(siteId)
+2. Get all URLs for a site by byCustomer: allBySiteIdAndByCustomer(siteId, byCustomer) - uses GSI
+3. Get a specific URL: findById(siteId, url) - uses composite primary key
+4. Get URLs by audit type: filter in code after allBySiteId (audits is a Set)
+
+Primary Key (Composite):
+- Partition Key (PK): siteId
+- Sort Key (SK): url
+- This provides natural uniqueness for siteId + url combinations
+- Similar pattern to LatestAudit (siteId + auditType)
+
+GSI: spacecat-data-gsi2pk-gsi2sk (byCustomer)
+- Partition Key: siteId
+- Sort Key: byCustomer, url
+- Enables efficient filtering by customer-added vs system-added URLs
+*/
+
+const schema = new SchemaBuilder(AuditUrl, AuditUrlCollection)
+  .withPrimaryPartitionKeys(['siteId'])
+  .withPrimarySortKeys(['url'])
+  .addReference('belongs_to', 'Site')
+  .addAttribute('url', {
+    type: 'string',
+    required: true,
+    validate: (value) => isValidUrl(value),
+  })
+  .addAttribute('byCustomer', {
+    type: 'boolean',
+    required: true,
+    default: true,
+  })
+  .addIndex(
+    { composite: ['siteId'] },
+    { composite: ['byCustomer', 'url'] },
+  )
+  .addAttribute('audits', {
+    type: 'set',
+    items: 'string',
+    required: true,
+    default: [],
+  })
+  .addAttribute('createdBy', {
+    type: 'string',
+    required: true,
+    readOnly: true,
+    default: 'system',
+  });
+
+export default schema.build();

package/src/models/audit-url/index.d.ts

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import type { BaseCollection, BaseModel, Site } from '../index';
+
+/**
+ * AuditUrl entity representing a URL to be audited for a site.
+ * Composite primary key: siteId (PK) + url (SK)
+ * Similar pattern to LatestAudit (siteId + auditType)
+ */
+export interface AuditUrl extends BaseModel {
+  getAudits(): string[];
+  getCreatedAt(): string;
+  getCreatedBy(): string;
+  getUpdatedAt(): string;
+  getUpdatedBy(): string;
+  getSite(): Promise<Site>;
+  getSiteId(): string;
+  getByCustomer(): boolean;
+  getUrl(): string;
+  setAudits(audits: string[]): AuditUrl;
+  setSiteId(siteId: string): AuditUrl;
+  setByCustomer(byCustomer: boolean): AuditUrl;
+  setUrl(url: string): AuditUrl;
+  setUpdatedBy(updatedBy: string): AuditUrl;
+  isAuditEnabled(auditType: string): boolean;
+  enableAudit(auditType: string): AuditUrl;
+  disableAudit(auditType: string): AuditUrl;
+  isCustomerUrl(): boolean;
+}
+
+export interface AuditUrlCollection extends BaseCollection<AuditUrl> {
+  findById(siteId: string, url: string): Promise<AuditUrl | null>;
+  findBySiteIdAndUrl(siteId: string, url: string): Promise<AuditUrl | null>;
+  allBySiteId(siteId: string): Promise<AuditUrl[]>;
+  allBySiteIdAndByCustomer(siteId: string, byCustomer: boolean): Promise<AuditUrl[]>;
+  allBySiteIdAndUrl(siteId: string, url: string): Promise<AuditUrl[]>;
+  allBySiteIdSorted(siteId: string, options?: { limit?: number; cursor?: string; sortBy?: string; sortOrder?: string }): Promise<{ data: AuditUrl[]; cursor: string | null }>;
+  allBySiteIdByCustomerSorted(siteId: string, byCustomer: boolean, options?: { limit?: number; cursor?: string; sortBy?: string; sortOrder?: string }): Promise<{ data: AuditUrl[]; cursor: string | null }>;
+  allBySiteIdAndAuditType(siteId: string, auditType: string, options?: { limit?: number; cursor?: string; sortBy?: string; sortOrder?: string }): Promise<{ data: AuditUrl[]; cursor: string | null }>;
+  removeForSiteId(siteId: string): Promise<void>;
+  removeForSiteIdByCustomer(siteId: string, byCustomer: boolean): Promise<void>;
+}

package/src/models/audit-url/index.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import AuditUrl from './audit-url.model.js';
+import AuditUrlCollection from './audit-url.collection.js';
+
+export {
+  AuditUrl,
+  AuditUrlCollection,
+};

package/src/models/base/base.collection.js

@@ -27,6 +27,7 @@ import {
   entityNameToAllPKValue,
   removeElectroProperties,
 } from '../../util/util.js';
+import { DATASTORE_TYPE } from '../../util/index.js';
 
 function isValidParent(parent, child) {
   if (!hasText(parent.entityName)) {
@@ -55,6 +56,13 @@ class BaseCollection {
    */
   static COLLECTION_NAME = undefined;
 
+  /**
+   * The datastore type for this collection. Defaults to DYNAMO.
+   * Override in subclasses to use a different datastore (e.g., S3).
+   * @type {string}
+   */
+  static DATASTORE_TYPE = DATASTORE_TYPE.DYNAMO;
+
   /**
    * Constructs an instance of BaseCollection.
    * @constructor
@@ -245,6 +253,7 @@ class BaseCollection {
         order: options.order || 'desc',
         ...options.limit && { limit: options.limit },
         ...options.attributes && { attributes: options.attributes },
+        /* c8 ignore next */
         ...options.cursor && { cursor: options.cursor },
       };
 
@@ -257,6 +266,11 @@ class BaseCollection {
         );
       }
 
+      // Apply where clause (FilterExpression) if provided
+      if (typeof options.where === 'function') {
+        query = query.where(options.where);
+      }
+
       // execute the initial query
       let result = await query.go(queryOptions);
       let allData = result.data;
@@ -284,6 +298,7 @@ class BaseCollection {
         return allData.length ? this.#createInstance(allData[0]) : null;
       } else {
         const instances = this.#createInstances(allData);
+        /* c8 ignore next 2 */
         return shouldReturnCursor
           ? { data: instances, cursor: result.cursor || null }
           : instances;
@@ -412,6 +427,7 @@ class BaseCollection {
         .filter((entity) => entity !== null);
 
       // Extract unprocessed keys
+      /* c8 ignore next 3 */
       const unprocessed = result.unprocessed
         ? result.unprocessed.map((item) => item)
         : [];