db-wrapper 0.0.7 → 0.0.8

package/fesm2015/db-wrapper.js

@@ -1,231 +1,118 @@
-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 {?}
-     */
+let WindowService = class WindowService {
     get nativeWindow() {
         return _window();
     }
-}
-WindowService.decorators = [
-    { type: Injectable }
-];
-/**
- * @return {?}
- */
+};
+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) => {
+        this._readyPromise = new Promise((resolve, reject) => {
             if (typeof window.cordova === 'undefined') {
-                setTimeout((/**
-                 * @return {?}
-                 */
-                () => {
-                    this.init(dbSchema).then((/**
-                     * @return {?}
-                     */
-                    () => {
+                setTimeout(() => {
+                    this.init(dbSchema).then(() => {
                         resolve();
-                    }))
-                        .catch((/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    (err) => {
+                    })
+                        .catch((err) => {
                         reject(err);
-                    }));
-                }), 500);
+                    });
+                }, 500);
             }
             else {
-                document.addEventListener('deviceready', (/**
-                 * @return {?}
-                 */
-                () => {
+                document.addEventListener('deviceready', () => {
                     console.log('dbWrapper: device ready.');
-                    this.initDevice(dbSchema).then((/**
-                     * @return {?}
-                     */
-                    () => resolve())).catch((/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    (err) => reject(err)));
-                }));
+                    this.initDevice(dbSchema).then(() => resolve()).catch((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) => {
+        return new Promise((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 => {
+                this.generate(dbSchema).catch(err => {
                     reject(err);
-                })).then((/**
-                 * @return {?}
-                 */
-                () => { resolve(); }));
+                }).then(() => { resolve(); });
             }
             else {
                 resolve();
             }
-        }));
+        });
     }
-    /**
-     * @param {?} dbSchema
-     * @return {?}
-     */
     init(dbSchema) {
-        /** @type {?} */
         const window = (new WindowService()).nativeWindow;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
-         * @return {?}
-         */
-        (resolve, reject) => {
+        return new Promise((resolve, reject) => {
             this.db = window.openDatabase(this._dbName, '1.0', 'database', -1);
             if (dbSchema) {
-                this.generate(dbSchema).catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                err => {
+                this.generate(dbSchema).catch(err => {
                     reject(err);
-                })).then((/**
-                 * @return {?}
-                 */
-                () => {
+                }).then(() => {
                     resolve();
-                }));
+                });
             }
             else {
                 resolve();
             }
-        }));
+        });
     }
