@bbn/bbn 2.0.237 → 2.0.239

package/dist/db/classes/ObjectProxy.d.ts

@@ -0,0 +1,18 @@
+import { DbApi, OrderClause } from '../types.js';
+export default class bbnDbObjectProxy implements DbApi {
+    private readonly _dbName;
+    lastErr: any;
+    constructor(dbName: string);
+    get dbName(): string;
+    insert(table: string, data: any): Promise<number>;
+    update(table: string, data: any, where: any, replace?: boolean): Promise<number>;
+    delete(table: string, where: any): Promise<number>;
+    selectOne(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number): Promise<unknown>;
+    select(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number): Promise<unknown>;
+    selectAll(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<unknown>;
+    getColumnValues(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<unknown>;
+    copyTable(target: string, table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<number>;
+    deleteTable(table: string): Promise<boolean>;
+    close(): void;
+    lastError(): unknown;
+}

package/dist/db/classes/ObjectProxy.js

@@ -0,0 +1,79 @@
+import log from '../../fn/browser/log.js';
+let requestId = 0;
+function callServiceWorker(obj, method, args) {
+    return new Promise((resolve, reject) => {
+        if (!navigator.serviceWorker?.controller) {
+            reject(new Error('No active service worker controller'));
+            return;
+        }
+        const id = ++requestId;
+        const channel = new MessageChannel();
+        channel.port1.onmessage = event => {
+            const msg = event.data;
+            log(['SW response', msg]);
+            if (msg?.id !== id) {
+                return;
+            }
+            if (msg.error) {
+                obj.lastErr = msg.error;
+            }
+            if (msg.ok) {
+                resolve(msg.result);
+            }
+            else {
+                reject(new Error(msg.error || 'IndexedDB service worker error'));
+            }
+            channel.port1.close();
+        };
+        const command = {
+            id,
+            database: obj.dbName,
+            method,
+            args
+        };
+        navigator.serviceWorker.controller.postMessage(command, [channel.port2]);
+    });
+}
+export default class bbnDbObjectProxy {
+    _dbName;
+    lastErr = null;
+    constructor(dbName) {
+        this._dbName = dbName;
+    }
+    get dbName() {
+        return this._dbName;
+    }
+    insert(table, data) {
+        return callServiceWorker(this, 'object.insert', [table, data]);
+    }
+    update(table, data, where, replace = false) {
+        return callServiceWorker(this, 'object.update', [table, data, where, replace]);
+    }
+    delete(table, where) {
+        return callServiceWorker(this, 'object.delete', [table, where]);
+    }
+    selectOne(table, field, where, order, start, limit) {
+        return callServiceWorker(this, 'object.selectOne', [table, field, where, order, start, limit]);
+    }
+    select(table, fields, where, order, start) {
+        return callServiceWorker(this, 'object.select', [table, fields, where, order, start]);
+    }
+    selectAll(table, fields, where, order, start, limit) {
+        return callServiceWorker(this, 'object.selectAll', [table, fields, where, order, start, limit]);
+    }
+    getColumnValues(table, field, where, order, start, limit) {
+        return callServiceWorker(this, 'object.getColumnValues', [table, field, where, order, start, limit]);
+    }
+    copyTable(target, table, fields, where, order, start, limit) {
+        return callServiceWorker(this, 'object.copyTable', [target, table, fields, where, order, start, limit]);
+    }
+    deleteTable(table) {
+        return callServiceWorker(this, 'object.deleteTable', [table]);
+    }
+    close() {
+        void callServiceWorker(this, 'object.close', []);
+    }
+    lastError() {
+        return callServiceWorker(this, 'object.lastError', [this.dbName]);
+    }
+}

package/dist/db/classes/Proxy.d.ts

@@ -0,0 +1,10 @@
+import { DbApi, DbStructure } from '../types.js';
+declare const bbnDbProxy: {
+    ok: boolean;
+    open(database: string, version?: number): Promise<DbApi>;
+    add(database: string, name: string, structure: DbStructure): Promise<boolean>;
+    remove(database: string, name: string): Promise<void>;
+    importStructure(database: string, structure: Record<string, DbStructure>): Promise<void>;
+    close(database: string): Promise<void>;
+};
+export default bbnDbProxy;

package/dist/db/classes/Proxy.js

@@ -0,0 +1,52 @@
+import bbnDbObjectProxy from './ObjectProxy.js';
+let requestId = 0;
+function callServiceWorker(database, method, args) {
+    return new Promise((resolve, reject) => {
+        if (!navigator.serviceWorker?.controller) {
+            reject(new Error('No active service worker controller'));
+            return;
+        }
+        const id = ++requestId;
+        const channel = new MessageChannel();
+        channel.port1.onmessage = event => {
+            const msg = event.data;
+            if (msg?.id !== id) {
+                return;
+            }
+            if (msg.ok) {
+                resolve(msg.result);
+            }
+            else {
+                reject(new Error(msg.error || 'IndexedDB service worker error'));
+            }
+            channel.port1.close();
+        };
+        const command = {
+            id,
+            database,
+            method,
+            args
+        };
+        navigator.serviceWorker.controller.postMessage(command, [channel.port2]);
+    });
+}
+const bbnDbProxy = {
+    ok: true,
+    async open(database, version) {
+        await callServiceWorker(database, 'manager.open', [database, version]);
+        return new bbnDbObjectProxy(database);
+    },
+    async add(database, name, structure) {
+        return await callServiceWorker(database, 'manager.add', [database, name, structure]);
+    },
+    async remove(database, name) {
+        return await callServiceWorker(database, 'manager.remove', [database, name]);
+    },
+    async importStructure(database, structure) {
+        return await callServiceWorker(database, 'manager.importStructure', [database, structure]);
+    },
+    async close(database) {
+        return await callServiceWorker(database, 'manager.close', [database]);
+    }
+};
+export default bbnDbProxy;

package/dist/db/functions/fieldsFromFilter.d.ts

@@ -0,0 +1 @@
+export default function fieldsFromFilter(filter: unknown, fields?: string[]): string[];

package/dist/db/functions/fieldsFromFilter.js

@@ -0,0 +1,33 @@
+import iterate from '../../fn/loop/iterate.js';
+import isObject from '../../fn/type/isObject.js';
+import isArray from '../../fn/type/isArray.js';
+export default function fieldsFromFilter(filter, fields = []) {
+    if (filter?.conditions?.length) {
+        filter.conditions.forEach((cond) => {
+            if (cond.field && !fields.includes(cond.field)) {
+                fields.push(cond.field);
+            }
+            else if (cond.conditions) {
+                fieldsFromFilter(cond, fields);
+            }
+        });
+    }
+    else if (isObject(filter)) {
+        iterate(filter, (_v, n) => {
+            if (!fields.includes(n)) {
+                fields.push(n);
+            }
+        });
+    }
+    else if (isArray(filter)) {
+        filter.forEach((cond) => {
+            if (cond.field && !fields.includes(cond.field)) {
+                fields.push(cond.field);
+            }
+            else if (cond.conditions) {
+                fieldsFromFilter(cond, fields);
+            }
+        });
+    }
+    return fields;
+}

package/dist/db/functions/getPrimaryKey.d.ts

@@ -0,0 +1,2 @@
+import { DbStructure } from '../types.js';
+export default function getPrimaryKey(structure: DbStructure): string | string[];

package/dist/db/functions/getPrimaryKey.js

@@ -0,0 +1,8 @@
+import _ from '../../_.js';
+export default function getPrimaryKey(structure) {
+    if (!structure.keys?.PRIMARY?.columns) {
+        throw new Error(_('No primary key defined in the structure'));
+    }
+    const cols = structure.keys.PRIMARY.columns;
+    return cols.length > 1 ? cols : cols[0];
+}

package/dist/db/functions/requestToPromise.d.ts

@@ -0,0 +1 @@
+export default function requestToPromise<T = unknown>(req: IDBRequest<T>): Promise<T>;

package/dist/db/functions/requestToPromise.js

@@ -0,0 +1,6 @@
+export default function requestToPromise(req) {
+    return new Promise((resolve, reject) => {
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}

package/dist/db/functions/transactionDone.d.ts

@@ -0,0 +1 @@
+export default function transactionDone(tx: IDBTransaction): Promise<void>;

package/dist/db/functions/transactionDone.js

@@ -0,0 +1,7 @@
+export default function transactionDone(tx) {
+    return new Promise((resolve, reject) => {
+        tx.oncomplete = () => resolve();
+        tx.onabort = () => reject(tx.error);
+        tx.onerror = () => reject(tx.error);
+    });
+}

package/dist/db/functions/transformResult.d.ts

@@ -0,0 +1 @@
+export default function transformResult(obj: Record<string, unknown> | undefined, fields?: string[]): Record<string, unknown> | undefined;

package/dist/db/functions/transformResult.js

@@ -0,0 +1,16 @@
+import iterate from '../../fn/loop/iterate.js';
+export default function transformResult(obj, fields) {
+    if (!obj) {
+        return undefined;
+    }
+    if (fields?.length) {
+        const res = {};
+        iterate(obj, (v, n) => {
+            if (fields.includes(n)) {
+                res[n] = v;
+            }
+        });
+        return res;
+    }
+    return obj;
+}

package/dist/db/types.d.ts

@@ -0,0 +1,56 @@
+export type IndexedDbFactory = IDBFactory | undefined;
+export type Primitive = string | number | boolean | null | undefined | Date;
+export interface DbIndexDefinition {
+    columns: string[];
+    unique?: boolean;
+}
+export interface DbStructure {
+    keys: Record<string, DbIndexDefinition>;
+    fields: Record<string, Record<string, unknown>>;
+    version?: number;
+}
+export interface DbStructures {
+    [database: string]: {
+        [store: string]: DbStructure;
+    };
+}
+export type WhereObject = Record<string, unknown> | null;
+export type OrderClause = unknown;
+export type DbCommand = {
+    id: number;
+    database: string;
+    method: string;
+    args: unknown[];
+};
+export interface DbApi {
+    lastErr: any;
+    get dbName(): string;
+    lastError(): unknown;
+    close(): void;
+    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<number>;
+    update(table: string, data: Record<string, unknown>, where: WhereObject, replace?: boolean): Promise<number>;
+    delete(table: string, where: Record<string, unknown>): Promise<number>;
+    selectOne(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number): Promise<unknown>;
+    select(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number): Promise<unknown>;
+    selectAll(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<unknown>;
+    getColumnValues(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<unknown>;
+    copyTable(target: string, table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<number>;
+    deleteTable(table: string): Promise<boolean>;
+}
+export interface DbManager {
+    ok: boolean;
+    open(name: string, version?: number): Promise<DbApi>;
+    add(database: string, name: string, structure: DbStructure): Promise<boolean>;
+    remove(database: string, name: string): Promise<void>;
+    importStructure(database: string, structure: Record<string, DbStructure>): Promise<void>;
+    close(database: string): void;
+}
+export interface DbManagerInternal extends DbManager {
+    _structures: DbStructures;
+    _connections: Record<string, IDBDatabase>;
+    _objects: Record<string, DbApi>;
+    _stores: Record<string, unknown>;
+    updateStructure(storeName: string, structure: DbStructure, database: IDBDatabase): void;
+    reopenWithUpgrade(name: string): Promise<DbApi>;
+    getExistingVersion(name: string): Promise<number>;
+}

package/dist/db/types.js

@@ -0,0 +1 @@
+export {};

package/dist/db.d.ts

@@ -1,66 +1,3 @@
-interface DbIndexDefinition {
-    columns: string[];
-    unique?: boolean;
-}
-interface DbStructure {
-    keys: Record<string, DbIndexDefinition>;
-    fields: Record<string, Record<string, unknown>>;
-    version?: number;
-}
-interface DbStructures {
-    [database: string]: {
-        [store: string]: DbStructure;
-    };
-}
-type WhereObject = Record<string, unknown> | null;
-type OrderClause = unknown;
-interface IDbApi {
-    lastError(): unknown;
-    close(): void;
-    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<number>;
-    update(table: string, data: Record<string, unknown>, where: WhereObject, replace?: boolean): Promise<number>;
-    delete(table: string, where: Record<string, unknown>): Promise<number>;
-    selectOne(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number): Promise<unknown>;
-    select(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number): Promise<Record<string, unknown> | null>;
-    selectAll(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<Record<string, unknown>[]>;
-    getColumnValues(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<unknown[]>;
-    copyTable(target: string, table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<number>;
-    deleteTable(table: string): Promise<boolean>;
-}
-declare class DbObject implements IDbApi {
-    private readonly dbName;
-    private lastErr;
-    constructor(dbName: string);
-    private hasMissingStores;
-    private getConnection;
-    private get structure();
-    private getStore;
-    lastError(): unknown;
-    close(): void;
-    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<number>;
-    update(table: string, data: Record<string, unknown>, where: WhereObject, replace?: boolean): Promise<number>;
-    delete(table: string, where: Record<string, unknown>): Promise<number>;
-    selectOne(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number): Promise<unknown>;
-    select(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number): Promise<Record<string, unknown> | null>;
-    selectAll(table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<Record<string, unknown>[]>;
-    getColumnValues(table: string, field: string, where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<unknown[]>;
-    copyTable(target: string, table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<number>;
-    deleteTable(table: string): Promise<boolean>;
-}
-interface DbManager {
-    _structures: DbStructures;
-    _connections: Record<string, IDBDatabase>;
-    _objects: Record<string, DbObject>;
-    _stores: Record<string, unknown>;
-    ok: boolean;
-    open(name: string, version?: number): Promise<IDbApi>;
-    add(database: string, name: string, structure: DbStructure): Promise<boolean>;
-    remove(database: string, name: string): Promise<void>;
-    updateStructure(storeName: string, structure: DbStructure, database: IDBDatabase): void;
-    importStructure(database: string, structure: Record<string, DbStructure>): Promise<void>;
-    reopenWithUpgrade(name: string): Promise<IDbApi>;
-    getExistingVersion(name: string): Promise<number>;
-    close(database: string): void;
-}
-declare const db: DbManager;
-export default db;
+import bbnDb from './db/classes/Object.js';
+import bbnDbProxy from './db/classes/Proxy.js';
+export { bbnDb, bbnDbProxy };