provide support for table upgrade from schema, rm table version support

ujjwalguptaofficial · Jun 13, 2021 · a7d11f8 · a7d11f8
1 parent 7616033
commit a7d11f8
Show file tree

Hide file tree

Showing 13 changed files with 103 additions and 95 deletions.
diff --git a/src/common/interfaces.ts b/src/common/interfaces.ts
@@ -18,7 +18,7 @@ export type TColumns = {
 export interface ITable {
     name: string;
     columns: TColumns;
-    version?: number;
+    upgrade?: boolean;
 }
 
 export interface IColumnOption {

diff --git a/src/worker/enums/index.ts b/src/worker/enums/index.ts
@@ -1 +0,0 @@
-export * from "./table_state";

diff --git a/src/worker/enums/table_state.ts b/src/worker/enums/table_state.ts
diff --git a/src/worker/idbutil/index.ts b/src/worker/idbutil/index.ts
@@ -1,5 +1,4 @@
 import { DbMeta, TableMeta } from "@worker/model";
-import { TABLE_STATE } from "@worker/enums";
 import { IDB_MODE, QUERY_OPTION, promise } from "@/common";
 import { LogHelper } from "@worker/utils";
 
@@ -121,9 +120,8 @@ export class IDBUtil {
                         }
                     });
                 }
