db-wrapper 0.0.5 → 0.0.8

package/fesm5/db-wrapper.js

@@ -1,434 +1,235 @@
+import { __decorate, __awaiter, __generator } from 'tslib';
 import { Injectable, InjectionToken, NgModule } from '@angular/core';
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 var WindowService = /** @class */ (function () {
     function WindowService() {
     }
     Object.defineProperty(WindowService.prototype, "nativeWindow", {
-        get: /**
-         * @return {?}
-         */
-        function () {
+        get: function () {
             return _window();
         },
         enumerable: true,
         configurable: true
     });
-    WindowService.decorators = [
-        { type: Injectable }
-    ];
+    WindowService = __decorate([
+        Injectable()
+    ], WindowService);
     return WindowService;
 }());
-/**
- * @return {?}
- */
 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
- */
 var DbWrapperService = /** @class */ (function () {
     function DbWrapperService(dbConfig, dbSchema) {
         var _this = this;
         this._dbName = dbConfig.dbName;
         this._location = dbConfig.location || 'default';
         this._iosDatabaseLocation = dbConfig.iosDatabaseLocation || 'Library';
-        /** @type {?} */
         var window = (new WindowService()).nativeWindow;
         if (dbSchema) {
             this.schema = dbSchema;
         }
-        this._readyPromise = new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
+        this._readyPromise = new Promise(function (resolve, reject) {
             if (typeof window.cordova === 'undefined') {
-                setTimeout((/**
-                 * @return {?}
-                 */
-                function () {
-                    _this.init(dbSchema).then((/**
-                     * @return {?}
-                     */
-                    function () { return resolve(); })).catch((/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    function (err) { return reject(err); }));
-                }), 500);
+                setTimeout(function () {
+                    _this.init(dbSchema).then(function () {
+                        resolve();
+                    })
+                        .catch(function (err) {
+                        reject(err);
+                    });
+                }, 500);
             }
             else {
-                document.addEventListener('deviceready', (/**
-                 * @return {?}
-                 */
-                function () {
+                document.addEventListener('deviceready', function () {
                     console.log('dbWrapper: device ready.');
-                    _this.initDevice(dbSchema).then((/**
-                     * @return {?}
-                     */
-                    function () { return resolve(); })).catch((/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    function (err) { return reject(err); }));
-                }));
+                    _this.initDevice(dbSchema).then(function () { return resolve(); }).catch(function (err) { return reject(err); });
+                });
             }
-        }));
+        });
     }
-    /**
-     * @return {?}
-     */
-    DbWrapperService.prototype.ready = /**
-     * @return {?}
-     */
-    function () {
+    DbWrapperService.prototype.ready = function () {
         return this._readyPromise;
     };
-    /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
-    DbWrapperService.prototype.initDevice = /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
-    function (dbSchema) {
+    DbWrapperService.prototype.initDevice = function (dbSchema) {
         var _this = this;
-        /** @type {?} */
         var window = (new WindowService()).nativeWindow;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
+        return new Promise(function (resolve, reject) {
             _this.db = window.sqlitePlugin.openDatabase({
                 name: _this._dbName,
                 location: _this._location,
                 androidLockWorkaround: 1
             });
             if (dbSchema) {
-                _this.generate(dbSchema).catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                function (err) {
+                _this.generate(dbSchema).catch(function (err) {
                     reject(err);
-                })).then((/**
-                 * @return {?}
-                 */
-                function () { resolve(); }));
+                }).then(function () { resolve(); });
             }
             else {
                 resolve();
             }
-        }));
+        });
     };
-    /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
-    DbWrapperService.prototype.init = /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
-    function (dbSchema) {
+    DbWrapperService.prototype.init = function (dbSchema) {
         var _this = this;
-        /** @type {?} */
         var window = (new WindowService()).nativeWindow;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
+        return new Promise(function (resolve, reject) {
             _this.db = window.openDatabase(_this._dbName, '1.0', 'database', -1);
             if (dbSchema) {
-                _this.generate(dbSchema).catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                function (err) {
+                _this.generate(dbSchema).catch(function (err) {
                     reject(err);
-                })).then((/**
-                 * @return {?}
-                 */
-                function () { resolve(); }));
+                }).then(function () {
+                    resolve();
+                });
             }
             else {
                 resolve();
             }
-        }));
+        });
     };