-    /**
-     * @param {?} schema
-     * @return {?}
-     */
     generate(schema) {
-        /** @type {?} */
         const sentences = [];
         this.schema = schema;
         if (schema.tables) {
-            schema.tables.forEach((/**
-             * @param {?} table
-             * @return {?}
-             */
-            table => {
+            schema.tables.forEach(table => {
                 sentences.push(this.createTable(table));
-            }));
+            });
         }
         if (schema.views) {
-            schema.views.forEach((/**
-             * @param {?} view
-             * @return {?}
-             */
-            view => {
+            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);
     }
-    /**
-     * @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);
+            let sql = '', onConflictPrimary;
+            const sentences = [], newColumns = [];
+            const tableDDL = yield this._tableExists(table.name);
             if (tableDDL) {
-                table.columns.forEach((/**
-                 * @param {?} col
-                 * @return {?}
-                 */
-                col => {
-                    if (!this.columnExists((/** @type {?} */ (tableDDL)), col.name)) {
+                table.columns.forEach(col => {
+                    if (!this._columnExists(tableDDL, col.name)) {
                         newColumns.push(this.addColumn(table.name, col));
                     }
-                }));
+                });
             }
             else {
-                table.columns.forEach((/**
-                 * @param {?} col
-                 * @return {?}
-                 */
-                col => {
+                table.columns.forEach(col => {
                     sentences.push(this.defColumn(col));
-                }));
+                });
             }
             onConflictPrimary = 'on conflict fail';
             if (Array.isArray(table.primary)) {
@@ -235,203 +122,88 @@ class DbWrapperService {
                 sentences.push(' CONSTRAINT identificador PRIMARY KEY (' + table.primary + ') ' + onConflictPrimary);
             }
             if (table.uniques) {
-                table.uniques.forEach((/**
-                 * @param {?} uniq
-                 * @return {?}
-                 */
-                uniq => {
+                table.uniques.forEach(uniq => {
                     sentences.push(this.defUnique(uniq));
-                }));
+                });
             }
             if (table.foreigns) {
-                table.foreigns.forEach((/**
-                 * @param {?} fore
-                 * @return {?}
-                 */
-                fore => {
+                table.foreigns.forEach(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) => {
+                    .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((/**
-                 * @return {?}
-                 */
-                () => { console.log(`Table ${table.name} created.`); }))
-                    .catch((/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => {
+                    .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((/**
-                 * @return {?}
-                 */
-                () => { console.log(`Table ${table.name} initialized.`); }));
+                return Promise.resolve().then(() => { 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 => {
+        this.schema.tables.forEach(table => {
             if (table.name === tableName) {
                 res = table;
             }
-        }));
+        });
         return res;
     }
-    /**
-     * @param {?} table
-     * @return {?}
-     */
     getUniquesTable(table) {
-        /** @type {?} */
         let res;
-        table.uniques.forEach((/**
-         * @param {?} uniq
-         * @return {?}
-         */
-        uniq => {
+        table.uniques.forEach(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) => {
+        return new Promise((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) => {
+                this.db.readTransaction((transaction) => {
+                    transaction.executeSql(query, bindings, (transaction, result) => {
                         resolve(result);
-                    }), (/**
-                     * @param {?} transaction
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    (transaction, error) => {
+                    }, (transaction, error) => {
                         reject(error);
-                    }));
-                }), (/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => reject(err)));
+                    });
+                }, (err) => reject(err));
             }
             else {
-                this.db.transaction((/**
-                 * @param {?} transaction
-                 * @return {?}
-                 */
-                (transaction) => {
-                    transaction.executeSql(query, bindings, (/**
-                     * @param {?} transaction
-                     * @param {?} result
-                     * @return {?}
-                     */
-                    (transaction, result) => {
+                this.db.transaction((transaction) => {
+                    transaction.executeSql(query, bindings, (transaction, result) => {
                         resolve(result);
-                    }), (/**
-                     * @param {?} transaction
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    (transaction, error) => {
+                    }, (transaction, error) => {
                         reject(error);
-                    }));
-                }), (/**
-                 * @param {?} err
-                 * @return {?}
-                 */
-                (err) => reject(err)));
+                    });
+                }, (err) => reject(err));
             }
-        }));
+        });
     }
-    /**
-     * @param {?} query
-     * @param {?=} bindings
-     * @return {?}
-     */
     Count(query, bindings = []) {
-        return this.query(query, bindings).then((/**
-         * @param {?} rows
-         * @return {?}
-         */
-        rows => {
+        return this.query(query, bindings).then(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 = [];
+        let sql = '', sqlBinds = [], sqlKeys = [], sqlValues = [];
         sql = sql + 'insert into ' + table + ' ';
         for (const index in bindings) {
             if (bindings.hasOwnProperty(index)) {
@@ -441,54 +213,21 @@ class DbWrapperService {
             }
         }
         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) => {
+        return new Promise((resolve, reject) => {
+            this.db.transaction(transaction => {
+                transaction.executeSql(sql, sqlValues, (transaction, result) => {
                     resolve(result);
-                }), (/**
-                 * @param {?} transaction
-                 * @param {?} error
-                 * @return {?}
-                 */
-                (transaction, error) => {
+                }, (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 = [];
+        let sql = '', sqlBinds = [], sqlKeys = [], 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);
@@ -521,105 +260,52 @@ class DbWrapperService {
             }
         }
         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) => {
+        return new Promise((resolve, reject) => {
+            this.db.transaction(transaction => {
+                transaction.executeSql(sql, sqlValues, (transaction, result) => {
                     resolve(result);
-                }), (/**
-                 * @param {?} transaction
-                 * @param {?} error
-                 * @return {?}
-                 */
-                (transaction, error) => {
+                }, (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 => {
+        return new Promise((resolve, reject) => {
+            tables.some(table => {
                 if (cont !== 0) {
                     this.query('DROP TABLE ' + table)
-                        .then((/**
-                     * @return {?}
-                     */
-                    () => {
+                        .then(() => {
                         if (cont === 1) {
                             resolve();
                         }
                         else {
                             cont--;
                         }
-                    }), (/**
-                     * @param {?} err
-                     * @return {?}
-                     */
-                    err => {
+                    }, 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;
+        let objeto = undefined, 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]];
@@ -627,21 +313,27 @@ class DbWrapperService {
         }
         return newObj;
     }
-    /**
-     * @param {?} result
-     * @return {?}
-     */
     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 */
-    /**
-     * @private
-     * @param {?} col
-     * @return {?}
-     */
     defColumn(col) {
-        /** @type {?} */
         let colSql;
         colSql = col.name + ' ' + col.type;
         if (!col.isNullable) {
@@ -659,17 +351,10 @@ class DbWrapperService {
         }
         return colSql;
     }
-    /**
-     * @private
-     * @param {?} unique
-     * @return {?}
-     */
     defUnique(unique) {
-        /** @type {?} */
         let uniqSql;
         // depende del entorno, producción o desarrollo
-        /** @type {?} */
-        const onConflictUnique = 'on conflict fail';
+        const onConflictUnique = 'on conflict replace';
         if (Array.isArray(unique.fields)) {
             uniqSql = ` CONSTRAINT ${unique.name} UNIQUE ( ${unique.fields.join(',')} ) ${onConflictUnique} `;
         }
@@ -678,13 +363,7 @@ class DbWrapperService {
         }
         return uniqSql;
     }
-    /**
-     * @private
-     * @param {?} fore
-     * @return {?}
-     */
     defForeign(fore) {
-        /** @type {?} */
         let foreSql;
         if (Array.isArray(fore.foreignKey)) {
             foreSql = ` FOREIGN KEY (  ${fore.foreignKey.join(',')} ) `;
@@ -700,34 +379,19 @@ class DbWrapperService {
         }
         return foreSql;
     }
-    /**
-     * @private
-     * @param {?} table
-     * @return {?}
-     */
-    tableExists(table) {
+    _tableExists(table) {
         return this.query('select  sql from sqlite_master ' +
             'where type=\'table\' and name=\'' + table + '\'')
-            .then((/**
-         * @param {?} result
-         * @return {?}
-         */
-        result => {
+            .then(result => {
             if (this.rowsCount(result) === 1) {
-                return (/** @type {?} */ (((/** @type {?} */ (this.fetch(result)))).sql));
+                return this.fetch(result).sql;
             }
             else {
                 return false;
             }
-        }));
+        });
     }
-    /**
-     * @private
-     * @param {?} tableDDL
-     * @param {?} column
-     * @return {?}
-     */
-    columnExists(tableDDL, column) {
+    _columnExists(tableDDL, column) {
         if (tableDDL.indexOf(column) === -1) {
             return false;
         }
@@ -735,27 +399,14 @@ class DbWrapperService {
             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',
@@ -763,30 +414,16 @@ function getDefaultDbConfig() {
         iosDatabaseLocation: 'Library'
     };
 }
-/**
- * @param {?} dbConfig
- * @param {?=} dbSchema
- * @return {?}
- */
 function provideDbWrapper(dbConfig, dbSchema) {
-    /** @type {?} */
     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 {?}
-     */
+var DbWrapperModule_1;
+let DbWrapperModule = DbWrapperModule_1 = class DbWrapperModule {
     static forRoot(dbConfig, schema) {
         return {
-            ngModule: DbWrapperModule,
+            ngModule: DbWrapperModule_1,
             providers: [
                 { provide: DB_CONFIG, useValue: dbConfig },
                 { provide: DB_SCHEMA, useValue: schema },
@@ -794,70 +431,63 @@ class DbWrapperModule {
             ]
         };
     }
-}
-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\'))',
-};
+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 = {}));
+
+/*
+ * 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