Add the DbContext and generate compiled version of indexedDB.js

Author: code-atom

.gitignore

@@ -0,0 +1 @@
+/DataBase

.vscode/tasks.json

@@ -4,7 +4,7 @@
     "version": "0.1.0",
     "command": "tsc",
     "isShellCommand": true,
-    "args": ["-p", "./DataBase"],
+    "args": ["-p", "./IndexedDBDAL"],
     "showOutput": "silent",
     "problemMatcher": "$tsc"
-}
+}

IndexedDBDAL/Contract/IDbContext.ts

@@ -0,0 +1,7 @@
+namespace IndexedDB {
+    export interface IDBContext {
+        Reset(): Promise<any>;
+        Delete(): Promise<any>;
+        CreateObjectSet(model: string): Promise<IDBObjectStore>
+    }
+}

IndexedDBDAL/Contract/IDbContextStorageContainer.ts

@@ -0,0 +1,5 @@
+namespace IndexedDB {
+     export interface IDbContextStorageContainer {
+        Get(): IDBContext;
+    }
+}

IndexedDBDAL/Contract/IRepository.ts

@@ -0,0 +1,9 @@
+namespace IndexedDB {
+    export interface IRepository<TObjectStore extends IDBObjectStore, TKey extends any> {
+        Add(TObject: any): Promise<any>;
+        Update(TObject: any): Promise<any>;
+        Delete(TKey: any): Promise<any>;
+        Get(TKey: any): Promise<any>;
+        GetAll(): Promise<any>;
+    }
+}

IndexedDb.DAL/DbContext.ts renamed to IndexedDBDAL/DbContext.ts

