@aws-amplify/datastore-storage-adapter 2.0.65 → 2.0.67

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

@@ -1,385 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.whereConditionFromPredicateObject = exports.implicitAuthFieldsForModel = void 0;
-exports.getSQLiteType = getSQLiteType;
-exports.generateSchemaStatements = generateSchemaStatements;
-exports.modelCreateTableStatement = modelCreateTableStatement;
-exports.modelInsertStatement = modelInsertStatement;
-exports.modelUpdateStatement = modelUpdateStatement;
-exports.queryByIdStatement = queryByIdStatement;
-exports.whereClauseFromPredicate = whereClauseFromPredicate;
-exports.orderByClauseFromSort = orderByClauseFromSort;
-exports.limitClauseFromPagination = limitClauseFromPagination;
-exports.queryAllStatement = queryAllStatement;
-exports.queryOneStatement = queryOneStatement;
-exports.deleteByIdStatement = deleteByIdStatement;
-exports.deleteByPredicateStatement = deleteByPredicateStatement;
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-const datastore_1 = require("@aws-amplify/datastore");
-const { USER, isNonModelConstructor, isModelConstructor } = datastore_1.utils;
-const keysFromModel = model => Object.keys(model)
-    .map(k => `"${k}"`)
-    .join(', ');
-const valuesFromModel = (model) => {
-    const values = Object.values(model).map(prepareValueForDML);
-    const paramaterized = values.map(() => '?').join(', ');
-    return [paramaterized, values];
-};
-const updateSet = model => {
-    const values = [];
-    const paramaterized = Object.entries(model)
-        .filter(([k]) => k !== 'id')
-        .map(([k, v]) => {
-        values.push(prepareValueForDML(v));
-        return `"${k}"=?`;
-    })
-        .join(', ');
-    return [paramaterized, values];
-};
-function prepareValueForDML(value) {
-    const scalarTypes = ['string', 'number', 'boolean'];
-    const isScalarType = value === null || value === undefined || scalarTypes.includes(typeof value);
-    if (isScalarType) {
-        return value;
-    }
-    const isObjectType = typeof value === 'object' &&
-        (Object.getPrototypeOf(value).constructor === Object ||
-            isNonModelConstructor(Object.getPrototypeOf(value).constructor) ||
-            isModelConstructor(Object.getPrototypeOf(value).constructor));
-    if (Array.isArray(value) || isObjectType) {
-        return JSON.stringify(value);
-    }
-    return `${value}`;
-}
-function getSQLiteType(scalar) {
-    switch (scalar) {
-        case 'Boolean':
-        case 'Int':
-        case 'AWSTimestamp':
-            return 'INTEGER';
-        case 'ID':
-        case 'String':
-        case 'AWSDate':
-        case 'AWSTime':
-        case 'AWSDateTime':
-        case 'AWSEmail':
-        case 'AWSJSON':
-        case 'AWSURL':
-        case 'AWSPhone':
-        case 'AWSIPAddress':
-            return 'TEXT';
-        case 'Float':
-            return 'REAL';
-        default: {
-            const _ = scalar;
-            throw new Error(`unknown type ${scalar}`);
-        }
-    }
-}
-function generateSchemaStatements(schema) {
-    return Object.keys(schema.namespaces).flatMap(namespaceName => {
-        const namespace = schema.namespaces[namespaceName];
-        const isUserModel = namespaceName === USER;
-        return Object.values(namespace.models).map(model => modelCreateTableStatement(model, isUserModel));
-    });
-}
-const implicitAuthFieldsForModel = (model) => {
-    if (!model.attributes || !model.attributes.length) {
-        return [];
-    }
-    const authRules = model.attributes.find(datastore_1.isModelAttributeAuth);
-    if (!authRules) {
-        return [];
-    }
-    const authFieldsForModel = authRules.properties.rules
-        .filter((rule) => rule.ownerField || rule.groupsField)
-        .map((rule) => rule.ownerField || rule.groupsField);
-    return authFieldsForModel.filter((authField) => {
-        const authFieldExplicitlyDefined = Object.values(model.fields).find((f) => f.name === authField);
-        return !authFieldExplicitlyDefined;
-    });
-};
-exports.implicitAuthFieldsForModel = implicitAuthFieldsForModel;
-function modelCreateTableStatement(model, userModel = false) {
-    // implicitly defined auth fields, e.g., `owner`, `groupsField`, etc.
-    const implicitAuthFields = (0, exports.implicitAuthFieldsForModel)(model);
-    let fields = Object.values(model.fields).reduce((acc, field) => {
-        if ((0, datastore_1.isGraphQLScalarType)(field.type)) {
-            if (field.name === 'id') {
-                return [...acc, '"id" PRIMARY KEY NOT NULL'];
-            }
-            let columnParam = `"${field.name}" ${getSQLiteType(field.type)}`;
-            if (field.isRequired) {
-                columnParam += ' NOT NULL';
-            }
-            return [...acc, `${columnParam}`];
-        }
-        if ((0, datastore_1.isModelFieldType)(field.type)) {
-            let columnParam = `"${field.name}" TEXT`;
-            // add targetName as well as field name for BELONGS_TO relations
-            if ((0, datastore_1.isTargetNameAssociation)(field.association)) {
-                // check if this field has been explicitly defined in the model
-                const fkDefinedInModel = Object.values(model.fields).find((f) => f.name === field?.association?.targetName);
-                // if the FK is not explicitly defined in the model, we have to add it here
-                if (!fkDefinedInModel) {
-                    const required = field.isRequired ? ' NOT NULL' : '';
-                    columnParam += `, "${field.association.targetName}" TEXT${required}`;
-                }
-            }
-            // ignore isRequired param for model fields, since they will not contain
-            // the related data locally
-            return [...acc, `${columnParam}`];
-        }
-        // default to TEXT
-        let columnParam = `"${field.name}" TEXT`;
-        if (field.isRequired) {
-            columnParam += ' NOT NULL';
-        }
-        return [...acc, `${columnParam}`];
-    }, []);
-    implicitAuthFields.forEach((authField) => {
-        fields.push(`${authField} TEXT`);
-    });
-    if (userModel) {
-        fields = [
-            ...fields,
-            `"_version" INTEGER`,
-            `"_lastChangedAt" INTEGER`,
-            `"_deleted" INTEGER`,
-        ];
-    }
-    const createTableStatement = `CREATE TABLE IF NOT EXISTS "${model.name}" (${fields.join(', ')});`;
-    return createTableStatement;
-}
-function modelInsertStatement(model, tableName) {
-    const keys = keysFromModel(model);
-    const [paramaterized, values] = valuesFromModel(model);
-    const insertStatement = `INSERT INTO "${tableName}" (${keys}) VALUES (${paramaterized})`;
-    return [insertStatement, values];
-}
-function modelUpdateStatement(model, tableName) {
-    const [paramaterized, values] = updateSet(model);
-    const updateStatement = `UPDATE "${tableName}" SET ${paramaterized} WHERE id=?`;
-    return [updateStatement, [...values, model.id]];
-}
-function queryByIdStatement(id, tableName) {
-    return [`SELECT * FROM "${tableName}" WHERE "id" = ?`, [id]];
-}
-/*
-    Predicates supported by DataStore:
-
-    Strings: eq | ne | le | lt | ge | gt | contains | notContains | beginsWith | between
-    Numbers: eq | ne | le | lt | ge | gt | between
-    Lists: contains | notContains
-*/
-const comparisonOperatorMap = {
-    eq: '=',
-    ne: '!=',
-    le: '<=',
-    lt: '<',
-    ge: '>=',
-    gt: '>',
-};
-const logicalOperatorMap = {
-    beginsWith: '= 1',
-    contains: '> 0',
-    notContains: '= 0',
-    between: 'BETWEEN',
-};
-const arrayOperatorMap = {
-    in: 'IN',
-    notIn: 'NOT IN',
-};
-/**
- * If the given (operator, operand) indicate the need for a special `NULL` comparison,
- * that `WHERE` clause condition will be returned. If not special `NULL` handling is
- * needed, `null` will be returned, and the caller should construct the `WHERE`
- * clause component using the normal operator map(s) and parameterization.
- *
- * @param operator "beginsWith" | "contains" | "notContains" | "between"
- * | "eq" | "ne" | "le" | "lt" | "ge" | "gt"
- * @param operand any
- * @returns (string | null) The `WHERE` clause component or `null` if N/A.
- */
-function buildSpecialNullComparison(field, operator, operand) {
-    if (operand === null || operand === undefined) {
-        if (operator === 'eq') {
-            return `"${field}" IS NULL`;
-        }
-        else if (operator === 'ne') {
-            return `"${field}" IS NOT NULL`;
-        }
-    }
-    // no special null handling required
-    return null;
-}
-/**
- * Builds a special SQL clause that always evaluates to true or false.
- * Used for edge cases like empty arrays in 'in'/'notIn' operators.
- *
- * @param operator The operator ('in' or 'notIn')
- * @returns A ParameterizedStatement that always evaluates to true or false
- */
-function buildSpecialAlwaysStatement(operator) {
-    // Empty array: nothing can be IN or NOT IN an empty set
-    // For 'in': always false (nothing matches)
-    // For 'notIn': always true (everything doesn't match)
-    return operator === 'in' ? ['1 = 0', []] : ['1 = 1', []];
-}
-const whereConditionFromPredicateObject = ({ field, operator, operand, }) => {
-    const specialNullClause = buildSpecialNullComparison(field, operator, operand);
-    if (specialNullClause) {
-        return [specialNullClause, []];
-    }
-    const comparisonOperator = comparisonOperatorMap[operator];
-    if (comparisonOperator) {
-        return [`"${field}" ${comparisonOperator} ?`, [operand]];
-    }
-    // Handle array operators ('in' and 'notIn')
-    const arrayOperator = arrayOperatorMap[operator];
-    if (arrayOperator) {
-        if (!Array.isArray(operand)) {
-            throw new Error(`Operand for ${operator} must be an array`);
-        }
-        if (operand.length === 0) {
-            return buildSpecialAlwaysStatement(operator);
-        }
-        // Prepare values for SQL (handle complex types)
-        const preparedValues = operand.map(prepareValueForDML);
-        const placeholders = preparedValues.map(() => '?').join(', ');
-        return [`"${field}" ${arrayOperator} (${placeholders})`, preparedValues];
-    }
-    const logicalOperatorKey = operator;
-    const logicalOperator = logicalOperatorMap[logicalOperatorKey];
-    let statement;
-    if (logicalOperator) {
-        let rightExp = [];
-        switch (logicalOperatorKey) {
-            case 'between':
-                rightExp = operand; // operand is a 2-tuple
-                statement = [
-                    `"${field}" ${logicalOperator} ${rightExp
-                        .map(_ => '?')
-                        .join(' AND ')}`,
-                    rightExp,
-                ];
-                break;
-            case 'beginsWith':
-            case 'contains':
-            case 'notContains':
-                statement = [`instr("${field}", ?) ${logicalOperator}`, [operand]];
-                break;
-            default: {
-                const _ = logicalOperatorKey;
-                // Incorrect WHERE clause can result in data loss
-                throw new Error('Cannot map predicate to a valid WHERE clause');
-            }
-        }
-        return statement;
-    }
-    // Incorrect WHERE clause can result in data loss
-    throw new Error('Cannot map predicate to a valid WHERE clause');
-};
-exports.whereConditionFromPredicateObject = whereConditionFromPredicateObject;
-function whereClauseFromPredicate(predicate) {
-    const result = [];
-    const params = [];
-    recurse(predicate, result, params);
-    const whereClause = `WHERE ${result.join(' ')}`;
-    return [whereClause, params];
-    function recurse(recursedPredicate, recursedResult = [], recursedParams = []) {
-        if ((0, datastore_1.isPredicateGroup)(recursedPredicate)) {
-            const { type: groupType, predicates: groupPredicates } = recursedPredicate;
-            let filterType = '';
-            let isNegation = false;
-            switch (groupType) {
-                case 'not':
-                    isNegation = true;
-                    break;
-                case 'and':
-                    filterType = 'AND';
-                    break;
-                case 'or':
-                    filterType = 'OR';
-                    break;
-                default: {
-                    const _ = groupType;
-                    throw new Error(`Invalid ${groupType}`);
-                }
-            }
-            const groupResult = [];
-            for (const p of groupPredicates) {
-                recurse(p, groupResult, recursedParams);
-            }
-            recursedResult.push(`${isNegation ? 'NOT' : ''}(${groupResult.join(` ${filterType} `)})`);
-        }
-        else if ((0, datastore_1.isPredicateObj)(recursedPredicate)) {
-            const [condition, conditionParams] = (0, exports.whereConditionFromPredicateObject)(recursedPredicate);
-            recursedResult.push(condition);
-            recursedParams.push(...conditionParams);
-        }
-    }
-}
-const sortDirectionMap = {
-    ASCENDING: 'ASC',
-    DESCENDING: 'DESC',
-};
-function orderByClauseFromSort(sortPredicate = []) {
-    const orderByParts = sortPredicate.map(({ field, sortDirection }) => `"${String(field)}" ${sortDirectionMap[sortDirection]}`);
-    // We always sort by _rowid_ last
-    orderByParts.push(`_rowid_ ${sortDirectionMap.ASCENDING}`);
-    return `ORDER BY ${orderByParts.join(', ')}`;
-}
-function limitClauseFromPagination(limit, page = 0) {
-    const params = [limit];
-    let clause = 'LIMIT ?';
-    if (page) {
-        const offset = limit * page;
-        params.push(offset);
-        clause += ' OFFSET ?';
-    }
-    return [clause, params];
-}
-function queryAllStatement(tableName, predicate, sort, limit, page) {
-    let statement = `SELECT * FROM "${tableName}"`;
-    const params = [];
-    if (predicate && predicate.predicates.length) {
-        const [whereClause, whereParams] = whereClauseFromPredicate(predicate);
-        statement += ` ${whereClause}`;
-        params.push(...whereParams);
-    }
-    const orderByClause = orderByClauseFromSort(sort);
-    statement += ` ${orderByClause}`;
-    if (limit) {
-        const [limitClause, limitParams] = limitClauseFromPagination(limit, page);
-        statement += ` ${limitClause}`;
-        params.push(...limitParams);
-    }
-    return [statement, params];
-}
-function queryOneStatement(firstOrLast, tableName) {
-    if (firstOrLast === datastore_1.QueryOne.FIRST) {
-        // ORDER BY rowid will no longer work as expected if a customer has
-        // a field by that name in their schema. We may want to enforce it
-        // as a reserved keyword in Codegen
-        return [`SELECT * FROM ${tableName} ORDER BY _rowid_ LIMIT 1`, []];
-    }
-    else {
-        return [`SELECT * FROM ${tableName} ORDER BY _rowid_ DESC LIMIT 1`, []];
-    }
-}
-function deleteByIdStatement(id, tableName) {
-    const deleteStatement = `DELETE FROM "${tableName}" WHERE "id"=?`;
-    return [deleteStatement, [id]];
-}
-function deleteByPredicateStatement(tableName, predicate) {
-    let statement = `DELETE FROM "${tableName}"`;
-    const params = [];
-    if (predicate && predicate.predicates.length) {
-        const [whereClause, whereParams] = whereClauseFromPredicate(predicate);
-        statement += ` ${whereClause}`;
-        params.push(...whereParams);
-    }
-    return [statement, params];
-}

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

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB_NAME = void 0;
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-exports.DB_NAME = 'AmplifyDatastore';

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLiteAdapter = void 0;
-const tslib_1 = require("tslib");
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-const SQLiteAdapter_1 = tslib_1.__importDefault(require("./SQLiteAdapter/SQLiteAdapter"));
-exports.SQLiteAdapter = SQLiteAdapter_1.default;

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

