electrodb 3.6.2 → 3.7.0

package/src/entity.js

@@ -33,7 +33,7 @@ const {
   IndexProjectionOptions,
 } = require("./types");
 const { FilterFactory } = require("./filters");
-const { FilterOperations, formatExpressionName } = require("./operations");
+const { FilterOperations, ExpressionState, formatExpressionName } = require("./operations");
 const { WhereFactory } = require("./where");
 const { clauses, ChainState } = require("./clauses");
 const { EventManager } = require("./events");
@@ -312,6 +312,8 @@ class Entity {
     const chain = this._makeChain(index, clauses, clauses.index, chainOptions);
     if (options.indexType === IndexTypes.clustered) {
       return chain.clusteredCollection(collection, facets);
+    } else if (options.indexType === IndexTypes.composite) {
+      return chain.compositeCollection(collection, facets);
     } else {
       return chain.collection(collection, facets);
     }
@@ -432,21 +434,19 @@ class Entity {
   }
 
   async transactWrite(parameters, config) {
-    let response = await this._exec(
+    return this._exec(
       MethodTypes.transactWrite,
       parameters,
       config,
     );
-    return response;
   }
 
   async transactGet(parameters, config) {
-    let response = await this._exec(
+    return this._exec(
       MethodTypes.transactGet,
       parameters,
       config,
     );
-    return response;
   }
 
   async go(method, parameters = {}, config = {}) {
@@ -1035,12 +1035,13 @@ class Entity {
     let keys = {};
     const secondaryIndexStrictMode =
       options.strict === "all" || options.strict === "pk" ? "pk" : "none";
-    for (const { index } of Object.values(this.model.indexes)) {
+    for (const index of Object.values(this.model.indexes)) {
+      const indexName = index.index;
       const indexKeys = this._fromCompositeToKeysByIndex(
-        { indexName: index, provided },
+        { indexName, provided },
         {
           strict:
-            index === TableIndex ? options.strict : secondaryIndexStrictMode,
+            indexName === TableIndex ? options.strict : secondaryIndexStrictMode,
         },
       );
       if (indexKeys) {
@@ -1224,21 +1225,28 @@ class Entity {
   ) {
     let allKeys = {};
 
-    const indexKeys = this._deconstructIndex({
-      index: indexName,
-      keys: provided,
-    });
-    if (!indexKeys) {
-      throw new e.ElectroError(
-        e.ErrorCodes.InvalidConversionKeysProvided,
-        `Provided keys did not include valid properties for the index "${indexName}"`,
-      );
+    if (this._getIndexType(indexName) === IndexTypes.composite) {
+      const item = this.model.schema.translateFromFields(provided);
+      allKeys = {
+        ...this._findFacets(item, this.model.facets.byIndex[indexName].pk),
+        ...this._findFacets(item, this.model.facets.byIndex[indexName].sk),
+      }
+    } else {
+      const indexKeys = this._deconstructIndex({
+        index: indexName,
+        keys: provided,
+      });
+      if (!indexKeys) {
+        throw new e.ElectroError(
+          e.ErrorCodes.InvalidConversionKeysProvided,
+          `Provided keys did not include valid properties for the index "${indexName}"`,
+        );
+      }
+      allKeys = {
+        ...indexKeys,
+      };
     }
 
-    allKeys = {
-      ...indexKeys,
-    };
-
     let tableKeys;
     if (indexName !== TableIndex) {
       tableKeys = this._deconstructIndex({ index: TableIndex, keys: provided });
@@ -1283,10 +1291,17 @@ class Entity {
     );
   }
 
+  _getIndexType(indexName) {
+    return this.model.facets.byIndex[indexName].type;
+  }
+
   _trimKeysToIndex({ indexName = TableIndex, provided }) {
     if (!provided) {
       return null;
     }
+    if (this.model.facets.byIndex[indexName].type === IndexTypes.composite) {
+      return provided;
+    }
 
     const pkName = this.model.translations.keys[indexName].pk;
     const skName = this.model.translations.keys[indexName].sk;
@@ -1315,13 +1330,17 @@ class Entity {
       );
     }
 
-    const pkName = this.model.translations.keys[indexName].pk;
-    const skName = this.model.translations.keys[indexName].sk;
-
-    return (
-      provided[pkName] !== undefined &&
-      (!skName || provided[skName] !== undefined)
-    );
+    if (this._getIndexType(indexName) === IndexTypes.composite) {
+      const item = this.model.schema.translateFromFields(provided);
+      return this.model.facets.byIndex[indexName].pk.every((attr) => item[attr] !== undefined);
+    } else {
+      const pkName = this.model.translations.keys[indexName].pk;
+      const skName = this.model.translations.keys[indexName].sk;
+      return (
+        provided[pkName] !== undefined &&
+        (!skName || provided[skName] !== undefined)
+      );
+    }
   }
 
   _formatReturnPager(config, lastEvaluatedKey) {
@@ -1585,12 +1604,19 @@ class Entity {
 
   _constructPagerIndex(index = TableIndex, item, options = {}) {
     let pkAttributes = options.relaxedPk
-      ? item
+      ? this._findFacets(item, this.model.facets.byIndex[index].pk)
       : this._expectFacets(item, this.model.facets.byIndex[index].pk);
     let skAttributes = options.relaxedSk
-      ? item
+      ? this._findFacets(item, this.model.facets.byIndex[index].sk)
       : this._expectFacets(item, this.model.facets.byIndex[index].sk);
 
+    if (this._getIndexType(index) === IndexTypes.composite) {
+      return this.model.schema.translateToFields({
+        ...pkAttributes,
+        ...skAttributes,
+      });
+    }
+
     let keys = this._makeIndexKeys({
       index,
       pkAttributes,
@@ -2257,20 +2283,20 @@ class Entity {
     return key;
   }
 
-  getIdentifierExpressions(alias = this.getName()) {
-    let name = this.getName();
-    let version = this.getVersion();
-    return {
-      names: {
-        [`#${this.identifiers.entity}`]: this.identifiers.entity,
-        [`#${this.identifiers.version}`]: this.identifiers.version,
-      },
-      values: {
-        [`:${this.identifiers.entity}_${alias}`]: name,
-        [`:${this.identifiers.version}_${alias}`]: version,
-      },
-      expression: `(#${this.identifiers.entity} = :${this.identifiers.entity}_${alias} AND #${this.identifiers.version} = :${this.identifiers.version}_${alias})`,
-    };
+  applyIdentifierExpressionState(expressionState, alias) {
+    const name = this.getName();
+    const version = this.getVersion();
+    const nameRef = expressionState.setName({}, this.identifiers.entity, this.identifiers.entity);
+    const versionRef = expressionState.setName({}, this.identifiers.version, this.identifiers.version);
+    const nameVal = expressionState.setValue(
+      `${this.identifiers.entity}_${alias || name}`,
+      name,
+    );
+    const versionVal = expressionState.setValue(
+      `${this.identifiers.version}_${alias || name}`,
+      version,
+    );
+    return `(${nameRef.expression} = ${nameVal} AND ${versionRef.expression} = ${versionVal})`;
   }
 
   /* istanbul ignore next */
@@ -2682,7 +2708,7 @@ class Entity {
     }
     expressions.UpdateExpression = `${operation.toUpperCase()} ${expressions.UpdateExpression.join(
       ", ",
-    )}`;
+    )}`.trim();
     return expressions;
   }
 
@@ -2709,61 +2735,236 @@ class Entity {
     }
   }
 
-  /* istanbul ignore next */
-  _queryParams(state = {}, options = {}) {
-    const indexKeys = this._makeQueryKeys(state, options);
-    let parameters = {};
+
+  _compositeQueryParams(state = {}, options = {}) {
+    // todo: review "_consolidateQueryFacets"
+    const consolidated = this._consolidateQueryFacets(
+      state.query.keys.sk,
+    ) || [];
+
+    const pkAttributes = state.query.keys.pk;
+    const skAttributes = consolidated[0] || {};
+
+    // provided has length, isArray?
+    const provided = state.query.keys.provided;
+    const all = state.query.facets.all || [];
+    const queryType = state.query.type;
+    const expressionState = new ExpressionState({ prefix: "k_" });
+
+    const expressions = [];
+    if (queryType === QueryTypes.between) {
+      for (const [name, value] of Object.entries(pkAttributes)) {
+        const field = this.model.schema.getFieldName(name);
+        const nameRef = expressionState.setName({}, name, field);
+        const valueRef = expressionState.setValue(name, value);
+        expressions.push(`${nameRef.expression} = ${valueRef}`);
+      }
+      let is = {}
+      let start = {}
+      let end = {};
+      (state.query.keys.sk ?? []).forEach(({type, facets}) => {
+        if (type === QueryTypes.is || type === QueryTypes.composite_collection) {
+          is = facets;
+        } else if (type === QueryTypes.between) {
+          start = facets;
+        } else if (type === QueryTypes.and) {
+          end = facets;
+        } else {
+          // todo: improve error handling
+          throw new Error('Internal error: Invalid sort key type in composite between query');
+        }
+      });
+
+      let lastFound;
+      const skNames = state.query.facets.sk || [];
+      for (const name of skNames) {
+        if (is[name] !== undefined) {
+          lastFound = name;
+        } else if (start[name] !== undefined && end[name] !== undefined) {
+          lastFound = name;
+        } else if (start[name] !== undefined || end[name] !== undefined) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidQueryParameters,
+            `Invalid attribute combination provided to between query. Between queries on composite indexes must have the same attribute for start and end values until the last sort key attribute. The provided attribute ${name} is missing ${start[name] !== undefined ? 'an end' : 'a start'} value. This is a DynamoDB constraint.`
+          );
+        } else {
+          break;
+        }
+      }
+
+      for (let i = 0; i < skNames.length; i++) {
+        const name = skNames[i];
+        if (lastFound === name) {
+          const startValue = start[name];
+          const endValue = end[name];
+          const field = this.model.schema.getFieldName(name);
+          const nameRef = expressionState.setName({}, name, field);
+          const startValueRef = expressionState.setValue(name, startValue);
+          const endValueRef = expressionState.setValue(name, endValue);
+          expressions.push(`${nameRef.expression} BETWEEN ${startValueRef} AND ${endValueRef}`);
+        } else if (is[name] !== undefined) {
+          const value = is[name];
+          const field = this.model.schema.getFieldName(name);
+          const nameRef = expressionState.setName({}, name, field);
+          const valueRef = expressionState.setValue(name, value);
+          expressions.push(`${nameRef.expression} = ${valueRef}`);
+        } else if (start[name] !== undefined && end[name] !== undefined) {
+          if (start[name] !== end[name]) {
+            throw new e.ElectroError(
+              e.ErrorCodes.InvalidQueryParameters,
+              `Invalid attribute combination provided to between query. Between queries on composite indexes must have the same attribute for start and end values until the last sort key attribute. The provided attribute ${name} has different start and end values. This is a DynamoDB constraint.`
+            );
+          }
+          const value = start[name];
+          const field = this.model.schema.getFieldName(name);
+          const nameRef = expressionState.setName({}, name, field);
+          const valueRef = expressionState.setValue(name, value);
+          expressions.push(`${nameRef.expression} = ${valueRef}`);
+        }
+      }
+    } else {
+      const attrs = [];
+      for (const { type, name } of all) {
+        const value = type === "pk" ? pkAttributes[name] : skAttributes[name];
+        if (value === undefined) {
+          break;
+        }
+        attrs.push({type, name, value});
+      }
+      for (let i = 0; i < attrs.length; i++) {
+        const { type, name, value } = attrs[i];
+        const field = this.model.schema.getFieldName(name);
+        const nameRef = expressionState.setName({}, name, field);
+        const valueRef = expressionState.setValue(name, value);
+        const shouldApplyEq = !(type === "sk" && i === attrs.length - 1)
+        if (shouldApplyEq) {
+          expressions.push(`${nameRef.expression} = ${valueRef}`);
+          continue;
+        }
+        switch (queryType) {
+          case QueryTypes.is:
+          case QueryTypes.eq:
+          case QueryTypes.collection:
+          case QueryTypes.composite_collection:
+            expressions.push(`${nameRef.expression} = ${valueRef}`);
+            break;
+          case QueryTypes.begins:
+            expressions.push(`begins_with(${nameRef.expression}, ${valueRef})`);
+            break;
+          case QueryTypes.gt:
+            expressions.push(`${nameRef.expression} > ${valueRef}`);
+            break;
+          case QueryTypes.gte:
+            expressions.push(`${nameRef.expression} >= ${valueRef}`);
+            break;
+          case QueryTypes.lt:
+            expressions.push(`${nameRef.expression} < ${valueRef}`);
+            break;
+          case QueryTypes.lte:
+            expressions.push(`${nameRef.expression} <= ${valueRef}`);
+            break;
+          case QueryTypes.between: {
+            const second = consolidated[consolidated.length - 1];
+            const value2 = second[name];
+            const valueRef2 = expressionState.setValue(name, value2);
+            expressions.push(`${nameRef.expression} BETWEEN ${valueRef} AND ${valueRef2}`);
+            break;
+          }
+          // todo: clean up here
+          case QueryTypes.clustered_collection:
+          default:
+            // todo: improve error handling
+            throw new Error('Not supported')
+        }
+      }
+    }
+
+    const filter = state.query.filter[ExpressionTypes.FilterExpression];
+    const customExpressions = {
+      names: (state.query.options.expressions && state.query.options.expressions.names) || {},
+      values: (state.query.options.expressions && state.query.options.expressions.values) || {},
+      expression: (state.query.options.expressions && state.query.options.expressions.expression) || "",
+    };
+
+    // identifiers are added via custom expressions on collection queries inside `clauses/handleNonIsolatedCollection`
+    // Don't duplicate filters if they are provided.
+    const identifierExpression = !options.ignoreOwnership && !customExpressions.expression ? this.applyIdentifierExpressionState(expressionState) : '';
+
+    const params = {
+      IndexName: state.query.index,
+      KeyConditionExpression: expressions.join(' AND '),
+      TableName: this.getTableName(),
+      ExpressionAttributeNames: this._mergeExpressionsAttributes(
+        filter.getNames(),
+        expressionState.getNames(),
+        customExpressions.names,
+      ),
+      ExpressionAttributeValues: this._mergeExpressionsAttributes(
+        filter.getValues(),
+        expressionState.getValues(),
+        customExpressions.values,
+      ),
+    }
+
+    let filerExpressions = [customExpressions.expression || "", filter.build(), identifierExpression]
+      .map(s => s.trim())
+      .filter(Boolean)
+      .join(" AND ");
+
+    if (filerExpressions.length) {
+      params.FilterExpression = filerExpressions;
+    }
+
+    return params;
+  }
+
+  _makeQueryParams(state = {}, options = {}, indexKeys) {
     switch (state.query.type) {
       case QueryTypes.is:
-        parameters = this._makeIsQueryParams(
+        return this._makeIsQueryParams(
           state.query,
           state.query.index,
           state.query.filter[ExpressionTypes.FilterExpression],
           indexKeys.pk,
           ...indexKeys.sk,
         );
-        break;
       case QueryTypes.begins:
-        parameters = this._makeBeginsWithQueryParams(
+        return this._makeBeginsWithQueryParams(
           state.query.options,
           state.query.index,
           state.query.filter[ExpressionTypes.FilterExpression],
           indexKeys.pk,
           ...indexKeys.sk,
         );
-        break;
       case QueryTypes.collection:
-        parameters = this._makeBeginsWithQueryParams(
+        return this._makeBeginsWithQueryParams(
           state.query.options,
           state.query.index,
           state.query.filter[ExpressionTypes.FilterExpression],
           indexKeys.pk,
           this._getCollectionSk(state.query.collection),
         );
-        break;
       case QueryTypes.clustered_collection:
-        parameters = this._makeBeginsWithQueryParams(
+        return this._makeBeginsWithQueryParams(
           state.query.options,
           state.query.index,
           state.query.filter[ExpressionTypes.FilterExpression],
           indexKeys.pk,
           ...indexKeys.sk,
         );
-        break;
       case QueryTypes.between:
-        parameters = this._makeBetweenQueryParams(
+        return this._makeBetweenQueryParams(
           state.query.options,
           state.query.index,
           state.query.filter[ExpressionTypes.FilterExpression],
           indexKeys.pk,
           ...indexKeys.sk,
         );
-        break;
       case QueryTypes.gte:
       case QueryTypes.gt:
       case QueryTypes.lte:
       case QueryTypes.lt:
-        parameters = this._makeComparisonQueryParams(
+        return this._makeComparisonQueryParams(
           state.query.index,
           state.query.type,
           state.query.filter[ExpressionTypes.FilterExpression],
@@ -2771,10 +2972,20 @@ class Entity {
           options,
           state.query.options,
         );
-        break;
       default:
         throw new Error(`Invalid query type: ${state.query.type}`);
     }
+  }
+
+  /* istanbul ignore next */
+  _queryParams(state = {}, options = {}) {
+    const indexKeys = this._makeQueryKeys(state, options);
+    let parameters;
+    if (state.query.options.indexType !== IndexTypes.composite) {
+      parameters = this._makeQueryParams(state, options, indexKeys);
+    } else {
+      parameters = this._compositeQueryParams(state, options);
+    }
 
     const appliedParameters = this._applyParameterOptions({
       params: parameters,
@@ -3064,8 +3275,12 @@ class Entity {
   _makeKeysFromAttributes(indexes, attributes, conditions) {
     let indexKeys = {};
     for (let [index, keyTypes] of Object.entries(indexes)) {
+      if (this.model.lookup.compositeIndexes.has(index)) {
+        continue;
+      }
+
       const shouldMakeKeys =
-        !this._indexConditionIsDefined(index) || conditions[index];
+        (!this._indexConditionIsDefined(index) || conditions[index]);
       if (!shouldMakeKeys && index !== TableIndex) {
         continue;
       }
@@ -3285,6 +3500,11 @@ class Entity {
       if (attributes[attribute] !== undefined) {
         facets[attribute] = attributes[attribute];
         indexes.forEach((definition) => {
+          // composite indexes do not have keys
+          if (definition.type === IndexTypes.composite) {
+            return;
+          }
+
           const { index, type } = definition;
           impactedIndexes[index] = impactedIndexes[index] || {};
           impactedIndexes[index][type] = impactedIndexes[index][type] || [];
@@ -3303,9 +3523,12 @@ class Entity {
 
     // this function is used to determine key impact for update `set`, update `delete`, and `put`. This block is currently only used by update `set`
     if (utilizeIncludedOnlyIndexes) {
-      for (const [index, { pk, sk }] of Object.entries(
+      for (const [index, { pk, sk, type }] of Object.entries(
         this.model.facets.byIndex,
       )) {
+        if (type === IndexTypes.composite) {
+          continue;
+        }
         // The main table index is handled somewhere else (messy I know), and we only want to do this processing if an
         // index condition is defined for backwards compatibility. Backwards compatibility is not required for this
         // change, but I have paranoid concerns of breaking changes around sparse indexes.
@@ -3367,10 +3590,12 @@ class Entity {
       }
     }
 
-    let indexesWithMissingComposites = Object.entries(
-      this.model.facets.byIndex,
-    ).map(([index, definition]) => {
-      const { pk, sk } = definition;
+    let indexesWithMissingComposites = [];
+    for (const [index, definition] of Object.entries(this.model.facets.byIndex)) {
+      const { pk, sk, type  } = definition;
+      if (type === IndexTypes.composite) {
+        continue;
+      }
       let impacted = impactedIndexes[index];
       let impact = {
         index,
@@ -3408,8 +3633,8 @@ class Entity {
         }
       }
 
-      return impact;
-    });
+      indexesWithMissingComposites.push(impact);
+    }
 
     let incomplete = [];
     for (const { index, missing, definition } of indexesWithMissingComposites) {
@@ -3536,7 +3761,11 @@ class Entity {
     }
   }
 
-  _findProperties(obj, properties) {
+  _findFacets(obj, properties) {
+    return Object.fromEntries(this._findProperties(obj, properties));
+  }
+
+  _findProperties(obj, properties = []) {
     return properties.map((name) => [name, obj[name]]);
   }
 
@@ -3707,8 +3936,8 @@ class Entity {
           e.ErrorCodes.IncompatibleKeyCasing,
           `Partition Key (pk) on Access Pattern '${u.formatIndexNameForDisplay(
             tableIndex.index,
-          )}' is defined with the casing ${keys.pk.casing}, but the accessPattern '${u.formatIndexNameForDisplay(
-            previouslyDefinedPk.indexName,
+          )}' is defined with the casing ${keys.pk.casing}, but the Access Pattern '${u.formatIndexNameForDisplay(
+            previouslyDefinedPk.definition.accessPattern,
           )}' defines the same index field with the ${previouslyDefinedPk.definition.casing === DefaultKeyCasing ? '(default)' : ''} casing ${previouslyDefinedPk.definition.casing}. Key fields must have the same casing definitions across all indexes they are involved with.`,
         );
       }
@@ -3723,8 +3952,8 @@ class Entity {
           e.ErrorCodes.IncompatibleKeyCasing,
           `Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(
             tableIndex.index,
-          )}' is defined with the casing ${keys.sk.casing}, but the accessPattern '${u.formatIndexNameForDisplay(
-            previouslyDefinedSk.indexName,
+          )}' is defined with the casing ${keys.sk.casing}, but the Access Pattern '${u.formatIndexNameForDisplay(
+            previouslyDefinedSk.definition.accessPattern,
           )}' defines the same index field with the ${previouslyDefinedSk.definition.casing === DefaultKeyCasing ? '(default)' : ''} casing ${previouslyDefinedSk.definition.casing}. Key fields must have the same casing definitions across all indexes they are involved with.`,
         );
       }
@@ -3832,7 +4061,6 @@ class Entity {
           this.model.facets.labels[index] &&
           Array.isArray(this.model.facets.labels[index].sk);
         let labels = hasLabels ? this.model.facets.labels[index].sk : [];
-        // const hasFacets = Object.keys(skFacet).length > 0;
         let sortKey = this._makeKey(prefixes.sk, facets.sk, skFacet, labels, {
           excludeLabelTail: true,
           excludePostfix,
@@ -4277,6 +4505,7 @@ class Entity {
     let indexHasSortKeys = {};
     let indexHasSubCollections = {};
     let clusteredIndexes = new Set();
+    let compositeIndexes = new Set();
     let indexAccessPatternTransaction = {
       fromAccessPatternToIndex: {},
       fromIndexToAccessPattern: {},
@@ -4320,9 +4549,48 @@ class Entity {
       let conditionDefined = v.isFunction(index.condition);
       let indexCondition = index.condition || (() => true);
 
-      if (indexType === "clustered") {
+      if (indexType === IndexTypes.clustered) {
+        // todo: make contents consistent with "compositeIndexes" below
+        // this is not consistent with "compositeIndexes" (which uses the index name), this should be fixed in the future.
         clusteredIndexes.add(accessPattern);
+      } else if (indexType === IndexTypes.composite) {
+        if (indexName === TableIndex) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexDefinition,
+            `The Access Pattern "${accessPattern}" cannot be defined as a composite index. AWS DynamoDB does not allow for composite indexes on the main table index.`,
+          );
+        }
+        if (conditionDefined) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexCondition,
+            `The Access Pattern "${accessPattern}" is defined as a "${indexType}" index, but a condition callback is defined. Composite indexes do not support the use of a condition callback.`,
+          );
+        }
+        if (index.scope !== undefined) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexCondition,
+            `The Access Pattern "${accessPattern}" is defined as a "${indexType}" index, but a "scope" value was defined. Composite indexes do not support the use of scope.`,
+          );
+        }
+        if (index.pk.field !== undefined || (index.sk && index.sk.field !== undefined)) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexDefinition,
+            `The Access Pattern "${accessPattern}" is defined as a "${indexType}" index, but the Partition Key or Sort Key is defined with a field property. Composite indexes do not support the use of a field property, their attributes defined in the composite array define the indexes member attributes.`,
+          );
+        }
+        // this is not consistent with "clusteredIndexes" (which uses the access pattern name), but it is more correct given the naming.
+        compositeIndexes.add(indexName);
+      }
+
+      if (indexType !== IndexTypes.composite) {
+        if (index.pk.field === undefined || (index.sk && index.sk.field === undefined)) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexDefinition,
+            `The Access Pattern "${accessPattern}" is defined as a "${indexType}" index, but the Partition Key or Sort Key is defined without a field property. Unless using composite attributes, indexes must be defined with a field property that maps to the field name on the DynamoDB table KeySchema.`,
+          );
+        }
       }
+
       if (seenIndexes[indexName] !== undefined) {
         if (indexName === TableIndex) {
           throw new e.ElectroError(
@@ -4349,6 +4617,22 @@ class Entity {
           )}', contains a collection definition without a defined SK. Collections can only be defined on indexes with a defined SK.`,
         );
       }
+
+      if (indexType !== IndexTypes.composite) {
+        if (hasSk && index.sk.field === undefined) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexCompositeAttributes,
+            `The ${accessPattern} Access pattern is defined as a "${indexType}" index, but a Sort Key is defined without a Range Key field mapping.`,
+          );
+        }
+        if (index.pk.field === undefined) {
+          throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexCompositeAttributes,
+            `The ${accessPattern} Access pattern is defined as a "${indexType}" index, but a Partition Key is defined without a HasKey field mapping.`,
+          );
+        }
+      }
+
       let collection = index.collection || "";
       let customFacets = {
         pk: false,
@@ -4522,13 +4806,16 @@ class Entity {
       facets.attributes = [...facets.attributes, ...attributes];
       facets.projections = [...facets.projections, ...projections];
 
-      facets.fields.push(pk.field);
+      if (definition.type !== IndexTypes.composite) {
+        facets.fields.push(pk.field);
+      }
 
       facets.byIndex[indexName] = {
         customFacets,
         pk: pk.facets,
         sk: sk.facets,
         all: attributes,
+        type: index.type,
         collection: index.collection,
         hasSortKeys: !!indexHasSortKeys[indexName],
         hasSubCollections: !!indexHasSubCollections[indexName],
@@ -4538,110 +4825,111 @@ class Entity {
         },
       };
 
-      facets.byField = facets.byField || {};
-      facets.byField[pk.field] = facets.byField[pk.field] || {};
-      facets.byField[pk.field][indexName] = pk;
-      if (sk.field) {
-        facets.byField[sk.field] = facets.byField[sk.field] || {};
-        facets.byField[sk.field][indexName] = sk;
-      }
-
-      if (seenIndexFields[pk.field] !== undefined) {
-        const definition = Object.values(facets.byField[pk.field]).find(
-          (definition) => definition.index !== indexName,
-        );
-
-        const definitionsMatch = validations.stringArrayMatch(
-          pk.facets,
-          definition.facets,
-        );
-
-        if (!definitionsMatch) {
-          throw new e.ElectroError(
-            e.ErrorCodes.InconsistentIndexDefinition,
-            `Partition Key (pk) on Access Pattern '${u.formatIndexNameForDisplay(
-              accessPattern,
-            )}' is defined with the composite attribute(s) ${u.commaSeparatedString(
-              pk.facets,
-            )}, but the accessPattern '${u.formatIndexNameForDisplay(
-              definition.index,
-            )}' defines this field with the composite attributes ${u.commaSeparatedString(
-              definition.facets,
-            )}'. Key fields must have the same composite attribute definitions across all indexes they are involved with`,
-          );
-        }
-
-        const keyTemplatesMatch = pk.template === definition.template
-
-        if (!keyTemplatesMatch) {
-          throw new e.ElectroError(
-            e.ErrorCodes.IncompatibleKeyCompositeAttributeTemplate,
-            `Partition Key (pk) on Access Pattern '${u.formatIndexNameForDisplay(
-              accessPattern,
-            )}' is defined with the template ${pk.template || '(undefined)'}, but the accessPattern '${u.formatIndexNameForDisplay(
-              definition.index,
-            )}' defines this field with the key labels ${definition.template || '(undefined)'}'. Key fields must have the same template definitions across all indexes they are involved with`,
-          );
+      if (definition.type !== IndexTypes.composite) {
+        facets.byField = facets.byField || {};
+        facets.byField[pk.field] = facets.byField[pk.field] || {};
+        facets.byField[pk.field][indexName] = pk;
+        if (sk.field) {
+          facets.byField[sk.field] = facets.byField[sk.field] || {};
+          facets.byField[sk.field][indexName] = sk;
         }
 
-        seenIndexFields[pk.field].push({ accessPattern, type: "pk" });
-      } else {
-        seenIndexFields[pk.field] = [];
-        seenIndexFields[pk.field].push({ accessPattern, type: "pk" });
-      }
-
-      if (sk.field) {
-        if (sk.field === pk.field) {
-          throw new e.ElectroError(
-            e.ErrorCodes.DuplicateIndexFields,
-            `The Access Pattern '${u.formatIndexNameForDisplay(
-              accessPattern,
-            )}' references the field '${
-              sk.field
-            }' as the field name for both the PK and SK. Fields used for indexes need to be unique to avoid conflicts.`,
-          );
-        } else if (seenIndexFields[sk.field] !== undefined) {
-          const definition = Object.values(facets.byField[sk.field]).find(
+        if (seenIndexFields[pk.field] !== undefined) {
+          const definition = Object.values(facets.byField[pk.field]).find(
             (definition) => definition.index !== indexName,
           );
 
           const definitionsMatch = validations.stringArrayMatch(
-            sk.facets,
+            pk.facets,
             definition.facets,
-          )
-
+          );
           if (!definitionsMatch) {
             throw new e.ElectroError(
-              e.ErrorCodes.DuplicateIndexFields,
-              `Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(
+              e.ErrorCodes.InconsistentIndexDefinition,
+              `Partition Key (pk) on Access Pattern '${u.formatIndexNameForDisplay(
                 accessPattern,
               )}' is defined with the composite attribute(s) ${u.commaSeparatedString(
-                sk.facets,
-              )}, but the accessPattern '${u.formatIndexNameForDisplay(
-                definition.index,
+                pk.facets,
+              )}, but the Access Pattern '${u.formatIndexNameForDisplay(
+                definition.accessPattern,
               )}' defines this field with the composite attributes ${u.commaSeparatedString(
                 definition.facets,
               )}'. Key fields must have the same composite attribute definitions across all indexes they are involved with`,
             );
           }
 
