@aws-amplify/datastore 4.7.6-api-v6-models.b3abc9b.0 → 5.0.0

package/lib-esm/sync/utils.js

@@ -1,12 +1,10 @@
-import { __assign, __awaiter, __generator, __read, __spread, __values } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/api-graphql';
 import { GraphQLAuthError } from '@aws-amplify/api';
-import { Logger } from '@aws-amplify/core';
 import { isEnumFieldType, isGraphQLScalarType, isPredicateObj, isSchemaModel, isSchemaModelWithAttributes, isTargetNameAssociation, isNonModelFieldType, OpType, ModelOperation, isPredicateGroup, } from '../types';
 import { extractPrimaryKeyFieldNames, establishRelationAndKeys, IDENTIFIER_KEY_SEPARATOR, } from '../util';
-var logger = new Logger('DataStore');
+import { ConsoleLogger } from '@aws-amplify/core';
+const logger = new ConsoleLogger('DataStore');
 var GraphQLOperationType;
 (function (GraphQLOperationType) {
     GraphQLOperationType["LIST"] = "query";
@@ -22,24 +20,21 @@ export var TransformerMutationType;
     TransformerMutationType["DELETE"] = "Delete";
     TransformerMutationType["GET"] = "Get";
 })(TransformerMutationType || (TransformerMutationType = {}));
