@aws-amplify/api 5.4.5 → 5.4.6-api-v6-models.3f48fe3.0

package/lib/API.d.ts

@@ -1,8 +1,9 @@
 import { AWSAppSyncRealTimeProvider } from '@aws-amplify/pubsub';
-import { GraphQLOptions, GraphQLResult } from '@aws-amplify/api-graphql';
+import { GraphQLOptions, GraphQLResult, GraphQLQuery, GraphQLSubscription } from '@aws-amplify/api-graphql';
+import { graphql as v6graphql } from '@aws-amplify/api-graphql/internals';
 import Observable from 'zen-observable-ts';
-import { GraphQLQuery, GraphQLSubscription } from './types';
 import { InternalAPIClass } from './internals/InternalAPI';
+import type { ModelTypes } from '@aws-amplify/types-package-alpha';
 /**
  * @deprecated
  * Use RestApi or GraphQLAPI to reduce your application bundle size
@@ -23,5 +24,20 @@ export declare class APIClass extends InternalAPIClass {
         provider: AWSAppSyncRealTimeProvider;
         value: GraphQLResult<T>;
     }> : Promise<GraphQLResult<any>> | Observable<object>;
+    /**
+     * Generates an API client that can work with models or raw GraphQL
+     */
+    generateClient<T extends Record<any, any> = never>(): V6Client<T>;
 }
+type FilteredKeys<T> = {
+    [P in keyof T]: T[P] extends never ? never : P;
+}[keyof T];
+type ExcludeNeverFields<O> = {
+    [K in FilteredKeys<O>]: O[K];
+};
+declare type V6Client<T extends Record<any, any> = never> = ExcludeNeverFields<{
+    graphql: typeof v6graphql;
+    models: ModelTypes<T>;
+}>;
 export declare const API: APIClass;
+export {};

package/lib/API.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.API = exports.APIClass = void 0;
 var tslib_1 = require("tslib");
+var internals_1 = require("@aws-amplify/api-graphql/internals");
 var core_1 = require("@aws-amplify/core");
 var InternalAPI_1 = require("./internals/InternalAPI");