@@ -1,3 +0,0 @@
-import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
-declare const ExpoSQLiteAdapter: CommonSQLiteAdapter;
-export default ExpoSQLiteAdapter;

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

@@ -1,6 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
-import ExpoSQLiteDatabase from './ExpoSQLiteDatabase';
-const ExpoSQLiteAdapter = new CommonSQLiteAdapter(new ExpoSQLiteDatabase());
-export default ExpoSQLiteAdapter;

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

@@ -1,17 +0,0 @@
-import { PersistentModel } from '@aws-amplify/datastore';
-import { CommonSQLiteDatabase, ParameterizedStatement } from '../common/types';
-declare class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
-    private db;
-    init(): Promise<void>;
-    createSchema(statements: string[]): Promise<void>;
-    clear(): Promise<void>;
-    get<T extends PersistentModel>(statement: string, params: (string | number)[]): Promise<T>;
-    getAll<T extends PersistentModel>(statement: string, params: (string | number)[]): Promise<T[]>;
-    save(statement: string, params: (string | number)[]): Promise<void>;
-    batchQuery<T = any>(queryParameterizedStatements?: Set<ParameterizedStatement>): Promise<T[]>;
-    batchSave(saveParameterizedStatements?: Set<ParameterizedStatement>, deleteParameterizedStatements?: Set<ParameterizedStatement>): Promise<void>;
-    selectAndDelete<T = any>(queryParameterizedStatement: ParameterizedStatement, deleteParameterizedStatement: ParameterizedStatement): Promise<T[]>;
-    private executeStatements;
-    private closeDB;
-}
-export default ExpoSQLiteDatabase;

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

