@aws-amplify/api-graphql 4.0.1-api-v6-models.c1977f8.0 → 4.0.1-api-v6-models.891fe0d.0

package/lib-esm/internals/APIClient.js

@@ -1,8 +1,8 @@
-import { __assign, __read, __spreadArray, __values } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { resolveOwnerFields } from '../utils/resolveOwnerFields';
-var connectionType = {
+import { __authMode, __authToken } from '../types';
+const connectionType = {
     HAS_ONE: 'HAS_ONE',
     HAS_MANY: 'HAS_MANY',
     BELONGS_TO: 'BELONGS_TO',
@@ -12,15 +12,12 @@ var connectionType = {
  * @param GraphQL response object
  * @returns response object with `items` properties flattened
  */
-export var flattenItems = function (obj) {
-    var res = {};
-    Object.entries(obj).forEach(function (_a) {
-        var _b = __read(_a, 2), prop = _b[0], value = _b[1];
+export const flattenItems = (obj) => {
+    const res = {};
+    Object.entries(obj).forEach(([prop, value]) => {
         if (typeof value === 'object' && value !== null) {
             if (value.items !== undefined) {
-                res[prop] = value.items.map(function (item) {
-                    return flattenItems(item);
-                });
+                res[prop] = value.items.map((item) => flattenItems(item));
                 return;
             }
             res[prop] = flattenItems(value);
@@ -31,114 +28,136 @@ export var flattenItems = function (obj) {
     return res;
 };
 // TODO: this should accept single result to support CRUD methods; create helper for array/list
-export function initializeModel(client, modelName, result, modelIntrospection, authMode, authToken) {
-    var introModel = modelIntrospection.models[modelName];
-    var introModelFields = introModel.fields;
-    var modelFields = Object.entries(introModelFields)
-        .filter(function (_a) {
-        var _b;
-        var _c = __read(_a, 2), _ = _c[0], field = _c[1];
-        return ((_b = field === null || field === void 0 ? void 0 : field.type) === null || _b === void 0 ? void 0 : _b.model) !== undefined;
-    })
-        .map(function (_a) {
-        var _b = __read(_a, 1), fieldName = _b[0];
-        return fieldName;
-    });
-    return result.map(function (record) {
-        var e_1, _a;
-        var _b, _c;
-        var initializedRelationalFields = {};
-        var _loop_1 = function (field) {
-            var relatedModelName = introModelFields[field].type.model;
-            var relatedModel = modelIntrospection.models[relatedModelName];
-            var relatedModelPKFieldName = relatedModel.primaryKeyInfo.primaryKeyFieldName;
-            var relatedModelSKFieldNames = relatedModel.primaryKeyInfo.sortKeyFieldNames;
-            var relationType = introModelFields[field].association.connectionType;
-            var connectionFields = introModelFields[field].association.associatedWith;
-            var targetNames = ((_b = introModelFields[field].association) === null || _b === void 0 ? void 0 : _b.targetNames) || [];
+export function initializeModel(client, modelName, result, modelIntrospection, authMode, authToken, context = false) {
+    const introModel = modelIntrospection.models[modelName];
+    const introModelFields = introModel.fields;
+    const modelFields = Object.entries(introModelFields)
+        .filter(([_, field]) => field?.type?.model !== undefined)
+        .map(([fieldName]) => fieldName);
+    return result.map(record => {
+        const initializedRelationalFields = {};
+        for (const field of modelFields) {
+            const relatedModelName = introModelFields[field].type.model;
+            const relatedModel = modelIntrospection.models[relatedModelName];
+            const relatedModelPKFieldName = relatedModel.primaryKeyInfo.primaryKeyFieldName;
+            const relatedModelSKFieldNames = relatedModel.primaryKeyInfo.sortKeyFieldNames;
+            const relationType = introModelFields[field].association.connectionType;
+            const connectionFields = introModelFields[field].association.associatedWith;
+            const targetNames = introModelFields[field].association?.targetNames || [];
             switch (relationType) {
                 case connectionType.HAS_ONE:
                 case connectionType.BELONGS_TO:
-                    var sortKeyValues_1 = relatedModelSKFieldNames.reduce(function (acc, curVal) {
+                    const sortKeyValues = relatedModelSKFieldNames.reduce((acc, curVal) => {
                         if (record[curVal]) {
                             return (acc[curVal] = record[curVal]);
                         }
                     }, {});
-                    initializedRelationalFields[field] = function (options) {
-                        var _a;
-                        if (record[targetNames[0]]) {
-                            return client.models[relatedModelName].get(__assign((_a = {}, _a[relatedModelPKFieldName] = record[targetNames[0]], _a), sortKeyValues_1), {
-                                authMode: (options === null || options === void 0 ? void 0 : options.authMode) || authMode,
-                                authToken: (options === null || options === void 0 ? void 0 : options.authToken) || authToken,
-                            });
-                        }
-                        return undefined;
-                    };
+                    if (context) {
+                        initializedRelationalFields[field] = (contextSpec, options) => {
+                            if (record[targetNames[0]]) {
+                                return client.models[relatedModelName].get(contextSpec, {
+                                    [relatedModelPKFieldName]: record[targetNames[0]],
+                                    ...sortKeyValues,
+                                }, {
+                                    authMode: options?.authMode || authMode,
+                                    authToken: options?.authToken || authToken,
+                                });
+                            }
+                            return undefined;
+                        };
+                    }
+                    else {
+                        initializedRelationalFields[field] = (options) => {
+                            if (record[targetNames[0]]) {
+                                return client.models[relatedModelName].get({
+                                    [relatedModelPKFieldName]: record[targetNames[0]],
+                                    ...sortKeyValues,
+                                }, {
+                                    authMode: options?.authMode || authMode,
+                                    authToken: options?.authToken || authToken,
+                                });
+                            }
+                            return undefined;
+                        };
+                    }
                     break;
                 case connectionType.HAS_MANY:
-                    var parentPk_1 = introModel.primaryKeyInfo.primaryKeyFieldName;
-                    var parentSK_1 = introModel.primaryKeyInfo.sortKeyFieldNames;
+                    const parentPk = introModel.primaryKeyInfo.primaryKeyFieldName;
+                    const parentSK = introModel.primaryKeyInfo.sortKeyFieldNames;
                     // M:N check - TODO: refactor
-                    if ((_c = relatedModel.fields[connectionFields[0]]) === null || _c === void 0 ? void 0 : _c.type.model) {
-                        var relatedTargetNames = relatedModel.fields[connectionFields[0]].association.targetNames;
-                        var hasManyFilter_1 = relatedTargetNames.map(function (field, idx) {
-                            var _a, _b;
+                    if (relatedModel.fields[connectionFields[0]]?.type.model) {
+                        const relatedTargetNames = relatedModel.fields[connectionFields[0]].association.targetNames;
+                        const hasManyFilter = relatedTargetNames.map((field, idx) => {
                             if (idx === 0) {
-                                return _a = {}, _a[field] = { eq: record[parentPk_1] }, _a;
+                                return { [field]: { eq: record[parentPk] } };
                             }
-                            return _b = {}, _b[field] = { eq: record[parentSK_1[idx - 1]] }, _b;
+                            return { [field]: { eq: record[parentSK[idx - 1]] } };
                         });
-                        initializedRelationalFields[field] = function (options) {
-                            if (record[parentPk_1]) {
+                        if (context) {
+                            initializedRelationalFields[field] = (contextSpec, options) => {
+                                if (record[parentPk]) {
+                                    return client.models[relatedModelName].list(contextSpec, {
+                                        filter: { and: hasManyFilter },
+                                        authMode: options?.authMode || authMode,
+                                        authToken: options?.authToken || authToken,
+                                    });
+                                }
+                                return [];
+                            };
+                        }
+                        else {
+                            initializedRelationalFields[field] = (options) => {
+                                if (record[parentPk]) {
+                                    return client.models[relatedModelName].list({
+                                        filter: { and: hasManyFilter },
+                                        authMode: options?.authMode || authMode,
+                                        authToken: options?.authToken || authToken,
+                                    });
+                                }
+                                return [];
+                            };
+                        }
+                        break;
+                    }
+                    const hasManyFilter = connectionFields.map((field, idx) => {
+                        if (idx === 0) {
+                            return { [field]: { eq: record[parentPk] } };
+                        }
+                        return { [field]: { eq: record[parentSK[idx - 1]] } };
+                    });
+                    if (context) {
+                        initializedRelationalFields[field] = (contextSpec, options) => {
+                            if (record[parentPk]) {
+                                return client.models[relatedModelName].list(contextSpec, {
+                                    filter: { and: hasManyFilter },
+                                    authMode: options?.authMode || authMode,
+                                    authToken: options?.authToken || authToken,
+                                });
+                            }
+                            return [];
+                        };
+                    }
+                    else {
+                        initializedRelationalFields[field] = (options) => {
+                            if (record[parentPk]) {
                                 return client.models[relatedModelName].list({
-                                    filter: { and: hasManyFilter_1 },
-                                    authMode: (options === null || options === void 0 ? void 0 : options.authMode) || authMode,
-                                    authToken: (options === null || options === void 0 ? void 0 : options.authToken) || authToken,
+                                    filter: { and: hasManyFilter },
+                                    authMode: options?.authMode || authMode,
+                                    authToken: options?.authToken || authToken,
                                 });
                             }
                             return [];
                         };
-                        break;
                     }
-                    var hasManyFilter_2 = connectionFields.map(function (field, idx) {
-                        var _a, _b;
-                        if (idx === 0) {
-                            return _a = {}, _a[field] = { eq: record[parentPk_1] }, _a;
-                        }
-                        return _b = {}, _b[field] = { eq: record[parentSK_1[idx - 1]] }, _b;
-                    });
-                    initializedRelationalFields[field] = function (options) {
-                        if (record[parentPk_1]) {
-                            return client.models[relatedModelName].list({
-                                filter: { and: hasManyFilter_2 },
-                                authMode: (options === null || options === void 0 ? void 0 : options.authMode) || authMode,
-                                authToken: (options === null || options === void 0 ? void 0 : options.authToken) || authToken,
-                            });
-                        }
-                        return [];
-                    };
                     break;
                 default:
                     break;
             }
-        };
-        try {
-            for (var modelFields_1 = __values(modelFields), modelFields_1_1 = modelFields_1.next(); !modelFields_1_1.done; modelFields_1_1 = modelFields_1.next()) {
-                var field = modelFields_1_1.value;
-                _loop_1(field);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (modelFields_1_1 && !modelFields_1_1.done && (_a = modelFields_1.return)) _a.call(modelFields_1);
-            }
-            finally { if (e_1) throw e_1.error; }
         }
-        return __assign(__assign({}, record), initializedRelationalFields);
+        return { ...record, ...initializedRelationalFields };
     });
 }
-export var graphQLOperationsInfo = {
+export const graphQLOperationsInfo = {
     CREATE: { operationPrefix: 'create', usePlural: false },
     READ: { operationPrefix: 'get', usePlural: false },
     UPDATE: { operationPrefix: 'update', usePlural: false },
@@ -149,24 +168,21 @@ export var graphQLOperationsInfo = {
     ONDELETE: { operationPrefix: 'onDelete', usePlural: false },
     OBSERVE_QUERY: { operationPrefix: 'observeQuery', usePlural: false },
 };
-var graphQLDocumentsCache = new Map();
-var SELECTION_SET_WILDCARD = '*';
+const graphQLDocumentsCache = new Map();
+const SELECTION_SET_WILDCARD = '*';
 function defaultSelectionSetForModel(modelDefinition) {
     // fields that are explicitly part of the graphql schema; not
     // inferred from owner auth rules.
-    var fields = modelDefinition.fields;
-    var explicitFields = Object.values(fields)
-        .map(function (_a) {
-        var type = _a.type, name = _a.name;
-        return typeof type === 'string' && name;
-    }) // Default selection set omits model fields
+    const { fields } = modelDefinition;
+    const explicitFields = Object.values(fields)
+        .map(({ type, name }) => typeof type === 'string' && name) // Default selection set omits model fields
         .filter(Boolean);
     // fields used for owner auth rules that may or may not also
     // be explicit on the model.
-    var ownerFields = resolveOwnerFields(modelDefinition);
+    const ownerFields = resolveOwnerFields(modelDefinition);
     return Array.from(new Set(explicitFields.concat(ownerFields)));
 }
-var FIELD_IR = '';
+const FIELD_IR = '';
 /**
  * Generates nested Custom Selection Set IR from path
  *
@@ -187,48 +203,47 @@ var FIELD_IR = '';
  * ```
  */
 export function customSelectionSetToIR(modelIntrospection, modelName, selectionSet) {
-    var modelDefinition = modelIntrospection[modelName];
-    var modelFields = modelDefinition.fields;
-    return selectionSet.reduce(function (resultObj, path) {
-        var _a, _b, _c;
-        var _d = __read(path.split('.')), fieldName = _d[0], nested = _d[1], rest = _d.slice(2);
+    const modelDefinition = modelIntrospection[modelName];
+    const { fields: modelFields } = modelDefinition;
+    return selectionSet.reduce((resultObj, path) => {
+        const [fieldName, nested, ...rest] = path.split('.');
         if (nested) {
-            var relatedModel = (_b = (_a = modelFields[fieldName]) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.model;
+            const relatedModel = modelFields[fieldName]?.type?.model;
             if (!relatedModel) {
                 // TODO: may need to change this to support custom types
-                throw Error("".concat(fieldName, " is not a model field"));
+                throw Error(`${fieldName} is not a model field`);
             }
-            var relatedModelDefinition = modelIntrospection[relatedModel];
-            var selectionSet_1 = nested === SELECTION_SET_WILDCARD
+            const relatedModelDefinition = modelIntrospection[relatedModel];
+            const selectionSet = nested === SELECTION_SET_WILDCARD
                 ? defaultSelectionSetIR(relatedModelDefinition)
                 : // if we have a path like 'field.anotherField' recursively build up selection set IR
                     customSelectionSetToIR(modelIntrospection, relatedModel, [
-                        __spreadArray([nested], __read(rest), false).join('.'),
+                        [nested, ...rest].join('.'),
                     ]);
-            if ((_c = modelFields[fieldName]) === null || _c === void 0 ? void 0 : _c.isArray) {
-                var existing = resultObj[fieldName] || {
+            if (modelFields[fieldName]?.isArray) {
+                const existing = resultObj[fieldName] || {
                     items: {},
                 };
-                var merged_1 = __assign(__assign({}, existing.items), selectionSet_1);
-                resultObj[fieldName] = { items: merged_1 };
+                const merged = { ...existing.items, ...selectionSet };
+                resultObj[fieldName] = { items: merged };
                 return resultObj;
             }
-            var existingItems = resultObj[fieldName] || {};
-            var merged = __assign(__assign({}, existingItems), selectionSet_1);
+            const existingItems = resultObj[fieldName] || {};
+            const merged = { ...existingItems, ...selectionSet };
             resultObj[fieldName] = merged;
             return resultObj;
         }
-        var exists = Boolean(modelFields[fieldName]);
+        const exists = Boolean(modelFields[fieldName]);
         if (!exists) {
-            throw Error("".concat(fieldName, " is not a field of model ").concat(modelName));
+            throw Error(`${fieldName} is not a field of model ${modelName}`);
         }
         resultObj[fieldName] = FIELD_IR;
         return resultObj;
     }, {});
 }
-var defaultSelectionSetIR = function (relatedModelDefinition) {
-    var defaultSelectionSet = defaultSelectionSetForModel(relatedModelDefinition);
-    var reduced = defaultSelectionSet.reduce(function (acc, curVal) {
+const defaultSelectionSetIR = relatedModelDefinition => {
+    const defaultSelectionSet = defaultSelectionSetForModel(relatedModelDefinition);
+    const reduced = defaultSelectionSet.reduce((acc, curVal) => {
         acc[curVal] = FIELD_IR;
         return acc;
     }, {});
@@ -250,14 +265,13 @@ var defaultSelectionSetIR = function (relatedModelDefinition) {
  * `'id comments { items { post { id } } }'`
  */
 export function selectionSetIRToString(obj) {
-    var res = [];
-    Object.entries(obj).forEach(function (_a) {
-        var _b = __read(_a, 2), fieldName = _b[0], value = _b[1];
+    const res = [];
+    Object.entries(obj).forEach(([fieldName, value]) => {
         if (value === FIELD_IR) {
             res.push(fieldName);
         }
         else if (typeof value === 'object' && value !== null) {
-            if (value === null || value === void 0 ? void 0 : value.items) {
+            if (value?.items) {
                 res.push(fieldName, '{', 'items', '{', selectionSetIRToString(value.items), '}', '}');
             }
             else {
@@ -268,88 +282,87 @@ export function selectionSetIRToString(obj) {
     return res.join(' ');
 }
 export function generateSelectionSet(modelIntrospection, modelName, selectionSet) {
-    var modelDefinition = modelIntrospection[modelName];
+    const modelDefinition = modelIntrospection[modelName];
     if (!selectionSet) {
         return defaultSelectionSetForModel(modelDefinition).join(' ');
     }
-    var selSetIr = customSelectionSetToIR(modelIntrospection, modelName, selectionSet);
-    var selSetString = selectionSetIRToString(selSetIr);
+    const selSetIr = customSelectionSetToIR(modelIntrospection, modelName, selectionSet);
+    const selSetString = selectionSetIRToString(selSetIr);
     return selSetString;
 }
 export function generateGraphQLDocument(modelIntrospection, modelName, modelOperation, listArgs) {
-    var _a;
-    var _b, _c;
-    var modelDefinition = modelIntrospection[modelName];
-    var name = modelDefinition.name, pluralName = modelDefinition.pluralName, fields = modelDefinition.fields, _d = modelDefinition.primaryKeyInfo, isCustomPrimaryKey = _d.isCustomPrimaryKey, primaryKeyFieldName = _d.primaryKeyFieldName, sortKeyFieldNames = _d.sortKeyFieldNames;
-    var _e = graphQLOperationsInfo[modelOperation], operationPrefix = _e.operationPrefix, usePlural = _e.usePlural;
-    var selectionSet = (listArgs || {}).selectionSet;
-    var fromCache = (_b = graphQLDocumentsCache.get(name)) === null || _b === void 0 ? void 0 : _b.get(modelOperation);
+    const modelDefinition = modelIntrospection[modelName];
+    const { name, pluralName, fields, primaryKeyInfo: { isCustomPrimaryKey, primaryKeyFieldName, sortKeyFieldNames, }, } = modelDefinition;
+    const { operationPrefix, usePlural } = graphQLOperationsInfo[modelOperation];
+    const { selectionSet } = listArgs || {};
+    const fromCache = graphQLDocumentsCache.get(name)?.get(modelOperation);
     if (fromCache !== undefined) {
         return fromCache;
     }
     if (!graphQLDocumentsCache.has(name)) {
         graphQLDocumentsCache.set(name, new Map());
     }
-    var graphQLFieldName = "".concat(operationPrefix).concat(usePlural ? pluralName : name);
-    var graphQLOperationType;
-    var graphQLSelectionSet;
-    var graphQLArguments;
-    var selectionSetFields = generateSelectionSet(modelIntrospection, modelName, selectionSet);
+    const graphQLFieldName = `${operationPrefix}${usePlural ? pluralName : name}`;
+    let graphQLOperationType;
+    let graphQLSelectionSet;
+    let graphQLArguments;
+    const selectionSetFields = generateSelectionSet(modelIntrospection, modelName, selectionSet);
     switch (modelOperation) {
         case 'CREATE':
         case 'UPDATE':
         case 'DELETE':
-            graphQLArguments !== null && graphQLArguments !== void 0 ? graphQLArguments : (graphQLArguments = {
-                input: "".concat(operationPrefix.charAt(0).toLocaleUpperCase() +
-                    operationPrefix.slice(1)).concat(name, "Input!"),
-            });
-            graphQLOperationType !== null && graphQLOperationType !== void 0 ? graphQLOperationType : (graphQLOperationType = 'mutation');
+            graphQLArguments ??
+                (graphQLArguments = {
+                    input: `${operationPrefix.charAt(0).toLocaleUpperCase() +
+                        operationPrefix.slice(1)}${name}Input!`,
+                });
+            graphQLOperationType ?? (graphQLOperationType = 'mutation');
         case 'READ':
-            graphQLArguments !== null && graphQLArguments !== void 0 ? graphQLArguments : (graphQLArguments = isCustomPrimaryKey
-                ? __spreadArray([primaryKeyFieldName], __read(sortKeyFieldNames), false).reduce(function (acc, fieldName) {
-                    acc[fieldName] = fields[fieldName].type;
-                    return acc;
-                }, {})
-                : (_a = {},
-                    _a[primaryKeyFieldName] = "".concat(fields[primaryKeyFieldName].type, "!"),
-                    _a));
-            graphQLSelectionSet !== null && graphQLSelectionSet !== void 0 ? graphQLSelectionSet : (graphQLSelectionSet = selectionSetFields);
+            graphQLArguments ??
+                (graphQLArguments = isCustomPrimaryKey
+                    ? [primaryKeyFieldName, ...sortKeyFieldNames].reduce((acc, fieldName) => {
+                        acc[fieldName] = fields[fieldName].type;
+                        return acc;
+                    }, {})
+                    : {
+                        [primaryKeyFieldName]: `${fields[primaryKeyFieldName].type}!`,
+                    });
+            graphQLSelectionSet ?? (graphQLSelectionSet = selectionSetFields);
         case 'LIST':
-            graphQLArguments !== null && graphQLArguments !== void 0 ? graphQLArguments : (graphQLArguments = {
-                filter: "Model".concat(name, "FilterInput"),
-                limit: 'Int',
-                nextToken: 'String',
-            });
-            graphQLOperationType !== null && graphQLOperationType !== void 0 ? graphQLOperationType : (graphQLOperationType = 'query');
-            graphQLSelectionSet !== null && graphQLSelectionSet !== void 0 ? graphQLSelectionSet : (graphQLSelectionSet = "items { ".concat(selectionSetFields, " } nextToken __typename"));
+            graphQLArguments ??
+                (graphQLArguments = {
+                    filter: `Model${name}FilterInput`,
+                    limit: 'Int',
+                    nextToken: 'String',
+                });
+            graphQLOperationType ?? (graphQLOperationType = 'query');
+            graphQLSelectionSet ??
+                (graphQLSelectionSet = `items { ${selectionSetFields} } nextToken __typename`);
         case 'ONCREATE':
         case 'ONUPDATE':
         case 'ONDELETE':
-            graphQLArguments !== null && graphQLArguments !== void 0 ? graphQLArguments : (graphQLArguments = {
-                filter: "ModelSubscription".concat(name, "FilterInput"),
-            });
-            graphQLOperationType !== null && graphQLOperationType !== void 0 ? graphQLOperationType : (graphQLOperationType = 'subscription');
-            graphQLSelectionSet !== null && graphQLSelectionSet !== void 0 ? graphQLSelectionSet : (graphQLSelectionSet = selectionSetFields);
+            graphQLArguments ??
+                (graphQLArguments = {
+                    filter: `ModelSubscription${name}FilterInput`,
+                });
+            graphQLOperationType ?? (graphQLOperationType = 'subscription');
+            graphQLSelectionSet ?? (graphQLSelectionSet = selectionSetFields);
             break;
         case 'OBSERVE_QUERY':
         default:
             throw new Error('Internal error: Attempted to generate graphql document for observeQuery. Please report this error.');
     }
-    var graphQLDocument = "".concat(graphQLOperationType).concat(graphQLArguments
-        ? "(".concat(Object.entries(graphQLArguments).map(function (_a) {
-            var _b = __read(_a, 2), fieldName = _b[0], type = _b[1];
-            return "$".concat(fieldName, ": ").concat(type);
-        }), ")")
-        : '', " { ").concat(graphQLFieldName).concat(graphQLArguments
-        ? "(".concat(Object.keys(graphQLArguments).map(function (fieldName) { return "".concat(fieldName, ": $").concat(fieldName); }), ")")
-        : '', " { ").concat(graphQLSelectionSet, " } }");
-    (_c = graphQLDocumentsCache.get(name)) === null || _c === void 0 ? void 0 : _c.set(modelOperation, graphQLDocument);
+    const graphQLDocument = `${graphQLOperationType}${graphQLArguments
+        ? `(${Object.entries(graphQLArguments).map(([fieldName, type]) => `\$${fieldName}: ${type}`)})`
+        : ''} { ${graphQLFieldName}${graphQLArguments
+        ? `(${Object.keys(graphQLArguments).map(fieldName => `${fieldName}: \$${fieldName}`)})`
+        : ''} { ${graphQLSelectionSet} } }`;
+    graphQLDocumentsCache.get(name)?.set(modelOperation, graphQLDocument);
     return graphQLDocument;
 }
 export function buildGraphQLVariables(modelDefinition, operation, arg, modelIntrospection) {
-    var _a;
-    var fields = modelDefinition.fields, _b = modelDefinition.primaryKeyInfo, isCustomPrimaryKey = _b.isCustomPrimaryKey, primaryKeyFieldName = _b.primaryKeyFieldName, sortKeyFieldNames = _b.sortKeyFieldNames;
-    var variables = {};
+    const { fields, primaryKeyInfo: { isCustomPrimaryKey, primaryKeyFieldName, sortKeyFieldNames, }, } = modelDefinition;
+    let variables = {};
     // TODO: process input
     switch (operation) {
         case 'CREATE':
@@ -360,9 +373,8 @@ export function buildGraphQLVariables(modelDefinition, operation, arg, modelIntr
         case 'UPDATE':
             // readonly fields are not  updated
             variables = {
-                input: Object.fromEntries(Object.entries(normalizeMutationInput(arg, modelDefinition, modelIntrospection)).filter(function (_a) {
-                    var _b = __read(_a, 1), fieldName = _b[0];
-                    var isReadOnly = fields[fieldName].isReadOnly;
+                input: Object.fromEntries(Object.entries(normalizeMutationInput(arg, modelDefinition, modelIntrospection)).filter(([fieldName]) => {
+                    const { isReadOnly } = fields[fieldName];
                     return !isReadOnly;
                 })),
             };
@@ -371,27 +383,27 @@ export function buildGraphQLVariables(modelDefinition, operation, arg, modelIntr
         case 'DELETE':
             // only identifiers are sent
             variables = isCustomPrimaryKey
-                ? __spreadArray([primaryKeyFieldName], __read(sortKeyFieldNames), false).reduce(function (acc, fieldName) {
+                ? [primaryKeyFieldName, ...sortKeyFieldNames].reduce((acc, fieldName) => {
                     acc[fieldName] = arg[fieldName];
                     return acc;
                 }, {})
-                : (_a = {}, _a[primaryKeyFieldName] = arg[primaryKeyFieldName], _a);
+                : { [primaryKeyFieldName]: arg[primaryKeyFieldName] };
             if (operation === 'DELETE') {
                 variables = { input: variables };
             }
             break;
         case 'LIST':
-            if (arg === null || arg === void 0 ? void 0 : arg.filter) {
+            if (arg?.filter) {
                 variables.filter = arg.filter;
             }
-            if (arg === null || arg === void 0 ? void 0 : arg.nextToken) {
+            if (arg?.nextToken) {
                 variables.nextToken = arg.nextToken;
             }
             break;
         case 'ONCREATE':
         case 'ONUPDATE':
         case 'ONDELETE':
-            if (arg === null || arg === void 0 ? void 0 : arg.filter) {
+            if (arg?.filter) {
                 variables = { filter: arg.filter };
             }
             break;
@@ -399,8 +411,8 @@ export function buildGraphQLVariables(modelDefinition, operation, arg, modelIntr
             throw new Error('Internal error: Attempted to build variables for observeQuery. Please report this error.');
             break;
         default:
-            var exhaustiveCheck = operation;
-            throw new Error("Unhandled operation case: ".concat(exhaustiveCheck));
+            const exhaustiveCheck = operation;
+            throw new Error(`Unhandled operation case: ${exhaustiveCheck}`);
     }
     return variables;
 }
@@ -419,30 +431,28 @@ export function buildGraphQLVariables(modelDefinition, operation, arg, modelIntr
  *
  */
 export function normalizeMutationInput(mutationInput, model, modelDefinition) {
-    var fields = model.fields;
-    var normalized = {};
-    Object.entries(mutationInput).forEach(function (_a) {
-        var _b, _c, _d;
-        var _e = __read(_a, 2), inputFieldName = _e[0], inputValue = _e[1];
-        var relatedModelName = (_c = (_b = fields[inputFieldName]) === null || _b === void 0 ? void 0 : _b.type) === null || _c === void 0 ? void 0 : _c.model;
+    const { fields } = model;
+    const normalized = {};
+    Object.entries(mutationInput).forEach(([inputFieldName, inputValue]) => {
+        const relatedModelName = fields[inputFieldName]?.type?.model;
         if (relatedModelName) {
-            var association_1 = (_d = fields[inputFieldName]) === null || _d === void 0 ? void 0 : _d.association;
-            var relatedModelDef = modelDefinition.models[relatedModelName];
-            var relatedModelPkInfo_1 = relatedModelDef.primaryKeyInfo;
-            if (association_1.connectionType === connectionType.HAS_ONE) {
-                association_1.targetNames.forEach(function (targetName, idx) {
-                    var associatedFieldName = association_1.associatedWith[idx];
+            const association = fields[inputFieldName]?.association;
+            const relatedModelDef = modelDefinition.models[relatedModelName];
+            const relatedModelPkInfo = relatedModelDef.primaryKeyInfo;
+            if (association.connectionType === connectionType.HAS_ONE) {
+                association.targetNames.forEach((targetName, idx) => {
+                    const associatedFieldName = association.associatedWith[idx];
                     normalized[targetName] = inputValue[associatedFieldName];
                 });
             }
-            if (association_1.connectionType === connectionType.BELONGS_TO) {
-                association_1.targetNames.forEach(function (targetName, idx) {
+            if (association.connectionType === connectionType.BELONGS_TO) {
+                association.targetNames.forEach((targetName, idx) => {
                     if (idx === 0) {
-                        var associatedFieldName = relatedModelPkInfo_1.primaryKeyFieldName;
+                        const associatedFieldName = relatedModelPkInfo.primaryKeyFieldName;
                         normalized[targetName] = inputValue[associatedFieldName];
                     }
                     else {
-                        var associatedFieldName = relatedModelPkInfo_1.sortKeyFieldNames[idx - 1];
+                        const associatedFieldName = relatedModelPkInfo.sortKeyFieldNames[idx - 1];
                         normalized[targetName] = inputValue[associatedFieldName];
                     }
                 });
@@ -454,3 +464,18 @@ export function normalizeMutationInput(mutationInput, model, modelDefinition) {
     });
     return normalized;
 }
+/**
+ * Produces a parameter object that can contains auth mode/token overrides
+ * only if present in either `options` (first) or configured on the `client`
+ * as a fallback.
+ *
+ * @param client Configured client from `generateClient`
+ * @param options Args/Options obect from call site.
+ * @returns
+ */
+export function authModeParams(client, options = {}) {
+    return {
+        authMode: options.authMode || client[__authMode],
+        authToken: options.authToken || client[__authToken],
+    };
+}

package/lib-esm/internals/InternalGraphQLAPI.d.ts

@@ -37,7 +37,7 @@ export declare class InternalGraphQLAPIClass {
      * @param [additionalHeaders] - headers to merge in after any `graphql_headers` set in the config
      * @returns An Observable if the query is a subscription query, else a promise of the graphql result.
      */
-    graphql<T = any>(amplify: AmplifyClassV6, { query: paramQuery, variables, authMode, authToken }: GraphQLOptions, additionalHeaders?: {
+    graphql<T = any>(amplify: AmplifyClassV6 | ((fn: (amplify: any) => Promise<any>) => Promise<AmplifyClassV6>), { query: paramQuery, variables, authMode, authToken }: GraphQLOptions, additionalHeaders?: {
         [key: string]: string;
     }, customUserAgentDetails?: CustomUserAgentDetails): Observable<GraphQLResult<T>> | Promise<GraphQLResult<T>>;
     private _graphql;