@bbn/bbn 2.0.240 → 2.0.243

package/dist/db/classes/Object.js

@@ -153,44 +153,212 @@ class DbObject {
         const rows = await this.selectAll(table, fields, where, order, start, 1);
         return rows.length ? rows[0] : null;
     }
+    /* async selectAll(
+      table: string,
+      fields: string[] = [],
+      where: unknown = null,
+      order: OrderClause = null,
+      start = 0,
+      limit: number | null = null
+    ): Promise<Record<string, unknown>[]> {
+      void order;
+  
+      const [tx, store] = await this.getStore(table, 'readonly');
+      const structure = this.structure[table];
+      const primary = getPrimaryKey(structure);
+      const results: Record<string, unknown>[] = [];
+  
+      const searchField = isObject(where)
+        ? Object.keys(where as Record<string, unknown>)[0]
+        : (!where || isArray(where) ? null : primary);
+  
+      if (!Array.isArray(primary) && searchField === primary) {
+        if (Array.isArray((where as any)?.[primary])) {
+          const ids = (where as any)[primary] as IDBValidKey[];
+          const max = Math.min(ids.length - start, limit ?? ids.length);
+          const slice = ids.slice(start, start + max);
+  
+          for (const id of slice) {
+            const row = await requestToPromise<Record<string, unknown> | undefined>(store.get(id));
+            const transformed = transformResult(row, fields);
+            if (transformed) {
+              results.push(transformed);
+            }
+          }
+  
+          await transactionDone(tx);
+          return results;
+        }
+  
+        const key = isObject(where)
+          ? (where as Record<string, unknown>)[primary]
+          : where;
+  
+        const row = await requestToPromise<Record<string, unknown> | undefined>(
+          store.get(key as IDBValidKey)
+        );
+  
+        const transformed = transformResult(row, fields);
+        if (transformed) {
+          results.push(transformed);
+        }
+  
+        await transactionDone(tx);
+        return results;
+      }
+  
+      await new Promise<void>((resolve, reject) => {
+        const req = store.openCursor();
+        let i = 0;
+  
+        req.onsuccess = (e: Event) => {
+          const cursor = (e.target as IDBRequest<IDBCursorWithValue | null>).result;
+  
+          if (!cursor) {
+            resolve();
+            return;
+          }
+  
+          const matches = !where || !(globalThis as any).bbn?.fn?.search
+            ? true
+            : 0 === (globalThis as any).bbn.fn.search([cursor.value], where);
+  
+          if (matches) {
+            if (i >= start) {
+              const transformed = transformResult(cursor.value, fields);
+              if (transformed) {
+                results.push(transformed);
+              }
+  
+              if (limit !== null && results.length >= limit) {
+                resolve();
+                return;
+              }
+            }
+            i++;
+          }
+  
+          cursor.continue();
+        };
+  
+        req.onerror = () => {
+          this.lastErr = req.error;
+          log(req.error);
+          reject(req.error);
+        };
+      });
+  
+      await transactionDone(tx);
+      return results;
+    } */
     async selectAll(table, fields = [], where = null, order = null, start = 0, limit = null) {
-        void order;
         const [tx, store] = await this.getStore(table, 'readonly');
         const structure = this.structure[table];
         const primary = getPrimaryKey(structure);
-        const results = [];
+        const rows = [];
+        const normalizeDir = (dir) => {
+            return String(dir).toLowerCase() === 'desc' ? 'desc' : 'asc';
+        };
+        const normalizeOrder = (order) => {
+            if (!order) {
+                return [];
+            }
+            /*
+            * Format:
+            * { field: 'asc' }
+            * { field: 'desc' }
+            */
+            if (isObject(order) && !Array.isArray(order)) {
+                return Object.keys(order).map(field => ({
+                    field,
+                    dir: normalizeDir(order[field])
+                }));
+            }
+            /*
+            * Format:
+            * [
+            *   { field: 'field', dir: 'asc' },
+            *   { field: 'field2', dir: 'desc' }
+            * ]
+            */
+            if (Array.isArray(order)) {
+                return order
+                    .filter(item => isObject(item) && typeof item.field === 'string')
+                    .map(item => ({
+                    field: item.field,
+                    dir: normalizeDir(item.dir)
+                }));
+            }
+            return [];
+        };
+        const orderClauses = normalizeOrder(order);
+        const compareValues = (a, b) => {
+            if (a === b) {
+                return 0;
+            }
+            if (a === undefined || a === null) {
+                return -1;
+            }
+            if (b === undefined || b === null) {
+                return 1;
+            }
+            if (typeof a === 'number' && typeof b === 'number') {
+                return a - b;
+            }
+            if (a instanceof Date && b instanceof Date) {
+                return a.getTime() - b.getTime();
+            }
+            return String(a).localeCompare(String(b));
+        };
+        const sortRows = (rows) => {
+            if (!orderClauses.length) {
+                return;
+            }
+            rows.sort((a, b) => {
+                for (const clause of orderClauses) {
+                    const cmp = compareValues(a[clause.field], b[clause.field]);
+                    if (cmp !== 0) {
+                        return clause.dir === 'desc' ? -cmp : cmp;
+                    }
+                }
+                return 0;
+            });
+        };
         const searchField = isObject(where)
             ? Object.keys(where)[0]
             : (!where || isArray(where) ? null : primary);
         if (!Array.isArray(primary) && searchField === primary) {
             if (Array.isArray(where?.[primary])) {
                 const ids = where[primary];
-                const max = Math.min(ids.length - start, limit ?? ids.length);
-                const slice = ids.slice(start, start + max);
-                for (const id of slice) {
+                for (const id of ids) {
                     const row = await requestToPromise(store.get(id));
-                    const transformed = transformResult(row, fields);
-                    if (transformed) {
-                        results.push(transformed);
+                    if (row) {
+                        rows.push(row);
                     }
                 }
                 await transactionDone(tx);
-                return results;
+                sortRows(rows);
+                const sliced = limit === null
+                    ? rows.slice(start)
+                    : rows.slice(start, start + limit);
+                return sliced
+                    .map(row => transformResult(row, fields))
+                    .filter((row) => !!row);
             }
             const key = isObject(where)
                 ? where[primary]
                 : where;
             const row = await requestToPromise(store.get(key));
-            const transformed = transformResult(row, fields);
-            if (transformed) {
-                results.push(transformed);
+            if (row) {
+                rows.push(row);
             }
             await transactionDone(tx);
-            return results;
+            return rows
+                .map(row => transformResult(row, fields))
+                .filter((row) => !!row);
         }
         await new Promise((resolve, reject) => {
             const req = store.openCursor();
-            let i = 0;
             req.onsuccess = (e) => {
                 const cursor = e.target.result;
                 if (!cursor) {
@@ -201,17 +369,7 @@ class DbObject {
                     ? true
                     : 0 === globalThis.bbn.fn.search([cursor.value], where);
                 if (matches) {
-                    if (i >= start) {
-                        const transformed = transformResult(cursor.value, fields);
-                        if (transformed) {
-                            results.push(transformed);
-                        }
-                        if (limit !== null && results.length >= limit) {
-                            resolve();
-                            return;
-                        }
-                    }
-                    i++;
+                    rows.push(cursor.value);
                 }
                 cursor.continue();
             };
@@ -222,7 +380,13 @@ class DbObject {
             };
         });
         await transactionDone(tx);
-        return results;
+        sortRows(rows);
+        const sliced = limit === null
+            ? rows.slice(start)
+            : rows.slice(start, start + limit);
+        return sliced
+            .map(row => transformResult(row, fields))
+            .filter((row) => !!row);
     }
     async getColumnValues(table, field, where = null, order = null, start = 0, limit = null) {
         const rows = await this.selectAll(table, fieldsFromFilter(where, [field]), where, order, start, limit);
@@ -230,6 +394,74 @@ class DbObject {
             .map(row => row[field])
             .filter(v => v !== undefined);
     }
+    async count(table, where = null) {
+        const [tx, store] = await this.getStore(table, 'readonly');
+        const structure = this.structure[table];
+        const primary = getPrimaryKey(structure);
+        const searchField = isObject(where)
+            ? Object.keys(where)[0]
+            : (!where || isArray(where) ? null : primary);
+        if (!where) {
+            const total = await requestToPromise(store.count());
+            await transactionDone(tx);
+            return total;
+        }
+        if (!Array.isArray(primary) && searchField === primary) {
+            if (Array.isArray(where?.[primary])) {
+                const ids = where[primary];
+                let total = 0;
+                for (const id of ids) {
+                    const exists = await requestToPromise(store.getKey(id));
+                    if (exists !== undefined) {
+                        total++;
+                    }
+                }
+                await transactionDone(tx);
+                return total;
+            }
+            const key = isObject(where)
+                ? where[primary]
+                : where;
+            const total = await requestToPromise(store.count(key));
+            await transactionDone(tx);
+            return total;
+        }
+        if (typeof searchField === 'string' &&
+            isObject(where) &&
+            !Array.isArray(where[searchField]) &&
+            store.indexNames.contains(searchField)) {
+            const index = store.index(searchField);
+            const value = where[searchField];
+            const total = await requestToPromise(index.count(IDBKeyRange.only(value)));
+            await transactionDone(tx);
+            return total;
+        }
+        let total = 0;
+        await new Promise((resolve, reject) => {
+            const req = store.openCursor();
+            req.onsuccess = (e) => {
+                const cursor = e.target.result;
+                if (!cursor) {
+                    resolve();
+                    return;
+                }
+                const matches = !where || !globalThis.bbn?.fn?.search
+                    ? true
+                    : 0 === globalThis.bbn.fn.search([cursor.value], where);
+                if (matches) {
+                    total++;
+                }
+                cursor.continue();
+            };
+            req.onerror = () => {
+                this.lastErr = req.error;
+                log(req.error);
+                reject(req.error);
+            };
+        });
+        await transactionDone(tx);
+        return total;
+    }
     async copyTable(target, table, fields = [], where = null, order = null, start = 0, limit = null) {
         if (!this.structure[table]) {
             throw new Error(_('Source table %s does not exist in structure', table));

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

@@ -11,6 +11,7 @@ export default class bbnDbObjectProxy implements DbApi {
     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>;
+    count(table: string, where?: unknown): Promise<number>;
     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;

package/dist/db/classes/ObjectProxy.js

@@ -64,6 +64,9 @@ export default class bbnDbObjectProxy {
     getColumnValues(table, field, where, order, start, limit) {
         return callServiceWorker(this, 'object.getColumnValues', [table, field, where, order, start, limit]);
     }
+    count(table, where) {
+        return callServiceWorker(this, 'object.count', [table, where]);
+    }
     copyTable(target, table, fields, where, order, start, limit) {
         return callServiceWorker(this, 'object.copyTable', [target, table, fields, where, order, start, limit]);
     }

package/dist/db/types.d.ts

@@ -34,6 +34,7 @@ export interface DbApi {
     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>;
+    count(table: string, where?: unknown): Promise<number>;
     copyTable(target: string, table: string, fields?: string[], where?: unknown, order?: OrderClause, start?: number, limit?: number | null): Promise<number>;
     deleteTable(table: string): Promise<boolean>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "2.0.240",
+  "version": "2.0.243",
   "description": "Javascript toolkit",
   "main": "./dist/index.js",
   "module": "./dist/index.js",