@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/common/SQLiteUtils.js

@@ -0,0 +1,331 @@
+// 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';
+const { USER, isNonModelConstructor, isModelConstructor } = 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}`;
+}
+export 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}`);
+    }
+}
+export 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));
+    });
+}
+export const implicitAuthFieldsForModel = (model) => {
+    if (!model.attributes || !model.attributes.length) {
+        return [];
+    }
+    const authRules = model.attributes.find(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;
+    });
+};
+export function modelCreateTableStatement(model, userModel = false) {
+    // implicitly defined auth fields, e.g., `owner`, `groupsField`, etc.
+    const implicitAuthFields = implicitAuthFieldsForModel(model);
+    let fields = Object.values(model.fields).reduce((acc, field) => {
+        if (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 (isModelFieldType(field.type)) {
+            let columnParam = `"${field.name}" TEXT`;
+            // add targetName as well as field name for BELONGS_TO relations
+            if (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;
+}
+export function modelInsertStatement(model, tableName) {
+    const keys = keysFromModel(model);
+    const [paramaterized, values] = valuesFromModel(model);
+    const insertStatement = `INSERT INTO "${tableName}" (${keys}) VALUES (${paramaterized})`;
+    return [insertStatement, values];
+}
+export function modelUpdateStatement(model, tableName) {
+    const [paramaterized, values] = updateSet(model);
+    const updateStatement = `UPDATE "${tableName}" SET ${paramaterized} WHERE id=?`;
+    return [updateStatement, [...values, model.id]];
+}
+export 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',
+};
+/**
+ * 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;
+}
+export 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]];
+    }
+    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;
+    }
+};
+export function whereClauseFromPredicate(predicate) {
+    const result = [];
+    const params = [];
+    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;
+            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, params);
+            }
+            result.push(`${isNegation ? 'NOT' : ''}(${groupResult.join(` ${filterType} `)})`);
+        }
+        else if (isPredicateObj(predicate)) {
+            const [condition, conditionParams] = whereConditionFromPredicateObject(predicate);
+            result.push(condition);
+            params.push(...conditionParams);
+        }
+    }
+}
+const sortDirectionMap = {
+    ASCENDING: 'ASC',
+    DESCENDING: 'DESC',
+};
+export 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(', ')}`;
+}
+export 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];
+}
+export 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];
+}
+export function queryOneStatement(firstOrLast, tableName) {
+    if (firstOrLast === 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`, []];
+    }
+}
+export function deleteByIdStatement(id, tableName) {
+    const deleteStatement = `DELETE FROM "${tableName}" WHERE "id"=?`;
+    return [deleteStatement, [id]];
+}
+export 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/esm/common/constants.d.ts

@@ -0,0 +1 @@
+export declare const DB_NAME = "AmplifyDatastore";

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

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export const DB_NAME = 'AmplifyDatastore';

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

@@ -0,0 +1,16 @@
+import { PersistentModel, ModelInstanceMetadata } from '@aws-amplify/datastore';
+export interface CommonSQLiteDatabase {
+    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>(queryParameterizedStatement: Set<ParameterizedStatement>): Promise<T[]>;
+    batchSave(saveParameterizedStatements: Set<ParameterizedStatement>, deleteParameterizedStatements?: Set<ParameterizedStatement>): Promise<void>;
+    selectAndDelete<T = any>(queryParameterizedStatement: ParameterizedStatement, deleteParameterizedStatement: ParameterizedStatement): Promise<T[]>;
+}
+export type ParameterizedStatement = [string, any[]];
+export type ModelInstanceMetadataWithId = ModelInstanceMetadata & {
+    id: string;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import SQLiteAdapter from './SQLiteAdapter/SQLiteAdapter';
+export { SQLiteAdapter };

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

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import SQLiteAdapter from './SQLiteAdapter/SQLiteAdapter';
+export { SQLiteAdapter };