-                const createStates = [TABLE_STATE.Create, TABLE_STATE.Delete];
                 db.tables.forEach(table => {
-                    if (createStates.indexOf(table.state) >= 0) {
+                    if (table.upgrade) {
                         createObjectStore(table);
                     }
                 });

diff --git a/src/worker/model/db_meta.ts b/src/worker/model/db_meta.ts
@@ -10,6 +10,7 @@ export class DbMeta {
 
     constructor(db: IDataBase) {
         this.name = db.name;
+        this.version = db.version || 1;
         db.tables.push({
             name: MetaHelper.tableName,
             columns: {
@@ -19,11 +20,12 @@ export class DbMeta {
                 value: {
                     enableSearch: false
                 }
-            }
+            },
+            upgrade: this.version === 1
         })
         this.tables = db.tables.map(table => {
-            return new TableMeta(table, db.version);
+            return new TableMeta(table);
         });
-        this.version = db.version || 1;
+
     }
 }
diff --git a/src/worker/model/table_meta.ts b/src/worker/model/table_meta.ts
@@ -1,16 +1,14 @@
 import { ITable } from "@/common";
-import { TABLE_STATE } from "@/worker/enums";
 import { IColumn } from "@/worker/interfaces";
 
 export class TableMeta {
     name: string;
     columns: IColumn[];
     primaryKey: string;
-    state: TABLE_STATE;
-    version: number;
     autoIncColumnValue = {};
+    upgrade: boolean;
 
-    constructor(table: ITable, dbVersion: number) {
+    constructor(table: ITable) {
         const columns = [];
         for (const columnName in table.columns) {
             const column: IColumn = table.columns[columnName] as any;
@@ -26,14 +24,8 @@ export class TableMeta {
         }
         this.columns = columns;
         this.name = table.name;
-        this.version = table.version || 1;
-        if (dbVersion > this.version) {
-            this.version = dbVersion;
-        }
-        this.setState_();
+        this.upgrade = table.upgrade == null ? true : table.upgrade;
     }
 
-    private setState_() {
-        this.state = TABLE_STATE.Create;
-    }
+
 }
diff --git a/src/worker/query_manager.ts b/src/worker/query_manager.ts
@@ -13,7 +13,6 @@ import { Union } from "./union";
 import { Remove } from "@executors/remove";
 import { Clear } from "@executors/clear";
 import { Transaction } from "@executors/transaction";
-import { TABLE_STATE } from "./enums";
 import { LogHelper, getError, promiseReject, variableFromPath, userDbSchema, getLength } from "@worker/utils";
 
 export class QueryManager {
@@ -244,9 +243,11 @@ export class QueryManager {
                 version: query.version
             });
         }
-        return pResult.then(() => {
-            return this.db;
-        });
+        return this.closeDb().then(_ => {
+            return pResult.then(() => {
+                return this.db;
+            });
+        })
     }
 
     initDb(dataBase?: IDataBase) {
@@ -258,69 +259,26 @@ export class QueryManager {
 
         const dbMeta = dataBase ? new DbMeta(dataBase) : this.db;
         this.util = new IDBUtil(dbMeta);
-        const upgradeDbSchema = (result) => {
-            return promise((res, rej) => {
-                MetaHelper.get(MetaHelper.dbSchema, this.util).then((savedDb: DbMeta) => {
-                    let shouldReCreateDb = false;
-                    let dbVersion;
-                    if (savedDb) {
-                        dbVersion = savedDb.version;
-
-                        savedDb.tables.forEach((savedTable, index) => {
-                            const providedTable = dbMeta.tables[index];
-
-                            if (providedTable) {
-                                if (savedTable.version < providedTable.version) {
-                                    providedTable.state = TABLE_STATE.Delete;
-                                    shouldReCreateDb = true;
-                                    if (dbVersion < providedTable.version) {
-                                        dbVersion = providedTable.version;
-                                    }
-                                }
-                                else {
-                                    providedTable.state = null;
-                                }
-                            }
-                        });
-                    }
-
-                    if (shouldReCreateDb) {
-                        dbMeta.version = dbVersion;
-                        this.terminate().then(_ => {
-                            this.util = new IDBUtil(dbMeta);
-                            this.util.initDb().then((isCreated) => {
-                                res(isCreated);
-                            }).catch(rej);
-                        });
 
-                        return;
-                    }
-                    else if (!result) {
-                        this.db = savedDb;
-                    }
-                    res(result);
-                });
-            });
-        };
         return promise<boolean>((res, rej) => {
             this.util.initDb().then((isCreated) => {
                 if (isCreated) {
-                    return isCreated;
-                }
-                return upgradeDbSchema(isCreated);
-            }).then(result => {
-                if (result) {
+                    this.db = dbMeta;
                     MetaHelper.set(
                         MetaHelper.dbSchema, dbMeta,
                         this.util
                     ).then(() => {
-                        this.db = dbMeta;
                         res(true);
                     });
                 }
                 else {
-
-                    res(false);
+                    MetaHelper.get(
+                        MetaHelper.dbSchema,
+                        this.util
+                    ).then((value: any) => {
+                        this.db = value;
+                        res(false);
+                    });
                 }
             }).catch(rej);
         });

diff --git a/src/worker/utils/db_schema.ts b/src/worker/utils/db_schema.ts
@@ -10,7 +10,6 @@ export const userDbSchema = (db: DbMeta) => {
     db.tables.forEach(table => {
         const tableAsObj = {
             name: table.name,
-            version: table.version,
             columns: {}
         } as ITable;
         table.columns.forEach(column => {

diff --git a/test/cases/column_option/multi_entry_test.js b/test/cases/column_option/multi_entry_test.js
@@ -105,7 +105,8 @@ describe('Multi Entry Test', function () {
 
     it('change db with multientry column', function (done) {
         var db = MultiEntryTest.getDbSchema();
-        db.tables[0].version = 2;
+        db.version = 2;
+        // db.tables[0].version = 2;
         db.tables[0].columns[Object.keys(db.tables[0].columns)[1]].multiEntry = true;
         con.initDb(db).then(function (isDbCreated) {
             expect(isDbCreated).to.be.an('boolean').equal(true);

diff --git a/test/cases/count/count_middleware.js b/test/cases/count/count_middleware.js
@@ -1,6 +1,6 @@
 var JsStoreOptions = {
     countMiddleware: function (request, context) {
-        debugger;
+        // debugger;
         // do not delete data
         const name = context.database.name;
         if (request.name == "count" && request.query['add5']) {

diff --git a/test/cases/db_update_datatype.js b/test/cases/db_update_datatype.js
@@ -29,7 +29,7 @@ describe('Db Update data type Test', function () {
             const processIdColumn = schema.tables[0].columns[1];
             expect(processIdColumn.name).to.equal("process_id");
             expect(processIdColumn.dataType).to.equal("number");
-            expect(schema.tables[0].version).equal(1)
+            // expect(schema.tables[0].version).equal(1)
             expect(schema.version).equal(1);
             done();
         }).catch(function (err) {
@@ -52,7 +52,7 @@ describe('Db Update data type Test', function () {
             const processIdColumn = schema.tables[0].columns[1];
             expect(processIdColumn.name).to.equal("process_id");
             expect(processIdColumn.dataType).to.equal("string");
-            expect(schema.tables[0].version).equal(2);
+            expect(schema.tables[0].upgrade).equal(true);
             expect(schema.version).equal(2);
             done();
         }).catch(function (err) {
@@ -101,11 +101,13 @@ var DbUpdateTest = {
                     "dataType": "string"
                 },
             },
-            version: 2
+            // upgrade:false
         },
             dataBase = {
                 name: 'DbUpdateTest',
-                tables: [people]
+                tables: [people],
+                version: 2
+
             };
         return dataBase;
     },

diff --git a/test/cases/db_upgrade.js b/test/cases/db_upgrade.js
@@ -13,22 +13,34 @@ describe('Db upgrade Test', function () {
 
     });
 
+    it('insert data', function () {
+        var values = DbUpgradeTest.getValues();
+        return connection.insert({
+            into: "test",
+            values: values
+        }).then(results => {
+            expect(results).to.equal(3);
+        })
+    })
+
     it('getDbSchema', function (done) {
         connection.openDb(DbUpgradeTest.getDbSchema().name).then(function (schema) {
             const processIdColumn = schema.tables[0].columns[1];
             expect(processIdColumn.name).to.equal("process_id");
             expect(processIdColumn.dataType).to.equal("number");
-            expect(schema.tables[0].version).equal(1)
+            expect(schema.tables[0].columns[1].encrypt).equal(true)
             expect(schema.version).equal(1);
+            expect(schema.tables[1].upgrade).equal(true);
             done();
         }).catch(function (err) {
             done(err);
         });
     });
 
-    it('change db', function (done) {
+    it('change db to v2', function (done) {
         var db = DbUpgradeTest.getDbSchema();
         db.version = 2;
+        db.tables[0].upgrade = false;
         connection.initDb(db).then(function (isDbCreated) {
             expect(isDbCreated).to.be.an('boolean').equal(true);
             done();
@@ -37,8 +49,8 @@ describe('Db upgrade Test', function () {
         });
     });
 
-    it('open db with old version', function (done) {
-        connection.openDb("DbUpdateTest").catch(function (err) {
+    it('open db with old version', function () {
+        connection.openDb("DbUpgradeTest").catch(function (err) {
             console.error(JSON.stringify(err));
             const expected = {
                 "message": "The requested version (1) is less than the existing version (2).",
@@ -49,13 +61,61 @@ describe('Db upgrade Test', function () {
         });
     })
 
+
     it('getDbSchema after updating db', function (done) {
-        connection.openDb("DbUpdateTest", 2).then(function (schema) {
+        connection.openDb("DbUpgradeTest", 2).then(function (schema) {
             const processIdColumn = schema.tables[0].columns[1];
             expect(processIdColumn.name).to.equal("process_id");
-            expect(processIdColumn.dataType).to.equal("string");
-            expect(schema.tables[0].version).equal(2)
+            expect(processIdColumn.dataType).to.equal("number");
+            // expect(schema.tables[0].version).equal(2)
+            expect(schema.tables[0].upgrade).equal(false);
+            expect(schema.tables[1].upgrade).equal(false);
             expect(schema.version).equal(2);
+            expect(schema.tables[0].columns[1].encrypt).equal(true)
+            done();
+        }).catch(function (err) {
+            done(err);
+        });
+    });
+
+    it('count data to ensure data is not deleted', function () {
+        return connection.count({
+            from: "test",
+        }).then(results => {
+            expect(results).to.equal(3);
+        })
+    })
+
+    it('change db to v3', function (done) {
+        var db = DbUpgradeTest.getDbSchema();
+        db.version = 3;
+        db.tables[0].columns.process_id.encrypt = false;
+        connection.initDb(db).then(function (isDbCreated) {
+            expect(isDbCreated).to.be.an('boolean').equal(true);
+            done();
+        }).catch(function (err) {
+            done(err);
+        });
+    });
+
+    it('count data to ensure data is deleted', function () {
+        return connection.count({
+            from: "test",
+        }).then(results => {
+            expect(results).to.equal(0);
+        })
+    })
+
+    it('getDbSchema after updating db to v3', function (done) {
+        connection.openDb("DbUpgradeTest", 3).then(function (schema) {
+            const processIdColumn = schema.tables[0].columns[1];
+            expect(processIdColumn.name).to.equal("process_id");
+            expect(processIdColumn.dataType).to.equal("number");
+            // expect(schema.tables[0].version).equal(2)
+            expect(schema.tables[0].upgrade).equal(true);
+            expect(schema.tables[1].upgrade).equal(false);
+            expect(schema.version).equal(3);
+            expect(schema.tables[0].columns[1].encrypt).equal(false)
             done();
         }).catch(function (err) {
             done(err);
@@ -81,7 +141,8 @@ var DbUpgradeTest = {
                     "notNull": true
                 },
                 "process_id": {
-                    "dataType": "number"
+                    "dataType": "number",
+                    encrypt: true
                 },
             },
 

diff --git a/test/cases/select/join_order.js b/test/cases/select/join_order.js
@@ -154,7 +154,7 @@ describe('select join order test', function () {
         })
     });
 
-    it('drop db', function (done) {
+    it('drop db student', function (done) {
         con.dropDb().then(function () {
             done();
         }).catch(function (err) {