@adobe/spacecat-shared-data-access 1.60.2 → 1.61.0

package/src/v2/models/base/index.d.ts

@@ -12,7 +12,13 @@
 
 import type { ValidationError } from '../../errors';
 
+export interface MultiStatusCreateResult<T> {
+  createdItems: T[],
+  errorItems: { item: object, error: ValidationError }[],
+}
+
 export interface BaseModel {
+  _remove(): Promise<this>;
   getCreatedAt(): string;
   getId(): string;
   getUpdatedAt(): string;
@@ -21,11 +27,6 @@ export interface BaseModel {
   toJSON(): object;
 }
 
-export interface MultiStatusCreateResult<T> {
-  createdItems: T[],
-  errorItems: { item: object, error: ValidationError }[],
-}
-
 export interface QueryOptions {
   index?: string;
   limit?: number;
@@ -34,12 +35,15 @@ export interface QueryOptions {
 }
 
 export interface BaseCollection<T extends BaseModel> {
+  _onCreate(item: T): void;
+  _onCreateMany(items: MultiStatusCreateResult<T>): void;
+  _saveMany(items: T[]): Promise<T[]>;
   all(sortKeys?: object, options?: QueryOptions): Promise<T[]>;
   allByIndexKeys(keys: object, options?: QueryOptions): Promise<T[]>;
   create(item: object): Promise<T>;
-  createMany(items: object[]): Promise<MultiStatusCreateResult<T>>;
-  findByAll(sortKeys?: object, options?: QueryOptions): Promise<T>;
-  findById(id: string): Promise<T>;
+  createMany(items: object[], parent?: T): Promise<MultiStatusCreateResult<T>>;
+  findByAll(sortKeys?: object, options?: QueryOptions): Promise<T> | null;
+  findById(id: string): Promise<T> | null;
   findByIndexKeys(indexKeys: object): Promise<T>;
   removeByIds(ids: string[]): Promise<void>;
 }
@@ -56,6 +60,7 @@ export interface Reference {
   getTarget(): string;
   getType(): string;
   isRemoveDependents(): boolean;
+  toAccessorConfigs(): object[];
 }
 
 export interface IndexAccessor {
@@ -64,27 +69,41 @@ export interface IndexAccessor {
 }
 
 export interface Schema {
+  allowsRemove(): boolean;
+  allowsUpdates(): boolean;
   findIndexBySortKeys(sortKeys: string[]): object | null;
   findIndexByType(type: string): object | null;
+  findIndexNameByKeys(keys: object): string;
   getAttribute(name: string): object;
   getAttributes(): object;
   getCollectionName(): string;
   getEntityName(): string;
   getIdName(): string;
   getIndexAccessors(): Array<IndexAccessor>;
-  getIndexes(): object;
+  getIndexByName(indexName: string): object;
   getIndexKeys(indexName: string): string[];
+  getIndexTypes(): string[];
+  getIndexes(): object;
   getModelClass(): object;
   getModelName(): string;
+  getReciprocalReference(registry: EntityRegistry, reference: Reference): Reference | null;
+  getReferenceByTypeAndTarget(referenceType: string, target: string): Reference | undefined;
   getReferences(): Reference[];
   getReferencesByType(referenceType: string): Reference[];
-  getReferenceByTypeAndTarget(referenceType: string, target: string): Reference | undefined;
+  getServiceName(): string;
+  getVersion(): number;
+  toAccessorConfigs(): object[];
+  toElectroDBSchema(): object;
 }
 
 export interface SchemaBuilder {
-  addAttribute(name: string, data: object): SchemaBuilder;
   addAllIndex(sortKeys: string[]): SchemaBuilder;
+  addAttribute(name: string, data: object): SchemaBuilder;
   addIndex(name: string, partitionKey: object, sortKey: object): SchemaBuilder;
   addReference(referenceType: string, entityName: string, sortKeys?: string[]): SchemaBuilder;
+  allowRemove(allow: boolean): SchemaBuilder;
+  allowUpdate(allow: boolean): SchemaBuilder;
   build(): Schema;
+  withPrimaryPartitionKeys(partitionKeys: string[]): SchemaBuilder
+  withPrimarySortKeys(sortKeys: string[]): SchemaBuilder;
 }

package/src/v2/models/base/reference.js

@@ -10,7 +10,9 @@
  * governing permissions and limitations under the License.
  */
 
-import { hasText } from '@adobe/spacecat-shared-utils';
+import { hasText, isNonEmptyObject } from '@adobe/spacecat-shared-utils';
+
+import ReferenceError from '../../errors/reference.error.js';
 import {
   entityNameToCollectionName,
   entityNameToIdName,
@@ -19,6 +21,48 @@ import {
   referenceToBaseMethodName,
 } from '../../util/util.js';
 
+const createSortKeyAccessorConfigs = (
+  entity,
+  baseConfig,
+  baseMethodName,
+  target,
+  targetCollection,
+  foreignKeyName,
+  foreignKeyValue,
+  log,
+) => {
+  const configs = [];
+
+  const belongsToRef = targetCollection.schema.getReferenceByTypeAndTarget(
+    // eslint-disable-next-line no-use-before-define
+    Reference.TYPES.BELONGS_TO,
+    entity.schema.getModelName(),
+  );
+
+  if (!belongsToRef) {
+    log.warn(`Reciprocal reference not found for ${entity.schema.getModelName()} to ${target}`);
+    return configs;
+  }
+
+  const sortKeys = belongsToRef.getSortKeys();
+  if (!isNonEmptyArray(sortKeys)) {
+    log.debug(`No sort keys defined for ${entity.schema.getModelName()} to ${target}`);
+    return configs;
+  }
+
+  for (let i = 1; i <= sortKeys.length; i += 1) {
+    const subset = sortKeys.slice(0, i);
+    configs.push({
+      name: keyNamesToMethodName(subset, `${baseMethodName}By`),
+      requiredKeys: subset,
+      foreignKey: { name: foreignKeyName, value: foreignKeyValue },
+      ...baseConfig,
+    });
+  }
+
+  return configs;
+};
+
 class Reference {
   static TYPES = {
     BELONGS_TO: 'belongs_to',
@@ -36,11 +80,11 @@ class Reference {
 
   constructor(type, target, options = {}) {
     if (!Reference.isValidType(type)) {
-      throw new Error(`Invalid reference type: ${type}`);
+      throw new ReferenceError(this, `Invalid reference type: ${type}`);
     }
 
     if (!hasText(target)) {
-      throw new Error('Invalid target');
+      throw new ReferenceError(this, 'Invalid target');
     }
 
     this.type = type;
@@ -65,6 +109,14 @@ class Reference {
   }
 
   toAccessorConfigs(registry, entity) {
+    if (!isNonEmptyObject(registry)) {
+      throw new ReferenceError(this, 'Invalid registry');
+    }
+
+    if (!isNonEmptyObject(entity)) {
+      throw new ReferenceError(this, 'Invalid entity');
+    }
+
     const { log } = registry;
     const accessorConfigs = [];
 
@@ -100,6 +152,20 @@ class Reference {
           requiredKeys: [],
           foreignKey: { name: foreignKeyName, value: foreignKeyValue },
         });
+
+        accessorConfigs.push(
+          ...createSortKeyAccessorConfigs(
+            entity,
+            {},
+            baseMethodName,
+            target,
+            targetCollection,
+            foreignKeyName,
+            foreignKeyValue,
+            log,
+          ),
+        );
+
         break;
       }
 
@@ -115,37 +181,24 @@ class Reference {
           foreignKey: { name: foreignKeyName, value: foreignKeyValue },
         });
 
-        const belongsToRef = targetCollection.schema.getReferenceByTypeAndTarget(
-          Reference.TYPES.BELONGS_TO,
-          entity.schema.getModelName(),
+        accessorConfigs.push(
+          ...createSortKeyAccessorConfigs(
+            entity,
+            { all: true },
+            baseMethodName,
+            target,
+            targetCollection,
+            foreignKeyName,
+            foreignKeyValue,
+            log,
+          ),
         );
 
-        if (!belongsToRef) {
-          log.warn(`Reciprocal reference not found for ${entity.schema.getModelName()} to ${target}`);
-          break;
-        }
-
-        const sortKeys = belongsToRef.getSortKeys();
-        if (!isNonEmptyArray(sortKeys)) {
-          log.debug(`No sort keys defined for ${entity.schema.getModelName()} to ${target}`);
-          break;
-        }
-
-        for (let i = 1; i <= sortKeys.length; i += 1) {
-          const subset = sortKeys.slice(0, i);
-          accessorConfigs.push({
-            name: keyNamesToMethodName(subset, `${baseMethodName}By`),
-            requiredKeys: subset,
-            all: true,
-            foreignKey: { name: foreignKeyName, value: foreignKeyValue },
-          });
-        }
-
         break;
       }
 
       default:
-        throw new Error(`Unsupported reference type: ${type}`);
+        throw new ReferenceError(this, `Unsupported reference type: ${type}`);
     }
 
     return accessorConfigs.map((config) => ({

package/src/v2/models/base/schema.builder.js

@@ -10,10 +10,13 @@
  * governing permissions and limitations under the License.
  */
 
-import { hasText, isInteger, isNonEmptyObject } from '@adobe/spacecat-shared-utils';
+import {
+  hasText, isBoolean, isInteger, isNonEmptyObject,
+} from '@adobe/spacecat-shared-utils';
 
 import { v4 as uuid, validate as uuidValidate } from 'uuid';
 
+import { SchemaBuilderError } from '../../errors/index.js';
 import {
   decapitalize,
   entityNameToAllPKValue,
@@ -21,7 +24,6 @@ import {
   isNonEmptyArray,
 } from '../../util/util.js';
 
-import { INDEX_TYPES } from './constants.js';
 import BaseModel from './base.model.js';
 import BaseCollection from './base.collection.js';
 import Reference from './reference.js';
@@ -86,21 +88,21 @@ class SchemaBuilder {
    * @param {BaseModel} modelClass - The model class for this entity.
    * @param {BaseCollection} collectionClass - The collection class for this entity.
    * @param {number} schemaVersion - A positive integer representing the schema's version.
-   * @throws {Error} If entityName is not a non-empty string.
-   * @throws {Error} If schemaVersion is not a positive integer.
-   * @throws {Error} If serviceName is not a non-empty string.
+   * @throws {SchemaBuilderError} If entityName is not a non-empty string.
+   * @throws {SchemaBuilderError} If schemaVersion is not a positive integer.
+   * @throws {SchemaBuilderError} If serviceName is not a non-empty string.
    */
   constructor(modelClass, collectionClass, schemaVersion = 1) {
     if (!modelClass || !(modelClass.prototype instanceof BaseModel)) {
-      throw new Error('modelClass must be a subclass of BaseModel.');
+      throw new SchemaBuilderError(this, 'modelClass must be a subclass of BaseModel.');
     }
 
     if (!collectionClass || !(collectionClass.prototype instanceof BaseCollection)) {
-      throw new Error('collectionClass must be a subclass of BaseCollection.');
+      throw new SchemaBuilderError(this, 'collectionClass must be a subclass of BaseCollection.');
     }
 
     if (!isInteger(schemaVersion) || schemaVersion < 1) {
-      throw new Error('schemaVersion is required and must be a positive integer.');
+      throw new SchemaBuilderError(this, 'schemaVersion is required and must be a positive integer.');
     }
 
     this.modelClass = modelClass;
@@ -118,6 +120,7 @@ class SchemaBuilder {
       other: [],
     };
 
+    this.options = { allowUpdates: true, allowRemove: true };
     this.attributes = {};
 
     // will be populated by build() from rawIndexes
@@ -153,21 +156,89 @@ class SchemaBuilder {
     });
   }
 
+  withPrimaryPartitionKeys(partitionKeys) {
+    if (!isNonEmptyArray(partitionKeys)) {
+      throw new SchemaBuilderError(this, 'Partition keys are required and must be a non-empty array.');
+    }
+    this.rawIndexes.primary.pk.composite = partitionKeys;
+
+    return this;
+  }
+
+  /**
+   * Sets the sort keys for the primary index (main table). The given sort keys
+   * together with the entity id (partition key) will form the primary key. This will
+   * change the behavior of collection methods (like findById) that rely on the main
+   * table primary key.
+   *
+   * This should only be used in special cases.
+   *
+   * @param {Array<string>} sortKeys - The attributes to form the sort key.
+   * @throws {SchemaBuilderError} If sortKeys are not provided or are not a non-empty array.
+   * @return {SchemaBuilder}
+   */
+  withPrimarySortKeys(sortKeys) {
+    if (!isNonEmptyArray(sortKeys)) {
+      throw new SchemaBuilderError(this, 'Sort keys are required and must be a non-empty array.');
+    }
+    this.rawIndexes.primary.sk.composite = sortKeys;
+
+    return this;
+  }
+
+  /**
+   * By default a schema allows removes. This method allows
+   * to disable removes for this entity. Note that this does
+   * not prevent removes at the database level, but rather
+   * at the application level. The flag is ignored when
+   * remove is called implicitly when the entity is removed
+   * as part of parent entity remove (dependents).
+   * @param {boolean} allow - Whether to allow removes.
+   * @throws {SchemaBuilderError} If allow is not a boolean.
+   * @return {SchemaBuilder}
+   */
+  allowRemove(allow) {
+    if (!isBoolean(allow)) {
+      throw new SchemaBuilderError(this, 'allow must be a boolean.');
+    }
+    this.options.allowRemove = allow;
+
+    return this;
+  }
+
+  /**
+   * By default a schema allows updates. This method allows
+   * to disable updates for this entity. Note that this does
+   * not prevent updates at the database level, but rather
+   * at the application level.
+   * @param {boolean} allow - Whether to allow updates.
+   * @throws {SchemaBuilderError} If allow is not a boolean.
+   * @return {SchemaBuilder}
+   */
+  allowUpdates(allow) {
+    if (!isBoolean(allow)) {
+      throw new SchemaBuilderError(this, 'allow must be a boolean.');
+    }
+    this.options.allowUpdates = allow;
+
+    return this;
+  }
+
   /**
    * Adds a new attribute to the schema definition.
    *
    * @param {string} name - The attribute name.
    * @param {object} data - The attribute definition (type, required, validation, etc.).
    * @returns {SchemaBuilder} Returns this builder for method chaining.
-   * @throws {Error} If name is not non-empty or data is not an object.
+   * @throws {SchemaBuilderError} If name is not non-empty or data is not an object.
    */
   addAttribute(name, data) {
     if (!hasText(name)) {
-      throw new Error('Attribute name is required and must be non-empty.');
+      throw new SchemaBuilderError(this, 'Attribute name is required and must be non-empty.');
     }
 
     if (!isNonEmptyObject(data)) {
-      throw new Error(`Attribute data for "${name}" is required and must be a non-empty object.`);
+      throw new SchemaBuilderError(this, `Attribute data for "${name}" is required and must be a non-empty object.`);
     }
 
     this.attributes[name] = data;
@@ -182,17 +253,17 @@ class SchemaBuilder {
    *
    * @param {Array<string>} sortKeys - The attributes to form the sort key.
    * @returns {SchemaBuilder} Returns this builder for method chaining.
-   * @throws {Error} If composite attribute names or template are not provided.
+   * @throws {SchemaBuilderError} If composite attribute names or template are not provided.
    */
   addAllIndex(sortKeys) {
     if (!isNonEmptyArray(sortKeys)) {
-      throw new Error('Sort keys are required and must be a non-empty array.');
+      throw new SchemaBuilderError(this, 'Sort keys are required and must be a non-empty array.');
     }
 
     this.#internalAddIndex(
       { template: entityNameToAllPKValue(this.entityName) },
       { composite: sortKeys },
-      INDEX_TYPES.ALL,
+      Schema.INDEX_TYPES.ALL,
     );
 
     return this;
@@ -205,18 +276,18 @@ class SchemaBuilder {
    * (e.g., { composite: [attributeName] }).
    * @param {object} sortKey - The sort key definition.
    * @returns {SchemaBuilder} Returns this builder for method chaining.
-   * @throws {Error} If index name is reserved or pk/sk configs are invalid.
+   * @throws {SchemaBuilderError} If index name is reserved or pk/sk configs are invalid.
    */
   addIndex(partitionKey, sortKey) {
     if (!isNonEmptyObject(partitionKey)) {
-      throw new Error('Partition key configuration (pk) is required and must be a non-empty object.');
+      throw new SchemaBuilderError(this, 'Partition key configuration (pk) is required and must be a non-empty object.');
     }
 
     if (!isNonEmptyObject(sortKey)) {
-      throw new Error('Sort key configuration (sk) is required and must be a non-empty object.');
+      throw new SchemaBuilderError(this, 'Sort key configuration (sk) is required and must be a non-empty object.');
     }
 
-    this.#internalAddIndex(partitionKey, sortKey, INDEX_TYPES.OTHER);
+    this.#internalAddIndex(partitionKey, sortKey, Schema.INDEX_TYPES.OTHER);
 
     return this;
   }
@@ -226,22 +297,22 @@ class SchemaBuilder {
    *
    * @param {string} type - One of Reference.TYPES (BELONGS_TO, HAS_MANY, HAS_ONE).
    * @param {string} entityName - The referenced entity name.
-   * @param {Array<string>} [sortKeys=['updatedAt']] - The attributes to form the sort key.
+   * @param {Array<string>} [sortKeys=[]] - The attributes to form the sort key.
    * @param {object} [options] - Additional reference options.
    * @param {boolean} [options.required=true] - Whether the reference is required. Only applies to
    * BELONGS_TO references.
    * @param {boolean} [options.removeDependents=false] - Whether to remove dependent entities
    * on delete. Only applies to HAS_MANY and HAS_ONE references.
    * @returns {SchemaBuilder} Returns this builder for method chaining.
-   * @throws {Error} If type or entityName are invalid.
+   * @throws {SchemaBuilderError} If type or entityName are invalid.
    */
   addReference(type, entityName, sortKeys = [], options = {}) {
     if (!Reference.isValidType(type)) {
-      throw new Error(`Invalid referenceType: "${type}".`);
+      throw new SchemaBuilderError(this, `Invalid referenceType: "${type}".`);
     }
 
     if (!hasText(entityName)) {
-      throw new Error('entityName for reference is required and must be a non-empty string.');
+      throw new SchemaBuilderError(this, 'entityName for reference is required and must be a non-empty string.');
     }
     const reference = {
       type,
@@ -274,7 +345,7 @@ class SchemaBuilder {
       this.#internalAddIndex(
         { composite: [decapitalize(foreignKeyName)] },
         { composite: isNonEmptyArray(sortKeys) ? sortKeys : ['updatedAt'] },
-        INDEX_TYPES.BELONGS_TO,
+        Schema.INDEX_TYPES.BELONGS_TO,
       );
     }
 
@@ -303,7 +374,7 @@ class SchemaBuilder {
     ];
 
     if (orderedIndexes.length > 5) {
-      throw new Error('Cannot have more than 5 indexes.');
+      throw new SchemaBuilderError(this, 'Cannot have more than 5 indexes.');
     }
 
     this.indexes = { primary: this.rawIndexes.primary };
@@ -342,6 +413,7 @@ class SchemaBuilder {
         attributes: this.attributes,
         indexes: this.indexes,
         references: this.references,
+        options: this.options,
       },
     );
   }

package/src/v2/models/base/schema.js

@@ -12,6 +12,7 @@
 
 import { hasText, isNonEmptyObject } from '@adobe/spacecat-shared-utils';
 
+import { SchemaError, SchemaValidationError } from '../../errors/index.js';
 import {
   classExtends,
   entityNameToCollectionName,
@@ -24,10 +25,16 @@ import {
 
 import BaseCollection from './base.collection.js';
 import BaseModel from './base.model.js';
-import { INDEX_TYPES } from './constants.js';
 import Reference from './reference.js';
 
 class Schema {
+  static INDEX_TYPES = {
+    PRIMARY: 'primary',
+    ALL: 'all',
+    BELONGS_TO: 'belongs_to',
+    OTHER: 'other',
+  };
+
   /**
    * Constructs a new Schema instance.
    * @constructor
@@ -38,6 +45,7 @@ class Schema {
    * @param {number} rawSchema.schemaVersion - The version of the schema.
    * @param {object} rawSchema.attributes - The attributes of the schema.
    * @param {object} rawSchema.indexes - The indexes of the schema.
+   * @param {object} rawSchema.options - The options of the schema.
    * @param {Reference[]} [rawSchema.references] - The references of the schema.
    */
   constructor(
@@ -52,6 +60,7 @@ class Schema {
     this.schemaVersion = rawSchema.schemaVersion;
     this.attributes = rawSchema.attributes;
     this.indexes = rawSchema.indexes;
+    this.options = rawSchema.options;
     this.references = rawSchema.references || [];
 
     this.#validateSchema();
@@ -59,34 +68,46 @@ class Schema {
 
   #validateSchema() {
     if (!classExtends(this.modelClass, BaseModel)) {
-      throw new Error('Model class must extend BaseModel');
+      throw new SchemaValidationError('Model class must extend BaseModel');
     }
 
     if (!classExtends(this.collectionClass, BaseCollection)) {
-      throw new Error('Collection class must extend BaseCollection');
+      throw new SchemaValidationError('Collection class must extend BaseCollection');
     }
 
     if (!hasText(this.serviceName)) {
-      throw new Error('Schema must have a service name');
+      throw new SchemaValidationError('Schema must have a service name');
     }
 
     if (!isPositiveInteger(this.schemaVersion)) {
-      throw new Error('Schema version must be a positive integer');
+      throw new SchemaValidationError('Schema version must be a positive integer');
     }
 
     if (!isNonEmptyObject(this.attributes)) {
-      throw new Error('Schema must have attributes');
+      throw new SchemaValidationError('Schema must have attributes');
     }
 
     if (!isNonEmptyObject(this.indexes)) {
-      throw new Error('Schema must have indexes');
+      throw new SchemaValidationError('Schema must have indexes');
     }
 
     if (!Array.isArray(this.references)) {
-      throw new Error('References must be an array');
+      throw new SchemaValidationError('References must be an array');
+    }
+
+    if (!isNonEmptyObject(this.options)) {
+      throw new SchemaValidationError('Schema must have options');
     }
   }
 
+  allowsRemove() {
+    return this.options?.allowRemove;
+  }
+
+  allowsUpdates() {
+    return this.options?.allowUpdates;
+  }
+
   getAttribute(name) {
     return this.attributes[name];
   }
@@ -117,7 +138,7 @@ class Schema {
    *   ]
    */
   getIndexAccessors() {
-    const indexes = this.getIndexes([INDEX_TYPES.PRIMARY]);
+    const indexes = this.getIndexes([Schema.INDEX_TYPES.PRIMARY]);
     const result = [];
 
     Object.keys(indexes).forEach((indexName) => {
@@ -161,6 +182,36 @@ class Schema {
     return null;
   }
 
+  /**
+   * Finds the index name by the keys provided. The index is searched
+   * keys to match the combination of partition and sort keys. If no
+   * index is found, we fall back to the "all" index, then the "primary".
+   *
+   * @param {Object} keys - The keys to search for.
+   * @return {string} - The index name.
+   */
+  findIndexNameByKeys(keys) {
+    const { ALL, PRIMARY } = this.getIndexTypes();
+    const keyNames = Object.keys(keys);
+
+    const index = this.findIndexBySortKeys(keyNames);
+    if (index) {
+      return index.index || PRIMARY;
+    }
+
+    const allIndex = this.findIndexByType(ALL);
+    if (allIndex) {
+      return allIndex.index;
+    }
+
+    return PRIMARY;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getIndexTypes() {
+    return Schema.INDEX_TYPES;
+  }
+
   findIndexByType(type) {
     return Object.values(this.indexes).find((index) => index.indexType === type) || null;
   }
@@ -252,7 +303,24 @@ class Schema {
     return this.schemaVersion;
   }
 
-  toAccessorConfigs(entity, log) {
+  /**
+   * Given an entity, generates accessor configurations for all index-based accessors.
+   * This is useful for creating methods on the entity that can be used to fetch data
+   * based on the index keys. For example, if we have an index by 'opportunityId' and 'status',
+   * this method will generate accessor configurations like allByOpportunityId,
+   * findByOpportunityId, etc. The accessor configurations can then be used to create
+   * accessor methods on the entity using the createAccessors (accessor utils) method.
+   *
+   * @param {BaseModel|BaseCollection} entity - The entity for which to generate accessors.
+   * @param {Object} [log] - The logger to use for logging information
+   * @throws {SchemaError} - Throws an error if the entity is not a BaseModel or BaseCollection.
+   * @return {Object[]}
+   */
+  toAccessorConfigs(entity, log = console) {
+    if (!(entity instanceof BaseModel) && !(entity instanceof BaseCollection)) {
+      throw new SchemaError(this, 'Entity must extend BaseModel or BaseCollection');
+    }
+
     const indexAccessors = this.getIndexAccessors();
     const accessorConfigs = [];