-          const keyTemplatesMatch = sk.template === definition.template
+          const keyTemplatesMatch = pk.template === definition.template
 
           if (!keyTemplatesMatch) {
             throw new e.ElectroError(
               e.ErrorCodes.IncompatibleKeyCompositeAttributeTemplate,
-              `Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(
+              `Partition Key (pk) on Access Pattern '${u.formatIndexNameForDisplay(
                 accessPattern,
-              )}' is defined with the template ${sk.template || '(undefined)'}, but the accessPattern '${u.formatIndexNameForDisplay(
-                definition.index,
+              )}' is defined with the template ${pk.template || '(undefined)'}, but the Access Pattern '${u.formatIndexNameForDisplay(
+                definition.accessPattern,
               )}' defines this field with the key labels ${definition.template || '(undefined)'}'. Key fields must have the same template definitions across all indexes they are involved with`,
             );
           }
 
-          seenIndexFields[sk.field].push({ accessPattern, type: "sk" });
+          seenIndexFields[pk.field].push({ accessPattern, type: "pk" });
         } else {
-          seenIndexFields[sk.field] = [];
-          seenIndexFields[sk.field].push({ accessPattern, type: "sk" });
+          seenIndexFields[pk.field] = [];
+          seenIndexFields[pk.field].push({ accessPattern, type: "pk" });
+        }
+
+        if (sk.field) {
+          if (sk.field === pk.field) {
+            throw new e.ElectroError(
+              e.ErrorCodes.DuplicateIndexFields,
+              `The Access Pattern '${u.formatIndexNameForDisplay(
+                accessPattern,
+              )}' references the field '${
+                sk.field
+              }' as the field name for both the PK and SK. Fields used for indexes need to be unique to avoid conflicts.`,
+            );
+          } else if (seenIndexFields[sk.field] !== undefined) {
+            const definition = Object.values(facets.byField[sk.field]).find(
+              (definition) => definition.index !== indexName,
+            );
+
+            const definitionsMatch = validations.stringArrayMatch(
+              sk.facets,
+              definition.facets,
+            )
+
+            if (!definitionsMatch) {
+              throw new e.ElectroError(
+                e.ErrorCodes.DuplicateIndexFields,
+                `Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(
+                  accessPattern,
+                )}' is defined with the composite attribute(s) ${u.commaSeparatedString(
+                  sk.facets,
+                )}, but the Access Pattern '${u.formatIndexNameForDisplay(
+                  definition.accessPattern,
+                )}' defines this field with the composite attributes ${u.commaSeparatedString(
+                  definition.facets,
+                )}'. Key fields must have the same composite attribute definitions across all indexes they are involved with`,
+              );
+            }
+
+            const keyTemplatesMatch = sk.template === definition.template
+
+            if (!keyTemplatesMatch) {
+              throw new e.ElectroError(
+                e.ErrorCodes.IncompatibleKeyCompositeAttributeTemplate,
+                `Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(
+                  accessPattern,
+                )}' is defined with the template ${sk.template || '(undefined)'}, but the Access Pattern '${u.formatIndexNameForDisplay(
+                  definition.accessPattern,
+                )}' defines this field with the key labels ${definition.template || '(undefined)'}'. Key fields must have the same template definitions across all indexes they are involved with`,
+              );
+            }
+
+            seenIndexFields[sk.field].push({ accessPattern, type: "sk" });
+          } else {
+            seenIndexFields[sk.field] = [];
+            seenIndexFields[sk.field].push({ accessPattern, type: "sk" });
+          }
         }
       }
 
@@ -4713,6 +5001,7 @@ class Entity {
       subCollections,
       indexHasSortKeys,
       clusteredIndexes,
+      compositeIndexes,
       indexHasSubCollections,
       indexes: normalized,
       indexField: indexFieldTranslation,
@@ -4918,6 +5207,7 @@ class Entity {
       subCollections,
       indexCollection,
       clusteredIndexes,
+      compositeIndexes,
       indexHasSortKeys,
       indexAccessPattern,
       indexHasSubCollections,
@@ -4991,6 +5281,7 @@ class Entity {
       modelVersion,
       subCollections,
       lookup: {
+        compositeIndexes,
         clusteredIndexes,
         indexHasSortKeys,
         indexHasSubCollections,