@aws-amplify/api-graphql 4.0.1-console-preview.be08038.0 → 4.0.1-server-generate-client.1e317a1.0

package/lib-esm/internals/APIClient.js

@@ -0,0 +1,432 @@
+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 = {
+    HAS_ONE: 'HAS_ONE',
+    HAS_MANY: 'HAS_MANY',
+    BELONGS_TO: 'BELONGS_TO',
+};
+/**
+ *
+ * @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];
+        if (typeof value === 'object' && value !== null) {
+            if (value.items !== undefined) {
+                res[prop] = value.items.map(function (item) {
+                    return flattenItems(item);
+                });
+                return;
+            }
+            res[prop] = flattenItems(value);
+            return;
+        }
+        res[prop] = value;
+    });
+    return res;
+};
+// TODO: this should accept single result to support CRUD methods; create helper for array/list
+export 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 = __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) || [];
+            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(__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 = __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);
+    });
+}
+export var 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 },
+    ONCREATE: { operationPrefix: 'onCreate', usePlural: false },
+    ONUPDATE: { operationPrefix: 'onUpdate', usePlural: false },
+    ONDELETE: { operationPrefix: 'onDelete', usePlural: false },
+};
+var graphQLDocumentsCache = new Map();
+var 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
+        .filter(Boolean);
+    // fields used for owner auth rules that may or may not also
+    // be explicit on the model.
+    var ownerFields = resolveOwnerFields(modelDefinition);
+    return Array.from(new Set(explicitFields.concat(ownerFields)));
+}
+var FIELD_IR = '';
+/**
+ * Generates nested Custom Selection Set IR from path
+ *
+ * @param modelIntrospection
+ * @param modelName
+ * @param selectionSet - array of object paths
+ * @example
+ * ### Given
+ * `selectionSet = ['id', 'comments.post.id']`
+ * ### Returns
+ * ```ts
+ * {
+ *   id: '',
+ *   comments: {
+ *     items: { post: { id: '' } }
+ *   }
+ * }
+ * ```
+ */
+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);
+        if (nested) {
+            var relatedModel = (_b = (_a = modelFields[fieldName]) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.model;
+            if (!relatedModel) {
+                // TODO: may need to change this to support custom types
+                throw Error("".concat(fieldName, " is not a model field"));
+            }
+            var relatedModelDefinition = modelIntrospection[relatedModel];
+            var selectionSet_1 = 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('.'),
+                    ]);
+            if ((_c = modelFields[fieldName]) === null || _c === void 0 ? void 0 : _c.isArray) {
+                var existing = resultObj[fieldName] || {
+                    items: {},
+                };
+                var merged_1 = __assign(__assign({}, existing.items), selectionSet_1);
+                resultObj[fieldName] = { items: merged_1 };
+                return resultObj;
+            }
+            var existingItems = resultObj[fieldName] || {};
+            var merged = __assign(__assign({}, existingItems), selectionSet_1);
+            resultObj[fieldName] = merged;
+            return resultObj;
+        }
+        var exists = Boolean(modelFields[fieldName]);
+        if (!exists) {
+            throw Error("".concat(fieldName, " is not a field of model ").concat(modelName));
+        }
+        resultObj[fieldName] = FIELD_IR;
+        return resultObj;
+    }, {});
+}
+var defaultSelectionSetIR = function (relatedModelDefinition) {
+    var defaultSelectionSet = defaultSelectionSetForModel(relatedModelDefinition);
+    var reduced = defaultSelectionSet.reduce(function (acc, curVal) {
+        acc[curVal] = FIELD_IR;
+        return acc;
+    }, {});
+    return reduced;
+};
+/**
+ * Stringifies selection set IR
+ * * @example
+ * ### Given
+ * ```ts
+ * {
+ *   id: '',
+ *   comments: {
+ *     items: { post: { id: '' } }
+ *   }
+ * }
+ * ```
+ * ### Returns
+ * `'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];
+        if (value === FIELD_IR) {
+            res.push(fieldName);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            if (value === null || value === void 0 ? void 0 : value.items) {
+                res.push(fieldName, '{', 'items', '{', selectionSetIRToString(value.items), '}', '}');
+            }
+            else {
+                res.push(fieldName, '{', selectionSetIRToString(value), '}');
+            }
+        }
+    });
+    return res.join(' ');
+}
+export function generateSelectionSet(modelIntrospection, modelName, selectionSet) {
+    var modelDefinition = modelIntrospection[modelName];
+    if (!selectionSet) {
+        return defaultSelectionSetForModel(modelDefinition).join(' ');
+    }
+    var selSetIr = customSelectionSetToIR(modelIntrospection, modelName, selectionSet);
+    var 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);
+    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);
+    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
+                ? __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);
+        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, " }"));
+        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);
+    }
+    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);
+    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 = {};
+    // 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 = __read(_a, 1), fieldName = _b[0];
+                    var isReadOnly = fields[fieldName].isReadOnly;
+                    return !isReadOnly;
+                })),
+            };
+            break;
+        case 'READ':
+        case 'DELETE':
+            // only identifiers are sent
+            variables = isCustomPrimaryKey
+                ? __spreadArray([primaryKeyFieldName], __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':
+        case 'ONCREATE':
+        case 'ONUPDATE':
+        case 'ONDELETE':
+            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;
+}
+/**
+ * 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 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;
+        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;
+}

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

@@ -3,7 +3,7 @@ import { Observable } from 'rxjs';
 import { AmplifyClassV6 } from '@aws-amplify/core';
 import { CustomUserAgentDetails } from '@aws-amplify/core/internals/utils';
 import { GraphQLResult, GraphQLOperation, GraphQLOptions } from '../types';
-export declare const graphqlOperation: (query: any, variables?: {}, authToken?: string | undefined) => {
+export declare const graphqlOperation: (query: any, variables?: {}, authToken?: string) => {
     query: any;
     variables: {};
     authToken: string | undefined;
@@ -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;

package/lib-esm/internals/InternalGraphQLAPI.js

@@ -19,6 +19,12 @@ export var graphqlOperation = function (query, variables, authToken) {
         authToken: authToken,
     });
 };
+var isAmplifyInstance = function (amplify) {
+    if (typeof amplify !== 'function') {
+        return true;
+    }
+    return false;
+};
 /**
  * Export Cloud Logic APIs
  */
