@aws-amplify/datastore-storage-adapter 2.0.52 → 2.0.54

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

@@ -0,0 +1,111 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import SQLite from 'react-native-sqlite-storage';
+import { ConsoleLogger } from '@aws-amplify/core';
+import { DB_NAME } from '../common/constants';
+const logger = new ConsoleLogger('SQLiteDatabase');
+SQLite.enablePromise(true);
+if (ConsoleLogger.LOG_LEVEL === 'DEBUG') {
+    SQLite.DEBUG(true);
+}
+/*
+
+Note:
+I purposely avoided using arrow functions () => {} in this class,
+Because I ran into issues with them in some of the SQLite method callbacks
+
+Also, even though the SQLite library is promisified, certain operations
+only work correctly with callbacks. Specifically, any time you need to
+get the result of an `executeSql` command inside of a transaction
+(see the batchQuery method below)
+
+*/
+class SQLiteDatabase {
+    async init() {
+        // only open database once.
+        if (!this.db) {
+            this.db = await SQLite.openDatabase({
+                name: DB_NAME,
+                location: 'default',
+            });
+        }
+    }
+    async createSchema(statements) {
+        return await this.executeStatements(statements);
+    }
+    async clear() {
+        await this.closeDB();
+        logger.debug('Deleting database');
+        await SQLite.deleteDatabase({ name: DB_NAME, location: 'default' });
+        logger.debug('Database deleted');
+    }
+    async get(statement, params) {
+        const results = await this.getAll(statement, params);
+        return results[0];
+    }
+    async getAll(statement, params) {
+        const [resultSet] = await this.db.executeSql(statement, params);
+        const result = resultSet &&
+            resultSet.rows &&
+            resultSet.rows.length &&
+            resultSet.rows.raw &&
+            resultSet.rows.raw();
+        return result || [];
+    }
+    async save(statement, params) {
+        await this.db.executeSql(statement, params);
+    }
+    async batchQuery(queryParameterizedStatements) {
+        const results = [];
+        await this.db.readTransaction(tx => {
+            for (const [statement, params] of queryParameterizedStatements) {
+                tx.executeSql(statement, params, (_, res) => {
+                    results.push(res.rows.raw()[0]);
+                }, logger.warn);
+            }
+        });
+        return results;
+    }
+    async batchSave(saveParameterizedStatements, deleteParameterizedStatements) {
+        await this.db.transaction(tx => {
+            for (const [statement, params] of saveParameterizedStatements) {
+                tx.executeSql(statement, params);
+            }
+        });
+        if (deleteParameterizedStatements) {
+            await this.db.transaction(tx => {
+                for (const [statement, params] of deleteParameterizedStatements) {
+                    tx.executeSql(statement, params);
+                }
+            });
+        }
+    }
+    async selectAndDelete(queryParameterizedStatement, deleteParameterizedStatement) {
+        let results = [];
+        const [queryStatement, queryParams] = queryParameterizedStatement;
+        const [deleteStatement, deleteParams] = deleteParameterizedStatement;
+        await this.db.transaction(tx => {
+            tx.executeSql(queryStatement, queryParams, (_, res) => {
+                results = res.rows.raw();
+            }, logger.warn);
+            tx.executeSql(deleteStatement, deleteParams, () => { }, logger.warn);
+        });
+        return results;
+    }
+    async executeStatements(statements) {
+        await this.db.transaction(tx => {
+            for (const statement of statements) {
+                tx.executeSql(statement);
+            }
+        });
+    }
+    async closeDB() {
+        if (this.db) {
+            logger.debug('Closing Database');
+            await this.db.close();
+            logger.debug('Database closed');
+            this.db = undefined;
+        }
+    }
+}
+export default SQLiteDatabase;

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

@@ -0,0 +1,23 @@
+import { StorageAdapter, ModelInstanceCreator, InternalSchema, ModelPredicate, NamespaceResolver, NAMESPACES, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '@aws-amplify/datastore';
+import { CommonSQLiteDatabase, ModelInstanceMetadataWithId } from './types';
+export declare class CommonSQLiteAdapter implements StorageAdapter {
+    private schema;
+    private namespaceResolver;
+    private modelInstanceCreator;
+    private getModelConstructorByModelName;
+    private db;
+    private initPromise;
+    private resolve;
+    private reject;
+    constructor(db: CommonSQLiteDatabase);
+    setUp(theSchema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: NAMESPACES, modelName: string) => PersistentModelConstructor<any>): Promise<void>;
+    clear(): Promise<void>;
+    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
+    private load;
+    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
+    private getById;
+    private idFromPredicate;
+    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T | undefined>;
+    delete<T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>): Promise<[T[], T[]]>;
+    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadataWithId[]): Promise<[T, OpType][]>;
+}

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