@@ -1,22 +1,23 @@
-import * as Helpers from "./Helpers/Util";
-import * as DbContext from "./Contract/IDbContext";
-export namespace IndexedDb {
-    export abstract class DbContext implements DbContext.IndexedDb.IDBContext {
+/// <reference path="./Contract/IDbContext.ts" />
+/// <reference path="./Helpers/Util.ts" />
+
+namespace IndexedDB {
+    export abstract class DbContext implements IDBContext {
         private _dbNative: IDBFactory;
         constructor(databaseNative: IDBFactory, public dbName?: string) {
             this._dbNative = databaseNative;
             this.dbName = this.dbName || 'SampleDB';
             this.Begin();
         }
-        
+
         public Begin(): Promise<any> {
             var self = this;
             var creationRequest = self._dbNative.open(this.dbName);
-            var promise = Helpers.IndexedDb.Helpers.Util.CreatePromise();
+            var promise = Util.CreatePromise();
             creationRequest.onsuccess = function (event: any) {
                 promise.resolve(event.target.result);
             }
-            
+
             creationRequest.onupgradeneeded = function (event: any) {
                 var db = event.target.result as IDBDatabase;
                 self.ModelBuilding(db);
@@ -31,19 +32,19 @@ export namespace IndexedDb {
             return this.Begin()
                 .then(function (db: IDBDatabase) {
                     db.close();
-                    var promise = Helpers.IndexedDb.Helpers.Util.CreatePromise();
+                    var promise = Util.CreatePromise();
                     var req = self._dbNative.deleteDatabase(self.dbName);
                     req.onsuccess = function () {
                         promise.resolve();
-                        Helpers.IndexedDb.Helpers.Util.Log("Deleted database successfully");
+                        Util.Log("Deleted database successfully");
                     };
                     req.onerror = function () {
                         promise.reject();
-                        Helpers.IndexedDb.Helpers.Util.Log("Couldn't delete database");
+                        Util.Log("Couldn't delete database");
                     };
                     req.onblocked = function () {
                         promise.reject();
-                        Helpers.IndexedDb.Helpers.Util.Log("Couldn't delete database due to the operation being blocked");
+                        Util.Log("Couldn't delete database due to the operation being blocked");
                     };
                     return promise;
                 });
@@ -62,6 +63,6 @@ export namespace IndexedDb {
                 });
         }
 
-        protected abstract ModelBuilding(databse :IDBDatabase);
+        protected abstract ModelBuilding(databse: IDBDatabase): void;
     }
 }

IndexedDBDAL/DbContextContainer.ts

@@ -0,0 +1,14 @@
+/// <reference path="./Contract/IDbContextStorageContainer.ts" />
+/// <reference path="./SampleContext.ts" />
+
+namespace IndexedDB {
+    export class DbContextConatiner implements IDbContextStorageContainer {
+        private _context: SampleContext;
+        constructor(databaseNative: IDBFactory) {
+            this._context = new SampleContext(databaseNative);
+        }
+        public Get(): IDBContext {
+            return this._context;
+        }
+    }
+}

IndexedDBDAL/DbContextStorageFactory.ts

@@ -0,0 +1,12 @@
+namespace IndexedDB {
+    export class DbContextStorageFactory {
+        private ContextContainer: IDbContextStorageContainer;
+        constructor(dbNative: IDBFactory) {
+            this.ContextContainer = new DbContextConatiner(dbNative);
+        }
+        get Context(): IDBContext {
+            return this.ContextContainer.Get();
+        }
+
+    }
+}

IndexedDb.DAL/Helpers/Util.ts renamed to IndexedDBDAL/Helpers/Util.ts

@@ -1,4 +1,4 @@
-export namespace IndexedDb.Helpers {
+namespace IndexedDB {
     export class Util {
         static CreatePromise(): any {
             var promiseHandler = <IPromiseHandler>{};

IndexedDBDAL/Repositories/BaseRepository.ts

@@ -0,0 +1,89 @@
+/// <reference path="../Contract/IRepository.ts" />
+/// <reference path="../Helpers/Util.ts" />
+
+namespace IndexedDB {
+    export class BaseRepository<TObjectStore extends IDBObjectStore, TKey extends string | number> implements IRepository<TObjectStore, TKey>{
+        private _ObjectStore: IDBObjectStore;
+        constructor(ObjectStore: TObjectStore) {
+            this._ObjectStore = ObjectStore;
+        }
+
+        public Add(TObject: any): Promise<any> {
+            var promise = Util.CreatePromise();
+            var creationRequest = this._ObjectStore.add(TObject);
+            creationRequest.onerror = (event: any) => {
+                promise.reject();
+                Util.Log("Fail");
+            }
+            creationRequest.onsuccess = (event: any) => {
+                promise.resolve();
+                Util.Log("Fail");
+            }
+            return promise;
+        }
+
+        public Update(TObject: any): Promise<any> {
+            var promise = Util.CreatePromise();
+            var creationRequest = this._ObjectStore.put(TObject);
+            creationRequest.onerror = (event: any) => {
+                promise.reject();
+                Util.Log("Fail");
+            }
+            creationRequest.onsuccess = (event: any) => {
+                promise.resolve();
+                Util.Log("Fail");
+            }
+            return promise;
+        }
+
+        public Delete(Key: TKey): Promise<any> {
+            var promise = Util.CreatePromise();
+            var deleteRequest = this._ObjectStore.delete(Key);
+            deleteRequest.onerror = (event: any) => {
+                promise.reject();
+                Util.Log("Fail");
+            }
+            deleteRequest.onsuccess = (event: any) => {
+                promise.resolve();
+                Util.Log("success");
+            }
+            return promise;
+        }
+
+        public Get(TKey: any): Promise<any> {
+            var promise = Util.CreatePromise();
+            var retrievalRequest = this._ObjectStore.get(TKey);
+            retrievalRequest.onsuccess = function (evt: any) {
+                var data = evt.target.result;
+                Util.Log("successfully");
+                promise.resolve(data);
+            };
+            retrievalRequest.onerror = function () {
+                promise.reject();
+                Util.Log("Fail");
+            };
+            return promise;
+        }
+
+        public GetAll(): Promise<any> {
+            var dbCollection : any = [];
+            var promise = Util.CreatePromise();
+            var getAllRequest = this._ObjectStore.openCursor();
+            getAllRequest.onsuccess = function (evt: any) {
+                var cursor = evt.target.result;
+                if (cursor) {
+                    dbCollection.push(cursor.value);
+                    cursor.continue()
+                } else {
+                    Util.Log("success");
+                    promise.resolve(dbCollection);
+                }
+            };
+            getAllRequest.onerror = function () {
+                promise.reject();
+                Util.Log("Fail");
+            };
+            return promise;
+        }
+    }
+}