@@ -1,203 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { ConsoleLogger } from '@aws-amplify/core';
-import { deleteAsync, documentDirectory } from 'expo-file-system';
-import { openDatabase } from 'expo-sqlite';
-import { DB_NAME } from '../common/constants';
-const logger = new ConsoleLogger('ExpoSQLiteDatabase');
-/*
-
-Note:
-ExpoSQLite transaction error callbacks require returning a boolean value to indicate whether the
-error was handled or not. Returning a true value indicates the error was handled and does not
-rollback the whole transaction.
-
-*/
-class ExpoSQLiteDatabase {
-    async init() {
-        // only open database once.
-        if (!this.db) {
-            // As per expo docs version, description and size arguments are ignored,
-            // but are accepted by the function for compatibility with the WebSQL specification.
-            // Hence, we do not need those arguments.
-            this.db = openDatabase(DB_NAME);
-        }
-    }
-    createSchema(statements) {
-        return this.executeStatements(statements);
-    }
-    async clear() {
-        try {
-            logger.debug('Clearing database');
-            await this.closeDB();
-            // delete database is not supported by expo-sqlite.
-            // Database file needs to be deleted using deleteAsync from expo-file-system
-            await deleteAsync(`${documentDirectory}SQLite/${DB_NAME}`);
-            logger.debug('Database cleared');
-        }
-        catch (error) {
-            logger.warn('Error clearing the database.', error);
-            // open database if it was closed earlier and this.db was set to undefined.
-            this.init();
-        }
-    }
-    async get(statement, params) {
-        const results = await this.getAll(statement, params);
-        return results[0];
-    }
-    getAll(statement, params) {
-        return new Promise((resolve, reject) => {
-            this.db.readTransaction(transaction => {
-                transaction.executeSql(statement, params, (_, result) => {
-                    resolve(result.rows._array || []);
-                }, (_, error) => {
-                    reject(error);
-                    logger.warn(error);
-                    return true;
-                });
-            });
-        });
-    }
-    save(statement, params) {
-        return new Promise((resolve, reject) => {
-            this.db.transaction(transaction => {
-                transaction.executeSql(statement, params, () => {
-                    resolve(null);
-                }, (_, error) => {
-                    reject(error);
-                    logger.warn(error);
-                    return true;
-                });
-            });
-        });
-    }
-    batchQuery(queryParameterizedStatements = new Set()) {
-        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) => {
-                        transaction.executeSql(statement, params, (_, result) => {
-                            _resolve(result.rows._array[0]);
-                        }, (_, error) => {
-                            _reject(error);
-                            logger.warn(error);
-                            return true;
-                        });
-                    })));
-                    resolveTransaction(results);
-                }
-                catch (error) {
-                    rejectTransaction(error);
-                    logger.warn(error);
-                }
-            });
-        });
-    }
-    batchSave(saveParameterizedStatements = new Set(), deleteParameterizedStatements) {
-        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) => {
-                        transaction.executeSql(statement, params, () => {
-                            _resolve(null);
-                        }, (_, 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;
-                            });
-                        })));
-                    }
-                    resolveTransaction(null);
-                }
-                catch (error) {
-                    rejectTransaction(error);
-                    logger.warn(error);
-                }
-            });
-        });
-    }
-    selectAndDelete(queryParameterizedStatement, deleteParameterizedStatement) {
-        const [queryStatement, queryParams] = queryParameterizedStatement;
-        const [deleteStatement, deleteParams] = deleteParameterizedStatement;
-        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, (_, sqlResult) => {
-                            _resolve(sqlResult.rows._array || []);
-                        }, (_, error) => {
-                            _reject(error);
-                            logger.warn(error);
-                            return true;
-                        });
-                    });
-                    await new Promise((_resolve, _reject) => {
-                        transaction.executeSql(deleteStatement, deleteParams, () => {
-                            _resolve(null);
-                        }, (_, error) => {
-                            _reject(error);
-                            logger.warn(error);
-                            return true;
-                        });
-                    });
-                    resolveTransaction(result);
-                }
-                catch (error) {
-                    rejectTransaction(error);
-                    logger.warn(error);
-                }
-            });
-        });
-    }
-    executeStatements(statements) {
-        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) => {
-                        transaction.executeSql(statement, [], () => {
-                            _resolve(null);
-                        }, (_, error) => {
-                            _reject(error);
-                            return true;
-                        });
-                    })));
-                    resolveTransaction(null);
-                }
-                catch (error) {
-                    rejectTransaction(error);
-                    logger.warn(error);
-                }
-            });
-        });
-    }
-    async closeDB() {
-        if (this.db) {
-            logger.debug('Closing Database');
-            // closing database is not supported by expo-sqlite.
-            // Workaround is to access the private db variable and call the close() method.
-            await this.db._db.close();
-            logger.debug('Database closed');
-            this.db = undefined;
-        }
-    }
-}
-export default ExpoSQLiteDatabase;

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

