369 lines
10 KiB
TypeScript
369 lines
10 KiB
TypeScript
import {blobConstruct, bytesToBase64, blobSafeMimeType, dataUrlToBlob} from './bin_utils';
|
|
import FileManager from './filemanager';
|
|
import { logger } from './logger';
|
|
|
|
class IdbFileStorage {
|
|
public dbName = 'cachedFiles';
|
|
public dbStoreName = 'files';
|
|
public dbVersion = 2;
|
|
public openDbPromise: Promise<IDBDatabase>;
|
|
public storageIsAvailable = true;
|
|
public name = 'IndexedDB';
|
|
|
|
private log: ReturnType<typeof logger> = logger('IDB');
|
|
|
|
constructor() {
|
|
this.openDatabase(true);
|
|
}
|
|
|
|
public isAvailable() {
|
|
return this.storageIsAvailable;
|
|
}
|
|
|
|
public openDatabase(createNew = false): Promise<IDBDatabase> {
|
|
if(this.openDbPromise && !createNew) {
|
|
return this.openDbPromise;
|
|
}
|
|
|
|
const createObjectStore = (db: IDBDatabase) => {
|
|
db.createObjectStore(this.dbStoreName);
|
|
};
|
|
|
|
try {
|
|
var request = indexedDB.open(this.dbName, this.dbVersion);
|
|
|
|
if(!request) {
|
|
throw new Error();
|
|
}
|
|
} catch(error) {
|
|
this.log.error('error opening db', error.message)
|
|
this.storageIsAvailable = false;
|
|
return Promise.reject(error);
|
|
}
|
|
|
|
let finished = false;
|
|
setTimeout(() => {
|
|
if(!finished) {
|
|
request.onerror({type: 'IDB_CREATE_TIMEOUT'} as Event);
|
|
}
|
|
}, 3000);
|
|
|
|
return this.openDbPromise = new Promise<IDBDatabase>((resolve, reject) => {
|
|
request.onsuccess = (event) => {
|
|
finished = true;
|
|
const db = request.result;
|
|
let calledNew = false;
|
|
|
|
this.log('Opened');
|
|
|
|
db.onerror = (error) => {
|
|
this.storageIsAvailable = false;
|
|
this.log.error('Error creating/accessing IndexedDB database', error);
|
|
reject(error);
|
|
};
|
|
|
|
db.onclose = (e) => {
|
|
this.log.error('closed:', e);
|
|
!calledNew && this.openDatabase();
|
|
};
|
|
|
|
db.onabort = (e) => {
|
|
this.log.error('abort:', e);
|
|
const transaction = e.target as IDBTransaction;
|
|
|
|
this.openDatabase(calledNew = true);
|
|
|
|
if(transaction.onerror) {
|
|
transaction.onerror(e);
|
|
}
|
|
|
|
db.close();
|
|
};
|
|
|
|
db.onversionchange = (e) => {
|
|
this.log.error('onversionchange, lol?');
|
|
};
|
|
|
|
resolve(db);
|
|
};
|
|
|
|
request.onerror = (event) => {
|
|
finished = true;
|
|
this.storageIsAvailable = false;
|
|
this.log.error('Error creating/accessing IndexedDB database', event);
|
|
reject(event);
|
|
};
|
|
|
|
request.onupgradeneeded = (event) => {
|
|
finished = true;
|
|
this.log.warn('performing idb upgrade from', event.oldVersion, 'to', event.newVersion);
|
|
|
|
// @ts-ignore
|
|
var db = event.target.result as IDBDatabase;
|
|
if(event.oldVersion == 1) {
|
|
db.deleteObjectStore(this.dbStoreName);
|
|
}
|
|
|
|
createObjectStore(db);
|
|
};
|
|
});
|
|
}
|
|
|
|
public deleteFile(fileName: string): Promise<void> {
|
|
//return Promise.resolve();
|
|
return this.openDatabase().then((db) => {
|
|
try {
|
|
this.log('Delete file: `' + fileName + '`');
|
|
var objectStore = db.transaction([this.dbStoreName], 'readwrite')
|
|
.objectStore(this.dbStoreName);
|
|
|
|
var request = objectStore.delete(fileName);
|
|
} catch(error) {
|
|
return Promise.reject(error);
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const timeout = setTimeout(() => {
|
|
this.log.error('deleteFile request not finished!', fileName, request);
|
|
resolve();
|
|
}, 3000);
|
|
|
|
request.onsuccess = (event) => {
|
|
this.log('deleted file', event);
|
|
resolve();
|
|
clearTimeout(timeout);
|
|
};
|
|
|
|
request.onerror = (error) => {
|
|
reject(error);
|
|
clearTimeout(timeout);
|
|
};
|
|
});
|
|
});
|
|
}
|
|
|
|
public saveFile(fileName: string, blob: Blob | Uint8Array): Promise<Blob> {
|
|
return Promise.resolve(blobConstruct([blob]));
|
|
return this.openDatabase().then((db) => {
|
|
if(!(blob instanceof Blob)) {
|
|
blob = blobConstruct([blob]) as Blob;
|
|
}
|
|
|
|
this.log('saveFile:', fileName, blob);
|
|
|
|
const handleError = (error: Error) => {
|
|
this.log.error('saveFile transaction error:', fileName, blob, db, error, error && error.name);
|
|
if((!error || error.name === 'InvalidStateError')/* && false */) {
|
|
setTimeout(() => {
|
|
this.saveFile(fileName, blob);
|
|
}, 2e3);
|
|
} else {
|
|
//console.error('IndexedDB saveFile transaction error:', error, error && error.name);
|
|
}
|
|
};
|
|
|
|
try {
|
|
const transaction = db.transaction([this.dbStoreName], 'readwrite');
|
|
transaction.onerror = (e) => {
|
|
handleError(transaction.error);
|
|
};
|
|
transaction.oncomplete = (e) => {
|
|
this.log('saveFile transaction complete:', fileName);
|
|
};
|
|
|
|
/* transaction.addEventListener('abort', (e) => {
|
|
//handleError();
|
|
this.log.error('IndexedDB: saveFile transaction abort!', transaction.error);
|
|
}); */
|
|
|
|
const objectStore = transaction.objectStore(this.dbStoreName);
|
|
var request = objectStore.put(blob, fileName);
|
|
} catch(error) {
|
|
handleError(error);
|
|
return blob;
|
|
|
|
/* this.storageIsAvailable = false;
|
|
throw error; */
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const timeout = setTimeout(() => {
|
|
this.log.error('saveFile request not finished', fileName, request);
|
|
}, 3000);
|
|
|
|
request.onsuccess = (event) => {
|
|
resolve(blob as Blob);
|
|
clearTimeout(timeout);
|
|
};
|
|
|
|
request.onerror = (error) => {
|
|
reject(error);
|
|
clearTimeout(timeout);
|
|
};
|
|
});
|
|
});
|
|
}
|
|
|
|
public saveFileBase64(db: IDBDatabase, fileName: string, blob: Blob | any): Promise<Blob> {
|
|
if(this.getBlobSize(blob) > 10 * 1024 * 1024) {
|
|
return Promise.reject();
|
|
}
|
|
|
|
if(!(blob instanceof Blob)) {
|
|
var safeMimeType = blobSafeMimeType(blob.type || 'image/jpeg');
|
|
var address = 'data:' + safeMimeType + ';base64,' + bytesToBase64(blob);
|
|
return this.storagePutB64String(db, fileName, address).then(() => {
|
|
return blob;
|
|
});
|
|
}
|
|
|
|
try {
|
|
var reader = new FileReader();
|
|
} catch (e) {
|
|
this.storageIsAvailable = false;
|
|
return Promise.reject();
|
|
}
|
|
|
|
let promise = new Promise<Blob>((resolve, reject) => {
|
|
reader.onloadend = () => {
|
|
this.storagePutB64String(db, fileName, reader.result as string).then(() => {
|
|
resolve(blob);
|
|
}, reject);
|
|
}
|
|
|
|
reader.onerror = reject;
|
|
});
|
|
|
|
|
|
try {
|
|
reader.readAsDataURL(blob);
|
|
} catch (e) {
|
|
this.storageIsAvailable = false;
|
|
return Promise.reject();
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
public storagePutB64String(db: IDBDatabase, fileName: string, b64string: string) {
|
|
try {
|
|
var objectStore = db.transaction([this.dbStoreName], 'readwrite')
|
|
.objectStore(this.dbStoreName);
|
|
var request = objectStore.put(b64string, fileName);
|
|
} catch(error) {
|
|
this.storageIsAvailable = false;
|
|
return Promise.reject(error);
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
request.onsuccess = function(event) {
|
|
resolve();
|
|
};
|
|
|
|
request.onerror = reject;
|
|
});
|
|
}
|
|
|
|
public getBlobSize(blob: any) {
|
|
return blob.size || blob.byteLength || blob.length;
|
|
}
|
|
|
|
public getFile(fileName: string): Promise<Blob> {
|
|
//return Promise.reject();
|
|
return this.openDatabase().then((db) => {
|
|
this.log('getFile pre:', fileName);
|
|
|
|
try {
|
|
const transaction = db.transaction([this.dbStoreName], 'readonly');
|
|
transaction.onabort = (e) => {
|
|
this.log.error('getFile transaction onabort?', e);
|
|
};
|
|
const objectStore = transaction.objectStore(this.dbStoreName);
|
|
var request = objectStore.get(fileName);
|
|
|
|
//this.log.log('IDB getFile:', fileName, request);
|
|
} catch(err) {
|
|
this.log.error('getFile error:', err, fileName, request, request.error);
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const timeout = setTimeout(() => {
|
|
this.log.error('getFile request not finished!', fileName, request);
|
|
reject();
|
|
}, 3000);
|
|
|
|
request.onsuccess = function(event) {
|
|
const result = request.result;
|
|
if(result === undefined) {
|
|
reject();
|
|
} else if(typeof result === 'string' &&
|
|
result.substr(0, 5) === 'data:') {
|
|
resolve(dataUrlToBlob(result));
|
|
} else {
|
|
resolve(result);
|
|
}
|
|
|
|
clearTimeout(timeout);
|
|
}
|
|
|
|
request.onerror = () => {
|
|
clearTimeout(timeout);
|
|
reject();
|
|
};
|
|
});
|
|
});
|
|
}
|
|
|
|
public getAllKeys(): Promise<Array<string>> {
|
|
console.time('getAllEntries');
|
|
return this.openDatabase().then((db) => {
|
|
var objectStore = db.transaction([this.dbStoreName], 'readonly')
|
|
.objectStore(this.dbStoreName);
|
|
var request = objectStore.getAllKeys();
|
|
|
|
return new Promise((resolve, reject) => {
|
|
request.onsuccess = function(event) {
|
|
// @ts-ignore
|
|
var result = event.target.result;
|
|
resolve(result);
|
|
console.timeEnd('getAllEntries');
|
|
}
|
|
|
|
request.onerror = reject;
|
|
});
|
|
});
|
|
}
|
|
|
|
public isFileExists(fileName: string): Promise<boolean> {
|
|
console.time('isFileExists');
|
|
return this.openDatabase().then((db) => {
|
|
var objectStore = db.transaction([this.dbStoreName], 'readonly')
|
|
.objectStore(this.dbStoreName);
|
|
var request = objectStore.openCursor(fileName);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
request.onsuccess = function(event) {
|
|
// @ts-ignore
|
|
var cursor = event.target.result;
|
|
resolve(!!cursor);
|
|
console.timeEnd('isFileExists');
|
|
}
|
|
|
|
request.onerror = reject;
|
|
});
|
|
});
|
|
}
|
|
|
|
public getFileWriter(fileName: string, mimeType: string) {
|
|
var fakeWriter = FileManager.getFakeFileWriter(mimeType, (blob) => {
|
|
return this.saveFile(fileName, blob);
|
|
});
|
|
|
|
return Promise.resolve(fakeWriter);
|
|
}
|
|
}
|
|
|
|
const idbFileStorage = new IdbFileStorage();
|
|
(window as any).IdbFileStorage = idbFileStorage;
|
|
export default idbFileStorage;
|