dandelion/src/db.ts

// interface MyJsonObject {
//   id: string;
//   name: string;
//   email: string;
// }

const dbName: string = "ddln";
const storeNameBase: string = "posts";
let keyBase = "dandelion_posts_v1_"
let key = "";


interface IDBRequestEvent<T = any> extends Event {
    target: IDBRequest<T>;
}

// IndexedDB uses DOMException, so let's use it for error typing
type DBError = Event & {
    target: { errorCode: DOMException };
};

export function openDatabase(userID:string): Promise<IDBDatabase> {
    const storeName = `${storeNameBase}_${userID}`;

    return new Promise((resolve, reject) => {
        const request: IDBOpenDBRequest = indexedDB.open(dbName, 1);

        request.onerror = (event: Event) => {
            // Use a type assertion to access the specific properties of IDBRequest error event
            const errorEvent = event as IDBRequestEvent;
            reject(`Database error: ${errorEvent.target.error?.message}`);
        };

        request.onupgradeneeded = (event: IDBVersionChangeEvent) => {
            const db: IDBDatabase = (event.target as IDBOpenDBRequest).result;
            if (!db.objectStoreNames.contains(storeName)) {
                let store = db.createObjectStore(storeName, { keyPath: "id", autoIncrement: true });
                store.createIndex("datetimeIndex", "post_timestamp", { unique: false });
                store.createIndex("postIDIndex", "data.post_id", { unique: true });

            }
        };

        request.onsuccess = (event: Event) => {
            const db: IDBDatabase = (event.target as IDBOpenDBRequest).result;
            resolve(db);
        };
    });
}



export async function addData(userID: string, data: any): Promise<void> {
    try {
        const storeName = `${storeNameBase}_${userID}`;
        const db = await openDatabase(userID);
        const transaction = db.transaction(storeName, "readwrite");
        const store = transaction.objectStore(storeName);

        const addRequest = store.add({post_timestamp: data.post_timestamp, data:data});

        addRequest.onsuccess = (e: Event) => {
            // console.log('Data has been added:', (e.target as IDBRequest).result);
        };

        addRequest.onerror = (event: Event) => {
            // Use a type assertion to access the specific properties of IDBRequest error event
            const errorEvent = event as IDBRequestEvent;
            console.error('Error in adding data:', errorEvent.target.error?.message);
        };
    } catch (error) {
        console.error('Error in opening database:', error);
    }
}

export async function addDataArray(userID: string, array: any[]): Promise<void> {
    try {
        const storeName = `${storeNameBase}_${userID}`;
        const db = await openDatabase(userID);
        const transaction = db.transaction(storeName, "readwrite");
        const store = transaction.objectStore(storeName);

        let count = 0;

        array.reverse();

        for (let data of array) {
            const addRequest = store.add({post_timestamp: data.post_timestamp, data:data});
            addRequest.onsuccess = (e: Event) => {
                // console.log('Data has been added:', (e.target as IDBRequest).result);
            };
    
            addRequest.onerror = (event: Event) => {
                // Use a type assertion to access the specific properties of IDBRequest error event
                const errorEvent = event as IDBRequestEvent;
                console.error('Error in adding data:', errorEvent.target.error?.message);
            };

            count++;

            // if (count % 100 === 0) {
            //     console.log(`Added ${count} posts...`);
            // }
        }

       
    } catch (error) {
        console.error('Error in opening database:', error);
    }
}

export async function getData(userID:string, lowerID:Date, upperID:Date): Promise<any | undefined> {
    const storeName = `${storeNameBase}_${userID}`;
    const db = await openDatabase(userID);
    const transaction = db.transaction(storeName, "readonly");
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
        const keyRangeValue = IDBKeyRange.bound(lowerID, upperID);

        const records: any[] = [];

        const index = store.index("datetimeIndex");


        const cursorRequest = index.openCursor(keyRangeValue);

        cursorRequest.onsuccess = (event: Event) => {
            const cursor = (event.target as IDBRequest).result as IDBCursorWithValue;
            if (cursor) {
                records.push(cursor.value.data); // Collect the record
                cursor.continue(); // Move to the next item in the range
            } else {
                // No more entries in the range
                resolve(records);
            }
        };

        cursorRequest.onerror = (event: Event) => {
            // Use a type assertion to access the specific properties of IDBRequest error event
            const errorEvent = event as IDBRequestEvent;
            console.error('Transaction failed:', errorEvent.target.error?.message);
            reject(errorEvent.target.error); // Reject the promise if there's an error
        };
    });
}

export async function getAllData(userID:string): Promise<any | undefined> {
    const storeName = `${storeNameBase}_${userID}`;
    const db = await openDatabase(userID);
    const transaction = db.transaction(storeName, "readonly");
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
        const getRequest = store.getAll();

        getRequest.onsuccess = () => {
            if (getRequest.result) {
                //   console.log('Retrieved data:', getRequest.result.jsonData);
                // resolve(getRequest.result.jsonData as any);
                resolve(getRequest.result);
            } else {
                console.log('No data record found for key', key);
                resolve(undefined); // explicitly resolve with undefined when no data is found
            }
        };

        getRequest.onerror = (event: Event) => {
            // Use a type assertion to access the specific properties of IDBRequest error event
            const errorEvent = event as IDBRequestEvent;
            console.error('Transaction failed:', errorEvent.target.error?.message);
            reject(errorEvent.target.error); // reject the promise if there's an error
        };
    });
}