@@ -1,3 +0,0 @@
-import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
-declare const SQLiteAdapter: CommonSQLiteAdapter;
-export default SQLiteAdapter;

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

@@ -1,6 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
-import SQLiteDatabase from './SQLiteDatabase';
-const SQLiteAdapter = new CommonSQLiteAdapter(new SQLiteDatabase());
-export default SQLiteAdapter;

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

@@ -1,17 +0,0 @@
-import { PersistentModel } from '@aws-amplify/datastore';
-import { CommonSQLiteDatabase, ParameterizedStatement } from '../common/types';
-declare class SQLiteDatabase implements CommonSQLiteDatabase {
-    private db;
-    init(): Promise<void>;
-    createSchema(statements: string[]): Promise<void>;
-    clear(): Promise<void>;
-    get<T extends PersistentModel>(statement: string, params: (string | number)[]): Promise<T>;
-    getAll<T extends PersistentModel>(statement: string, params: (string | number)[]): Promise<T[]>;
-    save(statement: string, params: (string | number)[]): Promise<void>;
-    batchQuery<T = any>(queryParameterizedStatements: Set<ParameterizedStatement>): Promise<T[]>;
-    batchSave(saveParameterizedStatements: Set<ParameterizedStatement>, deleteParameterizedStatements?: Set<ParameterizedStatement>): Promise<void>;
-    selectAndDelete<T = any>(queryParameterizedStatement: ParameterizedStatement, deleteParameterizedStatement: ParameterizedStatement): Promise<T[]>;
-    private executeStatements;
-    private closeDB;
-}
-export default SQLiteDatabase;