From 6f6f4b2f1b179c4349e9f874f34217227f5fef39 Mon Sep 17 00:00:00 2001 From: Breno Date: Fri, 11 Sep 2020 21:30:32 -0300 Subject: [PATCH] Apply usecCallback hook --- src/createDatabaseTransaction.ts | 24 ++++ src/createReadonlyTransaction.ts | 18 +++ src/createReadwriteTransaction.ts | 17 +++ src/indexed-db.ts | 227 +++++++++++++++++------------- 4 files changed, 185 insertions(+), 101 deletions(-) create mode 100644 src/createDatabaseTransaction.ts create mode 100644 src/createReadonlyTransaction.ts create mode 100644 src/createReadwriteTransaction.ts diff --git a/src/createDatabaseTransaction.ts b/src/createDatabaseTransaction.ts new file mode 100644 index 00000000..2fa86b4d --- /dev/null +++ b/src/createDatabaseTransaction.ts @@ -0,0 +1,24 @@ +import { + createTransaction as defaultCreateTransaction, + optionsGenerator as defaultOptionsBuilder, +} from './Utils'; +import { DBMode } from './indexed-db'; + +export function createDatabaseTransaction( + database: IDBDatabase, + mode: DBMode, + storeName: string, + resolve: Function, + reject: Function, + createTransaction: typeof defaultCreateTransaction = defaultCreateTransaction, + buildOptions: typeof defaultOptionsBuilder = defaultOptionsBuilder, +) { + const options = buildOptions(mode, storeName, reject, resolve); + const transaction: IDBTransaction = createTransaction(database, options); + const store = transaction.objectStore(storeName); + + return { + store, + transaction, + }; +}; diff --git a/src/createReadonlyTransaction.ts b/src/createReadonlyTransaction.ts new file mode 100644 index 00000000..c8635511 --- /dev/null +++ b/src/createReadonlyTransaction.ts @@ -0,0 +1,18 @@ +import { DBMode } from './indexed-db'; +import { createDatabaseTransaction } from './createDatabaseTransaction'; + + +export function createReadonlyTransaction( + database: IDBDatabase, + store: string, + resolve: Function, + reject: Function + ) { + return createDatabaseTransaction( + database, + DBMode.readonly, + store, + resolve, + reject + ); +}; diff --git a/src/createReadwriteTransaction.ts b/src/createReadwriteTransaction.ts new file mode 100644 index 00000000..e7378907 --- /dev/null +++ b/src/createReadwriteTransaction.ts @@ -0,0 +1,17 @@ +import { DBMode } from './indexed-db'; +import { createDatabaseTransaction } from './createDatabaseTransaction'; + +export function createReadwriteTransaction( + database: IDBDatabase, + store: string, + resolve: Function, + reject: Function +) { + return createDatabaseTransaction( + database, + DBMode.readwrite, + store, + resolve, + reject + ); +}; diff --git a/src/indexed-db.ts b/src/indexed-db.ts index df32e899..7f16f648 100644 --- a/src/indexed-db.ts +++ b/src/indexed-db.ts @@ -1,5 +1,8 @@ -import { validateBeforeTransaction, createTransaction, optionsGenerator } from './Utils'; +import { useCallback } from 'react'; +import { validateBeforeTransaction } from './Utils'; import { ObjectStoreMeta, ObjectStoreSchema } from './indexed-hooks'; +import { createReadwriteTransaction } from './createReadwriteTransaction'; +import { createReadonlyTransaction } from './createReadonlyTransaction'; export type Key = string | number | Date | ArrayBufferView | ArrayBuffer | IDBArrayKey | IDBKeyRange; export interface IndexDetails { @@ -49,100 +52,46 @@ export function CreateObjectStore(dbName: string, version: number, storeSchemas: } export function DBOperations(dbName: string, version: number, currentStore: string) { - return { - add(value: T, key?: any) { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then((db: IDBDatabase) => { - let transaction = createTransaction(db, optionsGenerator(DBMode.readwrite, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore); - let request = objectStore.add(value, key); - request.onsuccess = (evt: any) => { - key = evt.target.result; - resolve(key); - }; - }); - }); - }, - getByID(id: string | number) { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then((db: IDBDatabase) => { - validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readonly, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore), - request: IDBRequest; - request = objectStore.get(+id); - request.onsuccess = function(event: Event) { - resolve((event.target as any).result as T); - }; - }); - }); - }, - getAll() { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then(db => { - validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readonly, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore), - result: Array = []; + // Readonly operations + const getAll = useCallback( + () => new Promise((resolve, reject) => { + openDatabase(dbName, version).then(db => { + validateBeforeTransaction(db, currentStore, reject); + const { store } = createReadonlyTransaction(db, currentStore, resolve, reject); + const request = store.getAll(); - const request: IDBRequest = objectStore.getAll(); + request.onerror = error => reject(error); - request.onerror = function(e) { - reject(e); - }; - - request.onsuccess = function({ target: { result } }: any) { - resolve(result as T[]); - }; - }); + request.onsuccess = function({ target: { result } }: any) { + resolve(result as T[]); + }; }); - }, - update(value: T, key?: any) { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then(db => { - validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readwrite, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore); - transaction.oncomplete = event => { - resolve(event); - }; - objectStore.put(value, key); - }); - }); - }, - deleteRecord(key: Key) { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then(db => { - validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readwrite, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore); - let request = objectStore.delete(key); - request.onsuccess = event => { - resolve(event); - }; - }); - }); - }, - clear() { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then(db => { - validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readwrite, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore); - objectStore.clear(); - transaction.oncomplete = event => { - resolve(); - }; - }); + }), + [dbName, version, currentStore] + ); + + const getByID = useCallback( + (id: string | number) => new Promise((resolve, reject) => { + openDatabase(dbName, version).then((db: IDBDatabase) => { + validateBeforeTransaction(db, currentStore, reject); + const { store } = createReadonlyTransaction(db, currentStore, resolve, reject); + const request = store.get(+id); + + request.onsuccess = function(event: Event) { + resolve((event.target as any).result as T); + }; }); - }, - openCursor(cursorCallback: (event: Event) => void, keyRange?: IDBKeyRange) { + }), + [dbName, version, currentStore], + ); + + const openCursor = useCallback( + (cursorCallback: (event: Event) => void, keyRange?: IDBKeyRange) => { return new Promise((resolve, reject) => { openDatabase(dbName, version).then(db => { validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readonly, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore), - request = objectStore.openCursor(keyRange); + const { store } = createReadonlyTransaction(db, currentStore, resolve, reject); + const request = store.openCursor(keyRange); request.onsuccess = (event: Event) => { cursorCallback(event); @@ -151,20 +100,96 @@ export function DBOperations(dbName: string, version: number, currentStore: stri }); }); }, - getByIndex(indexName: string, key: any) { - return new Promise((resolve, reject) => { - openDatabase(dbName, version).then(db => { - validateBeforeTransaction(db, currentStore, reject); - let transaction = createTransaction(db, optionsGenerator(DBMode.readonly, currentStore, reject, resolve)), - objectStore = transaction.objectStore(currentStore), - index = objectStore.index(indexName), - request = index.get(key); - request.onsuccess = (event: Event) => { - resolve((event.target).result); - }; - }); + [dbName, version, currentStore], + ); + + const getByIndex = useCallback( + (indexName: string, key: any) => new Promise((resolve, reject) => { + openDatabase(dbName, version).then(db => { + validateBeforeTransaction(db, currentStore, reject); + const { store } = createReadonlyTransaction(db, currentStore, resolve, reject); + const index = store.index(indexName); + const request = index.get(key); + + request.onsuccess = (event: Event) => { + resolve((event.target).result); + }; }); - } + }), + [dbName, version, currentStore], + ); + + // Readwrite operations + const add = useCallback( + (value: T, key?: any) => new Promise((resolve, reject) => { + openDatabase(dbName, version).then((db: IDBDatabase) => { + const { store } = createReadwriteTransaction(db, currentStore, resolve, reject); + const request = store.add(value, key); + + request.onsuccess = (evt: any) => { + key = evt.target.result; + resolve(key); + }; + + request.onerror = error => reject(error); + }); + }), + [dbName, version, currentStore], + ); + + const update = useCallback( + (value: T, key?: any) => new Promise((resolve, reject) => { + openDatabase(dbName, version).then(db => { + validateBeforeTransaction(db, currentStore, reject); + const { + transaction, + store, + } = createReadwriteTransaction(db, currentStore, resolve, reject); + + transaction.oncomplete = event => resolve(event); + + store.put(value, key); + }); + }), + [dbName, version, currentStore], + ); + + const deleteRecord = useCallback( + (key: Key) => new Promise((resolve, reject) => { + openDatabase(dbName, version).then(db => { + validateBeforeTransaction(db, currentStore, reject); + const { store } = createReadwriteTransaction(db, currentStore, resolve, reject); + const request = store.delete(key); + + request.onsuccess = event => resolve(event); + }); + }), + [dbName, version, currentStore], + ); + + const clear = useCallback( + () => new Promise((resolve, reject) => { + openDatabase(dbName, version).then(db => { + validateBeforeTransaction(db, currentStore, reject); + const { store, transaction } = createReadwriteTransaction(db, currentStore, resolve, reject); + + transaction.oncomplete = () => resolve(); + + store.clear(); + }); + }), + [dbName, version, currentStore], + ); + + return { + add, + getByID, + getAll, + update, + deleteRecord, + clear, + openCursor, + getByIndex, }; }