db-wrapper 0.0.7 → 0.0.9

package/fesm2015/db-wrapper.js

@@ -1,863 +1,495 @@
-import { __awaiter } from 'tslib';
+import { __decorate, __awaiter } from 'tslib';
 import { Injectable, InjectionToken, NgModule } from '@angular/core';
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class WindowService {
-    /**
-     * @return {?}
-     */
-    get nativeWindow() {
-        return _window();
-    }
-}
-WindowService.decorators = [
-    { type: Injectable }
-];
-/**
- * @return {?}
- */
-function _window() {
-    // Return the global native browser window object
-    return typeof window !== 'undefined' ? window : undefined;
+let WindowService = class WindowService {
+    get nativeWindow() {
+        return _window();
+    }
+};
+WindowService = __decorate([
+    Injectable()
+], WindowService);
+function _window() {
+    // Return the global native browser window object
+    return typeof window !== 'undefined' ? window : undefined;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class DbWrapperService {
-    /**
-     * @param {?} dbConfig
-     * @param {?=} dbSchema
-     */
-    constructor(dbConfig, dbSchema) {
-        this._dbName = dbConfig.dbName;
-        this._location = dbConfig.location || 'default';
-        this._iosDatabaseLocation = dbConfig.iosDatabaseLocation || 'Library';
-        /** @type {?} */
-        const window = (new WindowService()).nativeWindow;
-        if (dbSchema) {
-            this.schema = dbSchema;
-        }
-        this._readyPromise = new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            if (typeof window.cordova === 'undefined') {
-                setTimeout((/**
-                 * @return {?}
-                 */
-                () => {
-                    this.init(dbSchema).then((/**
-                     * @return {?}
-                     */
-                    () => {
-                        resolve();
-                    }))
-                        .catch((/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    (err) => {
-                        reject(err);
-                    }));
-                }), 500);
-            }
-            else {
-                document.addEventListener('deviceready', (/**
-                 * @return {?}
-                 */
-                () => {
-                    console.log('dbWrapper: device ready.');
-                    this.initDevice(dbSchema).then((/**
-                     * @return {?}
-                     */
-                    () => resolve())).catch((/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    (err) => reject(err)));
-                }));
-            }
-        }));
-    }
-    /**
-     * @return {?}
-     */
-    ready() {
-        return this._readyPromise;
-    }
-    /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
-    initDevice(dbSchema) {
-        /** @type {?} */
-        const window = (new WindowService()).nativeWindow;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            this.db = window.sqlitePlugin.openDatabase({
-                name: this._dbName,
-                location: this._location,
-                androidLockWorkaround: 1
-            });
-            if (dbSchema) {
-                this.generate(dbSchema).catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                err => {
-                    reject(err);
-                })).then((/**
-                 * @return {?}
-                 */
-                () => { resolve(); }));
-            }
-            else {
-                resolve();
-            }
-        }));
-    }
-    /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
-    init(dbSchema) {
-        /** @type {?} */
-        const window = (new WindowService()).nativeWindow;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            this.db = window.openDatabase(this._dbName, '1.0', 'database', -1);
-            if (dbSchema) {
-                this.generate(dbSchema).catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                err => {
-                    reject(err);
-                })).then((/**
-                 * @return {?}
-                 */
-                () => {
-                    resolve();
-                }));
-            }
-            else {
-                resolve();
-            }
-        }));
-    }
-    /**
-     * @param {?} schema
-     * @return {?}
-     */
-    generate(schema) {
-        /** @type {?} */
-        const sentences = [];
-        this.schema = schema;
-        if (schema.tables) {
-            schema.tables.forEach((/**
-             * @param {?} table
-             * @return {?}
-             */
-            table => {
-                sentences.push(this.createTable(table));
-            }));
-        }
-        if (schema.views) {
-            schema.views.forEach((/**
-             * @param {?} view
-             * @return {?}
-             */
-            view => {
-                sentences.push(this.createView(view));
-            }));
-        }
-        if (sentences.length === 0) {
-            throw new Error('Esquema de la base de datos vacia.');
-        }
-        return Promise.all(sentences);
-    }
-    /**
-     * @param {?} table
-     * @return {?}
-     */
-    createTable(table) {
-        return __awaiter(this, void 0, void 0, function* () {
-            /** @type {?} */
-            let sql = '';
-            /** @type {?} */
-            let onConflictPrimary;
-            /** @type {?} */
-            const sentences = [];
-            /** @type {?} */
-            const newColumns = [];
-            /** @type {?} */
-            const tableDDL = yield this.tableExists(table.name);
-            if (tableDDL) {
-                table.columns.forEach((/**
-                 * @param {?} col
-                 * @return {?}
-                 */
-                col => {
-                    if (!this.columnExists((/** @type {?} */ (tableDDL)), col.name)) {
-                        newColumns.push(this.addColumn(table.name, col));
-                    }
-                }));
-            }
-            else {
-                table.columns.forEach((/**
-                 * @param {?} col
-                 * @return {?}
-                 */
-                col => {
-                    sentences.push(this.defColumn(col));
-                }));
-            }
-            onConflictPrimary = 'on conflict fail';
-            if (Array.isArray(table.primary)) {
-                sentences.push(' CONSTRAINT identificador PRIMARY KEY (' + table.primary.join(',') + ') ' + onConflictPrimary);
-            }
-            if (typeof table.primary === 'string') {
-                sentences.push(' CONSTRAINT identificador PRIMARY KEY (' + table.primary + ') ' + onConflictPrimary);
-            }
-            if (table.uniques) {
-                table.uniques.forEach((/**
-                 * @param {?} uniq
-                 * @return {?}
-                 */
-                uniq => {
-                    sentences.push(this.defUnique(uniq));
-                }));
-            }
-            if (table.foreigns) {
-                table.foreigns.forEach((/**
-                 * @param {?} fore
-                 * @return {?}
-                 */
-                fore => {
-                    sentences.push(this.defForeign(fore));
-                }));
-            }
-            if (tableDDL && newColumns.length !== 0) {
-                return Promise.all(newColumns)
-                    .then((/**
-                 * @return {?}
-                 */
-                () => { console.log(`Table ${table.name} altered.`); }))
-                    .catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => {
-                    console.error(`Table ${table.name}: ${err.message}`);
-                    throw new Error(`Table ${table.name}: ${err.message}`);
-                }));
-            }
-            else if (!tableDDL) {
-                sql = 'CREATE TABLE IF NOT EXISTS ' + table.name + ' (' + sentences.join(',') + ')';
-                return this.query(sql)
-                    .then((/**
-                 * @return {?}
-                 */
-                () => { console.log(`Table ${table.name} created.`); }))
-                    .catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => {
-                    console.error(`Table ${table.name}: ${err.message}`);
-                    throw new Error(`Table ${table.name}: ${err.message}`);
-                }));
-            }
-            else {
-                return Promise.resolve().then((/**
-                 * @return {?}
-                 */
-                () => { console.log(`Table ${table.name} initialized.`); }));
-            }
-        });
-    }
-    /**
-     * @param {?} view
-     * @return {?}
-     */
-    createView(view) {
-        /** @type {?} */
-        let sql;
-        sql = 'CREATE VIEW IF NOT EXISTS ' + view.name
-            + ' AS ' + view.sql;
-        return this.query(sql);
-    }
-    /**
-     * @param {?} tableName
-     * @return {?}
-     */
-    getSchemaTable(tableName) {
-        /** @type {?} */
-        let res;
-        this.schema.tables.forEach((/**
-         * @param {?} table
-         * @return {?}
-         */
-        table => {
-            if (table.name === tableName) {
-                res = table;
-            }
-        }));
-        return res;
-    }
-    /**
-     * @param {?} table
-     * @return {?}
-     */
-    getUniquesTable(table) {
-        /** @type {?} */
-        let res;
-        table.uniques.forEach((/**
-         * @param {?} uniq
-         * @return {?}
-         */
-        uniq => {
-            res[uniq.name] = uniq;
-        }));
-        return res;
-    }
-    /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
-    query(query, bindings = []) {
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            if (query.indexOf('select') === 0) {
-                this.db.readTransaction((/**
-                 * @param {?} transaction
-                 * @return {?}
-                 */
-                (transaction) => {
-                    transaction.executeSql(query, bindings, (/**
-                     * @param {?} transaction
-                     * @param {?} result
-                     * @return {?}
-                     */
-                    (transaction, result) => {
-                        resolve(result);
-                    }), (/**
-                     * @param {?} transaction
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    (transaction, error) => {
-                        reject(error);
-                    }));
-                }), (/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => reject(err)));
-            }
-            else {
-                this.db.transaction((/**
-                 * @param {?} transaction
-                 * @return {?}
-                 */
-                (transaction) => {
-                    transaction.executeSql(query, bindings, (/**
-                     * @param {?} transaction
-                     * @param {?} result
-                     * @return {?}
-                     */
-                    (transaction, result) => {
-                        resolve(result);
-                    }), (/**
-                     * @param {?} transaction
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    (transaction, error) => {
-                        reject(error);
-                    }));
-                }), (/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => reject(err)));
-            }
-        }));
-    }
-    /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
-    Count(query, bindings = []) {
-        return this.query(query, bindings).then((/**
-         * @param {?} rows
-         * @return {?}
-         */
-        rows => {
-            return this.rowsCount(rows);
-        }));
-    }
-    /**
-     * @param {?} table
-     * @param {?} bindings
-     * @return {?}
-     */
-    insert(table, bindings) {
-        /** @type {?} */
-        let sql = '';
-        /** @type {?} */
-        let sqlBinds = [];
-        /** @type {?} */
-        let sqlKeys = [];
-        /** @type {?} */
-        let sqlValues = [];
-        sql = sql + 'insert into ' + table + ' ';
-        for (const index in bindings) {
-            if (bindings.hasOwnProperty(index)) {
-                sqlKeys.push(index);
-                sqlValues.push(bindings[index]);
-                sqlBinds.push('?');
-            }
-        }
-        sql = sql + '(' + sqlKeys.join(',') + ') values (' + sqlBinds.join(',') + ')';
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            this.db.transaction((/**
-             * @param {?} transaction
-             * @return {?}
-             */
-            transaction => {
-                transaction.executeSql(sql, sqlValues, (/**
-                 * @param {?} transaction
-                 * @param {?} result
-                 * @return {?}
-                 */
-                (transaction, result) => {
-                    resolve(result);
-                }), (/**
-                 * @param {?} transaction
-                 * @param {?} error
-                 * @return {?}
-                 */
-                (transaction, error) => {
-                    reject(error);
-                }));
-            }));
-        }));
-    }
-    /**
-     * @param {?} table
-     * @param {?} bindings
-     * @param {?} where
-     * @return {?}
-     */
-    update(table, bindings, where) {
-        /** @type {?} */
-        let sql = '';
-        /** @type {?} */
-        let sqlBinds = [];
-        /** @type {?} */
-        let sqlKeys = [];
-        /** @type {?} */
-        let sqlValues = [];
-        sql = sql + 'update ' + table + ' set ';
-        for (let index in bindings) {
-            if (bindings.hasOwnProperty(index)) {
-                /** @type {?} */
-                let newObj = bindings[index];
-                if (typeof newObj === 'object' && newObj !== null) {
-                    sqlValues.push(newObj.value);
-                    if (newObj.ifnull) {
-                        sqlBinds.push(index + ' = ifnull( ' + index + ',0) + ?');
-                    }
-                    else if (newObj.operator) {
-                        sqlBinds.push(index + ' = ' + index + newObj.operator + ' ?');
-                    }
-                    else {
-                        sqlBinds.push(index + ' = ?');
-                    }
-                }
-                else {
-                    sqlBinds.push(index + ' = ?');
-                    sqlValues.push(bindings[index]);
-                }
-            }
-        }
-        for (let index in where) {
-            if (where.hasOwnProperty(index)) {
-                if (typeof where[index] === 'object' && where[index] !== null) {
-                    sqlKeys.push(index + ' ' + where[index].operator + ' ?');
-                    sqlValues.push(where[index].value);
-                }
-                else {
-                    sqlKeys.push(index + ' = ?');
-                    sqlValues.push(where[index]);
-                }
-            }
-        }
-        sql = sql + sqlBinds.join(',') + ' where ' + sqlKeys.join(' and ');
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            this.db.transaction((/**
-             * @param {?} transaction
-             * @return {?}
-             */
-            transaction => {
-                transaction.executeSql(sql, sqlValues, (/**
-                 * @param {?} transaction
-                 * @param {?} result
-                 * @return {?}
-                 */
-                (transaction, result) => {
-                    resolve(result);
-                }), (/**
-                 * @param {?} transaction
-                 * @param {?} error
-                 * @return {?}
-                 */
-                (transaction, error) => {
-                    reject(error);
-                }));
-            }));
-        }));
-    }
-    /**
-     * @param {?} tables
-     * @return {?}
-     */
-    dropTable(tables) {
-        /** @type {?} */
-        let cont = 1;
-        cont = tables.length;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
-            tables.some((/**
-             * @param {?} table
-             * @return {?}
-             */
-            table => {
-                if (cont !== 0) {
-                    this.query('DROP TABLE ' + table)
-                        .then((/**
-                     * @return {?}
-                     */
-                    () => {
-                        if (cont === 1) {
-                            resolve();
-                        }
-                        else {
-                            cont--;
-                        }
-                    }), (/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    err => {
-                        cont = 0;
-                        reject(err);
-                        return true;
-                    }));
-                    return false;
-                }
-            }));
-        }));
-    }
-    /**
-     * @param {?} result
-     * @return {?}
-     */
-    fetchAll(result) {
-        /** @type {?} */
-        let output = [];
-        for (let i = 0; i < result.rows.length; i++) {
-            output.push(result.rows.item(i));
-        }
-        return output;
-    }
-    /**
-     * @param {?} result
-     * @return {?}
-     */
-    fetch(result) {
-        /** @type {?} */
-        let objeto = undefined;
-        /** @type {?} */
-        let newObj = undefined;
-        if (result.rows.length !== 0) {
-            objeto = result.rows.item(0);
-            newObj = {};
-            /** @type {?} */
-            const keys = Object.keys(objeto);
-            for (let key in keys) {
-                newObj[keys[key]] = objeto[keys[key]];
-            }
-        }
-        return newObj;
-    }
-    /**
-     * @param {?} result
-     * @return {?}
-     */
-    rowsCount(result) {
-        return result.rows.length;
-    }
-    /* Private */
-    /**
-     * @private
-     * @param {?} col
-     * @return {?}
-     */
-    defColumn(col) {
-        /** @type {?} */
-        let colSql;
-        colSql = col.name + ' ' + col.type;
-        if (!col.isNullable) {
-            colSql += ' NOT NULL ';
-        }
-        if (col.default) {
-            colSql += ' DEFAULT ' + col.default + ' ';
-        }
-        if (col.type === 'text' && col.length) {
-            colSql += ` CONSTRAINT ${col.name}_length CHECK ( `;
-            if (col.isNullable) {
-                colSql += `${col.name} is null OR `;
-            }
-            colSql += `length(${col.name}) <= ${col.length} )`;
-        }
-        return colSql;
-    }
-    /**
-     * @private
-     * @param {?} unique
-     * @return {?}
-     */
-    defUnique(unique) {
-        /** @type {?} */
-        let uniqSql;
-        // depende del entorno, producción o desarrollo
-        /** @type {?} */
-        const onConflictUnique = 'on conflict fail';
-        if (Array.isArray(unique.fields)) {
-            uniqSql = ` CONSTRAINT ${unique.name} UNIQUE ( ${unique.fields.join(',')} ) ${onConflictUnique} `;
-        }
-        if (typeof unique.fields === 'string') {
-            uniqSql = ` CONSTRAINT ${unique.name} UNIQUE ( ${unique.fields} ) ${onConflictUnique} `;
-        }
-        return uniqSql;
-    }
-    /**
-     * @private
-     * @param {?} fore
-     * @return {?}
-     */
-    defForeign(fore) {
-        /** @type {?} */
-        let foreSql;
-        if (Array.isArray(fore.foreignKey)) {
-            foreSql = ` FOREIGN KEY (  ${fore.foreignKey.join(',')} ) `;
-        }
-        if (typeof fore.foreignKey === 'string') {
-            foreSql = ` FOREIGN KEY (  ${fore.foreignKey} ) `;
-        }
-        if (Array.isArray(fore.primaryKey)) {
-            foreSql = ` REFERENCES ${fore.referenceTable} (  ${fore.primaryKey.join(',')} ) `;
-        }
-        if (typeof fore.primaryKey === 'string') {
-            foreSql = ` REFERENCES ${fore.referenceTable} (  ${fore.primaryKey} ) `;
-        }
-        return foreSql;
-    }
-    /**
-     * @private
-     * @param {?} table
-     * @return {?}
-     */
-    tableExists(table) {
-        return this.query('select  sql from sqlite_master ' +
-            'where type=\'table\' and name=\'' + table + '\'')
-            .then((/**
-         * @param {?} result
-         * @return {?}
-         */
-        result => {
-            if (this.rowsCount(result) === 1) {
-                return (/** @type {?} */ (((/** @type {?} */ (this.fetch(result)))).sql));
-            }
-            else {
-                return false;
-            }
-        }));
-    }
-    /**
-     * @private
-     * @param {?} tableDDL
-     * @param {?} column
-     * @return {?}
-     */
-    columnExists(tableDDL, column) {
-        if (tableDDL.indexOf(column) === -1) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    }
-    /**
-     * @private
-     * @param {?} table
-     * @param {?} col
-     * @return {?}
-     */
-    addColumn(table, col) {
-        /** @type {?} */
-        const colSql = this.defColumn(col);
-        /** @type {?} */
-        const query = 'alter TABLE ' + table + ' add COLUMN ' + colSql;
-        return this.query(query);
-    }
-}
-/** @type {?} */
-const DB_CONFIG = new InjectionToken('dbWrapperConfig');
-/** @type {?} */
-const DB_SCHEMA = new InjectionToken('dbWrapperSchema');
-/**
- * @return {?}
- */
-function getDefaultDbConfig() {
-    return {
-        dbName: 'db.sqlite',
-        location: 'default',
-        iosDatabaseLocation: 'Library'
-    };
-}
-/**
- * @param {?} dbConfig
- * @param {?=} dbSchema
- * @return {?}
- */
-function provideDbWrapper(dbConfig, dbSchema) {
-    /** @type {?} */
-    const config = !!dbConfig ? dbConfig : getDefaultDbConfig();
-    return new DbWrapperService(config, dbSchema);
+class DbWrapperService {
+    constructor(dbConfig, dbSchema) {
+        this._dbName = dbConfig.dbName;
+        this._location = dbConfig.location || 'default';
+        this._iosDatabaseLocation = dbConfig.iosDatabaseLocation || 'Library';
+        this._androidDatabaseProvider = dbConfig.androidDatabaseProvider || 'default';
+        const window = (new WindowService()).nativeWindow;
+        if (dbSchema) {
+            this.schema = dbSchema;
+        }
+        this._readyPromise = new Promise((resolve, reject) => {
+            if (typeof window.cordova === 'undefined') {
+                setTimeout(() => {
+                    this.init(dbSchema).then(() => {
+                        resolve();
+                    })
+                        .catch((err) => {
+                        reject(err);
+                    });
+                }, 500);
+            }
+            else {
+                document.addEventListener('deviceready', () => {
+                    console.log('dbWrapper: device ready.');
+                    this.initDevice(dbSchema).then(() => resolve()).catch((err) => reject(err));
+                });
+            }
+        });
+    }
+    ready() {
+        return this._readyPromise;
+    }
+    initDevice(dbSchema) {
+        const window = (new WindowService()).nativeWindow;
+        return new Promise((resolve, reject) => {
+            this.db = window.sqlitePlugin.openDatabase({
+                name: this._dbName,
+                location: this._location,
+                androidLockWorkaround: 1,
+                androidDatabaseProvider: this._androidDatabaseProvider,
+            });
+            if (dbSchema) {
+                this.generate(dbSchema).catch(err => {
+                    reject(err);
+                }).then(() => { resolve(); });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    init(dbSchema) {
+        const window = (new WindowService()).nativeWindow;
+        return new Promise((resolve, reject) => {
+            this.db = window.openDatabase(this._dbName, '1.0', 'database', -1);
+            if (dbSchema) {
+                this.generate(dbSchema).catch(err => {
+                    reject(err);
+                }).then(() => {
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    generate(schema) {
+        const sentences = [];
+        this.schema = schema;
+        if (schema.tables) {
+            schema.tables.forEach(table => {
+                sentences.push(this.createTable(table));
+            });
+        }
+        if (schema.views) {
+            schema.views.forEach(view => {
+                sentences.push(this.createView(view));
+            });
+        }
+        if (sentences.length === 0) {
+            throw new Error('Esquema de la base de datos vacia.');
+        }
+        return Promise.all(sentences);
+    }
+    createTable(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sql = '', onConflictPrimary;
+            const sentences = [], newColumns = [];
+            const tableDDL = yield this._tableExists(table.name);
+            if (tableDDL) {
+                table.columns.forEach(col => {
+                    if (!this._columnExists(tableDDL, col.name)) {
+                        newColumns.push(this.addColumn(table.name, col));
+                    }
+                });
+            }
+            else {
+                table.columns.forEach(col => {
+                    sentences.push(this.defColumn(col));
+                });
+            }
+            onConflictPrimary = 'on conflict fail';
+            if (Array.isArray(table.primary)) {
+                sentences.push(' CONSTRAINT identificador PRIMARY KEY (' + table.primary.join(',') + ') ' + onConflictPrimary);
+            }
+            if (typeof table.primary === 'string') {
+                sentences.push(' CONSTRAINT identificador PRIMARY KEY (' + table.primary + ') ' + onConflictPrimary);
+            }
+            if (table.uniques) {
+                table.uniques.forEach(uniq => {
+                    sentences.push(this.defUnique(uniq));
+                });
+            }
+            if (table.foreigns) {
+                table.foreigns.forEach(fore => {
+                    sentences.push(this.defForeign(fore));
+                });
+            }
+            if (tableDDL && newColumns.length !== 0) {
+                return Promise.all(newColumns)
+                    .then(() => { console.log(`Table ${table.name} altered.`); })
+                    .catch((err) => {
+                    console.error(`Table ${table.name}: ${err.message}`);
+                    throw new Error(`Table ${table.name}: ${err.message}`);
+                });
+            }
+            else if (!tableDDL) {
+                sql = 'CREATE TABLE IF NOT EXISTS ' + table.name + ' (' + sentences.join(',') + ')';
+                return this.query(sql)
+                    .then(() => { console.log(`Table ${table.name} created.`); })
+                    .catch((err) => {
+                    console.error(`Table ${table.name}: ${err.message}`);
+                    throw new Error(`Table ${table.name}: ${err.message}`);
+                });
+            }
+            else {
+                return Promise.resolve().then(() => { console.log(`Table ${table.name} initialized.`); });
+            }
+        });
+    }
+    createView(view) {
+        let sql;
+        sql = 'CREATE VIEW IF NOT EXISTS ' + view.name
+            + ' AS ' + view.sql;
+        return this.query(sql);
+    }
+    getSchemaTable(tableName) {
+        let res;
+        this.schema.tables.forEach(table => {
+            if (table.name === tableName) {
+                res = table;
+            }
+        });
+        return res;
+    }
+    getUniquesTable(table) {
+        let res;
+        table.uniques.forEach(uniq => {
+            res[uniq.name] = uniq;
+        });
+        return res;
+    }
+    query(query, bindings = []) {
+        return new Promise((resolve, reject) => {
+            if (query.indexOf('select') === 0) {
+                this.db.readTransaction((transaction) => {
+                    transaction.executeSql(query, bindings, (transaction, result) => {
+                        resolve(result);
+                    }, (transaction, error) => {
+                        reject(error);
+                    });
+                }, (err) => reject(err));
+            }
+            else {
+                this.db.transaction((transaction) => {
+                    transaction.executeSql(query, bindings, (transaction, result) => {
+                        resolve(result);
+                    }, (transaction, error) => {
+                        reject(error);
+                    });
+                }, (err) => reject(err));
+            }
+        });
+    }
+    Count(query, bindings = []) {
+        return this.query(query, bindings).then(rows => {
+            return this.rowsCount(rows);
+        });
+    }
+    insert(table, bindings) {
+        let sql = '', sqlBinds = [], sqlKeys = [], sqlValues = [];
+        sql = sql + 'insert into ' + table + ' ';
+        for (const index in bindings) {
+            if (bindings.hasOwnProperty(index)) {
+                sqlKeys.push(index);
+                sqlValues.push(bindings[index]);
+                sqlBinds.push('?');
+            }
+        }
+        sql = sql + '(' + sqlKeys.join(',') + ') values (' + sqlBinds.join(',') + ')';
+        return new Promise((resolve, reject) => {
+            this.db.transaction(transaction => {
+                transaction.executeSql(sql, sqlValues, (transaction, result) => {
+                    resolve(result);
+                }, (transaction, error) => {
+                    reject(error);
+                });
+            });
+        });
+    }
+    update(table, bindings, where) {
+        let sql = '', sqlBinds = [], sqlKeys = [], sqlValues = [];
+        sql = sql + 'update ' + table + ' set ';
+        for (let index in bindings) {
+            if (bindings.hasOwnProperty(index)) {
+                let newObj = bindings[index];
+                if (typeof newObj === 'object' && newObj !== null) {
+                    sqlValues.push(newObj.value);
+                    if (newObj.ifnull) {
+                        sqlBinds.push(index + ' = ifnull( ' + index + ',0) + ?');
+                    }
+                    else if (newObj.operator) {
+                        sqlBinds.push(index + ' = ' + index + newObj.operator + ' ?');
+                    }
+                    else {
+                        sqlBinds.push(index + ' = ?');
+                    }
+                }
+                else {
+                    sqlBinds.push(index + ' = ?');
+                    sqlValues.push(bindings[index]);
+                }
+            }
+        }
+        for (let index in where) {
+            if (where.hasOwnProperty(index)) {
+                if (typeof where[index] === 'object' && where[index] !== null) {
+                    sqlKeys.push(index + ' ' + where[index].operator + ' ?');
+                    sqlValues.push(where[index].value);
+                }
+                else {
+                    sqlKeys.push(index + ' = ?');
+                    sqlValues.push(where[index]);
+                }
+            }
+        }
+        sql = sql + sqlBinds.join(',') + ' where ' + sqlKeys.join(' and ');
+        return new Promise((resolve, reject) => {
+            this.db.transaction(transaction => {
+                transaction.executeSql(sql, sqlValues, (transaction, result) => {
+                    resolve(result);
+                }, (transaction, error) => {
+                    reject(error);
+                });
+            });
+        });
+    }
+    dropTable(tables) {
+        let cont = 1;
+        cont = tables.length;
+        return new Promise((resolve, reject) => {
+            tables.some(table => {
+                if (cont !== 0) {
+                    this.query('DROP TABLE ' + table)
+                        .then(() => {
+                        if (cont === 1) {
+                            resolve();
+                        }
+                        else {
+                            cont--;
+                        }
+                    }, err => {
+                        cont = 0;
+                        reject(err);
+                        return true;
+                    });
+                    return false;
+                }
+            });
+        });
+    }
+    fetchAll(result) {
+        let output = [];
+        for (let i = 0; i < result.rows.length; i++) {
+            output.push(result.rows.item(i));
+        }
+        return output;
+    }
+    fetch(result) {
+        let objeto = undefined, newObj = undefined;
+        if (result.rows.length !== 0) {
+            objeto = result.rows.item(0);
+            newObj = {};
+            const keys = Object.keys(objeto);
+            for (let key in keys) {
+                newObj[keys[key]] = objeto[keys[key]];
+            }
+        }
+        return newObj;
+    }
+    rowsCount(result) {
+        return result.rows.length;
+    }
+    tableExists(table) {
+        return this.query('select  sql from sqlite_master ' +
+            'where type=\'table\' and name=\'' + table + '\'')
+            .then(result => (this.rowsCount(result) === 1));
+    }
+    columnExists(table, column) {
+        return this._tableExists(table)
+            .then((tableDDL) => {
+            if (tableDDL) {
+                return this._columnExists(tableDDL, column);
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    /* Private */
+    defColumn(col) {
+        let colSql;
+        colSql = col.name + ' ' + col.type;
+        if (!col.isNullable) {
+            colSql += ' NOT NULL ';
+        }
+        if (col.default) {
+            colSql += ' DEFAULT ' + col.default + ' ';
+        }
+        if (col.type === 'text' && col.length) {
+            colSql += ` CONSTRAINT ${col.name}_length CHECK ( `;
+            if (col.isNullable) {
+                colSql += `${col.name} is null OR `;
+            }
+            colSql += `length(${col.name}) <= ${col.length} )`;
+        }
+        return colSql;
+    }
+    defUnique(unique) {
+        let uniqSql;
+        // depende del entorno, producción o desarrollo
+        const onConflictUnique = 'on conflict replace';
+        if (Array.isArray(unique.fields)) {
+            uniqSql = ` CONSTRAINT ${unique.name} UNIQUE ( ${unique.fields.join(',')} ) ${onConflictUnique} `;
+        }
+        if (typeof unique.fields === 'string') {
+            uniqSql = ` CONSTRAINT ${unique.name} UNIQUE ( ${unique.fields} ) ${onConflictUnique} `;
+        }
+        return uniqSql;
+    }
+    defForeign(fore) {
+        let foreSql;
+        if (Array.isArray(fore.foreignKey)) {
+            foreSql = ` FOREIGN KEY (  ${fore.foreignKey.join(',')} ) `;
+        }
+        if (typeof fore.foreignKey === 'string') {
+            foreSql = ` FOREIGN KEY (  ${fore.foreignKey} ) `;
+        }
+        if (Array.isArray(fore.primaryKey)) {
+            foreSql = ` REFERENCES ${fore.referenceTable} (  ${fore.primaryKey.join(',')} ) `;
+        }
+        if (typeof fore.primaryKey === 'string') {
+            foreSql = ` REFERENCES ${fore.referenceTable} (  ${fore.primaryKey} ) `;
+        }
+        return foreSql;
+    }
+    _tableExists(table) {
+        return this.query('select  sql from sqlite_master ' +
+            'where type=\'table\' and name=\'' + table + '\'')
+            .then(result => {
+            if (this.rowsCount(result) === 1) {
+                return this.fetch(result).sql;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    _columnExists(tableDDL, column) {
+        if (tableDDL.indexOf(column) === -1) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    addColumn(table, col) {
+        const colSql = this.defColumn(col);
+        const query = 'alter TABLE ' + table + ' add COLUMN ' + colSql;
+        return this.query(query);
+    }
+}
+const DB_CONFIG = new InjectionToken('dbWrapperConfig');
+const DB_SCHEMA = new InjectionToken('dbWrapperSchema');
+function getDefaultDbConfig() {
+    return {
+        dbName: 'db.sqlite',
+        location: 'default',
+        iosDatabaseLocation: 'Library'
+    };
+}
+function provideDbWrapper(dbConfig, dbSchema) {
+    const config = !!dbConfig ? dbConfig : getDefaultDbConfig();
+    return new DbWrapperService(config, dbSchema);
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class DbWrapperModule {
-    /**
-     * @param {?} dbConfig
-     * @param {?=} schema
-     * @return {?}
-     */
-    static forRoot(dbConfig, schema) {
-        return {
-            ngModule: DbWrapperModule,
-            providers: [
-                { provide: DB_CONFIG, useValue: dbConfig },
-                { provide: DB_SCHEMA, useValue: schema },
-                { provide: DbWrapperService, useFactory: provideDbWrapper, deps: [DB_CONFIG, DB_SCHEMA] }
-            ]
-        };
-    }
-}
-DbWrapperModule.decorators = [
-    { type: NgModule }
-];
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {string} */
-const DataType = {
-    Integer: 'integer',
-    Int: 'integer',
-    TinyInt: 'integer',
-    SmallInt: 'integer',
-    BigInt: 'integer',
-    Text: 'text',
-    Char: 'text',
-    NChar: 'text',
-    VarChar: 'text',
-    NVarChar: 'text',
-    CLOB: 'text',
-    BLOB: 'blob',
-    Real: 'real',
-    Double: 'real',
-    Decimal: 'real',
-    Float: 'real',
-    Boolean: 'integer',
-    DateTime: 'text',
-    Date: 'text',
-};
-/** @enum {string} */
-const DefaultType = {
-    Integer: '0',
-    Int: '0',
-    TinyInt: '0',
-    SmallInt: '0',
-    BigInt: '0',
-    Text: '\'\'',
-    Char: '\'\'',
-    NChar: '\'\'',
-    VarChar: '\'\'',
-    NVarChar: '\'\'',
-    CLOB: '\'\'',
-    BLOB: '0',
-    Real: '0.0',
-    Double: '0.0',
-    Decimal: '0.0',
-    Float: '0.0',
-    Boolean: '0',
-    DateTime: '(datetime(\'now\', \'localtime\'))',
-    Date: '(date(\'now\', \'localtime\'))',
+var DbWrapperModule_1;
+let DbWrapperModule = DbWrapperModule_1 = class DbWrapperModule {
+    static forRoot(dbConfig, schema) {
+        return {
+            ngModule: DbWrapperModule_1,
+            providers: [
+                { provide: DB_CONFIG, useValue: dbConfig },
+                { provide: DB_SCHEMA, useValue: schema },
+                { provide: DbWrapperService, useFactory: provideDbWrapper, deps: [DB_CONFIG, DB_SCHEMA] }
+            ]
+        };
+    }
 };
+DbWrapperModule = DbWrapperModule_1 = __decorate([
+    NgModule()
+], DbWrapperModule);
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+var DataType;
+(function (DataType) {
+    DataType["Integer"] = "integer";
+    DataType["Int"] = "integer";
+    DataType["TinyInt"] = "integer";
+    DataType["SmallInt"] = "integer";
+    DataType["BigInt"] = "integer";
+    DataType["Text"] = "text";
+    DataType["Char"] = "text";
+    DataType["NChar"] = "text";
+    DataType["VarChar"] = "text";
+    DataType["NVarChar"] = "text";
+    DataType["CLOB"] = "text";
+    DataType["BLOB"] = "blob";
+    DataType["Real"] = "real";
+    DataType["Double"] = "real";
+    DataType["Decimal"] = "real";
+    DataType["Float"] = "real";
+    DataType["Boolean"] = "integer";
+    DataType["DateTime"] = "text";
+    DataType["Date"] = "text";
+})(DataType || (DataType = {}));
+var DefaultType;
+(function (DefaultType) {
+    DefaultType["Integer"] = "0";
+    DefaultType["Int"] = "0";
+    DefaultType["TinyInt"] = "0";
+    DefaultType["SmallInt"] = "0";
+    DefaultType["BigInt"] = "0";
+    DefaultType["Text"] = "''";
+    DefaultType["Char"] = "''";
+    DefaultType["NChar"] = "''";
+    DefaultType["VarChar"] = "''";
+    DefaultType["NVarChar"] = "''";
+    DefaultType["CLOB"] = "''";
+    DefaultType["BLOB"] = "0";
+    DefaultType["Real"] = "0.0";
+    DefaultType["Double"] = "0.0";
+    DefaultType["Decimal"] = "0.0";
+    DefaultType["Float"] = "0.0";
+    DefaultType["Boolean"] = "0";
+    DefaultType["DateTime"] = "(datetime('now', 'localtime'))";
+    DefaultType["Date"] = "(date('now', 'localtime'))";
+})(DefaultType || (DefaultType = {}));
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+/*
+ * Public API Surface of db-wrapper
  */
 
-export { getDefaultDbConfig, provideDbWrapper, DbWrapperService, DB_CONFIG, DB_SCHEMA, DbWrapperModule, DataType, DefaultType };
+/**
+ * Generated bundle index. Do not edit.
+ */
 
-//# sourceMappingURL=db-wrapper.js.map
+export { DB_CONFIG, DB_SCHEMA, DataType, DbWrapperModule, DbWrapperService, DefaultType, getDefaultDbConfig, provideDbWrapper };
+//# sourceMappingURL=db-wrapper.js.map