+var APIClient_1 = require("./APIClient");
 var logger = new core_1.ConsoleLogger('API');
 /**
  * @deprecated
@@ -20,9 +23,108 @@ var APIClass = /** @class */ (function (_super) {
     APIClass.prototype.graphql = function (options, additionalHeaders) {
         return _super.prototype.graphql.call(this, options, additionalHeaders);
     };
+    /**
+     * Generates an API client that can work with models or raw GraphQL
+     */
+    APIClass.prototype.generateClient = function () {
+        var e_1, _a;
+        var _this = this;
+        var config = _super.prototype.configure.call(this, {});
+        var modelIntrospection = config.modelIntrospection;
+        var client = {
+            graphql: internals_1.graphql,
+            models: {},
+        };
+        var _loop_1 = function (model) {
+            var name_1 = model.name;
+            client.models[name_1] = {};
+            Object.entries(APIClient_1.graphQLOperationsInfo).forEach(function (_a) {
+                var _b = tslib_1.__read(_a, 2), key = _b[0], operationPrefix = _b[1].operationPrefix;
+                var operation = key;
+                if (operation === 'LIST') {
+                    client.models[name_1][operationPrefix] = function (args) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var query, variables, res, _a, key_1, flattenedResult, initialized;
+                        return tslib_1.__generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    query = (0, APIClient_1.generateGraphQLDocument)(modelIntrospection.models, name_1, 'LIST', args);
+                                    variables = (0, APIClient_1.buildGraphQLVariables)(model, 'LIST', args, modelIntrospection);
+                                    console.log('API list', query, variables);
+                                    return [4 /*yield*/, this.graphql({
+                                            query: query,
+                                            variables: variables,
+                                        })];
+                                case 1:
+                                    res = (_b.sent());
+                                    // flatten response
+                                    if (res.data !== undefined) {
+                                        _a = tslib_1.__read(Object.keys(res.data), 1), key_1 = _a[0];
+                                        if (res.data[key_1].items) {
+                                            flattenedResult = res.data[key_1].items;
+                                            // don't init if custom selection set
+                                            if (args === null || args === void 0 ? void 0 : args.selectionSet) {
+                                                return [2 /*return*/, flattenedResult];
+                                            }
+                                            else {
+                                                initialized = (0, APIClient_1.initializeModel)(client, name_1, flattenedResult, modelIntrospection);
+                                                console.log('initialized', initialized);
+                                                return [2 /*return*/, initialized];
+                                            }
+                                        }
+                                        return [2 /*return*/, res.data[key_1]];
+                                    }
+                                    return [2 /*return*/, res];
+                            }
+                        });
+                    }); };
+                }
+                else {
+                    client.models[name_1][operationPrefix] = function (arg, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var query, variables, res, _a, key_2, _b, initialized;
+                        return tslib_1.__generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    query = (0, APIClient_1.generateGraphQLDocument)(modelIntrospection.models, name_1, operation);
+                                    variables = (0, APIClient_1.buildGraphQLVariables)(model, operation, arg, modelIntrospection);
+                                    console.log("API ".concat(operationPrefix), query, variables);
+                                    return [4 /*yield*/, this.graphql({
+                                            query: query,
+                                            variables: variables,
+                                        })];
+                                case 1:
+                                    res = (_c.sent());
+                                    // flatten response
+                                    if (res.data !== undefined) {
+                                        _a = tslib_1.__read(Object.keys(res.data), 1), key_2 = _a[0];
+                                        _b = tslib_1.__read((0, APIClient_1.initializeModel)(client, name_1, [res.data[key_2]], modelIntrospection), 1), initialized = _b[0];
+                                        return [2 /*return*/, initialized];
+                                    }
+                                    return [2 /*return*/, res];
+                            }
+                        });
+                    }); };
+                }
+            });
+        };
+        try {
+            // TODO: refactor this to use separate methods for each CRUDL.
+            // Doesn't make sense to gen the methods dynamically given the different args and return values
+            for (var _b = tslib_1.__values(Object.values(modelIntrospection.models)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var model = _c.value;
+                _loop_1(model);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return client;
+    };
     return APIClass;
 }(InternalAPI_1.InternalAPIClass));
 exports.APIClass = APIClass;
 exports.API = new APIClass(null);
 core_1.Amplify.register(exports.API);
-//# sourceMappingURL=API.js.map

package/lib/APIClient.d.ts

@@ -0,0 +1,46 @@
+type ListArgs = {
+    selectionSet?: string[];
+    filter?: {};
+};
+export declare function initializeModel(client: any, modelName: string, result: any[], modelIntrospection: any): any[];
+export declare const graphQLOperationsInfo: {
+    CREATE: {
+        operationPrefix: "create";
+        usePlural: boolean;
+    };
+    READ: {
+        operationPrefix: "get";
+        usePlural: boolean;
+    };
+    UPDATE: {
+        operationPrefix: "update";
+        usePlural: boolean;
+    };
+    DELETE: {
+        operationPrefix: "delete";
+        usePlural: boolean;
+    };
+    LIST: {
+        operationPrefix: "list";
+        usePlural: boolean;
+    };
+};
+export type ModelOperation = keyof typeof graphQLOperationsInfo;
+export declare function generateGraphQLDocument(modelIntrospection: any, modelName: string, modelOperation: ModelOperation, listArgs?: ListArgs): string;
+export declare function buildGraphQLVariables(modelDefinition: any, operation: ModelOperation, arg: any, modelIntrospection: any): object;
+/**
+ * Iterates over mutation input values and resolves any model inputs to their corresponding join fields/values
+ *
+ * @example
+ * ### Usage
+ * ```ts
+ * const result = normalizeMutationInput({ post: post }, model, modelDefinition);
+ * ```
+ * ### Result
+ * ```ts
+ * { postId: "abc123" }
+ * ```
+ *
+ */
+export declare function normalizeMutationInput(mutationInput: any, model: any, modelDefinition: any): Record<string, unknown>;
+export {};

package/lib/APIClient.js

