@wxn0brp/db-core 0.12.0 → 0.12.2-alpha.0

package/dist/customFileCpu.d.ts

@@ -5,9 +5,10 @@ export type WriteFile = (file: string, data: any[]) => Promise<void>;
 export type ReadFile = (file: string) => Promise<any[]>;
 export declare function pathRepair(path: string): string;
 export declare class CustomFileCpu implements FileCpu {
+    requireClone: boolean;
     _readFile: ReadFile;
     _writeFile: WriteFile;
-    constructor(readFile: ReadFile, writeFile: WriteFile);
+    constructor(readFile: ReadFile, writeFile: WriteFile, requireClone?: boolean);
     add(file: string, config: VQueryT.Add): Promise<void>;
     find(file: string, config: VQueryT.Find): Promise<Data[]>;
     findOne(file: string, config: VQueryT.FindOne): Promise<DataInternal | false>;

package/dist/customFileCpu.js

@@ -1,11 +1,14 @@
-import { matchObj, findObj, updateObj } from "./utils/process.js";
+import { matchObj, updateObj } from "./utils/process.js";
+import { updateFindObject } from "./utils/updateFindObject.js";
 export function pathRepair(path) {
     return path.replace(/\/+/g, "/");
 }
 export class CustomFileCpu {
+    requireClone;
     _readFile;
     _writeFile;
-    constructor(readFile, writeFile) {
+    constructor(readFile, writeFile, requireClone = false) {
+        this.requireClone = requireClone;
         this._readFile = readFile;
         this._writeFile = writeFile;
     }
@@ -18,15 +21,27 @@ export class CustomFileCpu {
     async find(file, config) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        return entries.map(entry => findObj(config, entry)).filter(Boolean);
+        const findOpts = config.findOpts || {};
+        const result = [];
+        for (let i = 0; i < entries.length; i++) {
+            if (matchObj(config, entries[i])) {
+                const obj = this.requireClone
+                    ? structuredClone(entries[i])
+                    : entries[i];
+                result.push(updateFindObject(obj, findOpts));
+            }
+        }
+        return result;
     }
     async findOne(file, config) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
         for (const entry of entries) {
-            const result = findObj(config, entry);
-            if (result)
-                return result;
+            const isMatch = matchObj(config, entry);
+            if (!isMatch)
+                continue;
+            const obj = this.requireClone ? structuredClone(entry) : entry;
+            return updateFindObject(obj, config.findOpts || {});
         }
         return false;
     }

package/dist/db/memory.js

@@ -7,16 +7,16 @@ export class MemoryAction extends CustomActionsBase {
     smartExecutor = true;
     constructor() {
         super();
-        this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this));
+        this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this), true);
         this.memory = new Map();
     }
     _readMemory(key) {
         if (!this.memory.has(key))
             return [];
-        return structuredClone(this.memory.get(key));
+        return this.memory.get(key);
     }
     _writeMemory(key, data) {
-        this.memory.set(key, structuredClone(data));
+        this.memory.set(key, data);
     }
     async getCollections() {
         const collections = Array.from(this.memory.keys());

package/dist/helpers/gen.d.ts

@@ -2,6 +2,8 @@ import { Id } from "../types/Id.js";
 export declare function getIdData(): {
     usedIds: Map<any, any>;
     lastId: Id;
+    lastTimeStr: string;
+    lastCounter: number;
     recentIdsTimestamps: number[];
     startIndex: number;
     lastGeneratedMs: number;
@@ -17,6 +19,8 @@ export type IdData = ReturnType<typeof getIdData>;
 export declare function genId(parts?: number[], idData?: {
     usedIds: Map<any, any>;
     lastId: Id;
+    lastTimeStr: string;
+    lastCounter: number;
     recentIdsTimestamps: number[];
     startIndex: number;
     lastGeneratedMs: number;

package/dist/helpers/gen.js

@@ -2,6 +2,8 @@ export function getIdData() {
     return {
         usedIds: new Map(),
         lastId: undefined,
+        lastTimeStr: "",
+        lastCounter: 0,
         recentIdsTimestamps: [],
         startIndex: 0,
         lastGeneratedMs: 0,
@@ -35,13 +37,8 @@ export function genId(parts = null, idData = defaultIdData) {
 function getUniqueRandom(opts, idData) {
     while (true) {
         let minValue = 0;
-        if (idData.lastId) {
-            const parts = idData.lastId.split("-");
-            const lastTime = parts.shift();
-            if (lastTime === opts.time) {
-                const int36 = parts.join("");
-                minValue = parseInt(int36, 36) + 1;
-            }
+        if (idData.lastTimeStr === opts.time) {
+            minValue = idData.lastCounter + 1;
         }
         const partsLengthSum = opts.partsSchema.reduce((acc, num) => acc + num, 0);
         const partsData = generateBase36InRange(minValue, partsLengthSum, idData);
@@ -54,6 +51,8 @@ function getUniqueRandom(opts, idData) {
             idData.usedIds.set(id, true);
             setTimeout(() => idData.usedIds.delete(id), 1000);
             idData.lastId = id;
+            idData.lastTimeStr = opts.time;
+            idData.lastCounter = idData.lastRandomValue;
             return id;
         }
         opts.s++;

package/dist/utils/action.js

@@ -9,11 +9,16 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
     let datas = [];
     let skippedEntries = 0;
     if (Array.isArray(fileCpuOrData)) {
-        datas = [
-            ...fileCpuOrData,
-        ];
-        if (reverse && !sortBy)
-            datas.reverse();
+        const src = fileCpuOrData;
+        const len = src.length;
+        if (reverse && !sortBy) {
+            datas = new Array(len);
+            for (let i = 0; i < len; i++)
+                datas[i] = src[len - 1 - i];
+        }
+        else {
+            datas = src.slice();
+        }
         if (!needsAllData) {
             if (offset > 0 || limit !== -1) {
                 const start = offset;
@@ -33,7 +38,8 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
             if (reverse && !sortBy)
                 entries.reverse();
             if (needsAllData) {
-                datas.push(...entries);
+                for (let i = 0; i < entries.length; i++)
+                    datas.push(entries[i]);
                 continue;
             }
             if (offset > skippedEntries) {
@@ -50,7 +56,8 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
                 if (entries.length > remaining)
                     entries = entries.slice(0, remaining);
             }
-            datas.push(...entries);
+            for (let i = 0; i < entries.length; i++)
+                datas.push(entries[i]);
             if (limit !== -1 && datas.length >= limit)
                 return datas;
         }
@@ -71,18 +78,20 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
                 : [];
         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);
+                let key = String(data[groupKeys[0]] ?? "");
+                for (let i = 1; i < groupKeys.length; i++) {
+                    key += "|" + String(data[groupKeys[i]] ?? "");
+                }
+                let group = groups.get(key);
+                if (!group) {
+                    group = [];
+                    groups.set(key, group);
+                }
+                group.push(data);
             }
         }
         else {
-            groups.set("all", [
-                ...datas,
-            ]);
+            groups.set("all", datas.slice());
         }
         const aggregated = [];
         for (const [, groupItems] of groups) {
@@ -94,34 +103,72 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
             }
             if (count) {
                 for (const [outKey, srcKey] of Object.entries(count)) {
-                    result[outKey] = groupItems.filter(d => d[srcKey] !== undefined && d[srcKey] !== null).length;
+                    let c = 0;
+                    for (let i = 0; i < groupItems.length; i++) {
+                        const v = groupItems[i][srcKey];
+                        if (v !== undefined && v !== null)
+                            c++;
+                    }
+                    result[outKey] = c;
                 }
             }
-            for (const [outKey, srcField] of Object.entries(min ?? {})) {
-                const nums = groupItems
-                    .map(d => d[srcField])
-                    .filter((v) => typeof v === "number");
-                result[outKey] = nums.length ? Math.min(...nums) : null;
+            const minEntries = min ? Object.entries(min) : null;
+            const maxEntries = max ? Object.entries(max) : null;
+            const avgEntries = avg ? Object.entries(avg) : null;
+            const sumEntries = sum ? Object.entries(sum) : null;
+            if (minEntries) {
+                for (const [outKey, srcField] of minEntries) {
+                    let best = null;
+                    for (let i = 0; i < groupItems.length; i++) {
+                        const v = groupItems[i][srcField];
+                        if (typeof v === "number") {
+                            if (best === null || v < best)
+                                best = v;
+                        }
+                    }
+                    result[outKey] = best;
+                }
             }
-            for (const [outKey, srcField] of Object.entries(max ?? {})) {
-                const nums = groupItems
-                    .map(d => d[srcField])
-                    .filter((v) => typeof v === "number");
-                result[outKey] = nums.length ? Math.max(...nums) : null;
+            if (maxEntries) {
+                for (const [outKey, srcField] of maxEntries) {
+                    let best = null;
+                    for (let i = 0; i < groupItems.length; i++) {
+                        const v = groupItems[i][srcField];
+                        if (typeof v === "number") {
+                            if (best === null || v > best)
+                                best = v;
+                        }
+                    }
+                    result[outKey] = best;
+                }
             }
-            for (const [outKey, srcField] of Object.entries(avg ?? {})) {
-                const nums = groupItems
-                    .map(d => d[srcField])
-                    .filter((v) => typeof v === "number");
-                result[outKey] = nums.length
-                    ? nums.reduce((a, b) => a + b, 0) / nums.length
-                    : null;
+            if (avgEntries) {
+                for (const [outKey, srcField] of avgEntries) {
+                    let total = 0;
+                    let c = 0;
+                    for (let i = 0; i < groupItems.length; i++) {
+                        const v = groupItems[i][srcField];
+                        if (typeof v === "number") {
+                            total += v;
+                            c++;
+                        }
+                    }
+                    result[outKey] = c > 0 ? total / c : null;
+                }
             }
-            for (const [outKey, srcField] of Object.entries(sum ?? {})) {
-                const nums = groupItems
-                    .map(d => d[srcField])
-                    .filter((v) => typeof v === "number");
-                result[outKey] = nums.length ? nums.reduce((a, b) => a + b, 0) : null;
+            if (sumEntries) {
+                for (const [outKey, srcField] of sumEntries) {
+                    let total = 0;
+                    let c = 0;
+                    for (let i = 0; i < groupItems.length; i++) {
+                        const v = groupItems[i][srcField];
+                        if (typeof v === "number") {
+                            total += v;
+                            c++;
+                        }
+                    }
+                    result[outKey] = c > 0 ? total : null;
+                }
             }
             aggregated.push(result);
         }
@@ -129,14 +176,16 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
     }
     if (distinct) {
         const seen = new Set();
-        datas = datas.filter(item => {
-            const val = item[distinct];
-            const key = JSON.stringify(val);
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
+        const result = [];
+        for (let i = 0; i < datas.length; i++) {
+            const val = datas[i][distinct];
+            const key = typeof val === "object" && val !== null ? JSON.stringify(val) : val;
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(datas[i]);
+            }
+        }
+        datas = result;
     }
     if (sortBy) {
         if (sortBy === "random()") {

package/dist/utils/compare.js

@@ -10,7 +10,7 @@ export function compareSafe(a, b) {
     const typeA = typeof a;
     const typeB = typeof b;
     if (typeA === "string" && typeB === "string") {
-        return Math.sign(a.localeCompare(b));
+        return a < b ? -1 : a > b ? 1 : 0;
     }
     if ((typeA === "number" || a instanceof Date) &&
         (typeB === "number" || b instanceof Date)) {

package/dist/utils/hasFieldsAdvanced.js

@@ -11,14 +11,18 @@ export function hasFieldsAdvanced(obj, fields) {
         return true;
     const $fields = {};
     const subsetFields = {};
-    Object.keys(fields).forEach(key => {
-        if (key.startsWith("$"))
+    let hasSubset = false;
+    for (const key in fields) {
+        if (key.charCodeAt(0) === 36) {
             $fields[key.toLowerCase()] = fields[key];
-        else
+        }
+        else {
             subsetFields[key] = fields[key];
-    });
+            hasSubset = true;
+        }
+    }
     // Shallow fields first
-    if (Object.keys(subsetFields).length && !hasFields(obj, subsetFields))
+    if (hasSubset && !hasFields(obj, subsetFields))
         return false;
     // Direct fields only
     if (Object.keys($fields).length === 0)

package/dist/utils/merge.js

@@ -22,8 +22,20 @@ export function _deepMerge(target, ...sources) {
     }
     return _deepMerge(target, ...sources);
 }
+function fastClone(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(fastClone);
+    if (obj instanceof Date)
+        return new Date(obj.getTime());
+    const result = {};
+    for (const key in obj)
+        result[key] = fastClone(obj[key]);
+    return result;
+}
 export function deepMerge(target, ...sources) {
-    return _deepMerge(structuredClone(target), ...sources.map(s => structuredClone(s)));
+    return _deepMerge(fastClone(target), ...sources.map(fastClone));
 }
 function isObject(item) {
     return item && typeof item === "object" && !Array.isArray(item);

package/dist/utils/updateFindObject.js

@@ -1,40 +1,6 @@
 function resolvePath(path) {
     return Array.isArray(path) ? path : path.split(".");
 }
-function pathExists(obj, path) {
-    const segs = resolvePath(path);
-    if (segs.length === 0)
-        return false;
-    let cur = obj;
-    for (const s of segs) {
-        if (cur == null || typeof cur !== "object" || !(s in cur))
-            return false;
-        cur = cur[s];
-    }
-    return true;
-}
-function getValueAt(obj, path) {
-    const segs = resolvePath(path);
-    let cur = obj;
-    for (const s of segs) {
-        if (cur == null || typeof cur !== "object")
-            return undefined;
-        cur = cur[s];
-    }
-    return cur;
-}
-function setNested(obj, path, value) {
-    const segs = resolvePath(path);
-    let cur = obj;
-    for (let i = 0; i < segs.length - 1; i++) {
-        const s = segs[i];
-        if (!(s in cur) || typeof cur[s] !== "object" || Array.isArray(cur[s])) {
-            cur[s] = {};
-        }
-        cur = cur[s];
-    }
-    cur[segs[segs.length - 1]] = value;
-}
 function deleteNested(obj, path) {
     const segs = resolvePath(path);
     if (segs.length === 0)
@@ -72,9 +38,30 @@ export function updateFindObject(obj, findOpts) {
     if (Array.isArray(select)) {
         const result = {};
         for (const field of select) {
-            if ((typeof field === "string" || Array.isArray(field)) &&
-                pathExists(obj, field)) {
-                setNested(result, field, getValueAt(obj, field));
+            const segs = typeof field === "string" ? field.split(".") : field;
+            if (!segs.length)
+                continue;
+            let src = obj;
+            let found = true;
+            for (let i = 0; i < segs.length; i++) {
+                if (src == null || typeof src !== "object" || !(segs[i] in src)) {
+                    found = false;
+                    break;
+                }
+                src = src[segs[i]];
+            }
+            if (found) {
+                let dst = result;
+                for (let i = 0; i < segs.length - 1; i++) {
+                    const s = segs[i];
+                    if (!(s in dst) ||
+                        typeof dst[s] !== "object" ||
+                        Array.isArray(dst[s])) {
+                        dst[s] = {};
+                    }
+                    dst = dst[s];
+                }
+                dst[segs[segs.length - 1]] = src;
             }
         }
         obj = result;

package/dist/utils/updateObject.js

@@ -11,15 +11,24 @@ export function updateObjectAdvanced(obj, field) {
         return;
     const $fields = {};
     const subsetFields = {};
-    Object.keys(field).forEach(key => {
-        if (key.startsWith("$"))
+    let hasDollar = false;
+    let hasSubset = false;
+    for (const key in field) {
+        if (key.charCodeAt(0) === 36) {
             $fields[key.toLowerCase()] = field[key];
-        else
+            hasDollar = true;
+        }
+        else {
             subsetFields[key] = field[key];
-    });
-    mainUpdate(obj, $fields);
-    const mergedObj = deepMerge(obj, $fields);
-    updateObject(mergedObj, subsetFields);
+            hasSubset = true;
+        }
+    }
+    if (hasDollar) {
+        mainUpdate(obj, $fields);
+        deepMerge(obj, $fields);
+    }
+    if (hasSubset)
+        updateObject(obj, subsetFields);
 }
 function deepMerge(obj, fields) {
     if (!("$deepmerge" in fields))
@@ -68,7 +77,10 @@ function mainUpdate(obj, fields) {
         },
         merge: (item, updater) => {
             if (Array.isArray(item) && Array.isArray(updater)) {
-                return [...item, ...updater];
+                return [
+                    ...item,
+                    ...updater,
+                ];
             }
             if (typeof item === "object" &&
                 typeof updater === "object" &&

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.12.0";
+export const version = "0.12.2-alpha.0";

package/package.json

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