@wxn0brp/db-core 0.10.4 → 0.11.0-alpha.0

package/dist/types/options.d.ts

@@ -12,6 +12,11 @@ export interface DbFindOpts<T = any> {
     offset?: number;
     sortBy?: KeysMatching<T, any>;
     sortAsc?: boolean;
+    min?: Record<string, KeysMatching<T, number>>;
+    max?: Record<string, KeysMatching<T, number>>;
+    avg?: Record<string, KeysMatching<T, number>>;
+    groupBy?: KeysMatching<T, any> | KeysMatching<T, any>[];
+    count?: Record<string, string>;
 }
 export interface FindOpts<T = any> {
     select?: KeysMatching<T, any>[];

package/dist/types/query.d.ts

@@ -44,23 +44,3 @@ export declare namespace VQueryT {
         type: "added" | "removed";
     }
 }
-/** @deprecated */
-export type QueryBase<T = Data> = VQueryT.QueryBase<T>;
-/** @deprecated */
-export type AddQuery<T = Data> = VQueryT.Add<T>;
-/** @deprecated */
-export type FindQuery<T = Data> = VQueryT.Find<T>;
-/** @deprecated */
-export type FindOneQuery<T = Data> = VQueryT.FindOne<T>;
-/** @deprecated */
-export type UpdateQuery<T = Data> = VQueryT.Update<T>;
-/** @deprecated */
-export type RemoveQuery<T = Data> = VQueryT.Remove<T>;
-/** @deprecated */
-export type UpdateOneOrAddQuery<T = Data> = VQueryT.UpdateOneOrAdd<T>;
-/** @deprecated */
-export type ToggleOneQuery<T = Data> = VQueryT.ToggleOne<T>;
-/** @deprecated */
-export type UpdateOneOrAddResult<T> = VQueryT.UpdateOneOrAddResult<T>;
-/** @deprecated */
-export type ToggleOneResult<T> = VQueryT.ToggleOneResult<T>;

package/dist/utils/action.d.ts

@@ -1,4 +1,4 @@
 import { Data } from "../types/data.js";
 import { FileCpu } from "../types/fileCpu.js";
 import { VQueryT } from "../types/query.js";
-export declare function findUtil(query: VQueryT.Find, fileCpu: FileCpu, files: string[]): Promise<Data[]>;
+export declare function findUtil(query: VQueryT.Find, fileCpuOrData: FileCpu | Object[], files: string[]): Promise<Data[]>;

package/dist/utils/action.js

@@ -1,43 +1,86 @@
 import { compareSafe } from "./compare.js";
-export async function findUtil(query, fileCpu, files) {
+export async function findUtil(query, fileCpuOrData, files) {
     const { dbFindOpts = {} } = query;
-    const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true } = dbFindOpts;
-    if (reverse && !sortBy)
-        files.reverse();
+    const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true, min, max, avg, groupBy, count, } = dbFindOpts;
+    const needsAllData = min || max || avg || groupBy || count || sortBy;
     let datas = [];
-    let totalEntries = 0;
     let skippedEntries = 0;
-    for (const f of files) {
-        let entries = await fileCpu.find(f, query);
-        if (reverse && !sortBy)
-            entries.reverse();
-        if (!sortBy) {
+    if (Array.isArray(fileCpuOrData)) {
+        datas = [...fileCpuOrData];
+    }
+    else {
+        const filesToProcess = reverse && !sortBy ? [...files].reverse() : files;
+        for (const f of filesToProcess) {
+            let entries = await fileCpuOrData.find(f, query);
+            if (reverse && !sortBy)
+                entries.reverse();
+            if (needsAllData) {
+                datas.push(...entries);
+                continue;
+            }
             if (offset > skippedEntries) {
-                const remainingSkip = offset - skippedEntries;
-                if (entries.length <= remainingSkip) {
+                const toSkip = offset - skippedEntries;
+                if (entries.length <= toSkip) {
                     skippedEntries += entries.length;
                     continue;
                 }
-                entries = entries.slice(remainingSkip);
+                entries = entries.slice(toSkip);
                 skippedEntries = offset;
             }
             if (limit !== -1) {
-                if (totalEntries + entries.length > limit) {
-                    const remaining = limit - totalEntries;
+                const remaining = limit - datas.length;
+                if (entries.length > remaining)
                     entries = entries.slice(0, remaining);
-                    totalEntries = limit;
-                }
-                else {
-                    totalEntries += entries.length;
-                }
             }
             datas.push(...entries);
-            if (limit !== -1 && totalEntries >= limit)
-                break;
+            if (limit !== -1 && datas.length >= limit)
+                return datas;
+        }
+    }
+    if (!needsAllData)
+        return datas;
+    if (min || max || avg || groupBy || count) {
+        const groups = new Map();
+        const groupKeys = Array.isArray(groupBy) ? groupBy : groupBy ? [groupBy] : [];
+        if (groupKeys.length) {
+            for (const data of datas) {
+                const key = groupKeys.map(k => String(data[k] ?? "")).join("|");
+                if (!groups.has(key))
+                    groups.set(key, []);
+                groups.get(key).push(data);
+            }
         }
         else {
-            datas.push(...entries);
+            groups.set("all", [...datas]);
         }
+        const aggregated = [];
+        for (const [, groupItems] of groups) {
+            const result = {};
+            if (groupKeys.length) {
+                const sample = groupItems[0];
+                for (const k of groupKeys)
+                    result[k] = sample[k];
+            }
+            if (count) {
+                for (const [outKey, srcKey] of Object.entries(count)) {
+                    result[outKey] = groupItems.filter(d => d[srcKey] !== undefined && d[srcKey] !== null).length;
+                }
+            }
+            for (const [outKey, srcField] of Object.entries(min ?? {})) {
+                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                result[outKey] = nums.length ? Math.min(...nums) : null;
+            }
+            for (const [outKey, srcField] of Object.entries(max ?? {})) {
+                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                result[outKey] = nums.length ? Math.max(...nums) : null;
+            }
+            for (const [outKey, srcField] of Object.entries(avg ?? {})) {
+                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                result[outKey] = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+            }
+            aggregated.push(result);
+        }
+        datas = aggregated;
     }
     if (sortBy) {
         if (sortBy === "random()") {
@@ -47,6 +90,8 @@ export async function findUtil(query, fileCpu, files) {
             const dir = sortAsc ? 1 : -1;
             datas.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);
         }
+    }
+    if (offset > 0 || limit !== -1) {
         const start = offset;
         const end = limit !== -1 ? offset + limit : undefined;
         datas = datas.slice(start, end);

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.10.4";
+export const version = "0.11.0-alpha.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-core",
-  "version": "0.10.4",
+  "version": "0.11.0-alpha.0",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "wxn0brP",