@@ -0,0 +1,336 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMutationInput = exports.buildGraphQLVariables = exports.generateGraphQLDocument = exports.graphQLOperationsInfo = exports.initializeModel = void 0;
+var tslib_1 = require("tslib");
+var connectionType = {
+    HAS_ONE: 'HAS_ONE',
+    HAS_MANY: 'HAS_MANY',
+    BELONGS_TO: 'BELONGS_TO',
+};
+// TODO: this should accept single result to support CRUD methods; create helper for array/list
+function initializeModel(client, modelName, result, modelIntrospection) {
+    var introModel = modelIntrospection.models[modelName];
+    var introModelFields = introModel.fields;
+    var modelFields = Object.entries(introModelFields)
+        .filter(function (_a) {
+        var _b;
+        var _c = tslib_1.__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 = tslib_1.__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) || [];
+            switch (relationType) {
+                case connectionType.HAS_ONE:
+                case connectionType.BELONGS_TO:
+                    var sortKeyValues_1 = relatedModelSKFieldNames.reduce(function (acc, curVal) {
+                        if (record[curVal]) {
+                            return (acc[curVal] = record[curVal]);
+                        }
+                    }, {});
+                    initializedRelationalFields[field] = function () {
+                        var _a;
+                        if (record[targetNames[0]]) {
+                            return client.models[relatedModelName].get(tslib_1.__assign((_a = {}, _a[relatedModelPKFieldName] = record[targetNames[0]], _a), sortKeyValues_1));
+                        }
+                        return undefined;
+                    };
+                    break;
+                case connectionType.HAS_MANY:
+                    var parentPk_1 = introModel.primaryKeyInfo.primaryKeyFieldName;
+                    var parentSK_1 = 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 (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 () {
+                            if (record[parentPk_1]) {
+                                return client.models[relatedModelName].list({
+                                    filter: { and: hasManyFilter_1 },
+                                });
+                            }
+                            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 () {
+                        if (record[parentPk_1]) {
+                            return client.models[relatedModelName].list({
+                                filter: { and: hasManyFilter_2 },
+                            });
+                        }
+                        return [];
+                    };
+                    break;
+                default:
+                    break;
+            }
+        };
+        try {
+            for (var modelFields_1 = tslib_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 tslib_1.__assign(tslib_1.__assign({}, record), initializedRelationalFields);
+    });
+}
+exports.initializeModel = initializeModel;
+exports.graphQLOperationsInfo = {
+    CREATE: { operationPrefix: 'create', usePlural: false },
+    READ: { operationPrefix: 'get', usePlural: false },
+    UPDATE: { operationPrefix: 'update', usePlural: false },
+    DELETE: { operationPrefix: 'delete', usePlural: false },
+    LIST: { operationPrefix: 'list', usePlural: true },
+};
+var graphQLDocumentsCache = new Map();
+var SELECTION_SET_ALL_NESTED = '*';
+function defaultSelectionSetForModel(modelDefinition) {
+    var fields = modelDefinition.fields;
+    return Object.values(fields)
+        .map(function (_a) {
+        var type = _a.type, name = _a.name;
+        return typeof type === 'string' && name;
+    }) // Default selection set omits model fields
+        .filter(Boolean)
+        .join(' ');
+}
+function generateSelectionSet(modelIntrospection, modelName, selectionSet) {
+    var e_2, _a;
+    var _b, _c, _d;
+    var modelDefinition = modelIntrospection[modelName];
+    var fields = modelDefinition.fields;
+    if (!selectionSet) {
+        return defaultSelectionSetForModel(modelDefinition);
+    }
+    var selSet = [];
+    try {
+        for (var selectionSet_1 = tslib_1.__values(selectionSet), selectionSet_1_1 = selectionSet_1.next(); !selectionSet_1_1.done; selectionSet_1_1 = selectionSet_1.next()) {
+            var f = selectionSet_1_1.value;
+            var nested = f.includes('.');
+            if (nested) {
+                var _e = tslib_1.__read(f.split('.'), 2), modelFieldName = _e[0], selectedField = _e[1];
+                var relatedModel = (_c = (_b = fields[modelFieldName]) === null || _b === void 0 ? void 0 : _b.type) === null || _c === void 0 ? void 0 : _c.model;
+                if (!relatedModel) {
+                    // TODO: may need to change this to support custom types
+                    throw Error("".concat(modelFieldName, " is not a model field"));
+                }
+                if (selectedField === SELECTION_SET_ALL_NESTED) {
+                    var relatedModelDefinition = modelIntrospection[relatedModel];
+                    var defaultSelectionSet = defaultSelectionSetForModel(relatedModelDefinition);
+                    if ((_d = fields[modelFieldName]) === null || _d === void 0 ? void 0 : _d.isArray) {
+                        selSet.push("".concat(modelFieldName, " { items { ").concat(defaultSelectionSet, " } }"));
+                    }
+                    else {
+                        selSet.push("".concat(modelFieldName, " { ").concat(defaultSelectionSet, " }"));
+                    }
+                }
+            }
+            else {
+                var exists = Boolean(fields[f]);
+                if (!exists) {
+                    throw Error("".concat(f, " is not a field of model ").concat(modelName));
+                }
+                selSet.push(f);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (selectionSet_1_1 && !selectionSet_1_1.done && (_a = selectionSet_1.return)) _a.call(selectionSet_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return selSet.join(' ');
+}
+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 = exports.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);
+    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);
+    console.log('generated sel set', selectionSetFields);
+    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');
+        case 'READ':
+            graphQLArguments !== null && graphQLArguments !== void 0 ? graphQLArguments : (graphQLArguments = isCustomPrimaryKey
+                ? tslib_1.__spreadArray([primaryKeyFieldName], tslib_1.__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);
+        case 'LIST':
+            graphQLArguments !== null && graphQLArguments !== void 0 ? graphQLArguments : (graphQLArguments = {
+                filter: "Model".concat(name, "FilterInput"),
+            });
+            graphQLOperationType !== null && graphQLOperationType !== void 0 ? graphQLOperationType : (graphQLOperationType = 'query');
+            graphQLSelectionSet !== null && graphQLSelectionSet !== void 0 ? graphQLSelectionSet : (graphQLSelectionSet = "items { ".concat(selectionSetFields, " }"));
+    }
+    var graphQLDocument = "".concat(graphQLOperationType).concat(graphQLArguments
+        ? "(".concat(Object.entries(graphQLArguments).map(function (_a) {
+            var _b = tslib_1.__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);
+    return graphQLDocument;
+}
+exports.generateGraphQLDocument = generateGraphQLDocument;
+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 = {};
+    // TODO: process input
+    switch (operation) {
+        case 'CREATE':
+            variables = {
+                input: normalizeMutationInput(arg, modelDefinition, modelIntrospection),
+            };
+            break;
+        case 'UPDATE':
+            // readonly fields are not  updated
+            variables = {
+                input: Object.fromEntries(Object.entries(normalizeMutationInput(arg, modelDefinition, modelIntrospection)).filter(function (_a) {
+                    var _b = tslib_1.__read(_a, 1), fieldName = _b[0];
+                    var isReadOnly = fields[fieldName].isReadOnly;
+                    return !isReadOnly;
+                })),
+            };
+            break;
+        case 'READ':
+        case 'DELETE':
+            // only identifiers are sent
+            variables = isCustomPrimaryKey
+                ? tslib_1.__spreadArray([primaryKeyFieldName], tslib_1.__read(sortKeyFieldNames), false).reduce(function (acc, fieldName) {
+                    acc[fieldName] = arg[fieldName];
+                    return acc;
+                }, {})
+                : (_a = {}, _a[primaryKeyFieldName] = arg[primaryKeyFieldName], _a);
+            if (operation === 'DELETE') {
+                variables = { input: variables };
+            }
+            break;
+        case 'LIST':
+            if (arg === null || arg === void 0 ? void 0 : arg.filter) {
+                variables = { filter: arg.filter };
+            }
+            break;
+        default:
+            var exhaustiveCheck = operation;
+            throw new Error("Unhandled operation case: ".concat(exhaustiveCheck));
+    }
+    return variables;
+}
+exports.buildGraphQLVariables = buildGraphQLVariables;
+/**
+ * Iterates over mutation input values and resolves any model inputs to their corresponding join fields/values
+ *
+ * @example
+ * ### Usage
+ * ```ts
+ * const result = normalizeMutationInput({ post: post }, model, modelDefinition);
+ * ```
+ * ### Result
+ * ```ts
+ * { postId: "abc123" }
+ * ```
+ *
+ */
+function normalizeMutationInput(mutationInput, model, modelDefinition) {
+    var fields = model.fields;
+    var normalized = {};
+    Object.entries(mutationInput).forEach(function (_a) {
+        var _b, _c, _d;
+        var _e = tslib_1.__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;
+        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];
+                    normalized[targetName] = inputValue[associatedFieldName];
+                });
+            }
+            if (association_1.connectionType === connectionType.BELONGS_TO) {
+                association_1.targetNames.forEach(function (targetName, idx) {
+                    if (idx === 0) {
+                        var associatedFieldName = relatedModelPkInfo_1.primaryKeyFieldName;
+                        normalized[targetName] = inputValue[associatedFieldName];
+                    }
+                    else {
+                        var associatedFieldName = relatedModelPkInfo_1.sortKeyFieldNames[idx - 1];
+                        normalized[targetName] = inputValue[associatedFieldName];
+                    }
+                });
+            }
+        }
+        else {
+            normalized[inputFieldName] = inputValue;
+        }
+    });
+    return normalized;
+}
+exports.normalizeMutationInput = normalizeMutationInput;