@@ -41,8 +47,8 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
         return 'InternalGraphQLAPI';
     };
     InternalGraphQLAPIClass.prototype._headerBasedAuth = function (amplify, authMode, additionalHeaders) {
-        if (additionalHeaders === void 0) { additionalHeaders = {}; }
         var _a;
+        if (additionalHeaders === void 0) { additionalHeaders = {}; }
         return __awaiter(this, void 0, void 0, function () {
             var config, _b, region, appSyncGraphqlEndpoint, apiKey, defaultAuthMode, authenticationType, headers, _c, session, token, e_1;
             return __generator(this, function (_d) {
@@ -127,6 +133,7 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
      * @returns An Observable if the query is a subscription query, else a promise of the graphql result.
      */
     InternalGraphQLAPIClass.prototype.graphql = function (amplify, _a, additionalHeaders, customUserAgentDetails) {
+        var _this = this;
         var paramQuery = _a.query, _b = _a.variables, variables = _b === void 0 ? {} : _b, authMode = _a.authMode, authToken = _a.authToken;
         var query = typeof paramQuery === 'string'
             ? parse(paramQuery)
@@ -141,14 +148,23 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
         switch (operationType) {
             case 'query':
             case 'mutation':
-                var abortController = new AbortController();
-                var responsePromise = this._graphql(amplify, { query: query, variables: variables, authMode: authMode }, headers, abortController, customUserAgentDetails);
-                this._api.updateRequestToBeCancellable(responsePromise, abortController);
+                var abortController_1 = new AbortController();
+                var responsePromise = void 0;
+                if (isAmplifyInstance(amplify)) {
+                    responsePromise = this._graphql(amplify, { query: query, variables: variables, authMode: authMode }, headers, abortController_1, customUserAgentDetails);
+                }
+                else {
+                    var wrapper = function (amplifyInstance) {
+                        return _this._graphql(amplifyInstance, { query: query, variables: variables, authMode: authMode }, headers, abortController_1, customUserAgentDetails);
+                    };
+                    responsePromise = amplify(wrapper);
+                }
+                this._api.updateRequestToBeCancellable(responsePromise, abortController_1);
                 return responsePromise;
             case 'subscription':
                 return this._graphqlSubscribe(amplify, { query: query, variables: variables, authMode: authMode }, headers, customUserAgentDetails);
             default:
-                throw new Error("invalid operation type: " + operationType);
+                throw new Error("invalid operation type: ".concat(operationType));
         }
     };
     InternalGraphQLAPIClass.prototype._graphql = function (amplify, _a, additionalHeaders, abortController, customUserAgentDetails) {

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

@@ -0,0 +1,12 @@
+import { V6Client } from '../types';
+import { ClientGenerationParams } from './types';
+/**
+ * @private
+ *
+ * Creates a client that can be used to make GraphQL requests, using a provided `AmplifyClassV6`
+ * compatible context object for config and auth fetching.
+ *
+ * @param params
+ * @returns
+ */
+export declare function generateClient<T extends Record<any, any> = never>(params: ClientGenerationParams): V6Client<T>;

package/lib-esm/internals/generateClient.js

@@ -0,0 +1,26 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { graphql, cancel, isCancelError } from './v6';
+import { generateModelsProperty } from './generateModelsProperty';
+import { __amplify } from '../types';
+/**
+ * @private
+ *
+ * Creates a client that can be used to make GraphQL requests, using a provided `AmplifyClassV6`
+ * compatible context object for config and auth fetching.
+ *
+ * @param params
+ * @returns
+ */
+export function generateClient(params) {
+    var _a;
+    var client = (_a = {},
+        _a[__amplify] = params.amplify,
+        _a.graphql = graphql,
+        _a.cancel = cancel,
+        _a.isCancelError = isCancelError,
+        _a.models = {},
+        _a);
+    client.models = generateModelsProperty(client, params);
+    return client;
+}

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

@@ -0,0 +1,4 @@
+import { ModelTypes } from '@aws-amplify/amplify-api-next-types-alpha';
+import { ClientGenerationParams } from './types';
+import { V6Client } from '../types';
+export declare function generateModelsProperty<T extends Record<any, any> = never>(client: V6Client, params: ClientGenerationParams): ModelTypes<T>;