@@ -0,0 +1,236 @@
+// 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';
+const { traverseModel, validatePredicate, isModelConstructor } = utils;
+const logger = new ConsoleLogger('DataStore');
+export class CommonSQLiteAdapter {
+    constructor(db) {
+        this.db = db;
+    }
+    async setUp(theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
+        if (!this.initPromise) {
+            this.initPromise = new Promise((res, rej) => {
+                this.resolve = res;
+                this.reject = rej;
+            });
+        }
+        else {
+            await this.initPromise;
+            return;
+        }
+        this.schema = theSchema;
+        this.namespaceResolver = namespaceResolver;
+        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')));
+            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`.');
+            }
+            await this.db.init();
+            const statements = generateSchemaStatements(this.schema);
+            await this.db.createSchema(statements);
+            this.resolve();
+        }
+        catch (error) {
+            this.reject(error);
+        }
+    }
+    async clear() {
+        await this.db.clear();
+        this.initPromise = undefined;
+    }
+    async save(model, condition) {
+        const modelConstructor = Object.getPrototypeOf(model)
+            .constructor;
+        const { name: tableName } = modelConstructor;
+        const connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
+        const connectionStoreNames = Object.values(connectedModels).map(({ modelName, item, instance }) => {
+            return { modelName, item, instance };
+        });
+        const [queryStatement, params] = queryByIdStatement(model.id, tableName);
+        const fromDB = await this.db.get(queryStatement, params);
+        if (condition && fromDB) {
+            const predicates = ModelPredicateCreator.getPredicates(condition);
+            const { predicates: predicateObjs, type } = predicates;
+            const isValid = validatePredicate(fromDB, type, predicateObjs);
+            if (!isValid) {
+                const msg = 'Conditional update failed';
+                logger.error(msg, { model: fromDB, condition: predicateObjs });
+                throw new Error(msg);
+            }
+        }
+        const result = [];
+        const saveStatements = new Set();
+        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
+                ? modelUpdateStatement(instance, modelName)
+                : modelInsertStatement(instance, modelName);
+            if (id === model.id || opType === OpType.INSERT) {
+                saveStatements.add(saveStatement);
+                result.push([instance, opType]);
+            }
+        }
+        await this.db.batchSave(saveStatements);
+        return result;
+    }
+    async load(namespaceName, srcModelName, records) {
+        const namespace = this.schema.namespaces[namespaceName];
+        const relations = namespace.relationships[srcModelName].relationTypes;
+        const connectionTableNames = relations.map(({ modelName }) => modelName);
+        const modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
+        if (connectionTableNames.length === 0) {
+            return records.map(record => this.modelInstanceCreator(modelConstructor, record));
+        }
+        // Remove related-model fields. They're all `null` in the database,
+        // and any that happen to be required will result in a false validation
+        // error when DataStore attempts to initialize with `null`.
+        // These fields aren't actually needed here. DataStore will use the FK's
+        // from the schema model.
+        return records.map(record => {
+            for (const r of relations) {
+                delete record[r.fieldName];
+            }
+            return this.modelInstanceCreator(modelConstructor, record);
+        });
+    }
+    async query(modelConstructor, predicate, pagination) {
+        const { name: tableName } = modelConstructor;
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const predicates = predicate && ModelPredicateCreator.getPredicates(predicate);
+        const sortPredicates = pagination &&
+            pagination.sort &&
+            ModelSortPredicateCreator.getPredicates(pagination.sort);
+        const limit = pagination && pagination.limit;
+        const page = limit && pagination.page;
+        const queryById = predicates && this.idFromPredicate(predicates);
+        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);
+    }
+    async getById(tableName, id) {
+        const [queryStatement, params] = queryByIdStatement(id, tableName);
+        const record = await this.db.get(queryStatement, params);
+        return record;
+    }
+    idFromPredicate(predicates) {
+        const { predicates: predicateObjs } = predicates;
+        const idPredicate = predicateObjs.length === 1 &&
+            predicateObjs.find(p => isPredicateObj(p) && p.field === 'id' && p.operator === 'eq');
+        return idPredicate && idPredicate.operand;
+    }
+    async queryOne(modelConstructor, firstOrLast = QueryOne.FIRST) {
+        const { name: tableName } = modelConstructor;
+        const [queryStatement, params] = queryOneStatement(firstOrLast, tableName);
+        const result = await this.db.get(queryStatement, params);
+        const modelInstance = result && this.modelInstanceCreator(modelConstructor, result);
+        return modelInstance;
+    }
+    // Currently does not cascade
+    // TODO: use FKs in relations and have `ON DELETE CASCADE` set
+    // For Has Many and Has One relations to have SQL handle cascades automatically
+    async delete(modelOrModelConstructor, condition) {
+        if (isModelConstructor(modelOrModelConstructor)) {
+            const modelConstructor = modelOrModelConstructor;
+            const namespaceName = this.namespaceResolver(modelConstructor);
+            const { name: tableName } = modelConstructor;
+            const predicates = condition && ModelPredicateCreator.getPredicates(condition);
+            const queryStatement = queryAllStatement(tableName, predicates);
+            const deleteStatement = deleteByPredicateStatement(tableName, predicates);
+            const models = await this.db.selectAndDelete(queryStatement, deleteStatement);
+            const modelInstances = await this.load(namespaceName, modelConstructor.name, models);
+            return [modelInstances, modelInstances];
+        }
+        else {
+            const model = modelOrModelConstructor;
+            const modelConstructor = Object.getPrototypeOf(model)
+                .constructor;
+            const { name: tableName } = modelConstructor;
+            if (condition) {
+                const [queryStatement, params] = queryByIdStatement(model.id, tableName);
+                const fromDB = await this.db.get(queryStatement, params);
+                if (fromDB === undefined) {
+                    const msg = 'Model instance not found in storage';
+                    logger.warn(msg, { model });
+                    return [[model], []];
+                }
+                const predicates = ModelPredicateCreator.getPredicates(condition);
+                const { predicates: predicateObjs, type } = predicates;
+                const isValid = validatePredicate(fromDB, type, predicateObjs);
+                if (!isValid) {
+                    const msg = 'Conditional update failed';
+                    logger.error(msg, { model: fromDB, condition: predicateObjs });
+                    throw new Error(msg);
+                }
+                const [deleteStatement, deleteParams] = deleteByIdStatement(model.id, tableName);
+                await this.db.save(deleteStatement, deleteParams);
+                return [[model], [model]];
+            }
+            else {
+                const [deleteStatement, params] = deleteByIdStatement(model.id, tableName);
+                await this.db.save(deleteStatement, params);
+                return [[model], [model]];
+            }
+        }
+    }
+    async batchSave(modelConstructor, items) {
+        const { name: tableName } = modelConstructor;
+        const result = [];
+        const itemsToSave = [];
+        // To determine whether an item should result in an insert or update operation
+        // We first need to query the local DB on the item id
+        const queryStatements = new Set();
+        // Deletes don't need to be queried first, because if the item doesn't exist,
+        // the delete operation will be a no-op
+        const deleteStatements = new Set();
+        const saveStatements = new Set();
+        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);
+            if (_deleted) {
+                // create the delete statements right away
+                const deleteStatement = deleteByIdStatement(instance.id, tableName);
+                deleteStatements.add(deleteStatement);
+                result.push([item, OpType.DELETE]);
+            }
+            else {
+                // query statements for the saves at first
+                const queryStatement = queryByIdStatement(id, tableName);
+                queryStatements.add(queryStatement);
+                // combination of insert and update items
+                itemsToSave.push(instance);
+            }
+        }
+        // returns the query results for each of the save items
+        const queryResponses = await this.db.batchQuery(queryStatements);
+        queryResponses.forEach((response, idx) => {
+            if (response === undefined) {
+                const insertStatement = modelInsertStatement(itemsToSave[idx], tableName);
+                saveStatements.add(insertStatement);
+                result.push([itemsToSave[idx], OpType.INSERT]);
+            }
+            else {
+                const updateStatement = modelUpdateStatement(itemsToSave[idx], tableName);
+                saveStatements.add(updateStatement);
+                result.push([itemsToSave[idx], OpType.UPDATE]);
+            }
+        });
+        // perform all of the insert/update/delete operations in a single transaction
+        await this.db.batchSave(saveStatements, deleteStatements);
+        return result;
+    }
+}

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

@@ -0,0 +1,36 @@
+import { InternalSchema, SchemaModel, PersistentModel, PredicatesGroup, SortPredicatesGroup, GraphQLScalarType } 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[];
+export declare const implicitAuthFieldsForModel: (model: SchemaModel) => string[];
+export declare function modelCreateTableStatement(model: SchemaModel, userModel?: boolean): string;
+export declare function modelInsertStatement(model: PersistentModel, tableName: string): ParameterizedStatement;
+export declare function modelUpdateStatement(model: PersistentModel, tableName: string): ParameterizedStatement;
+export declare function queryByIdStatement(id: string, tableName: string): ParameterizedStatement;
+declare const comparisonOperatorMap: {
+    eq: string;
+    ne: string;
+    le: string;
+    lt: string;
+    ge: string;
+    gt: string;
+};
+declare const logicalOperatorMap: {
+    beginsWith: string;
+    contains: string;
+    notContains: string;
+    between: string;
+};
+export declare const whereConditionFromPredicateObject: ({ field, operator, operand, }: {
+    field: string;
+    operator: keyof typeof logicalOperatorMap | keyof typeof comparisonOperatorMap;
+    operand: any;
+}) => ParameterizedStatement;
+export declare function whereClauseFromPredicate<T extends PersistentModel>(predicate: PredicatesGroup<T>): ParameterizedStatement;
+export declare function orderByClauseFromSort<T extends PersistentModel>(sortPredicate?: SortPredicatesGroup<T>): string;
+export declare function limitClauseFromPagination(limit: number, page?: number): ParameterizedStatement;
+export declare function queryAllStatement<T extends PersistentModel>(tableName: string, predicate?: PredicatesGroup<T>, sort?: SortPredicatesGroup<T>, limit?: number, page?: number): ParameterizedStatement;
+export declare function queryOneStatement(firstOrLast: any, tableName: string): ParameterizedStatement;
+export declare function deleteByIdStatement(id: string, tableName: string): ParameterizedStatement;
+export declare function deleteByPredicateStatement<T extends PersistentModel>(tableName: string, predicate?: PredicatesGroup<T>): ParameterizedStatement;
+export {};