package/lib/index.js

@@ -2,11 +2,11 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPHQL_AUTH_MODE = exports.GraphQLAuthError = exports.graphqlOperation = exports.APIClass = exports.API = void 0;
 var API_1 = require("./API");
-exports.API = API_1.API;
-exports.APIClass = API_1.APIClass;
+Object.defineProperty(exports, "API", { enumerable: true, get: function () { return API_1.API; } });
+Object.defineProperty(exports, "APIClass", { enumerable: true, get: function () { return API_1.APIClass; } });
 var api_graphql_1 = require("@aws-amplify/api-graphql");
-exports.graphqlOperation = api_graphql_1.graphqlOperation;
-exports.GraphQLAuthError = api_graphql_1.GraphQLAuthError;
-exports.GRAPHQL_AUTH_MODE = api_graphql_1.GRAPHQL_AUTH_MODE;
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "graphqlOperation", { enumerable: true, get: function () { return api_graphql_1.graphqlOperation; } });
+Object.defineProperty(exports, "GraphQLAuthError", { enumerable: true, get: function () { return api_graphql_1.GraphQLAuthError; } });
+Object.defineProperty(exports, "GRAPHQL_AUTH_MODE", { enumerable: true, get: function () { return api_graphql_1.GRAPHQL_AUTH_MODE; } });

