ngx-universal-zone 0.0.1

package/fesm2022/ngx-universal-zone-database.mjs

@@ -0,0 +1,608 @@
+import { Observable, Subject, switchMap, of, forkJoin } from 'rxjs';
+import Dexie from 'dexie';
+import * as i0 from '@angular/core';
+import { Injectable, makeEnvironmentProviders } from '@angular/core';
+
+// @ts-ignore
+class DbServiceConfig {
+}
+var DbServiceType;
+(function (DbServiceType) {
+    DbServiceType[DbServiceType["IndexDd"] = 0] = "IndexDd";
+    DbServiceType[DbServiceType["Sqlite"] = 1] = "Sqlite";
+})(DbServiceType || (DbServiceType = {}));
+class DbService {
+    constructor() {
+        this.dbInitialized$ = new Observable();
+    }
+    get Db() {
+        return;
+    }
+    putLocal(store, data) {
+        // @ts-ignore
+        return;
+    }
+    putLocalRx(store, data) {
+        // @ts-ignore
+        return;
+    }
+    get(store, key) {
+        // @ts-ignore
+        return;
+    }
+    getRx(store, key) {
+        // @ts-ignore
+        return;
+    }
+    getAll(store, opt) {
+        // @ts-ignore
+        return;
+    }
+    getAllRx(store, opt) {
+        // @ts-ignore
+        return;
+    }
+    remove(store, id) {
+        // @ts-ignore
+        return;
+    }
+    removeRx(store, key) {
+        // @ts-ignore
+        return;
+    }
+    removeAll(store) {
+        // @ts-ignore
+        return;
+    }
+    removeAllRx(store) {
+        // @ts-ignore
+        return;
+    }
+    count(store, opts) {
+        // @ts-ignore
+        return;
+    }
+    countRx(store, opts) {
+        // @ts-ignore
+        return;
+    }
+    deleteDb() {
+        // @ts-ignore
+        return;
+    }
+    deleteTable(store) {
+        // @ts-ignore
+        return;
+    }
+}
+
+// @Injectable()
+class DbWebService extends Dexie {
+    constructor(config, schemaService) {
+        super(config.dbName);
+        this.config = config;
+        this.schemaService = schemaService;
+        this.dbInitialized = new Subject();
+        this.dbInitialized$ = this.dbInitialized.asObservable();
+        const schema = {};
+        schemaService.schema.stores.forEach((s) => {
+            let cols = ``;
+            for (let c of s.columns) {
+                cols += `${c.isPrimaryKey ? `++${c.name}` : `,${c.name}`}`;
+            }
+            schema[s.name] = cols;
+        });
+        this.version(1).stores(schema);
+        this.open()
+            .then((d) => {
+            this._db = d;
+            this.dbInitialized.next(d);
+        })
+            .catch((e) => alert(e));
+    }
+    get Db() {
+        return this._db;
+    }
+    putLocal(store, data) {
+        return new Promise(async (resolve, reject) => {
+            const schema = this.schemaService.schema.stores.filter((s) => s.name == store)[0];
+            const key = schema.columns.filter((s) => s.isPrimaryKey)[0];
+            const exist = data[key.name] ? await this.get(store, data[key.name]) : null;
+            if (exist) {
+                //update
+                this.Db
+                    .table(store)
+                    .update(data[key.name], data)
+                    .then((r) => resolve(null), (e) => reject(e));
+            }
+            else {
+                this.Db
+                    .table(store)
+                    .add(data)
+                    .then((r) => resolve(null), (e) => reject(e));
+            }
+        });
+    }
+    putLocalRx(store, data) {
+        return new Observable((observer) => {
+            this.putLocal(store, data).then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    get(store, key) {
+        return new Promise((resolve, reject) => {
+            if (!this.Db) {
+                return reject('Database not initialized. Please wait for dbInitialized$ to emit.');
+            }
+            this.Db
+                .table(store)
+                .get(key)
+                .then((r) => {
+                resolve(r);
+            }, (e) => reject(e));
+        });
+    }
+    getRx(store, key) {
+        return new Observable((observer) => {
+            this.get(store, key).then((value) => {
+                observer.next(value);
+                observer.complete();
+            });
+        });
+    }
+    getByFieldName(storeName, fieldName, key) {
+        const filter = {};
+        filter[fieldName] = key;
+        return this.Db.table(storeName).where(filter).toArray();
+    }
+    getAll(store, opt) {
+        return new Promise(async (resolve, reject) => {
+            if (!this.Db) {
+                return reject('Database not initialized. Please wait for dbInitialized$ to emit.');
+            }
+            let table = this.Db.table(store);
+            let collection = table.toCollection();
+            if (opt?.sortBy) {
+                collection = table.orderBy(opt.sortBy);
+            }
+            if (opt?.sortType && opt?.sortType == 'desc') {
+                collection = table.reverse();
+            }
+            // collection = this.Db.table(store).toCollection();
+            if (opt && opt.key && opt.value) {
+                if (!opt.keyRange) {
+                    opt.keyRange = KeyRangeType.equalTo;
+                }
+                switch (opt.keyRange) {
+                    case KeyRangeType.startsWithIgnoreCase:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .startsWithIgnoreCase(opt.value);
+                        break;
+                    case KeyRangeType.equalTo:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .equals(opt.value);
+                        break;
+                    case KeyRangeType.notEqualTo:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .notEqual(opt.value);
+                        break;
+                    case KeyRangeType.equalToIgnoreCase:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .equalsIgnoreCase(opt.value);
+                        break;
+                }
+            }
+            if (opt?.pageIndex != null) {
+                collection = collection.offset((opt.pageIndex - 1) * opt.pageSize);
+            }
+            if (opt?.pageSize != null) {
+                collection = collection.limit(opt.pageSize);
+            }
+            // let data!: T;
+            // if(opt?.sortBy) {
+            //   data = <T>await collection.sortBy(opt.sortBy);
+            // } else {
+            //   data = <T>await collection.toArray();
+            // }
+            // if(opt.sortType == 'desc') {
+            //   data = <T>(<any[]>data).reverse();
+            // }
+            const data = await collection.toArray();
+            resolve(data);
+        });
+    }
+    getAllRx(store, opt) {
+        return new Observable((observer) => {
+            this.getAll(store, opt).then((value) => {
+                observer.next(value);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    remove(store, key) {
+        return this.Db.table(store).delete(key);
+    }
+    removeRx(store, key) {
+        return new Observable((observer) => {
+            this.remove(store, key).then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    async removeAll(store) {
+        const all = await this.getAll(store);
+        const schema = this.schemaService.schema.stores.filter((s) => s.name == store)[0];
+        const key = schema.columns.filter((s) => s.isPrimaryKey)[0];
+        const promises = [];
+        for (let r of all) {
+            promises.push(this.Db.table(store).delete(key.name));
+        }
+        await Promise.all(promises);
+    }
+    removeAllRx(store) {
+        return this.getAllRx(store).pipe(switchMap((entries) => {
+            const observables = [];
+            for (let entry of entries) {
+                observables.push(this.removeRx(store, entry.id));
+            }
+            if (!observables.length) {
+                return of(null);
+            }
+            return forkJoin(observables);
+        }));
+    }
+    count(store, opts) {
+        if (opts && opts.key) {
+            const pk = this.schemaService.schema.stores
+                .filter((s) => s.name == store)[0]
+                .columns.filter((s) => s.isPrimaryKey)[0];
+            return this.Db.table(store).where(pk.name).equals(opts.key).count();
+        }
+        return this.Db.table(store).count();
+    }
+    countRx(store, opts) {
+        return new Observable((observer) => {
+            this.count(store, opts).then((value) => {
+                observer.next(value);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    deleteDb() {
+        return new Promise(async (resolve, reject) => {
+            await this.Db.delete();
+            resolve(null);
+        });
+    }
+    deleteTable(store) {
+        return new Observable((observer) => {
+            this.Db.table(store).clear().then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+}
+var KeyRangeType;
+(function (KeyRangeType) {
+    KeyRangeType[KeyRangeType["equalToIgnoreCase"] = 1] = "equalToIgnoreCase";
+    KeyRangeType[KeyRangeType["startsWithIgnoreCase"] = 2] = "startsWithIgnoreCase";
+    KeyRangeType[KeyRangeType["equalTo"] = 3] = "equalTo";
+    KeyRangeType[KeyRangeType["notEqualTo"] = 4] = "notEqualTo";
+})(KeyRangeType || (KeyRangeType = {}));
+
+class SchemaService {
+    /**
+     * Represents a SchemaService that manages the database schema.
+     */
+    constructor() {
+        this.schema = {
+            stores: []
+        };
+        this.tables = {};
+        this._config = {};
+    }
+    get config() {
+        return this._config;
+    }
+    init(config) {
+        this._config = config;
+        if (config.schema && config.schema.length) {
+            this.schema.stores = this.config.schema;
+            this.schema.stores.forEach((s) => this.tables[s.name] = s.name);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SchemaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SchemaService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SchemaService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class DbSettingConstant {
+    static { this.SETTING = 'setting'; }
+}
+const DbSettingConfig = {
+    schema: {
+        name: DbSettingConstant.SETTING,
+        columns: [
+            {
+                name: 'key',
+                isPrimaryKey: true,
+                type: 'TEXT',
+            },
+            {
+                name: 'value',
+                type: 'TEXT',
+            },
+        ],
+    }
+};
+
+class DbSqliteService {
+    constructor(config, schemaSvc) {
+        this.config = config;
+        this.schemaSvc = schemaSvc;
+        this._isDbInitialized = false;
+        this.dbInitialized = new Subject();
+        this.dbInitialized$ = this.dbInitialized.asObservable();
+        this._dbName = config.dbName;
+        // await this._deleteDatabase();
+        // this._db = CapacitorSQLite;
+        this._db.open({ database: this._dbName }).then(async (response) => {
+            if (response.result) {
+                await this._dbSuccess();
+                this.initializeDb();
+            }
+        }, (e) => {
+            this._dbError(e);
+        });
+    }
+    getAllRx(store, opt) {
+        throw new Error('Method not implemented.');
+    }
+    testDb() {
+        this._db.transaction((tr) => {
+            tr.executeSql('SELECT upper(?) AS upperString', ['Test string'], (tr, rs) => {
+                console.log('Got upperString result: ' + rs.rows.item(0).upperString);
+            });
+        });
+    }
+    initializeDb() {
+        const delay = 50;
+        //workaround: don't proceed unless db is initialized...wait everytime 50ms
+        const _self = this;
+        let timerId = setTimeout(async function request() {
+            if (!_self._isDbInitialized) {
+                //retry
+                timerId = setTimeout(request, delay);
+            }
+            else {
+                //clear timeout
+                clearTimeout(timerId);
+                timerId = null;
+                await _self._prepareTables();
+                // heavy database operations should start from this...
+                _self.dbInitialized.next(_self._db);
+            }
+        }, delay);
+    }
+    get Db() {
+        return this._db;
+    }
+    putLocal(store, data) {
+        return new Promise(async (resolve, reject) => {
+            let sql = `BEGIN TRANSACTION;`;
+            const values = [];
+            const total = await this.count(store);
+            if (total) {
+                //update
+                sql = `UPDATE ${store} SET `;
+                //columns
+                for (let prop in data) {
+                    if (data.hasOwnProperty(prop)) {
+                        sql += `${prop}='${data[prop]}',`;
+                    }
+                }
+                //remove extra ',' at the end
+                sql = sql.substr(0, sql.length - 1);
+            }
+            else {
+                //insert
+                sql = `INSERT INTO ${store} `;
+                //columns
+                sql += `(`;
+                for (let prop in data) {
+                    if (data.hasOwnProperty(prop)) {
+                        sql += `${prop},`;
+                    }
+                }
+                //remove extra ',' at the end
+                sql = sql.substr(0, sql.length - 1);
+                sql += `)`;
+                //values
+                sql += ` VALUES (`;
+                for (let prop in data) {
+                    sql += `?,`;
+                    values.push(data[prop]);
+                }
+                sql = sql.substr(0, sql.length - 1);
+                sql += `)`;
+            }
+            sql += `COMMIT TRANSACTION;`;
+            const { changes } = await this._db.execute({
+                statements: sql,
+                values: values,
+            });
+            resolve(changes);
+            // this._db.transaction(async (tx) => {
+            //     const res = await this._executeSql<{ rowsAffected, insertId }>(tx, sql, values);
+            //     resolve(res);
+            // }, (error) => reject(error));
+        });
+    }
+    putLocalRx(store, data) {
+        return new Observable((observer) => {
+            this.putLocal(store, data).then((result) => {
+                observer.next(result);
+                observer.complete();
+            });
+        });
+    }
+    get(store, key) {
+        return new Promise(async (resolve, reject) => {
+            //get primary key field form schema
+            const table = this.schemaSvc.schema.stores.filter((s) => s.name === store)[0];
+            const pk = table.columns.filter((c) => c.isPrimaryKey)[0];
+            const pkName = pk.name;
+            let sql = `SELECT * FROM ${store} WHERE ${pkName} = '${key}' LIMIT 1`;
+            try {
+                let data;
+                const { values } = await this._db.query({ statement: sql, values: [] });
+                if (values.length) {
+                    data = values[0];
+                }
+                resolve(data);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    getRx(store, key) {
+        // @ts-ignore
+        return;
+    }
+    getAll(store, opt) {
+        return new Promise(async (resolve, reject) => {
+            let sql = `SELECT * FROM ${store}`;
+            try {
+                let data;
+                const { values } = await this._db.query({ statement: sql, values: [] });
+                resolve(values);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    remove(store, key) {
+        return new Promise((resolve, reject) => {
+            throw 'remove not impleted in db-sql yet';
+        });
+    }
+    removeRx(store, key) {
+        throw 'remove not impleted in db-sql yet';
+    }
+    removeAll(store) {
+        return new Promise((resolve, reject) => {
+            throw 'removeAll not impleted in db-sql yet';
+        });
+    }
+    removeAllRx(store) {
+        throw 'removeAllRx not impleted in db-sql yet';
+    }
+    count(store, opts) {
+        return new Promise(async (resolve, reject) => {
+            let sql = `SELECT count(*) AS total FROM ${store} `;
+            const { values } = await this._db.query({ statement: sql, values: [] });
+            resolve(values);
+        });
+    }
+    countRx(store, opts) {
+        return new Observable((observer) => {
+            this.count(store, opts).then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (error) => observer.error(error));
+        });
+    }
+    deleteDb() {
+        return this._deleteDatabase();
+    }
+    deleteTable(store) {
+        throw 'deleteTable not impleted in db-sql yet';
+    }
+    _prepareTables() {
+        return new Promise(async (resolve, reject) => {
+            const schemas = this.schemaSvc.schema.stores;
+            const promises = [];
+            for (let schema of schemas) {
+                let sql = `BEGIN TRANSACTION;`;
+                sql += `CREATE TABLE IF NOT EXISTS ${schema.name} `;
+                sql += `(`;
+                for (let col of schema.columns) {
+                    //TODO: for user table, need to fix primary key
+                    // const ikPkTypeNumber = col['type'] == 'INTEGER';
+                    sql += `${col.name}${col.type ? ' ' + col.type : ''}${col['isPrimaryKey'] ? ' PRIMARY KEY' : ''},`;
+                }
+                //remove extra ',' at the end
+                sql = sql.substr(0, sql.length - 1);
+                sql += `)`;
+                sql += `COMMIT TRANSACTION;`;
+                const promise = this._db.execute({ statements: sql });
+                promises.push(promise);
+            }
+            try {
+                await Promise.all(promises);
+                resolve(null);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    _deleteDatabase() {
+        return this._db.deleteDatabase({ database: this._dbName });
+    }
+    _dbSuccess() {
+        this._isDbInitialized = true;
+    }
+    _dbError(err) {
+        alert('Open database ERROR: ' + JSON.stringify(err));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DbSqliteService, deps: [{ token: DbServiceConfig }, { token: SchemaService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DbSqliteService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DbSqliteService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: DbServiceConfig }, { type: SchemaService }] });
+
+function dbFactory(schemaSvc) {
+    const dbConfig = schemaSvc.config;
+    switch (dbConfig.dbType) {
+        case DbServiceType.IndexDd:
+            return new DbWebService(dbConfig, schemaSvc);
+        case DbServiceType.Sqlite:
+            return new DbSqliteService(dbConfig, schemaSvc);
+    }
+}
+const provideDb = () => {
+    const providers = [
+        SchemaService,
+        {
+            provide: DbService,
+            useFactory: dbFactory,
+            deps: [SchemaService],
+        }
+    ];
+    return makeEnvironmentProviders(providers);
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DbService, DbServiceConfig, DbServiceType, DbSettingConfig, DbSettingConstant, DbWebService, KeyRangeType, SchemaService, dbFactory, provideDb };
+//# sourceMappingURL=ngx-universal-zone-database.mjs.map