amateras 0.10.1 → 0.10.2

package/packages/idb/src/structure/$IDB.ts

@@ -0,0 +1,63 @@
+import { _Array_from, _null, _Object_assign, _Object_fromEntries, _Promise, isBoolean } from "@amateras/utils";
+import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
+import { $IDBTransaction } from "./$IDBTransaction";
+
+export interface $IDB<Config extends $IDBConfig = any> {
+    /** Object with store name key and `$IDBStoreConfig` value. */
+    readonly stores: Config['stores'];
+}
+export class $IDB<Config extends $IDBConfig = any> {
+    /** {@link IDBDatabase} instance. */
+    readonly idb: IDBDatabase;
+    /** IndexedDB database name. */
+    readonly name: Config['name'];
+    /** IndexedDB database version. */
+    readonly version: Config['version'];
+    constructor(idb: IDBDatabase, config: Omit<Config, 'name' | 'version'>) {
+        this.idb = idb;
+        this.name = idb.name;
+        this.version = idb.version;
+        _Object_assign(this, config);
+    }
+
+    /**
+     * Create new transaction with the store name, you can directly operating the target store with `handle` function. This method will return a `Promise` with the `handle` return type value.
+     * @param name - Store name
+     * @param writable - Enable readwrite mode
+     * @param handle - Function execute on transaction opened
+     * @returns The handle function return type
+     */
+    async store<K extends keyof Config['stores'] & string, T>(name: K, handle: (store: $IDBStore<Config['stores'][K]>) => T): Promise<T>
+    async store<K extends keyof Config['stores'] & string, T>(name: K, writable: boolean, handle: (store: $IDBStore<Config['stores'][K]>) => T): Promise<T>
+    async store<K extends keyof Config['stores'] & string, T>(name: K, resolver: boolean | Function, handle?: Function) {
+        if (isBoolean(resolver)) return this.transaction(name, resolver, $tx => handle!($tx.store(name)));
+        else return this.transaction(name, $tx => resolver($tx.store(name)))
+    }
+
+    /** 
+     * Create new transaction with the store name, you can pass multiple store name into `storeName` argument for operating multiple store in one transaction.
+     * @param store - Store name, allow string array
+     * @param writable - Enable readwrite mode
+     * @param handle - Function execute on transaction opened
+     * @returns The handle function return type
+     */
+    async transaction<K extends keyof Config['stores'] & string, T>(store: K | K[], handle: (transaction: $IDBTransaction<{ stores: Pick<Config['stores'], K> }>) => T): Promise<T>
+    async transaction<K extends keyof Config['stores'] & string, T>(store: K | K[], writable: boolean, handle: (transaction: $IDBTransaction<{ stores: Pick<Config['stores'], K> }>) => T): Promise<T>
+    async transaction<K extends keyof Config['stores'] & string, T>(store: K | K[], resolver?: boolean | Function, handle?: Function) {
+        handle = isBoolean(resolver) ? handle : resolver;
+        resolver = isBoolean(resolver) ? resolver : false;
+        const tx = this.idb.transaction(store, resolver ? 'readwrite' : 'readonly');
+        const $tx = new $IDBTransaction(this, tx);
+        const result = handle!($tx);
+        return new _Promise<T>((resolve, reject) => {
+            tx.oncomplete = _ => resolve(result);
+            tx.onerror = tx.onabort = _ => tx.error && reject(tx.error);
+        })
+    }
+}
+
+export type $IDBConfig = {
+    name: string;
+    version: number;
+    stores: { [key: string]: $IDBStoreConfig }
+}

package/packages/idb/src/structure/$IDBCursor.ts

