@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/esm/SQLiteAdapter/SQLiteDatabase.js

@@ -1,113 +0,0 @@
-// 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) {
-        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, () => {
-                // no-op
-            }, 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

@@ -1,23 +0,0 @@
-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;
-    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

@@ -1,238 +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 { 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 {
-    constructor(db) {
-        this.db = db;
-    }
-    async setUp(theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
-        if (!this.initPromise) {
-            this.initPromise = new Promise((_resolve, _reject) => {
-                this.resolve = _resolve;
-                this.reject = _reject;
-            });
-        }
-        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) => 
-            // 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`.');
-            }
-            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 [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) {
-                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 this.db.getAll(queryStatement, params);
-        })());
-        return 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: connectedModelInstance }) => connectedModelInstance.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

@@ -1,40 +0,0 @@
-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[];
-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;
-};
-declare const arrayOperatorMap: {
-    in: string;
-    notIn: string;
-};
-export declare const whereConditionFromPredicateObject: ({ field, operator, operand, }: {
-    field: string;
-    operator: keyof typeof logicalOperatorMap | keyof typeof comparisonOperatorMap | keyof typeof arrayOperatorMap;
-    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 {};