-    /**
-     * @param {?} schema
-     * @return {?}
-     */
-    DbWrapperService.prototype.generate = /**
-     * @param {?} schema
-     * @return {?}
-     */
-    function (schema) {
+    DbWrapperService.prototype.generate = function (schema) {
         var _this = this;
-        /** @type {?} */
         var sentences = [];
         this.schema = schema;
         if (schema.tables) {
-            schema.tables.forEach((/**
-             * @param {?} table
-             * @return {?}
-             */
-            function (table) {
+            schema.tables.forEach(function (table) {
                 sentences.push(_this.createTable(table));
-            }));
+            });
         }
         if (schema.views) {
-            schema.views.forEach((/**
-             * @param {?} view
-             * @return {?}
-             */
-            function (view) {
+            schema.views.forEach(function (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 {?}
-     */
-    DbWrapperService.prototype.createTable = /**
-     * @param {?} table
-     * @return {?}
-     */
-    function (table) {
-        var _this = this;
-        /** @type {?} */
-        var sql = '';
-        /** @type {?} */
-        var sentences = [];
-        /** @type {?} */
-        var onConflictPrimary;
-        table.columns.forEach((/**
-         * @param {?} col
-         * @return {?}
-         */
-        function (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 {?}
-             */
-            function (uniq) {
-                sentences.push(_this.defUnique(uniq));
-            }));
-        }
-        if (table.foreigns) {
-            table.foreigns.forEach((/**
-             * @param {?} fore
-             * @return {?}
-             */
-            function (fore) {
-                sentences.push(_this.defForeign(fore));
-            }));
-        }
-        sql = 'CREATE TABLE IF NOT EXISTS ' + table.name + ' (' + sentences.join(',') + ')';
-        return this.query(sql);
+    DbWrapperService.prototype.createTable = function (table) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sql, onConflictPrimary, sentences, newColumns, tableDDL;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sql = '';
+                        sentences = [], newColumns = [];
+                        return [4 /*yield*/, this._tableExists(table.name)];
+                    case 1:
+                        tableDDL = _a.sent();
+                        if (tableDDL) {
+                            table.columns.forEach(function (col) {
+                                if (!_this._columnExists(tableDDL, col.name)) {
+                                    newColumns.push(_this.addColumn(table.name, col));
+                                }
+                            });
+                        }
+                        else {
+                            table.columns.forEach(function (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(function (uniq) {
+                                sentences.push(_this.defUnique(uniq));
+                            });
+                        }
+                        if (table.foreigns) {
+                            table.foreigns.forEach(function (fore) {
+                                sentences.push(_this.defForeign(fore));
+                            });
+                        }
+                        if (tableDDL && newColumns.length !== 0) {
+                            return [2 /*return*/, Promise.all(newColumns)
+                                    .then(function () { console.log("Table " + table.name + " altered."); })
+                                    .catch(function (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 [2 /*return*/, this.query(sql)
+                                    .then(function () { console.log("Table " + table.name + " created."); })
+                                    .catch(function (err) {
+                                    console.error("Table " + table.name + ": " + err.message);
+                                    throw new Error("Table " + table.name + ": " + err.message);
+                                })];
+                        }
+                        else {
+                            return [2 /*return*/, Promise.resolve().then(function () { console.log("Table " + table.name + " initialized."); })];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
-    /**
-     * @param {?} view
-     * @return {?}
-     */
-    DbWrapperService.prototype.createView = /**
-     * @param {?} view
-     * @return {?}
-     */
-    function (view) {
-        /** @type {?} */
+    DbWrapperService.prototype.createView = function (view) {
         var sql;
         sql = 'CREATE VIEW IF NOT EXISTS ' + view.name
             + ' AS ' + view.sql;
         return this.query(sql);
     };
-    /**
-     * @param {?} tableName
-     * @return {?}
-     */
-    DbWrapperService.prototype.getSchemaTable = /**
-     * @param {?} tableName
-     * @return {?}
-     */
-    function (tableName) {
-        /** @type {?} */
+    DbWrapperService.prototype.getSchemaTable = function (tableName) {
         var res;
-        this.schema.tables.forEach((/**
-         * @param {?} table
-         * @return {?}
-         */
-        function (table) {
+        this.schema.tables.forEach(function (table) {
             if (table.name === tableName) {
                 res = table;
             }
-        }));
+        });
         return res;
     };
-    /**
-     * @param {?} table
-     * @return {?}
-     */
-    DbWrapperService.prototype.getUniquesTable = /**
-     * @param {?} table
-     * @return {?}
-     */
-    function (table) {
-        /** @type {?} */
+    DbWrapperService.prototype.getUniquesTable = function (table) {
         var res;
-        table.uniques.forEach((/**
-         * @param {?} uniq
-         * @return {?}
-         */
-        function (uniq) {
+        table.uniques.forEach(function (uniq) {
             res[uniq.name] = uniq;
-        }));
+        });
         return res;
     };
-    /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
-    DbWrapperService.prototype.query = /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
-    function (query, bindings) {
+    DbWrapperService.prototype.query = function (query, bindings) {
         var _this = this;
         if (bindings === void 0) { bindings = []; }
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
+        return new Promise(function (resolve, reject) {
             if (query.indexOf('select') === 0) {
-                _this.db.readTransaction((/**
-                 * @param {?} transaction
-                 * @return {?}
-                 */
-                function (transaction) {
-                    transaction.executeSql(query, bindings, (/**
-                     * @param {?} transaction
-                     * @param {?} result
-                     * @return {?}
-                     */
-                    function (transaction, result) {
+                _this.db.readTransaction(function (transaction) {
+                    transaction.executeSql(query, bindings, function (transaction, result) {
                         resolve(result);
-                    }), (/**
-                     * @param {?} transaction
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    function (transaction, error) {
+                    }, function (transaction, error) {
                         reject(error);
-                    }));
-                }), (/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                function (err) { return reject(err); }));
+                    });
+                }, function (err) { return reject(err); });
             }
             else {
-                _this.db.transaction((/**
-                 * @param {?} transaction
-                 * @return {?}
-                 */
-                function (transaction) {
-                    transaction.executeSql(query, bindings, (/**
-                     * @param {?} transaction
-                     * @param {?} result
-                     * @return {?}
-                     */
-                    function (transaction, result) {
+                _this.db.transaction(function (transaction) {
+                    transaction.executeSql(query, bindings, function (transaction, result) {
                         resolve(result);
-                    }), (/**
-                     * @param {?} transaction
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    function (transaction, error) {
+                    }, function (transaction, error) {
                         reject(error);
-                    }));
-                }), (/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                function (err) { return reject(err); }));
+                    });
+                }, function (err) { return reject(err); });
             }
-        }));
+        });
     };
-    /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
-    DbWrapperService.prototype.Count = /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
-    function (query, bindings) {
+    DbWrapperService.prototype.Count = function (query, bindings) {
         var _this = this;
         if (bindings === void 0) { bindings = []; }
-        return this.query(query, bindings).then((/**
-         * @param {?} rows
-         * @return {?}
-         */
-        function (rows) {
+        return this.query(query, bindings).then(function (rows) {
             return _this.rowsCount(rows);
-        }));
+        });
     };
-    /**
-     * @param {?} table
-     * @param {?} bindings
-     * @return {?}
-     */
-    DbWrapperService.prototype.insert = /**
-     * @param {?} table
-     * @param {?} bindings
-     * @return {?}
-     */
-    function (table, bindings) {
+    DbWrapperService.prototype.insert = function (table, bindings) {
         var _this = this;
-        /** @type {?} */
-        var sql = '';
-        /** @type {?} */
-        var sqlBinds = [];
-        /** @type {?} */
-        var sqlKeys = [];
-        /** @type {?} */
-        var sqlValues = [];
+        var sql = '', sqlBinds = [], sqlKeys = [], sqlValues = [];
         sql = sql + 'insert into ' + table + ' ';
         for (var index in bindings) {
             if (bindings.hasOwnProperty(index)) {
@@ -438,61 +239,22 @@ var DbWrapperService = /** @class */ (function () {
             }
         }
         sql = sql + '(' + sqlKeys.join(',') + ') values (' + sqlBinds.join(',') + ')';
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
-            _this.db.transaction((/**
-             * @param {?} transaction
-             * @return {?}
-             */
-            function (transaction) {
-                transaction.executeSql(sql, sqlValues, (/**
-                 * @param {?} transaction
-                 * @param {?} result
-                 * @return {?}
-                 */
-                function (transaction, result) {
+        return new Promise(function (resolve, reject) {
+            _this.db.transaction(function (transaction) {
+                transaction.executeSql(sql, sqlValues, function (transaction, result) {
                     resolve(result);
-                }), (/**
-                 * @param {?} transaction
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (transaction, error) {
+                }, function (transaction, error) {
                     reject(error);
-                }));
-            }));
-        }));
+                });
+            });
+        });
     };
-    /**
-     * @param {?} table
-     * @param {?} bindings
-     * @param {?} where
-     * @return {?}
-     */
-    DbWrapperService.prototype.update = /**
-     * @param {?} table
-     * @param {?} bindings
-     * @param {?} where
-     * @return {?}
-     */
-    function (table, bindings, where) {
+    DbWrapperService.prototype.update = function (table, bindings, where) {
         var _this = this;
-        /** @type {?} */
-        var sql = '';
-        /** @type {?} */
-        var sqlBinds = [];
-        /** @type {?} */
-        var sqlKeys = [];
-        /** @type {?} */
-        var sqlValues = [];
+        var sql = '', sqlBinds = [], sqlKeys = [], sqlValues = [];
         sql = sql + 'update ' + table + ' set ';
         for (var index in bindings) {
             if (bindings.hasOwnProperty(index)) {
-                /** @type {?} */
                 var newObj = bindings[index];
                 if (typeof newObj === 'object' && newObj !== null) {
                     sqlValues.push(newObj.value);
@@ -525,118 +287,53 @@ var DbWrapperService = /** @class */ (function () {
             }
         }
         sql = sql + sqlBinds.join(',') + ' where ' + sqlKeys.join(' and ');
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
-            _this.db.transaction((/**
-             * @param {?} transaction
-             * @return {?}
-             */
-            function (transaction) {
-                transaction.executeSql(sql, sqlValues, (/**
-                 * @param {?} transaction
-                 * @param {?} result
-                 * @return {?}
-                 */
-                function (transaction, result) {
+        return new Promise(function (resolve, reject) {
+            _this.db.transaction(function (transaction) {
+                transaction.executeSql(sql, sqlValues, function (transaction, result) {
                     resolve(result);
-                }), (/**
-                 * @param {?} transaction
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (transaction, error) {
+                }, function (transaction, error) {
                     reject(error);
-                }));
-            }));
-        }));
+                });
+            });
+        });
     };
-    /**
-     * @param {?} tables
-     * @return {?}
-     */
-    DbWrapperService.prototype.dropTable = /**
-     * @param {?} tables
-     * @return {?}
-     */
-    function (tables) {
+    DbWrapperService.prototype.dropTable = function (tables) {
         var _this = this;
-        /** @type {?} */
         var cont = 1;
         cont = tables.length;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        function (resolve, reject) {
-            tables.some((/**
-             * @param {?} table
-             * @return {?}
-             */
-            function (table) {
+        return new Promise(function (resolve, reject) {
+            tables.some(function (table) {
                 if (cont !== 0) {
                     _this.query('DROP TABLE ' + table)
-                        .then((/**
-                     * @return {?}
-                     */
-                    function () {
+                        .then(function () {
                         if (cont === 1) {
                             resolve();
                         }
                         else {
                             cont--;
                         }
-                    }), (/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    function (err) {
+                    }, function (err) {
                         cont = 0;
                         reject(err);
                         return true;
-                    }));
+                    });
                     return false;
                 }
-            }));
-        }));
+            });
+        });
     };
-    /**
-     * @param {?} result
-     * @return {?}
-     */
-    DbWrapperService.prototype.fetchAll = /**
-     * @param {?} result
-     * @return {?}
-     */
-    function (result) {
-        /** @type {?} */
+    DbWrapperService.prototype.fetchAll = function (result) {
         var output = [];
         for (var i = 0; i < result.rows.length; i++) {
             output.push(result.rows.item(i));
         }
         return output;
     };
-    /**
-     * @param {?} result
-     * @return {?}
-     */
-    DbWrapperService.prototype.fetch = /**
-     * @param {?} result
-     * @return {?}
-     */
-    function (result) {
-        /** @type {?} */
-        var objeto = undefined;
-        /** @type {?} */
-        var newObj = undefined;
+    DbWrapperService.prototype.fetch = function (result) {
+        var objeto = undefined, newObj = undefined;
         if (result.rows.length !== 0) {
             objeto = result.rows.item(0);
             newObj = {};
-            /** @type {?} */
             var keys = Object.keys(objeto);
             for (var key in keys) {
                 newObj[keys[key]] = objeto[keys[key]];
@@ -644,32 +341,29 @@ var DbWrapperService = /** @class */ (function () {
         }
         return newObj;
     };
-    /**
-     * @param {?} result
-     * @return {?}
-     */
-    DbWrapperService.prototype.rowsCount = /**
-     * @param {?} result
-     * @return {?}
-     */
-    function (result) {
+    DbWrapperService.prototype.rowsCount = function (result) {
         return result.rows.length;
     };
+    DbWrapperService.prototype.tableExists = function (table) {
+        var _this = this;
+        return this.query('select  sql from sqlite_master ' +
+            'where type=\'table\' and name=\'' + table + '\'')
+            .then(function (result) { return (_this.rowsCount(result) === 1); });
+    };
+    DbWrapperService.prototype.columnExists = function (table, column) {
+        var _this = this;
+        return this._tableExists(table)
+            .then(function (tableDDL) {
+            if (tableDDL) {
+                return _this._columnExists(tableDDL, column);
+            }
+            else {
+                return false;
+            }
+        });
+    };
     /* Private */
-    /* Private */
-    /**
-     * @private
-     * @param {?} col
-     * @return {?}
-     */
-    DbWrapperService.prototype.defColumn = /* Private */
-    /**
-     * @private
-     * @param {?} col
-     * @return {?}
-     */
-    function (col) {
-        /** @type {?} */
+    DbWrapperService.prototype.defColumn = function (col) {
         var colSql;
         colSql = col.name + ' ' + col.type;
         if (!col.isNullable) {
@@ -687,21 +381,9 @@ var DbWrapperService = /** @class */ (function () {
         }
         return colSql;
     };
-    /**
-     * @private
-     * @param {?} unique
-     * @return {?}
-     */
-    DbWrapperService.prototype.defUnique = /**
-     * @private
-     * @param {?} unique
-     * @return {?}
-     */
-    function (unique) {
-        /** @type {?} */
+    DbWrapperService.prototype.defUnique = function (unique) {
         var uniqSql;
         // depende del entorno, producción o desarrollo
-        /** @type {?} */
         var onConflictUnique = 'on conflict replace';
         if (Array.isArray(unique.fields)) {
             uniqSql = " CONSTRAINT " + unique.name + " UNIQUE ( " + unique.fields.join(',') + " ) " + onConflictUnique + " ";
@@ -711,18 +393,7 @@ var DbWrapperService = /** @class */ (function () {
         }
         return uniqSql;
     };
-    /**
-     * @private
-     * @param {?} fore
-     * @return {?}
-     */
-    DbWrapperService.prototype.defForeign = /**
-     * @private
-     * @param {?} fore
-     * @return {?}
-     */
-    function (fore) {
-        /** @type {?} */
+    DbWrapperService.prototype.defForeign = function (fore) {
         var foreSql;
         if (Array.isArray(fore.foreignKey)) {
             foreSql = " FOREIGN KEY (  " + fore.foreignKey.join(',') + " ) ";
@@ -738,15 +409,36 @@ var DbWrapperService = /** @class */ (function () {
         }
         return foreSql;
     };
+    DbWrapperService.prototype._tableExists = function (table) {
+        var _this = this;
+        return this.query('select  sql from sqlite_master ' +
+            'where type=\'table\' and name=\'' + table + '\'')
+            .then(function (result) {
+            if (_this.rowsCount(result) === 1) {
+                return _this.fetch(result).sql;
+            }
+            else {
+                return false;
+            }
+        });
+    };
+    DbWrapperService.prototype._columnExists = function (tableDDL, column) {
+        if (tableDDL.indexOf(column) === -1) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    };
+    DbWrapperService.prototype.addColumn = function (table, col) {
+        var colSql = this.defColumn(col);
+        var query = 'alter TABLE ' + table + ' add COLUMN ' + colSql;
+        return this.query(query);
+    };
     return DbWrapperService;
 }());
-/** @type {?} */
 var DB_CONFIG = new InjectionToken('dbWrapperConfig');
-/** @type {?} */
 var DB_SCHEMA = new InjectionToken('dbWrapperSchema');
-/**
- * @return {?}
- */
 function getDefaultDbConfig() {
     return {
         dbName: 'db.sqlite',
@@ -754,37 +446,18 @@ function getDefaultDbConfig() {
         iosDatabaseLocation: 'Library'
     };
 }
-/**
- * @param {?} dbConfig
- * @param {?=} dbSchema
- * @return {?}
- */
 function provideDbWrapper(dbConfig, dbSchema) {
-    /** @type {?} */
     var config = !!dbConfig ? dbConfig : getDefaultDbConfig();
     return new DbWrapperService(config, dbSchema);
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 var DbWrapperModule = /** @class */ (function () {
     function DbWrapperModule() {
     }
-    /**
-     * @param {?} dbConfig
-     * @param {?=} schema
-     * @return {?}
-     */
-    DbWrapperModule.forRoot = /**
-     * @param {?} dbConfig
-     * @param {?=} schema
-     * @return {?}
-     */
-    function (dbConfig, schema) {
+    DbWrapperModule_1 = DbWrapperModule;
+    DbWrapperModule.forRoot = function (dbConfig, schema) {
         return {
-            ngModule: DbWrapperModule,
+            ngModule: DbWrapperModule_1,
             providers: [
                 { provide: DB_CONFIG, useValue: dbConfig },
                 { provide: DB_SCHEMA, useValue: schema },
@@ -792,71 +465,65 @@ var DbWrapperModule = /** @class */ (function () {
             ]
         };
     };
-    DbWrapperModule.decorators = [
-        { type: NgModule }
-    ];
+    var DbWrapperModule_1;
+    DbWrapperModule = DbWrapperModule_1 = __decorate([
+        NgModule()
+    ], DbWrapperModule);
     return DbWrapperModule;
 }());
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {string} */
-var 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} */
-var 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 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
  */
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
-export { getDefaultDbConfig, provideDbWrapper, DbWrapperService, DB_CONFIG, DB_SCHEMA, DbWrapperModule, DataType, DefaultType };
-
-//# sourceMappingURL=db-wrapper.js.map
+export { DB_CONFIG, DB_SCHEMA, DataType, DbWrapperModule, DbWrapperService, DefaultType, getDefaultDbConfig, provideDbWrapper };
+//# sourceMappingURL=db-wrapper.js.map