@aws-amplify/datastore-storage-adapter 2.1.32 → 2.1.33-s-auth.30d0cd2.0

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/cjs/ExpoSQLiteAdapter/ExpoSQLiteDatabase.js

@@ -74,14 +74,16 @@ class ExpoSQLiteDatabase {
         });
     }
     batchQuery(queryParameterizedStatements = new Set()) {
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
-                    const results = await Promise.all([...queryParameterizedStatements].map(([statement, params]) => new Promise((resolve, reject) => {
+                    const results = await Promise.all([...queryParameterizedStatements].map(([statement, params]) => new Promise((_resolve, _reject) => {
                         transaction.executeSql(statement, params, (_, result) => {
-                            resolve(result.rows._array[0]);
+                            _resolve(result.rows._array[0]);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
@@ -96,27 +98,31 @@ class ExpoSQLiteDatabase {
         });
     }
     batchSave(saveParameterizedStatements = new Set(), deleteParameterizedStatements) {
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
                     // await for all sql statements promises to resolve
-                    await Promise.all([...saveParameterizedStatements].map(([statement, params]) => new Promise((resolve, reject) => {
+                    await Promise.all([...saveParameterizedStatements].map(([statement, params]) => new Promise((_resolve, _reject) => {
                         transaction.executeSql(statement, params, () => {
-                            resolve(null);
+                            _resolve(null);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
                     })));
                     if (deleteParameterizedStatements) {
-                        await Promise.all([...deleteParameterizedStatements].map(([statement, params]) => new Promise((resolve, reject) => transaction.executeSql(statement, params, () => {
-                            resolve(null);
-                        }, (_, error) => {
-                            reject(error);
-                            logger.warn(error);
-                            return true;
-                        }))));
+                        await Promise.all([...deleteParameterizedStatements].map(([statement, params]) => new Promise((_resolve, _reject) => {
+                            transaction.executeSql(statement, params, () => {
+                                _resolve(null);
+                            }, (_, error) => {
+                                _reject(error);
+                                logger.warn(error);
+                                return true;
+                            });
+                        })));
                     }
                     resolveTransaction(null);
                 }
@@ -130,23 +136,25 @@ class ExpoSQLiteDatabase {
     selectAndDelete(queryParameterizedStatement, deleteParameterizedStatement) {
         const [queryStatement, queryParams] = queryParameterizedStatement;
         const [deleteStatement, deleteParams] = deleteParameterizedStatement;
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
-                    const result = await new Promise((resolve, reject) => {
-                        transaction.executeSql(queryStatement, queryParams, (_, result) => {
-                            resolve(result.rows._array || []);
+                    const result = await new Promise((_resolve, _reject) => {
+                        transaction.executeSql(queryStatement, queryParams, (_, sqlResult) => {
+                            _resolve(sqlResult.rows._array || []);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
                     });
-                    await new Promise((resolve, reject) => {
+                    await new Promise((_resolve, _reject) => {
                         transaction.executeSql(deleteStatement, deleteParams, () => {
-                            resolve(null);
+                            _resolve(null);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
@@ -161,14 +169,16 @@ class ExpoSQLiteDatabase {
         });
     }
     executeStatements(statements) {
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
-                    await Promise.all(statements.map(statement => new Promise((resolve, reject) => {
+                    await Promise.all(statements.map(statement => new Promise((_resolve, _reject) => {
                         transaction.executeSql(statement, [], () => {
-                            resolve(null);
+                            _resolve(null);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             return true;
                         });
                     })));

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/cjs/SQLiteAdapter/SQLiteDatabase.js

@@ -34,7 +34,7 @@ class SQLiteDatabase {
         }
     }
     async createSchema(statements) {
-        return await this.executeStatements(statements);
+        await this.executeStatements(statements);
     }
     async clear() {
         await this.closeDB();
@@ -91,7 +91,9 @@ class SQLiteDatabase {
             tx.executeSql(queryStatement, queryParams, (_, res) => {
                 results = res.rows.raw();
             }, logger.warn);
-            tx.executeSql(deleteStatement, deleteParams, () => { }, logger.warn);
+            tx.executeSql(deleteStatement, deleteParams, () => {
+                // no-op
+            }, logger.warn);
         });
         return results;
     }

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/cjs/common/CommonSQLiteAdapter.js

@@ -4,8 +4,8 @@ exports.CommonSQLiteAdapter = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 const core_1 = require("@aws-amplify/core");
-const SQLiteUtils_1 = require("../common/SQLiteUtils");
 const datastore_1 = require("@aws-amplify/datastore");
+const SQLiteUtils_1 = require("../common/SQLiteUtils");
 const { traverseModel, validatePredicate, isModelConstructor } = datastore_1.utils;
 const logger = new core_1.ConsoleLogger('DataStore');
 class CommonSQLiteAdapter {
@@ -14,9 +14,9 @@ class CommonSQLiteAdapter {
     }
     async setUp(theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
         if (!this.initPromise) {
-            this.initPromise = new Promise((res, rej) => {
-                this.resolve = res;
-                this.reject = rej;
+            this.initPromise = new Promise((_resolve, _reject) => {
+                this.resolve = _resolve;
+                this.reject = _reject;
             });
         }
         else {
@@ -28,7 +28,9 @@ class CommonSQLiteAdapter {
         this.modelInstanceCreator = modelInstanceCreator;
         this.getModelConstructorByModelName = getModelConstructorByModelName;
         try {
-            const usesCPKCodegen = Object.values(this.schema.namespaces.user.models).some(model => Object.values(model.fields).some(field => field.association?.hasOwnProperty('targetNames')));
+            const usesCPKCodegen = Object.values(this.schema.namespaces.user.models).some(model => Object.values(model.fields).some(field => 
+            // eslint-disable-next-line no-prototype-builtins
+            field.association?.hasOwnProperty('targetNames')));
             if (usesCPKCodegen) {
                 logger.error('The SQLite adapter does not support schemas using custom primary key. Set `graphQLTransformer.respectPrimaryKeyAttributesOnConnectionField in `amplify/cli.json` to false to disable custom primary key. To regenerate your API, add or remove an empty newline to your GraphQL schema (to change the computed hash) then run `amplify push`.');
             }
@@ -70,10 +72,10 @@ class CommonSQLiteAdapter {
         for await (const resItem of connectionStoreNames) {
             const { modelName, item, instance } = resItem;
             const { id } = item;
-            const [queryStatement, params] = (0, SQLiteUtils_1.queryByIdStatement)(id, modelName);
-            const fromDB = await this.db.get(queryStatement, params);
-            const opType = fromDB === undefined ? datastore_1.OpType.INSERT : datastore_1.OpType.UPDATE;
-            const saveStatement = fromDB
+            const [queryStatementForRestItem, paramsForRestItem] = (0, SQLiteUtils_1.queryByIdStatement)(id, modelName);
+            const fromDBForRestItem = await this.db.get(queryStatementForRestItem, paramsForRestItem);
+            const opType = fromDBForRestItem === undefined ? datastore_1.OpType.INSERT : datastore_1.OpType.UPDATE;
+            const saveStatement = fromDBForRestItem
                 ? (0, SQLiteUtils_1.modelUpdateStatement)(instance, modelName)
                 : (0, SQLiteUtils_1.modelInsertStatement)(instance, modelName);
             if (id === model.id || opType === datastore_1.OpType.INSERT) {
@@ -114,15 +116,15 @@ class CommonSQLiteAdapter {
         const limit = pagination && pagination.limit;
         const page = limit && pagination.page;
         const queryById = predicates && this.idFromPredicate(predicates);
-        const records = await (async () => {
+        const records = (await (async () => {
             if (queryById) {
                 const record = await this.getById(tableName, queryById);
                 return record ? [record] : [];
             }
             const [queryStatement, params] = (0, SQLiteUtils_1.queryAllStatement)(tableName, predicates, sortPredicates, limit, page);
-            return await this.db.getAll(queryStatement, params);
-        })();
-        return await this.load(namespaceName, modelConstructor.name, records);
+            return this.db.getAll(queryStatement, params);
+        })());
+        return this.load(namespaceName, modelConstructor.name, records);
     }
     async getById(tableName, id) {
         const [queryStatement, params] = (0, SQLiteUtils_1.queryByIdStatement)(id, tableName);
@@ -203,7 +205,7 @@ class CommonSQLiteAdapter {
         for (const item of items) {
             const connectedModels = traverseModel(modelConstructor.name, this.modelInstanceCreator(modelConstructor, item), this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
             const { id, _deleted } = item;
-            const { instance } = connectedModels.find(({ instance }) => instance.id === id);
+            const { instance } = connectedModels.find(({ instance: connectedModelInstance }) => connectedModelInstance.id === id);
             if (_deleted) {
                 // create the delete statements right away
                 const deleteStatement = (0, SQLiteUtils_1.deleteByIdStatement)(instance.id, tableName);

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/cjs/common/SQLiteUtils.js

@@ -58,9 +58,10 @@ function getSQLiteType(scalar) {
             return 'TEXT';
         case 'Float':
             return 'REAL';
-        default:
+        default: {
             const _ = scalar;
             throw new Error(`unknown type ${scalar}`);
+        }
     }
 }
 exports.getSQLiteType = getSQLiteType;
@@ -231,10 +232,11 @@ const whereConditionFromPredicateObject = ({ field, operator, operand, }) => {
             case 'notContains':
                 statement = [`instr("${field}", ?) ${logicalOperator}`, [operand]];
                 break;
-            default:
+            default: {
                 const _ = logicalOperatorKey;
                 // Incorrect WHERE clause can result in data loss
                 throw new Error('Cannot map predicate to a valid WHERE clause');
+            }
         }
         return statement;
     }
@@ -246,9 +248,9 @@ function whereClauseFromPredicate(predicate) {
     recurse(predicate, result, params);
     const whereClause = `WHERE ${result.join(' ')}`;
     return [whereClause, params];
-    function recurse(predicate, result = [], params = []) {
-        if ((0, datastore_1.isPredicateGroup)(predicate)) {
-            const { type: groupType, predicates: groupPredicates } = predicate;
+    function recurse(recursedPredicate, recursedResult = [], recursedParams = []) {
+        if ((0, datastore_1.isPredicateGroup)(recursedPredicate)) {
+            const { type: groupType, predicates: groupPredicates } = recursedPredicate;
             let filterType = '';
             let isNegation = false;
             switch (groupType) {
@@ -261,20 +263,21 @@ function whereClauseFromPredicate(predicate) {
                 case 'or':
                     filterType = 'OR';
                     break;
-                default:
+                default: {
                     const _ = groupType;
                     throw new Error(`Invalid ${groupType}`);
+                }
             }
             const groupResult = [];
             for (const p of groupPredicates) {
-                recurse(p, groupResult, params);
+                recurse(p, groupResult, recursedParams);
             }
-            result.push(`${isNegation ? 'NOT' : ''}(${groupResult.join(` ${filterType} `)})`);
+            recursedResult.push(`${isNegation ? 'NOT' : ''}(${groupResult.join(` ${filterType} `)})`);
         }
-        else if ((0, datastore_1.isPredicateObj)(predicate)) {
-            const [condition, conditionParams] = (0, exports.whereConditionFromPredicateObject)(predicate);
-            result.push(condition);
-            params.push(...conditionParams);
+        else if ((0, datastore_1.isPredicateObj)(recursedPredicate)) {
+            const [condition, conditionParams] = (0, exports.whereConditionFromPredicateObject)(recursedPredicate);
+            recursedResult.push(condition);
+            recursedParams.push(...conditionParams);
         }
     }
 }

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/ExpoSQLiteAdapter/ExpoSQLiteDatabase.js

@@ -72,14 +72,16 @@ class ExpoSQLiteDatabase {
         });
     }
     batchQuery(queryParameterizedStatements = new Set()) {
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
-                    const results = await Promise.all([...queryParameterizedStatements].map(([statement, params]) => new Promise((resolve, reject) => {
+                    const results = await Promise.all([...queryParameterizedStatements].map(([statement, params]) => new Promise((_resolve, _reject) => {
                         transaction.executeSql(statement, params, (_, result) => {
-                            resolve(result.rows._array[0]);
+                            _resolve(result.rows._array[0]);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
@@ -94,27 +96,31 @@ class ExpoSQLiteDatabase {
         });
     }
     batchSave(saveParameterizedStatements = new Set(), deleteParameterizedStatements) {
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
                     // await for all sql statements promises to resolve
-                    await Promise.all([...saveParameterizedStatements].map(([statement, params]) => new Promise((resolve, reject) => {
+                    await Promise.all([...saveParameterizedStatements].map(([statement, params]) => new Promise((_resolve, _reject) => {
                         transaction.executeSql(statement, params, () => {
-                            resolve(null);
+                            _resolve(null);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
                     })));
                     if (deleteParameterizedStatements) {
-                        await Promise.all([...deleteParameterizedStatements].map(([statement, params]) => new Promise((resolve, reject) => transaction.executeSql(statement, params, () => {
-                            resolve(null);
-                        }, (_, error) => {
-                            reject(error);
-                            logger.warn(error);
-                            return true;
-                        }))));
+                        await Promise.all([...deleteParameterizedStatements].map(([statement, params]) => new Promise((_resolve, _reject) => {
+                            transaction.executeSql(statement, params, () => {
+                                _resolve(null);
+                            }, (_, error) => {
+                                _reject(error);
+                                logger.warn(error);
+                                return true;
+                            });
+                        })));
                     }
                     resolveTransaction(null);
                 }
@@ -128,23 +134,25 @@ class ExpoSQLiteDatabase {
     selectAndDelete(queryParameterizedStatement, deleteParameterizedStatement) {
         const [queryStatement, queryParams] = queryParameterizedStatement;
         const [deleteStatement, deleteParams] = deleteParameterizedStatement;
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
-                    const result = await new Promise((resolve, reject) => {
-                        transaction.executeSql(queryStatement, queryParams, (_, result) => {
-                            resolve(result.rows._array || []);
+                    const result = await new Promise((_resolve, _reject) => {
+                        transaction.executeSql(queryStatement, queryParams, (_, sqlResult) => {
+                            _resolve(sqlResult.rows._array || []);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
                     });
-                    await new Promise((resolve, reject) => {
+                    await new Promise((_resolve, _reject) => {
                         transaction.executeSql(deleteStatement, deleteParams, () => {
-                            resolve(null);
+                            _resolve(null);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             logger.warn(error);
                             return true;
                         });
@@ -159,14 +167,16 @@ class ExpoSQLiteDatabase {
         });
     }
     executeStatements(statements) {
-        return new Promise((resolveTransaction, rejectTransaction) => {
+        return new Promise((resolve, reject) => {
+            const resolveTransaction = resolve;
+            const rejectTransaction = reject;
             this.db.transaction(async (transaction) => {
                 try {
-                    await Promise.all(statements.map(statement => new Promise((resolve, reject) => {
+                    await Promise.all(statements.map(statement => new Promise((_resolve, _reject) => {
                         transaction.executeSql(statement, [], () => {
-                            resolve(null);
+                            _resolve(null);
                         }, (_, error) => {
-                            reject(error);
+                            _reject(error);
                             return true;
                         });
                     })));

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/SQLiteAdapter/SQLiteDatabase.js

@@ -31,7 +31,7 @@ class SQLiteDatabase {
         }
     }
     async createSchema(statements) {
-        return await this.executeStatements(statements);
+        await this.executeStatements(statements);
     }
     async clear() {
         await this.closeDB();
@@ -88,7 +88,9 @@ class SQLiteDatabase {
             tx.executeSql(queryStatement, queryParams, (_, res) => {
                 results = res.rows.raw();
             }, logger.warn);
-            tx.executeSql(deleteStatement, deleteParams, () => { }, logger.warn);
+            tx.executeSql(deleteStatement, deleteParams, () => {
+                // no-op
+            }, logger.warn);
         });
         return results;
     }

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/common/CommonSQLiteAdapter.d.ts

@@ -1,4 +1,4 @@
-import { StorageAdapter, ModelInstanceCreator, InternalSchema, ModelPredicate, NamespaceResolver, NAMESPACES, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '@aws-amplify/datastore';
+import { InternalSchema, ModelInstanceCreator, ModelPredicate, NAMESPACES, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne, StorageAdapter } from '@aws-amplify/datastore';
 import { CommonSQLiteDatabase, ModelInstanceMetadataWithId } from './types';
 export declare class CommonSQLiteAdapter implements StorageAdapter {
     private schema;

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/common/CommonSQLiteAdapter.js

@@ -1,8 +1,8 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { ConsoleLogger } from '@aws-amplify/core';
-import { generateSchemaStatements, queryByIdStatement, modelUpdateStatement, modelInsertStatement, queryAllStatement, queryOneStatement, deleteByIdStatement, deleteByPredicateStatement, } from '../common/SQLiteUtils';
-import { ModelPredicateCreator, ModelSortPredicateCreator, isPredicateObj, OpType, QueryOne, utils, } from '@aws-amplify/datastore';
+import { ModelPredicateCreator, ModelSortPredicateCreator, OpType, QueryOne, isPredicateObj, utils, } from '@aws-amplify/datastore';
+import { deleteByIdStatement, deleteByPredicateStatement, generateSchemaStatements, modelInsertStatement, modelUpdateStatement, queryAllStatement, queryByIdStatement, queryOneStatement, } from '../common/SQLiteUtils';
 const { traverseModel, validatePredicate, isModelConstructor } = utils;
 const logger = new ConsoleLogger('DataStore');
 export class CommonSQLiteAdapter {
@@ -11,9 +11,9 @@ export class CommonSQLiteAdapter {
     }
     async setUp(theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
         if (!this.initPromise) {
-            this.initPromise = new Promise((res, rej) => {
-                this.resolve = res;
-                this.reject = rej;
+            this.initPromise = new Promise((_resolve, _reject) => {
+                this.resolve = _resolve;
+                this.reject = _reject;
             });
         }
         else {
@@ -25,7 +25,9 @@ export class CommonSQLiteAdapter {
         this.modelInstanceCreator = modelInstanceCreator;
         this.getModelConstructorByModelName = getModelConstructorByModelName;
         try {
-            const usesCPKCodegen = Object.values(this.schema.namespaces.user.models).some(model => Object.values(model.fields).some(field => field.association?.hasOwnProperty('targetNames')));
+            const usesCPKCodegen = Object.values(this.schema.namespaces.user.models).some(model => Object.values(model.fields).some(field => 
+            // eslint-disable-next-line no-prototype-builtins
+            field.association?.hasOwnProperty('targetNames')));
             if (usesCPKCodegen) {
                 logger.error('The SQLite adapter does not support schemas using custom primary key. Set `graphQLTransformer.respectPrimaryKeyAttributesOnConnectionField in `amplify/cli.json` to false to disable custom primary key. To regenerate your API, add or remove an empty newline to your GraphQL schema (to change the computed hash) then run `amplify push`.');
             }
@@ -67,10 +69,10 @@ export class CommonSQLiteAdapter {
         for await (const resItem of connectionStoreNames) {
             const { modelName, item, instance } = resItem;
             const { id } = item;
-            const [queryStatement, params] = queryByIdStatement(id, modelName);
-            const fromDB = await this.db.get(queryStatement, params);
-            const opType = fromDB === undefined ? OpType.INSERT : OpType.UPDATE;
-            const saveStatement = fromDB
+            const [queryStatementForRestItem, paramsForRestItem] = queryByIdStatement(id, modelName);
+            const fromDBForRestItem = await this.db.get(queryStatementForRestItem, paramsForRestItem);
+            const opType = fromDBForRestItem === undefined ? OpType.INSERT : OpType.UPDATE;
+            const saveStatement = fromDBForRestItem
                 ? modelUpdateStatement(instance, modelName)
                 : modelInsertStatement(instance, modelName);
             if (id === model.id || opType === OpType.INSERT) {
@@ -111,15 +113,15 @@ export class CommonSQLiteAdapter {
         const limit = pagination && pagination.limit;
         const page = limit && pagination.page;
         const queryById = predicates && this.idFromPredicate(predicates);
-        const records = await (async () => {
+        const records = (await (async () => {
             if (queryById) {
                 const record = await this.getById(tableName, queryById);
                 return record ? [record] : [];
             }
             const [queryStatement, params] = queryAllStatement(tableName, predicates, sortPredicates, limit, page);
-            return await this.db.getAll(queryStatement, params);
-        })();
-        return await this.load(namespaceName, modelConstructor.name, records);
+            return this.db.getAll(queryStatement, params);
+        })());
+        return this.load(namespaceName, modelConstructor.name, records);
     }
     async getById(tableName, id) {
         const [queryStatement, params] = queryByIdStatement(id, tableName);
@@ -200,7 +202,7 @@ export class CommonSQLiteAdapter {
         for (const item of items) {
             const connectedModels = traverseModel(modelConstructor.name, this.modelInstanceCreator(modelConstructor, item), this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
             const { id, _deleted } = item;
-            const { instance } = connectedModels.find(({ instance }) => instance.id === id);
+            const { instance } = connectedModels.find(({ instance: connectedModelInstance }) => connectedModelInstance.id === id);
             if (_deleted) {
                 // create the delete statements right away
                 const deleteStatement = deleteByIdStatement(instance.id, tableName);

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/common/SQLiteUtils.d.ts

@@ -1,4 +1,4 @@
-import { InternalSchema, SchemaModel, PersistentModel, PredicatesGroup, SortPredicatesGroup, GraphQLScalarType } from '@aws-amplify/datastore';
+import { GraphQLScalarType, InternalSchema, PersistentModel, PredicatesGroup, SchemaModel, SortPredicatesGroup } from '@aws-amplify/datastore';
 import { ParameterizedStatement } from './types';
 export declare function getSQLiteType(scalar: keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction' | 'getSQLiteType'>): 'TEXT' | 'INTEGER' | 'REAL' | 'BLOB';
 export declare function generateSchemaStatements(schema: InternalSchema): string[];

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/common/SQLiteUtils.js

@@ -1,6 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { isGraphQLScalarType, QueryOne, isPredicateObj, isPredicateGroup, isModelFieldType, isTargetNameAssociation, isModelAttributeAuth, utils, } from '@aws-amplify/datastore';
+import { QueryOne, isGraphQLScalarType, isModelAttributeAuth, isModelFieldType, isPredicateGroup, isPredicateObj, isTargetNameAssociation, utils, } from '@aws-amplify/datastore';
 const { USER, isNonModelConstructor, isModelConstructor } = utils;
 const keysFromModel = model => Object.keys(model)
     .map(k => `"${k}"`)
@@ -55,9 +55,10 @@ export function getSQLiteType(scalar) {
             return 'TEXT';
         case 'Float':
             return 'REAL';
-        default:
+        default: {
             const _ = scalar;
             throw new Error(`unknown type ${scalar}`);
+        }
     }
 }
 export function generateSchemaStatements(schema) {
@@ -221,10 +222,11 @@ export const whereConditionFromPredicateObject = ({ field, operator, operand, })
             case 'notContains':
                 statement = [`instr("${field}", ?) ${logicalOperator}`, [operand]];
                 break;
-            default:
+            default: {
                 const _ = logicalOperatorKey;
                 // Incorrect WHERE clause can result in data loss
                 throw new Error('Cannot map predicate to a valid WHERE clause');
+            }
         }
         return statement;
     }
@@ -235,9 +237,9 @@ export function whereClauseFromPredicate(predicate) {
     recurse(predicate, result, params);
     const whereClause = `WHERE ${result.join(' ')}`;
     return [whereClause, params];
-    function recurse(predicate, result = [], params = []) {
-        if (isPredicateGroup(predicate)) {
-            const { type: groupType, predicates: groupPredicates } = predicate;
+    function recurse(recursedPredicate, recursedResult = [], recursedParams = []) {
+        if (isPredicateGroup(recursedPredicate)) {
+            const { type: groupType, predicates: groupPredicates } = recursedPredicate;
             let filterType = '';
             let isNegation = false;
             switch (groupType) {
@@ -250,20 +252,21 @@ export function whereClauseFromPredicate(predicate) {
                 case 'or':
                     filterType = 'OR';
                     break;
-                default:
+                default: {
                     const _ = groupType;
                     throw new Error(`Invalid ${groupType}`);
+                }
             }
             const groupResult = [];
             for (const p of groupPredicates) {
-                recurse(p, groupResult, params);
+                recurse(p, groupResult, recursedParams);
             }
-            result.push(`${isNegation ? 'NOT' : ''}(${groupResult.join(` ${filterType} `)})`);
+            recursedResult.push(`${isNegation ? 'NOT' : ''}(${groupResult.join(` ${filterType} `)})`);
         }
-        else if (isPredicateObj(predicate)) {
-            const [condition, conditionParams] = whereConditionFromPredicateObject(predicate);
-            result.push(condition);
-            params.push(...conditionParams);
+        else if (isPredicateObj(recursedPredicate)) {
+            const [condition, conditionParams] = whereConditionFromPredicateObject(recursedPredicate);
+            recursedResult.push(condition);
+            recursedParams.push(...conditionParams);
         }
     }
 }

package/.rollup.cache/home/runner/work/amplify-js/amplify-js/amplify-js/packages/datastore-storage-adapter/dist/esm/common/types.d.ts

@@ -1,4 +1,4 @@
-import { PersistentModel, ModelInstanceMetadata } from '@aws-amplify/datastore';
+import { ModelInstanceMetadata, PersistentModel } from '@aws-amplify/datastore';
 export interface CommonSQLiteDatabase {
     init(): Promise<void>;
     createSchema(statements: string[]): Promise<void>;