-var dummyMetadata = {
+const dummyMetadata = {
     _version: undefined,
     _lastChangedAt: undefined,
     _deleted: undefined,
 };
-var metadataFields = (Object.keys(dummyMetadata));
+const metadataFields = (Object.keys(dummyMetadata));
 export function getMetadataFields() {
     return metadataFields;
 }
 export function generateSelectionSet(namespace, modelDefinition) {
-    var scalarFields = getScalarFields(modelDefinition);
-    var nonModelFields = getNonModelFields(namespace, modelDefinition);
-    var implicitOwnerField = getImplicitOwnerField(modelDefinition, scalarFields);
-    var scalarAndMetadataFields = Object.values(scalarFields)
-        .map(function (_a) {
-        var name = _a.name;
-        return name;
-    })
+    const scalarFields = getScalarFields(modelDefinition);
+    const nonModelFields = getNonModelFields(namespace, modelDefinition);
+    const implicitOwnerField = getImplicitOwnerField(modelDefinition, scalarFields);
+    let scalarAndMetadataFields = Object.values(scalarFields)
+        .map(({ name }) => name)
         .concat(implicitOwnerField)
         .concat(nonModelFields);
     if (isSchemaModel(modelDefinition)) {
@@ -47,22 +42,22 @@ export function generateSelectionSet(namespace, modelDefinition) {
             .concat(getMetadataFields())
             .concat(getConnectionFields(modelDefinition, namespace));
     }
-    var result = scalarAndMetadataFields.join('\n');
+    const result = scalarAndMetadataFields.join('\n');
     return result;
 }
 function getImplicitOwnerField(modelDefinition, scalarFields) {
-    var ownerFields = getOwnerFields(modelDefinition);
+    const ownerFields = getOwnerFields(modelDefinition);
     if (!scalarFields.owner && ownerFields.includes('owner')) {
         return ['owner'];
     }
     return [];
 }
 function getOwnerFields(modelDefinition) {
-    var ownerFields = [];
+    const ownerFields = [];
     if (isSchemaModelWithAttributes(modelDefinition)) {
-        modelDefinition.attributes.forEach(function (attr) {
+        modelDefinition.attributes.forEach(attr => {
             if (attr.properties && attr.properties.rules) {
-                var rule = attr.properties.rules.find(function (rule) { return rule.allow === 'owner'; });
+                const rule = attr.properties.rules.find(rule => rule.allow === 'owner');
                 if (rule && rule.ownerField) {
                     ownerFields.push(rule.ownerField);
                 }
@@ -72,15 +67,15 @@ function getOwnerFields(modelDefinition) {
     return ownerFields;
 }
 function getScalarFields(modelDefinition) {
-    var fields = modelDefinition.fields;
-    var result = Object.values(fields)
-        .filter(function (field) {
+    const { fields } = modelDefinition;
+    const result = Object.values(fields)
+        .filter(field => {
         if (isGraphQLScalarType(field.type) || isEnumFieldType(field.type)) {
             return true;
         }
         return false;
     })
-        .reduce(function (acc, field) {
+        .reduce((acc, field) => {
         acc[field.name] = field;
         return acc;
     }, {});
@@ -88,15 +83,11 @@ function getScalarFields(modelDefinition) {
 }
 // Used for generating the selection set for queries and mutations
 function getConnectionFields(modelDefinition, namespace) {
-    var result = [];
+    const result = [];
     Object.values(modelDefinition.fields)
-        .filter(function (_a) {
-        var association = _a.association;
-        return association && Object.keys(association).length;
-    })
-        .forEach(function (_a) {
-        var name = _a.name, association = _a.association;
-        var connectionType = (association || {}).connectionType;
+        .filter(({ association }) => association && Object.keys(association).length)
+        .forEach(({ name, association }) => {
+        const { connectionType } = association || {};
         switch (connectionType) {
             case 'HAS_ONE':
             case 'HAS_MANY':
@@ -107,86 +98,79 @@ function getConnectionFields(modelDefinition, namespace) {
                     // New codegen (CPK)
                     if (association.targetNames && association.targetNames.length > 0) {
                         // Need to retrieve relations in order to get connected model keys
-                        var _b = __read(establishRelationAndKeys(namespace), 1), relations = _b[0];
-                        var connectedModelName = modelDefinition.fields[name].type['model'];
-                        var byPkIndex = relations[connectedModelName].indexes.find(function (_a) {
-                            var _b = __read(_a, 1), name = _b[0];
-                            return name === 'byPk';
-                        });
-                        var keyFields = byPkIndex && byPkIndex[1];
-                        var keyFieldSelectionSet = keyFields === null || keyFields === void 0 ? void 0 : keyFields.join(' ');
+                        const [relations] = establishRelationAndKeys(namespace);
+                        const connectedModelName = modelDefinition.fields[name].type['model'];
+                        const byPkIndex = relations[connectedModelName].indexes.find(([name]) => name === 'byPk');
+                        const keyFields = byPkIndex && byPkIndex[1];
+                        const keyFieldSelectionSet = keyFields?.join(' ');
                         // We rely on `_deleted` when we process the sync query (e.g. in batchSave in the adapters)
-                        result.push(name + " { " + keyFieldSelectionSet + " _deleted }");
+                        result.push(`${name} { ${keyFieldSelectionSet} _deleted }`);
                     }
                     else {
                         // backwards-compatability for schema generated prior to custom primary key support
-                        result.push(name + " { id _deleted }");
+                        result.push(`${name} { id _deleted }`);
                     }
                 }
                 break;
             default:
-                throw new Error("Invalid connection type " + connectionType);
+                throw new Error(`Invalid connection type ${connectionType}`);
         }
     });
     return result;
 }
 function getNonModelFields(namespace, modelDefinition) {
-    var result = [];
-    Object.values(modelDefinition.fields).forEach(function (_a) {
-        var name = _a.name, type = _a.type;
+    const result = [];
+    Object.values(modelDefinition.fields).forEach(({ name, type }) => {
         if (isNonModelFieldType(type)) {
-            var typeDefinition = namespace.nonModels[type.nonModel];
-            var scalarFields = Object.values(getScalarFields(typeDefinition)).map(function (_a) {
-                var name = _a.name;
-                return name;
-            });
-            var nested_1 = [];
-            Object.values(typeDefinition.fields).forEach(function (field) {
-                var type = field.type, name = field.name;
+            const typeDefinition = namespace.nonModels[type.nonModel];
+            const scalarFields = Object.values(getScalarFields(typeDefinition)).map(({ name }) => name);
+            const nested = [];
+            Object.values(typeDefinition.fields).forEach(field => {
+                const { type, name } = field;
                 if (isNonModelFieldType(type)) {
-                    var typeDefinition_1 = namespace.nonModels[type.nonModel];
-                    nested_1.push(name + " { " + generateSelectionSet(namespace, typeDefinition_1) + " }");
+                    const typeDefinition = namespace.nonModels[type.nonModel];
+                    nested.push(`${name} { ${generateSelectionSet(namespace, typeDefinition)} }`);
                 }
             });
-            result.push(name + " { " + scalarFields.join(' ') + " " + nested_1.join(' ') + " }");
+            result.push(`${name} { ${scalarFields.join(' ')} ${nested.join(' ')} }`);
         }
     });
     return result;
 }
 export function getAuthorizationRules(modelDefinition) {
     // Searching for owner authorization on attributes
-    var authConfig = []
+    const authConfig = []
         .concat(modelDefinition.attributes || [])
-        .find(function (attr) { return attr && attr.type === 'auth'; });
-    var _a = (authConfig || {}).properties, _b = (_a === void 0 ? {} : _a).rules, rules = _b === void 0 ? [] : _b;
-    var resultRules = [];
+        .find(attr => attr && attr.type === 'auth');
+    const { properties: { rules = [] } = {} } = authConfig || {};
+    const resultRules = [];
     // Multiple rules can be declared for allow: owner
-    rules.forEach(function (rule) {
+    rules.forEach(rule => {
         // setting defaults for backwards compatibility with old cli
-        var _a = rule.identityClaim, identityClaim = _a === void 0 ? 'cognito:username' : _a, _b = rule.ownerField, ownerField = _b === void 0 ? 'owner' : _b, _c = rule.operations, operations = _c === void 0 ? ['create', 'update', 'delete', 'read'] : _c, _d = rule.provider, provider = _d === void 0 ? 'userPools' : _d, _e = rule.groupClaim, groupClaim = _e === void 0 ? 'cognito:groups' : _e, _f = rule.allow, authStrategy = _f === void 0 ? 'iam' : _f, _g = rule.groups, groups = _g === void 0 ? [] : _g, _h = rule.groupsField, groupsField = _h === void 0 ? '' : _h;
-        var isReadAuthorized = operations.includes('read');
-        var isOwnerAuth = authStrategy === 'owner';
+        const { identityClaim = 'cognito:username', ownerField = 'owner', operations = ['create', 'update', 'delete', 'read'], provider = 'userPools', groupClaim = 'cognito:groups', allow: authStrategy = 'iam', groups = [], groupsField = '', } = rule;
+        const isReadAuthorized = operations.includes('read');
+        const isOwnerAuth = authStrategy === 'owner';
         if (!isReadAuthorized && !isOwnerAuth) {
             return;
         }
-        var authRule = {
-            identityClaim: identityClaim,
-            ownerField: ownerField,
-            provider: provider,
-            groupClaim: groupClaim,
-            authStrategy: authStrategy,
-            groups: groups,
-            groupsField: groupsField,
+        const authRule = {
+            identityClaim,
+            ownerField,
+            provider,
+            groupClaim,
+            authStrategy,
+            groups,
+            groupsField,
             areSubscriptionsPublic: false,
         };
         if (isOwnerAuth) {
             // look for the subscription level override
             // only pay attention to the public level
-            var modelConfig = []
+            const modelConfig = []
                 .concat(modelDefinition.attributes || [])
-                .find(function (attr) { return attr && attr.type === 'model'; });
+                .find(attr => attr && attr.type === 'model');
             // find the subscriptions level. ON is default
-            var _j = (modelConfig || {}).properties, _k = (_j === void 0 ? {} : _j).subscriptions, _l = (_k === void 0 ? {} : _k).level, level = _l === void 0 ? 'on' : _l;
+            const { properties: { subscriptions: { level = 'on' } = {} } = {} } = modelConfig || {};
             // treat subscriptions as public for owner auth with unprotected reads
             // when `read` is omitted from `operations`
             authRule.areSubscriptionsPublic =
@@ -201,81 +185,92 @@ export function getAuthorizationRules(modelDefinition) {
     });
     return resultRules;
 }
-export function buildSubscriptionGraphQLOperation(namespace, modelDefinition, transformerMutationType, isOwnerAuthorization, ownerField, filterArg) {
-    if (filterArg === void 0) { filterArg = false; }
-    var selectionSet = generateSelectionSet(namespace, modelDefinition);
-    var typeName = modelDefinition.name;
-    var opName = "on" + transformerMutationType + typeName;
-    var docArgs = [];
-    var opArgs = [];
+export function buildSubscriptionGraphQLOperation(namespace, modelDefinition, transformerMutationType, isOwnerAuthorization, ownerField, filterArg = false) {
+    const selectionSet = generateSelectionSet(namespace, modelDefinition);
+    const { name: typeName } = modelDefinition;
+    const opName = `on${transformerMutationType}${typeName}`;
+    const docArgs = [];
+    const opArgs = [];
     if (filterArg) {
-        docArgs.push("$filter: ModelSubscription" + typeName + "FilterInput");
+        docArgs.push(`$filter: ModelSubscription${typeName}FilterInput`);
         opArgs.push('filter: $filter');
     }
     if (isOwnerAuthorization) {
-        docArgs.push("$" + ownerField + ": String!");
-        opArgs.push(ownerField + ": $" + ownerField);
+        docArgs.push(`$${ownerField}: String!`);
+        opArgs.push(`${ownerField}: $${ownerField}`);
     }
-    var docStr = docArgs.length ? "(" + docArgs.join(',') + ")" : '';
-    var opStr = opArgs.length ? "(" + opArgs.join(',') + ")" : '';
+    const docStr = docArgs.length ? `(${docArgs.join(',')})` : '';
+    const opStr = opArgs.length ? `(${opArgs.join(',')})` : '';
     return [
         transformerMutationType,
         opName,
-        "subscription operation" + docStr + "{\n\t\t\t" + opName + opStr + "{\n\t\t\t\t" + selectionSet + "\n\t\t\t}\n\t\t}",
+        `subscription operation${docStr}{
+			${opName}${opStr}{
+				${selectionSet}
+			}
+		}`,
     ];
 }
 export function buildGraphQLOperation(namespace, modelDefinition, graphQLOpType) {
-    var selectionSet = generateSelectionSet(namespace, modelDefinition);
-    var typeName = modelDefinition.name, pluralTypeName = modelDefinition.pluralName;
-    var operation;
-    var documentArgs;
-    var operationArgs;
-    var transformerMutationType;
+    let selectionSet = generateSelectionSet(namespace, modelDefinition);
+    const { name: typeName, pluralName: pluralTypeName } = modelDefinition;
+    let operation;
+    let documentArgs;
+    let operationArgs;
+    let transformerMutationType;
     switch (graphQLOpType) {
         case 'LIST':
-            operation = "sync" + pluralTypeName;
-            documentArgs = "($limit: Int, $nextToken: String, $lastSync: AWSTimestamp, $filter: Model" + typeName + "FilterInput)";
+            operation = `sync${pluralTypeName}`;
+            documentArgs = `($limit: Int, $nextToken: String, $lastSync: AWSTimestamp, $filter: Model${typeName}FilterInput)`;
             operationArgs =
                 '(limit: $limit, nextToken: $nextToken, lastSync: $lastSync, filter: $filter)';
-            selectionSet = "items {\n\t\t\t\t\t\t\t" + selectionSet + "\n\t\t\t\t\t\t}\n\t\t\t\t\t\tnextToken\n\t\t\t\t\t\tstartedAt";
+            selectionSet = `items {
+							${selectionSet}
+						}
+						nextToken
+						startedAt`;
             break;
         case 'CREATE':
-            operation = "create" + typeName;
-            documentArgs = "($input: Create" + typeName + "Input!)";
+            operation = `create${typeName}`;
+            documentArgs = `($input: Create${typeName}Input!)`;
             operationArgs = '(input: $input)';
             transformerMutationType = TransformerMutationType.CREATE;
             break;
         case 'UPDATE':
-            operation = "update" + typeName;
-            documentArgs = "($input: Update" + typeName + "Input!, $condition: Model" + typeName + "ConditionInput)";
+            operation = `update${typeName}`;
+            documentArgs = `($input: Update${typeName}Input!, $condition: Model${typeName}ConditionInput)`;
             operationArgs = '(input: $input, condition: $condition)';
             transformerMutationType = TransformerMutationType.UPDATE;
             break;
         case 'DELETE':
-            operation = "delete" + typeName;
-            documentArgs = "($input: Delete" + typeName + "Input!, $condition: Model" + typeName + "ConditionInput)";
+            operation = `delete${typeName}`;
+            documentArgs = `($input: Delete${typeName}Input!, $condition: Model${typeName}ConditionInput)`;
             operationArgs = '(input: $input, condition: $condition)';
             transformerMutationType = TransformerMutationType.DELETE;
             break;
         case 'GET':
-            operation = "get" + typeName;
-            documentArgs = "($id: ID!)";
+            operation = `get${typeName}`;
+            documentArgs = `($id: ID!)`;
             operationArgs = '(id: $id)';
             transformerMutationType = TransformerMutationType.GET;
             break;
         default:
-            throw new Error("Invalid graphQlOpType " + graphQLOpType);
+            throw new Error(`Invalid graphQlOpType ${graphQLOpType}`);
     }
     return [
         [
             transformerMutationType,
             operation,
-            GraphQLOperationType[graphQLOpType] + " operation" + documentArgs + "{\n\t\t" + operation + operationArgs + "{\n\t\t\t" + selectionSet + "\n\t\t}\n\t}",
+            `${GraphQLOperationType[graphQLOpType]} operation${documentArgs}{
+		${operation}${operationArgs}{
+			${selectionSet}
+		}
+	}`,
         ],
     ];
 }
 export function createMutationInstanceFromModelOperation(relationships, modelDefinition, opType, model, element, condition, MutationEventConstructor, modelInstanceCreator, id) {
-    var operation;
+    let operation;
     switch (opType) {
         case OpType.INSERT:
             operation = TransformerMutationType.CREATE;
@@ -287,13 +282,13 @@ export function createMutationInstanceFromModelOperation(relationships, modelDef
             operation = TransformerMutationType.DELETE;
             break;
         default:
-            throw new Error("Invalid opType " + opType);
+            throw new Error(`Invalid opType ${opType}`);
     }
     // stringify nested objects of type AWSJSON
     // this allows us to return parsed JSON to users (see `castInstanceType()` in datastore.ts),
     // but still send the object correctly over the wire
-    var replacer = function (k, v) {
-        var isAWSJSON = k &&
+    const replacer = (k, v) => {
+        const isAWSJSON = k &&
             v !== null &&
             typeof v === 'object' &&
             modelDefinition.fields[k] &&
@@ -303,13 +298,20 @@ export function createMutationInstanceFromModelOperation(relationships, modelDef
         }
         return v;
     };
-    var modelId = getIdentifierValue(modelDefinition, element);
-    var optionalId = OpType.INSERT && id ? { id: id } : {};
-    var mutationEvent = modelInstanceCreator(MutationEventConstructor, __assign(__assign({}, optionalId), { data: JSON.stringify(element, replacer), modelId: modelId, model: model.name, operation: operation, condition: JSON.stringify(condition) }));
+    const modelId = getIdentifierValue(modelDefinition, element);
+    const optionalId = OpType.INSERT && id ? { id } : {};
+    const mutationEvent = modelInstanceCreator(MutationEventConstructor, {
+        ...optionalId,
+        data: JSON.stringify(element, replacer),
+        modelId,
+        model: model.name,
+        operation: operation,
+        condition: JSON.stringify(condition),
+    });
     return mutationEvent;
 }
 export function predicateToGraphQLCondition(predicate, modelDefinition) {
-    var result = {};
+    const result = {};
     if (!predicate || !Array.isArray(predicate.predicates)) {
         return result;
     }
@@ -320,7 +322,7 @@ export function predicateToGraphQLCondition(predicate, modelDefinition) {
     // Or all records where PK = some value but SKs are different values
     // TODO: if the Transform gets updated we'll need to modify this logic to only omit
     // key fields from the predicate/condition when ALL of the keyFields are present and using `eq` operators
-    var keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+    const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
     return predicateToGraphQLFilter(predicate, keyFields);
 }
 /**
@@ -338,37 +340,34 @@ export function predicateToGraphQLCondition(predicate, modelDefinition) {
     { and:[{ username: { eq: 'bob' }}] }
     ```
     */
-export function predicateToGraphQLFilter(predicatesGroup, fieldsToOmit, root) {
-    if (fieldsToOmit === void 0) { fieldsToOmit = []; }
-    if (root === void 0) { root = true; }
-    var result = {};
+export function predicateToGraphQLFilter(predicatesGroup, fieldsToOmit = [], root = true) {
+    const result = {};
     if (!predicatesGroup || !Array.isArray(predicatesGroup.predicates)) {
         return result;
     }
-    var type = predicatesGroup.type, predicates = predicatesGroup.predicates;
-    var isList = type === 'and' || type === 'or';
+    const { type, predicates } = predicatesGroup;
+    const isList = type === 'and' || type === 'or';
     result[type] = isList ? [] : {};
-    var children = [];
-    predicates.forEach(function (predicate) {
-        var _a, _b;
+    const children = [];
+    predicates.forEach(predicate => {
         if (isPredicateObj(predicate)) {
-            var field = predicate.field, operator = predicate.operator, operand = predicate.operand;
+            const { field, operator, operand } = predicate;
             if (fieldsToOmit.includes(field))
                 return;
-            var gqlField = (_a = {},
-                _a[field] = (_b = {}, _b[operator] = operand, _b),
-                _a);
+            const gqlField = {
+                [field]: { [operator]: operand },
+            };
             children.push(gqlField);
             return;
         }
-        var child = predicateToGraphQLFilter(predicate, fieldsToOmit, false);
+        const child = predicateToGraphQLFilter(predicate, fieldsToOmit, false);
         if (Object.keys(child).length > 0) {
             children.push(child);
         }
     });
     // flatten redundant list predicates
     if (children.length === 1) {
-        var _a = __read(children, 1), child = _a[0];
+        const [child] = children;
         if (
         // any nested list node
         (isList && !root) ||
@@ -379,7 +378,7 @@ export function predicateToGraphQLFilter(predicatesGroup, fieldsToOmit, root) {
             return result;
         }
     }
-    children.forEach(function (child) {
+    children.forEach(child => {
         if (isList) {
             result[type].push(child);
         }
@@ -403,18 +402,18 @@ export function predicateToGraphQLFilter(predicatesGroup, fieldsToOmit, root) {
  * @returns set of distinct field names in the filter group
  */
 export function filterFields(group) {
-    var fields = new Set();
+    const fields = new Set();
     if (!group || !Array.isArray(group.predicates))
         return fields;
-    var predicates = group.predicates;
-    var stack = __spread(predicates);
+    const { predicates } = group;
+    const stack = [...predicates];
     while (stack.length > 0) {
-        var current = stack.pop();
+        const current = stack.pop();
         if (isPredicateObj(current)) {
             fields.add(current.field);
         }
         else if (isPredicateGroup(current)) {
-            stack.push.apply(stack, __spread(current.predicates));
+            stack.push(...current.predicates);
         }
     }
     return fields;
@@ -425,27 +424,16 @@ export function filterFields(group) {
  * @returns set of field names used with dynamic auth modes configured for the provided model definition
  */
 export function dynamicAuthFields(modelDefinition) {
-    var e_1, _a;
-    var rules = getAuthorizationRules(modelDefinition);
-    var fields = new Set();
-    try {
-        for (var rules_1 = __values(rules), rules_1_1 = rules_1.next(); !rules_1_1.done; rules_1_1 = rules_1.next()) {
-            var rule = rules_1_1.value;
-            if (rule.groupsField && !rule.groups.length) {
-                // dynamic group rule will have no values in `rule.groups`
-                fields.add(rule.groupsField);
-            }
-            else if (rule.ownerField) {
-                fields.add(rule.ownerField);
-            }
+    const rules = getAuthorizationRules(modelDefinition);
+    const fields = new Set();
+    for (const rule of rules) {
+        if (rule.groupsField && !rule.groups.length) {
+            // dynamic group rule will have no values in `rule.groups`
+            fields.add(rule.groupsField);
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (rules_1_1 && !rules_1_1.done && (_a = rules_1.return)) _a.call(rules_1);
+        else if (rule.ownerField) {
+            fields.add(rule.ownerField);
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return fields;
 }
@@ -465,17 +453,17 @@ export function dynamicAuthFields(modelDefinition) {
 export function countFilterCombinations(group) {
     if (!group || !Array.isArray(group.predicates))
         return 0;
-    var count = 0;
-    var stack = [group];
+    let count = 0;
+    const stack = [group];
     while (stack.length > 0) {
-        var current = stack.pop();
+        const current = stack.pop();
         if (isPredicateGroup(current)) {
-            var predicates = current.predicates, type = current.type;
+            const { predicates, type } = current;
             // ignore length = 1; groups with 1 predicate will get flattened when converted to gqlFilter
             if (type === 'or' && predicates.length > 1) {
                 count += predicates.length;
             }
-            stack.push.apply(stack, __spread(predicates));
+            stack.push(...predicates);
         }
     }
     // if we didn't encounter any OR groups, default to 1
@@ -498,50 +486,37 @@ export function repeatedFieldInGroup(group) {
     if (!group || !Array.isArray(group.predicates))
         return null;
     // convert to filter in order to flatten redundant groups
-    var gqlFilter = predicateToGraphQLFilter(group);
-    var stack = [gqlFilter];
-    var hasGroupRepeatedFields = function (fields) {
-        var e_2, _a;
-        var seen = {};
-        try {
-            for (var fields_1 = __values(fields), fields_1_1 = fields_1.next(); !fields_1_1.done; fields_1_1 = fields_1.next()) {
-                var f = fields_1_1.value;
-                var _b = __read(Object.keys(f), 1), fieldName = _b[0];
-                if (seen[fieldName]) {
-                    return fieldName;
-                }
-                seen[fieldName] = true;
+    const gqlFilter = predicateToGraphQLFilter(group);
+    const stack = [gqlFilter];
+    const hasGroupRepeatedFields = (fields) => {
+        const seen = {};
+        for (const f of fields) {
+            const [fieldName] = Object.keys(f);
+            if (seen[fieldName]) {
+                return fieldName;
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (fields_1_1 && !fields_1_1.done && (_a = fields_1.return)) _a.call(fields_1);
-            }
-            finally { if (e_2) throw e_2.error; }
+            seen[fieldName] = true;
         }
         return null;
     };
     while (stack.length > 0) {
-        var current = stack.pop();
-        var _a = __read(Object.keys(current), 1), key = _a[0];
-        var values = current[key];
+        const current = stack.pop();
+        const [key] = Object.keys(current);
+        const values = current[key];
         if (!Array.isArray(values)) {
             return null;
         }
         // field value will be single object
-        var predicateObjects = values.filter(function (v) { return !Array.isArray(Object.values(v)[0]); });
+        const predicateObjects = values.filter(v => !Array.isArray(Object.values(v)[0]));
         // group value will be an array
-        var predicateGroups = values.filter(function (v) {
-            return Array.isArray(Object.values(v)[0]);
-        });
+        const predicateGroups = values.filter(v => Array.isArray(Object.values(v)[0]));
         if (key === 'and') {
-            var repeatedField = hasGroupRepeatedFields(predicateObjects);
+            const repeatedField = hasGroupRepeatedFields(predicateObjects);
             if (repeatedField) {
                 return repeatedField;
             }
         }
-        stack.push.apply(stack, __spread(predicateGroups));
+        stack.push(...predicateGroups);
     }
     return null;
 }
@@ -555,41 +530,41 @@ export var RTFError;
     RTFError[RTFError["FieldNotInType"] = 5] = "FieldNotInType";
 })(RTFError || (RTFError = {}));
 export function generateRTFRemediation(errorType, modelDefinition, predicatesGroup) {
-    var selSyncFields = filterFields(predicatesGroup);
-    var selSyncFieldStr = __spread(selSyncFields).join(', ');
-    var dynamicAuthModeFields = dynamicAuthFields(modelDefinition);
-    var dynamicAuthFieldsStr = __spread(dynamicAuthModeFields).join(', ');
-    var filterCombinations = countFilterCombinations(predicatesGroup);
-    var repeatedField = repeatedFieldInGroup(predicatesGroup);
+    const selSyncFields = filterFields(predicatesGroup);
+    const selSyncFieldStr = [...selSyncFields].join(', ');
+    const dynamicAuthModeFields = dynamicAuthFields(modelDefinition);
+    const dynamicAuthFieldsStr = [...dynamicAuthModeFields].join(', ');
+    const filterCombinations = countFilterCombinations(predicatesGroup);
+    const repeatedField = repeatedFieldInGroup(predicatesGroup);
     switch (errorType) {
         case RTFError.UnknownField:
-            return ("Your API was generated with an older version of the CLI that doesn't support backend subscription filtering." +
+            return (`Your API was generated with an older version of the CLI that doesn't support backend subscription filtering.` +
                 'To enable backend subscription filtering, upgrade your Amplify CLI to the latest version and push your app by running `amplify upgrade` followed by `amplify push`');
         case RTFError.MaxAttributes: {
-            var message = "Your selective sync expression for " + modelDefinition.name + " contains " + selSyncFields.size + " different model fields: " + selSyncFieldStr + ".\n\n";
+            let message = `Your selective sync expression for ${modelDefinition.name} contains ${selSyncFields.size} different model fields: ${selSyncFieldStr}.\n\n`;
             if (dynamicAuthModeFields.size > 0) {
                 message +=
-                    "Note: the number of fields you can use with selective sync is affected by @auth rules configured on the model.\n\n" +
-                        "Dynamic auth modes, such as owner auth and dynamic group auth each utilize 1 field.\n" +
-                        ("You currently have " + dynamicAuthModeFields.size + " dynamic auth mode(s) configured on this model: " + dynamicAuthFieldsStr + ".");
+                    `Note: the number of fields you can use with selective sync is affected by @auth rules configured on the model.\n\n` +
+                        `Dynamic auth modes, such as owner auth and dynamic group auth each utilize 1 field.\n` +
+                        `You currently have ${dynamicAuthModeFields.size} dynamic auth mode(s) configured on this model: ${dynamicAuthFieldsStr}.`;
             }
             return message;
         }
         case RTFError.MaxCombinations: {
-            var message = "Your selective sync expression for " + modelDefinition.name + " contains " + filterCombinations + " field combinations (total number of predicates in an OR expression).\n\n";
+            let message = `Your selective sync expression for ${modelDefinition.name} contains ${filterCombinations} field combinations (total number of predicates in an OR expression).\n\n`;
             if (dynamicAuthModeFields.size > 0) {
                 message +=
-                    "Note: the number of fields you can use with selective sync is affected by @auth rules configured on the model.\n\n" +
-                        "Dynamic auth modes, such as owner auth and dynamic group auth factor in to the number of combinations you're using.\n" +
-                        ("You currently have " + dynamicAuthModeFields.size + " dynamic auth mode(s) configured on this model: " + dynamicAuthFieldsStr + ".");
+                    `Note: the number of fields you can use with selective sync is affected by @auth rules configured on the model.\n\n` +
+                        `Dynamic auth modes, such as owner auth and dynamic group auth factor in to the number of combinations you're using.\n` +
+                        `You currently have ${dynamicAuthModeFields.size} dynamic auth mode(s) configured on this model: ${dynamicAuthFieldsStr}.`;
             }
             return message;
         }
         case RTFError.RepeatedFieldname:
-            return "Your selective sync expression for " + modelDefinition.name + " contains multiple entries for " + repeatedField + " in the same AND group.";
+            return `Your selective sync expression for ${modelDefinition.name} contains multiple entries for ${repeatedField} in the same AND group.`;
         case RTFError.NotGroup:
-            return ("Your selective sync expression for " + modelDefinition.name + " uses a `not` group. If you'd like to filter subscriptions in the backend, " +
-                "rewrite your expression using `ne` or `notContains` operators.");
+            return (`Your selective sync expression for ${modelDefinition.name} uses a \`not\` group. If you'd like to filter subscriptions in the backend, ` +
+                `rewrite your expression using \`ne\` or \`notContains\` operators.`);
         case RTFError.FieldNotInType:
             // no remediation instructions. We'll surface the message directly
             return '';
@@ -597,9 +572,9 @@ export function generateRTFRemediation(errorType, modelDefinition, predicatesGro
 }
 export function getUserGroupsFromToken(token, rule) {
     // validate token against groupClaim
-    var userGroups = token[rule.groupClaim] || [];
+    let userGroups = token[rule.groupClaim] || [];
     if (typeof userGroups === 'string') {
-        var parsedGroups = void 0;
+        let parsedGroups;
         try {
             parsedGroups = JSON.parse(userGroups);
         }
@@ -610,122 +585,92 @@ export function getUserGroupsFromToken(token, rule) {
     }
     return userGroups;
 }
-export function getModelAuthModes(_a) {
-    var authModeStrategy = _a.authModeStrategy, defaultAuthMode = _a.defaultAuthMode, modelName = _a.modelName, schema = _a.schema;
-    return __awaiter(this, void 0, void 0, function () {
-        var operations, modelAuthModes, error_1;
-        var _this = this;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    operations = Object.values(ModelOperation);
-                    modelAuthModes = {
-                        CREATE: [],
-                        READ: [],
-                        UPDATE: [],
-                        DELETE: [],
-                    };
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, Promise.all(operations.map(function (operation) { return __awaiter(_this, void 0, void 0, function () {
-                            var authModes;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, authModeStrategy({
-                                            schema: schema,
-                                            modelName: modelName,
-                                            operation: operation,
-                                        })];
-                                    case 1:
-                                        authModes = _a.sent();
-                                        if (typeof authModes === 'string') {
-                                            modelAuthModes[operation] = [authModes];
-                                        }
-                                        else if (Array.isArray(authModes) && authModes.length) {
-                                            modelAuthModes[operation] = authModes;
-                                        }
-                                        else {
-                                            // Use default auth mode if nothing is returned from authModeStrategy
-                                            modelAuthModes[operation] = [defaultAuthMode];
-                                        }
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                case 2:
-                    _b.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    error_1 = _b.sent();
-                    logger.debug("Error getting auth modes for model: " + modelName, error_1);
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/, modelAuthModes];
+export async function getModelAuthModes({ authModeStrategy, defaultAuthMode, modelName, schema, }) {
+    const operations = Object.values(ModelOperation);
+    const modelAuthModes = {
+        CREATE: [],
+        READ: [],
+        UPDATE: [],
+        DELETE: [],
+    };
+    try {
+        await Promise.all(operations.map(async (operation) => {
+            const authModes = await authModeStrategy({
+                schema,
+                modelName,
+                operation,
+            });
+            if (typeof authModes === 'string') {
+                modelAuthModes[operation] = [authModes];
             }
-        });
-    });
+            else if (Array.isArray(authModes) && authModes.length) {
+                modelAuthModes[operation] = authModes;
+            }
+            else {
+                // Use default auth mode if nothing is returned from authModeStrategy
+                modelAuthModes[operation] = [defaultAuthMode];
+            }
+        }));
+    }
+    catch (error) {
+        logger.debug(`Error getting auth modes for model: ${modelName}`, error);
+    }
+    return modelAuthModes;
 }
 export function getForbiddenError(error) {
-    var forbiddenErrorMessages = [
-        'Request failed with status code 401',
-        'Request failed with status code 403',
-    ];
-    var forbiddenError;
+    const forbiddenErrorCodes = [401, 403];
+    let forbiddenError;
     if (error && error.errors) {
-        forbiddenError = error.errors.find(function (err) {
-            return forbiddenErrorMessages.includes(err.message);
-        });
+        forbiddenError = error.errors.find(err => forbiddenErrorCodes.includes(resolveServiceErrorStatusCode(err)));
     }
     else if (error && error.message) {
         forbiddenError = error;
     }
     if (forbiddenError) {
-        return forbiddenError.message;
+        return (forbiddenError.message ??
+            `Request failed with status code ${resolveServiceErrorStatusCode(forbiddenError)}`);
     }
     return null;
 }
+export function resolveServiceErrorStatusCode(error) {
+    if (error?.['$metadata']?.['httpStatusCode']) {
+        return Number(error?.['$metadata']?.['httpStatusCode']);
+    }
+    else if (error?.originalError) {
+        return resolveServiceErrorStatusCode(error?.originalError);
+    }
+    else {
+        return null;
+    }
+}
 export function getClientSideAuthError(error) {
-    var clientSideAuthErrors = Object.values(GraphQLAuthError);
-    var clientSideError = error &&
+    const clientSideAuthErrors = Object.values(GraphQLAuthError);
+    const clientSideError = error &&
         error.message &&
-        clientSideAuthErrors.find(function (clientError) {
-            return error.message.includes(clientError);
-        });
+        clientSideAuthErrors.find(clientError => error.message.includes(clientError));
     return clientSideError || null;
 }
-export function getTokenForCustomAuth(authMode, amplifyConfig) {
-    if (amplifyConfig === void 0) { amplifyConfig = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, functionAuthProvider, token, error_2;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!(authMode === GRAPHQL_AUTH_MODE.AWS_LAMBDA)) return [3 /*break*/, 6];
-                    _a = amplifyConfig.authProviders, functionAuthProvider = (_a === void 0 ? { functionAuthProvider: null } : _a).functionAuthProvider;
-                    if (!(functionAuthProvider && typeof functionAuthProvider === 'function')) return [3 /*break*/, 5];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, functionAuthProvider()];
-                case 2:
-                    token = (_b.sent()).token;
-                    return [2 /*return*/, token];
-                case 3:
-                    error_2 = _b.sent();
-                    throw new Error("Error retrieving token from `functionAuthProvider`: " + error_2);
-                case 4: return [3 /*break*/, 6];
-                case 5: 
-                // TODO: add docs link once available
-                throw new Error("You must provide a `functionAuthProvider` function to `DataStore.configure` when using " + GRAPHQL_AUTH_MODE.AWS_LAMBDA);
-                case 6: return [2 /*return*/];
+export async function getTokenForCustomAuth(authMode, amplifyConfig = {}) {
+    if (authMode === 'lambda') {
+        const { authProviders: { functionAuthProvider } = { functionAuthProvider: null }, } = amplifyConfig;
+        if (functionAuthProvider && typeof functionAuthProvider === 'function') {
+            try {
+                const { token } = await functionAuthProvider();
+                return token;
             }
-        });
-    });
+            catch (error) {
+                throw new Error(`Error retrieving token from \`functionAuthProvider\`: ${error}`);
+            }
+        }
+        else {
+            // TODO: add docs link once available
+            throw new Error('You must provide a `functionAuthProvider` function to `DataStore.configure` when using lambda');
+        }
+    }
 }
 // Util that takes a modelDefinition and model and returns either the id value(s) or the custom primary key value(s)
 export function getIdentifierValue(modelDefinition, model) {
-    var pkFieldNames = extractPrimaryKeyFieldNames(modelDefinition);
-    var idOrPk = pkFieldNames.map(function (f) { return model[f]; }).join(IDENTIFIER_KEY_SEPARATOR);
+    const pkFieldNames = extractPrimaryKeyFieldNames(modelDefinition);
+    const idOrPk = pkFieldNames.map(f => model[f]).join(IDENTIFIER_KEY_SEPARATOR);
     return idOrPk;
 }
-//# sourceMappingURL=utils.js.map