package/lib/internals/InternalAPI.d.ts

@@ -1,8 +1,7 @@
-import { GraphQLOperation, GraphQLOptions, GraphQLResult, OperationTypeNode } from '@aws-amplify/api-graphql';
+import { GraphQLOperation, GraphQLOptions, GraphQLResult, OperationTypeNode, GraphQLQuery, GraphQLSubscription } from '@aws-amplify/api-graphql';
 import { CustomUserAgentDetails } from '@aws-amplify/core';
 import { AWSAppSyncRealTimeProvider } from '@aws-amplify/pubsub';
 import Observable from 'zen-observable-ts';
-import { GraphQLQuery, GraphQLSubscription } from '../types';
 /**
  * @deprecated
  * Use RestApi or GraphQLAPI to reduce your application bundle size

package/lib/internals/InternalAPI.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalAPI = exports.InternalAPIClass = void 0;
 var tslib_1 = require("tslib");
 var internals_1 = require("@aws-amplify/api-graphql/internals");
 var api_rest_1 = require("@aws-amplify/api-rest");
@@ -164,4 +165,3 @@ var InternalAPIClass = /** @class */ (function () {
 exports.InternalAPIClass = InternalAPIClass;
 exports.InternalAPI = new InternalAPIClass(null);
 core_1.Amplify.register(exports.InternalAPI);
-//# sourceMappingURL=InternalAPI.js.map

package/lib/internals/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalAPIClass = exports.InternalAPI = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 var InternalAPI_1 = require("./InternalAPI");
-exports.InternalAPI = InternalAPI_1.InternalAPI;
-exports.InternalAPIClass = InternalAPI_1.InternalAPIClass;
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "InternalAPI", { enumerable: true, get: function () { return InternalAPI_1.InternalAPI; } });
+Object.defineProperty(exports, "InternalAPIClass", { enumerable: true, get: function () { return InternalAPI_1.InternalAPIClass; } });