@@ -0,0 +1,34 @@
+import { _instanceof, _Object_assign, _Promise } from "@amateras/utils";
+import { $IDBRequest } from "#lib/$IDBRequest";
+import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
+import { $IDBIndex } from "./$IDBIndex";
+import type { $IDBStoreBase } from "./$IDBStoreBase";
+
+export interface $IDBCursor {}
+export class $IDBCursor<StoreConfig extends $IDBStoreConfig = any> {
+    #cursor: IDBCursorWithValue;
+    readonly store: $IDBStore<StoreConfig>;
+    readonly direction;
+    constructor(store: $IDBStoreBase, cursor: IDBCursorWithValue) {
+        this.#cursor = cursor;
+        this.store = _instanceof(store, $IDBIndex<StoreConfig>) ? store.store : store as $IDBStore;
+        this.direction = cursor.direction;
+    }
+
+    get value() { return this.#cursor.value }
+    get key() { return this.#cursor.key }
+    get primaryKey() { return this.#cursor.primaryKey }
+
+    async update<T>(value: T) {
+        return $IDBRequest(this.#cursor.update(value))
+    }
+
+    async delete() {
+        return $IDBRequest(this.#cursor.delete())
+    }
+
+    continue(key?: IDBValidKey) { this.#cursor.continue(key) }
+    continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey) { this.#cursor.continuePrimaryKey(key, primaryKey) }
+    advance(count: number) { this.#cursor.advance(count) }
+    abort() { this.#cursor.request.transaction?.abort() }
+}

package/packages/idb/src/structure/$IDBIndex.ts

@@ -0,0 +1,48 @@
+import { _Object_assign } from "@amateras/utils";
+import type { $IDBStore, $IDBStoreConfig, QueryMultipleKeyPath } from "./$IDBStore";
+import { $IDBStoreBase } from "./$IDBStoreBase";
+import type { $IDBCursor } from "./$IDBCursor";
+
+export class $IDBIndex<StoreConfig extends $IDBStoreConfig = any, Config extends $IDBIndexConfig = any> extends $IDBStoreBase{
+    readonly store: $IDBStore;
+    constructor(store: $IDBStore, index: IDBIndex, config: Config) {
+        super(index);
+        this.store = store;
+        _Object_assign(this, config);
+    }
+}
+
+export interface $IDBIndex<StoreConfig extends $IDBStoreConfig, Config extends $IDBIndexConfig = any> {
+    readonly unique: Config['unique'];
+    readonly multiEntry: Config['multiEntry'];
+    readonly keyPath: Config['keyPath'];
+    
+    /** {@link IDBIndex.cursor} */
+    cursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBIndex.keyCursor} */
+    keyCursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBIndex.count} */
+    count(query?: $IDBIndexKey<StoreConfig, Config> | IDBKeyRange): Promise<number>;
+
+    /** {@link IDBIndex.get} */
+    get(query: $IDBIndexKey<StoreConfig, Config> | IDBKeyRange): Promise<StoreConfig['schema']>
+
+    /** {@link IDBIndex.getAll} */
+    getAll(query?: $IDBIndexKey<StoreConfig, Config> | IDBKeyRange): Promise<StoreConfig['schema'][]>
+}
+
+export type $IDBIndexConfig = {
+    unique: boolean;
+    multiEntry: boolean;
+    keyPath: string | string[];
+    name: string;
+}
+
+export type $IDBIndexKey<StoreConfig extends $IDBStoreConfig, Config extends $IDBIndexConfig> = 
+    Config['keyPath'] extends string
+    ?   StoreConfig['schema'][Config['keyPath']]
+    :   Config['keyPath'] extends string[]
+        ?   QueryMultipleKeyPath<Config['keyPath'], StoreConfig>
+        :   IDBValidKey;

package/packages/idb/src/structure/$IDBStore.ts

@@ -0,0 +1,103 @@
+import { _instanceof, _Object_assign, _Promise } from "@amateras/utils";
+import { $IDBIndex, type $IDBIndexConfig } from "./$IDBIndex";
+import { $IDBRequest } from "#lib/$IDBRequest";
+import { $IDBStoreBase } from "./$IDBStoreBase";
+import type { $IDBCursor } from "./$IDBCursor";
+
+export class $IDBStore<Config extends $IDBStoreConfig = any> extends $IDBStoreBase {
+    #store: IDBObjectStore;
+    constructor(store: IDBObjectStore, config: Config) {
+        super(store);
+        this.#store = store;
+        _Object_assign(this, config);
+    }
+
+    /** {@link IDBObjectStore.put} */
+    put<V extends $IDBStoreValueResolver<Config>>(...value: V): Promise<$IDBStoreKey<Config>>
+    put(value: any, key?: any) {
+        return $IDBRequest(this.#store.put(value, key));
+    }
+
+    /** {@link IDBObjectStore.add} */
+    add<V extends $IDBStoreValueResolver<Config>>(value: V): Promise<$IDBStoreKey<Config>>
+    add(value: any, key?: any) {
+        return $IDBRequest(this.#store.add(value, key));
+    }
+
+    /** {@link IDBObjectStore.delete} */
+    delete(query: $IDBStoreKey<Config> | IDBKeyRange): Promise<undefined>;
+    delete(query: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#store.delete(query));
+    }
+
+    /** {@link IDBObjectStore.clear} */
+    clear() {
+        return $IDBRequest(this.#store.clear())
+    }
+
+    /** Get and return {@link $IDBIndex} */
+    index<K extends keyof Config['indexes'] & string>(name: K): $IDBIndex<Config, Config['indexes'][K]>
+    index(name: keyof Config['indexes'] & string) {
+        return new $IDBIndex(this, this.#store.index(name), this.indexes[name]!)
+    }
+}
+
+export interface $IDBStore<Config extends $IDBStoreConfig = any> {
+    readonly name: Config['name'];
+    readonly indexes: Config['indexes'];
+    readonly schema: Config['schema'];
+    readonly keyPath: Config['keyPath'];
+    readonly autoIncrement: Config['autoIncrement'];
+
+    /** {@link IDBObjectStore.cursor} */
+    cursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBObjectStore.keyCursor} */
+    keyCursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBObjectStore.count} */
+    count(query?: $IDBStoreKey<Config> | IDBKeyRange): Promise<number>;
+
+    /** {@link IDBObjectStore.get} */
+    get(query: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema']>
+
+    /** {@link IDBObjectStore.getAll} */
+    getAll(query?: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema'][]>
+}
+
+export type $IDBStoreConfig = {
+    name: string;
+    indexes: { [key: string]: $IDBIndexConfig };
+    schema: any;
+    keyPath: string | string[] | null;
+    autoIncrement: boolean;
+}
+
+export type $IDBStoreValueResolver<Config extends $IDBStoreConfig> = 
+Config['keyPath'] extends string
+    ?   Config['autoIncrement'] extends true
+        ?   [Omit<Config['schema'], Config['keyPath']> & {[key in Config['keyPath']]?: Config['schema'][key]}]
+        :   [Config['schema']]
+    :   Config['keyPath'] extends string[]
+        ?   [Config['schema']] 
+        :   Config['autoIncrement'] extends true 
+            ?   [Config['schema']] 
+            :   [Config['schema'], IDBValidKey];
+
+export type $IDBStoreKey<Config extends $IDBStoreConfig> = 
+    Config['keyPath'] extends string
+        ?   Config['schema'][Config['keyPath']]
+        :   Config['keyPath'] extends string[]
+            ?   QueryMultipleKeyPath<Config['keyPath'], Config>
+            :   Config['autoIncrement'] extends true
+                ?   number
+                :   IDBValidKey;
+
+export type QueryMultipleKeyPath<T extends string[], Config extends { schema: {} }> = 
+    T extends [infer A, ...infer Rest]
+    ?   A extends keyof Config['schema']
+        ?   Rest extends string[]
+            ?   [Config['schema'][A], ...QueryMultipleKeyPath<Rest, Config>]
+            :   [Config['schema'][A]]
+        :   never
+    : []

package/packages/idb/src/structure/$IDBStoreBase.ts

@@ -0,0 +1,30 @@
+import { _Array_from, _instanceof, _null, _Promise } from "@amateras/utils";
+import { $IDBRequest } from "#lib/$IDBRequest";
+import { $IDBCursor } from "./$IDBCursor";
+
+export abstract class $IDBStoreBase {
+    readonly #instance;
+    constructor(instance: IDBObjectStore | IDBIndex) {
+        this.#instance = instance;
+    }
+
+    cursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection) {
+        return $IDBRequest(this.#instance.openCursor(query, direction), (req , resolve) => req.result ? handle(new $IDBCursor(this, req.result)) : resolve(null))
+    }
+
+    keyCursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection) {
+        return $IDBRequest(this.#instance.openCursor(query, direction), (req , resolve) => req.result ? handle(new $IDBCursor(this, req.result)) : resolve(null))
+    }
+
+    count(query?: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#instance.count(query));
+    }
+
+    get(query: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#instance.get(query))
+    }
+
+    getAll(query?: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#instance.getAll(query))
+    }
+}

package/packages/idb/src/structure/$IDBTransaction.ts

@@ -0,0 +1,38 @@
+import { _Array_from, _Object_assign, forEach } from "@amateras/utils";
+import type { $IDB } from "./$IDB";
+import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
+
+export interface $IDBTransaction {}
+export class $IDBTransaction<Config extends $IDBTransactionConfig = any> {
+    #transaction: IDBTransaction;
+    #$idb: $IDB
+    readonly writable: boolean;
+    readonly stores: Config['stores'] = {};
+    readonly durability: string;
+    constructor($idb: $IDB, transaction: IDBTransaction) {
+        this.#transaction = transaction;
+        this.#$idb = $idb;
+        this.writable = transaction.mode !== 'readonly';
+        this.durability = transaction.durability;
+        forEach(_Array_from(transaction.objectStoreNames), name => {
+            _Object_assign(this.stores, { [name]: $idb.stores[name] })
+        })
+    }
+
+    store<N extends keyof Config['stores'] & string>(name: N): $IDBStore<Config['stores'][N]>
+    store(name: string) {
+        return new $IDBStore(this.#transaction.objectStore(name), this.#$idb.stores[name]);
+    }
+
+    commit() {
+        return this.#transaction.commit();
+    }
+
+    abort() {
+        return this.#transaction.abort();
+    }
+}
+
+export type $IDBTransactionConfig = {
+    stores: { [key: string]: $IDBStoreConfig }
+}

package/packages/idb/src/structure/builder/$IDBBuilder.ts

@@ -0,0 +1,229 @@
+import { $IDB, type $IDBConfig } from "#structure/$IDB";
+import { _Array_from, _instanceof, _JSON_stringify, _null, _Object_assign, _Object_fromEntries, _Promise, forEach, isFunction, trycatch } from "@amateras/utils";
+import { $IDBStoreBuilder } from "./$IDBStoreBuilder";
+import type { $IDBIndexConfig } from "#structure/$IDBIndex";
+import type { $IDBStoreConfig } from "#structure/$IDBStore";
+// optimizer variables
+const objectStoreNames = 'objectStoreNames';
+const deleteObjectStore = 'deleteObjectStore';
+const createObjectStore = 'createObjectStore';
+const _indexedDB = indexedDB;
+const onupgradeneeded = 'onupgradeneeded';
+const onsuccess = 'onsuccess';
+
+export interface $IDBBuilder {
+    readonly name: string;
+    readonly version: number;
+}
+export class $IDBBuilder<Config extends $IDBConfig = { name: string, stores: {}, version: number }> {
+    #deleteUnused = false;
+    storeMap = new Map<string, $IDBStoreBuilder>();
+    #devMode: boolean = false;
+    constructor(config: Config) {
+        _Object_assign(this, config);
+    }
+
+    /**
+     * This option helping developer to debug when initializing.
+     * @param dev - Enable dev mode
+     */
+    devMode(dev: boolean) {
+        this.#devMode = dev;
+        return this;
+    }
+    
+    /**
+     * If set to true, unused store will be deleted when initialize.
+     * @param enable - Enable delete unused stores
+     */
+    deleteUnused(enable: boolean) {
+        this.#deleteUnused = enable;
+        return this;
+    }
+
+    /**
+     * Add new store to builder.
+     * @param name - Store name
+     * @param builder - Store builder or builder function
+     */
+    store<N extends string, B extends $IDBStoreBuilderFunction>(name: N, builder: B): $IDBBuilder<Prettify<Config & { stores: Config['stores'] & Prettify<Record<N, ReturnType<B>['config']>> }>>
+    store<N extends string, B extends $IDBStoreBuilder<any>>(name: N, builder: B): $IDBBuilder<Prettify<Config & { stores: Config['stores'] & Prettify<Record<N, B['config']>> }>>
+    store(name: string, builder: $IDBStoreBuilderFunction | $IDBStoreBuilder)
+    {
+        this.storeMap.set(name, isFunction(builder) ? builder(new $IDBStoreBuilder({autoIncrement: false, keyPath: null, indexes: {}, name, schema: null})) : builder);
+        return this as any;
+    }
+
+    /**
+     * Open IDB and initialize, create new IDB if the name of IDB is not exists, or perform the upgrade if version number change.
+     */
+    async open(): Promise<$IDB<Config>> {
+        return new _Promise<$IDB>((resolve, reject) => {
+            const {version: dbVersion, name: dbName, storeMap} = this;
+            const initDBRequest = _indexedDB.open(dbName);
+            const createStoresMap = new Map<string, $IDBStoreBuilder<$IDBStoreConfig>>();
+            const createIndexMap = new Map<$IDBStoreBuilder, Map<string, $IDBIndexConfig>>();
+            const upgradeStoreMap = new Map<string, $IDBStoreBuilder<$IDBStoreConfig>>();
+            const cachedObjectMap = new Map<string, {key: any, value: any}[]>();
+            const unusedStoreNameList: string[] = [];
+            const debug = (message: string) => this.#devMode && console.debug(`[$IDBBuilder (${dbName})]`, message);
+            const storesObject: $IDBConfig['stores'] = _Object_fromEntries(_Array_from(storeMap).map(([name, {config: {keyPath, autoIncrement}, indexes}]) => [
+                name, 
+                {
+                    autoIncrement, keyPath, name,
+                    schema: _null,
+                    indexes: _Object_fromEntries(_Array_from(indexes).map(([name, {keyPath, multiEntry, unique}]) => [
+                        name,
+                        { keyPath, multiEntry, unique } as $IDBIndexConfig
+                    ]))
+                } as $IDBStoreConfig
+            ]))
+            const idbConfig = { version: dbVersion, name: dbName, stores: storesObject };
+            /** IndexedDB initial create function */
+            const initialCreateDB = () => {
+                debug(`No IDB detected, create IDB`);
+                const {transaction, result: idb} = initDBRequest;
+                forEach(storeMap, ([name, storeBuilder]) => {
+                    createStoresMap.set(name, storeBuilder);
+                    createIndexMap.set(storeBuilder, new Map(storeBuilder.indexes))
+                })
+                if (idb.version === dbVersion) upgradeStore(initDBRequest);
+                else transaction!.oncomplete = _ => {
+                    const upgradeDBRequest = indexedDB.open(dbName, dbVersion);
+                    upgradeDBRequest.onupgradeneeded = _ => upgradeStore(upgradeDBRequest);
+                }
+            }
+            /** IndexedDB initial open function */
+            const initialOpenDB = async () => {
+                debug(`IDB Detected`);
+                const idb = initDBRequest.result;
+                const $idb = new $IDB(idb, idbConfig);
+                const transaction = idb[objectStoreNames].length ?  idb.transaction(_Array_from(idb[objectStoreNames]), 'readonly') : null;
+                const noUpgrade = () => {
+                    debug(`No Upgrade`);
+                    resolve($idb);
+                }
+                if (idb.version === dbVersion) return noUpgrade();
+                // get unused stores
+                transaction && forEach(_Array_from(transaction[objectStoreNames]), name => storeMap.has(name) && unusedStoreNameList.push(name))
+                // check store config matches
+                forEach(storeMap, ([storeName, storeBuilder]) => {
+                    const {keyPath, autoIncrement} = storeBuilder.config;
+                    const indexMap = new Map();
+                    const checkIndexes = () =>
+                        forEach(storeBuilder.indexes, ([indexName, indexBuilder]) => {
+                            const [index] = trycatch(() => store?.index(indexName));
+                            const CONFIG_CHANGED = _JSON_stringify(indexBuilder.keyPath) !== _JSON_stringify(index?.keyPath)
+                                || !!indexBuilder.multiEntry !== index?.multiEntry 
+                                || !!indexBuilder.unique !== index?.unique;
+                            if (!index || CONFIG_CHANGED) {
+                                indexMap.set(indexName, indexBuilder);
+                                createIndexMap.set(storeBuilder, indexMap);
+                            }
+                        })
+                    // get store from idb
+                    const [store] = trycatch(() => transaction?.objectStore(storeName));
+                    // create store and break if idb have no store exist
+                    if (!store) return createStoresMap.set(storeName, storeBuilder), checkIndexes();
+                    // define matches variables
+                    const OBJECT_UPGRADE = _Array_from(storeBuilder.upgrades).find(([upgradeVersion],) => 
+                        dbVersion >= upgradeVersion && idb.version < upgradeVersion
+                    )
+                    const CONFIG_CHANGED = 
+                        _JSON_stringify(keyPath) !== _JSON_stringify(store.keyPath)
+                        || autoIncrement !== store?.autoIncrement
+                    const UPGRADE_NEEDED = OBJECT_UPGRADE || CONFIG_CHANGED;
+                    // add indexes
+                    checkIndexes();
+                    // store existed and not need upgrade
+                    if (store && !UPGRADE_NEEDED) return;
+                    // add upgrade store queue
+                    upgradeStoreMap.set(storeName, storeBuilder)
+                    
+                })
+                // resolve if no need upgrade
+                if (dbVersion === idb.version && !createStoresMap.size && !upgradeStoreMap.size && !unusedStoreNameList.length && !createIndexMap.size)
+                    return noUpgrade();
+                // cache objects
+                for (const [storeName, storeBuilder] of upgradeStoreMap) {
+                    const cache: {key: any, value: any}[] = [];
+                    // filter version lower than current idb
+                    const upgradeHandleList = _Array_from(storeBuilder.upgrades)
+                        .filter(([upgradeVersion]) => dbVersion >= upgradeVersion && idb.version < upgradeVersion )
+                        .sort((a, b) => a[0] - b[0])
+                        .map(config => config[1]);
+                    // cache objects from store
+                    await $idb.transaction(storeName, false, async $tx => {
+                        cachedObjectMap.set(storeName, cache);
+                        await $tx.store(storeName).cursor(async cursor => {
+                            cache.push({key: cursor.key, value: cursor.value});
+                            cursor.continue();
+                        })
+                    })
+                    // upgrade objects
+                    for (const upgradeHandle of upgradeHandleList) 
+                        cachedObjectMap.set(storeName, await upgradeHandle(cache, $idb));
+                }
+                // upgrade db from lower version
+                idb.close();
+                const upgradeDBRequest = _indexedDB.open(dbName, dbVersion);
+                upgradeDBRequest[onupgradeneeded] = _ => upgradeStore(upgradeDBRequest);
+                upgradeDBRequest[onsuccess] = _ => {
+                    debug('IDB Upgrade Completed');
+                    resolve(new $IDB(upgradeDBRequest.result, idbConfig));
+                }
+            }
+
+            /** IndexedDB upgrade version */
+            const upgradeStore = (req: IDBOpenDBRequest) => {
+                debug('Upgrade DB')
+                const idb = req.result;
+                /** 'versionchange' type transaction */
+                const transaction = req.transaction as IDBTransaction;
+                // create stores
+                forEach(createStoresMap, ([name, {config}]) => {
+                    idb[createObjectStore](name, config);
+                    debug(`Store Created: ${name}`);
+                });
+                // upgrade stores
+                forEach(upgradeStoreMap, ([name, {config}]) => {
+                    idb[deleteObjectStore](name); 
+                    idb[createObjectStore](name, config);
+                    debug(`Store Upgraded: ${name}`);
+                })
+                // create indexes
+                forEach(createIndexMap, ([{config: {name}}, indexMap]) => {
+                    const store = transaction.objectStore(name);
+                    forEach(indexMap, ([indexName, {keyPath, ...config}]) => {
+                        // if indexes existed, delete and create again
+                        if (store.indexNames.contains(indexName)) store.deleteIndex(indexName);
+                        store.createIndex(indexName, keyPath, config);
+                        debug(`Store '${name}' Index Created: ${indexName}`);
+                    })
+                })
+                // delete unused stores
+                if (this.#deleteUnused) forEach(unusedStoreNameList, name => {
+                    idb[deleteObjectStore](name);
+                    debug(`Unused Store Deleted: ${name}`);
+                });
+                // open db again for insert objects
+                forEach(cachedObjectMap, ([storeName, objectList]) => {
+                    const store = transaction.objectStore(storeName);
+                    forEach(objectList, ({key, value}) => {
+                        if (store.autoIncrement || store.keyPath) store.add(value);
+                        else store.add(value, key)
+                    })
+                    debug(`Recovered Store Objects: ${objectList.length} objects of store '${storeName}'`);
+                })
+            }
+
+            // If db not exist, create db will trigger upgraedneeded event
+            initDBRequest[onupgradeneeded] = initialCreateDB;
+            // If db exist, trigger success event
+            initDBRequest[onsuccess] = initialOpenDB;
+            initDBRequest.onerror = _ => reject(initDBRequest.error);
+        })
+    }
+}
+
+export type $IDBStoreBuilderFunction = (store: $IDBStoreBuilder) => $IDBStoreBuilder<any>;

package/packages/idb/src/structure/builder/$IDBStoreBuilder.ts

@@ -0,0 +1,100 @@
+import type { $IDB } from "#structure/$IDB";
+import { _null } from "@amateras/utils";
+import type { $IDBStoreConfig } from "#structure/$IDBStore";
+import type { $IDBIndexConfig } from "#structure/$IDBIndex";
+
+export class $IDBStoreBuilder<Config extends $IDBStoreConfig = { name: string, keyPath: null, autoIncrement: false, schema: any, indexes: {} }> {
+    readonly config: Config
+    upgrades = new Map<number, $IDBStoreUpgradeFunction>();
+    indexes = new Map<string, $IDBIndexConfig>();
+    constructor(config: Config) {
+        this.config = config;
+    }
+
+    /**
+     * Define the `keyPath` option of store.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB#structuring_the_database).
+     */
+    keyPath<K extends string[]>(keyPath: K): $IDBStoreBuilder<Prettify<Omit<Config, 'keyPath'> & { keyPath: K }>>;
+    keyPath<K extends string>(keyPath: K): $IDBStoreBuilder<Prettify<Omit<Config, 'keyPath'> & { keyPath: K }>>;
+    keyPath(keyPath: string | string[]) {
+        this.config.keyPath = keyPath;
+        return this as any;
+    }
+
+    /**
+     * Define the `autoIncrement` option of store. 
+     * 
+     * [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB#structuring_the_database).
+     */
+    autoIncrement<K extends boolean>(enable: K): $IDBStoreBuilder<Prettify<Omit<Config, 'autoIncrement'> & { autoIncrement: K }>>;
+    autoIncrement(enable: boolean) {
+        this.config.autoIncrement = enable;
+        return this as any;
+    }
+
+    /**
+     * Use the generic type to define store object type.
+     *
+     * @example
+     * store.schema<{
+     *     id: number,
+     *     name: string,
+     *     created: Date,
+     *     updated: Date
+     * }>()
+     */
+    schema<T extends $IDBStoreBuilderSchema<Config>>(): $IDBStoreBuilder<Prettify<Omit<Config, 'schema'> & { schema: T }>>;
+    schema() { return this as any }
+
+    /**
+     * Add new index to store builder.
+     * @param name - Index name
+     * @param config - {@link $IDBIndexOptionalConfig}
+     */
+    index<N extends string, C extends $IDBIndexOptionalConfig<Config>>(name: N, config: C): $IDBStoreBuilder<Prettify<Config & { indexes: Config['indexes'] & Prettify<Record<N, Prettify<$IDBIndexOptionalHandle<N, C>>>> }>>
+    index<C extends $IDBIndexConfig>(name: string, config: C) {
+        this.indexes.set(name, {
+            ...config, name,
+            multiEntry: config.multiEntry ?? false,
+            unique: config.unique ?? false
+        });
+        return this as any;
+    }
+
+    /**
+     * Add store upgrade function to store builder. The store upgrade function is used for change object structure when the store is upgrading. 
+     * @param version - Target version of database
+     * @param handle - Upgrade handle function
+     */
+    upgrade(version: number, handle: $IDBStoreUpgradeFunction) {
+        this.upgrades.set(version, handle);
+        return this;
+    }
+
+}
+
+export type $IDBStoreUpgradeFunction = (objects: {key: IDBValidKey, value: any}[], idb: $IDB<any>) => OrPromise<{key: IDBValidKey, value: any}[]>;
+
+export type $IDBIndexOptionalConfig<StoreConfig extends $IDBStoreConfig = any> = { 
+    keyPath: OrArray<keyof StoreConfig['schema']>, 
+    unique?: boolean, 
+    multiEntry?: boolean 
+}
+
+type $IDBIndexOptionalHandle<N extends string, Config extends $IDBIndexOptionalConfig> = {
+    name: N;
+    keyPath: Config['keyPath'];
+    multiEntry: Config['multiEntry'] extends boolean ? Config['multiEntry'] : false;
+    unique: Config['unique'] extends boolean ? Config['unique'] : false;
+}
+
+type $IDBStoreBuilderSchema<Config extends $IDBStoreConfig> = 
+    Config['keyPath'] extends string
+        ?   Config['autoIncrement'] extends true
+            ?   { [key in Config['keyPath']]: number }
+            :   { [key in Config['keyPath']]: IDBValidKey } 
+        : Config['keyPath'] extends string[]
+            ? { [key in Config['keyPath'][number]]: IDBValidKey }
+            : any;

package/packages/if/package.json

@@ -0,0 +1,15 @@
+{
+    "name": "@amateras/if",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/signal": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts"
+    },
+    "exports": {
+      ".": "./src/index.ts"
+    }
+}