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

package/dist/base/actions.d.ts

@@ -4,6 +4,7 @@ import { VQueryT } from "../types/query.js";
 export declare abstract class ActionsBase implements ActionsBaseInterface {
     _inited: boolean;
     numberId: boolean;
+    smartExecutor: boolean;
     init(...args: any[]): Promise<void>;
     abstract getCollections(): Promise<string[]>;
     abstract ensureCollection(collection: string): Promise<boolean>;

package/dist/base/actions.js

@@ -2,6 +2,7 @@ import { setDataForToggleOne, setDataForUpdateOneOrAdd } from "../helpers/assign
 export class ActionsBase {
     _inited = true;
     numberId = false;
+    smartExecutor = false;
     async init(...args) { }
     async updateOneOrAdd(config) {
         const res = await this.updateOne(config);

package/dist/customFileCpu.js

@@ -1,6 +1,4 @@
-import { hasFieldsAdvanced } from "./utils/hasFieldsAdvanced.js";
-import { updateFindObject } from "./utils/updateFindObject.js";
-import { updateObjectAdvanced } from "./utils/updateObject.js";
+import { match, findProcessLine, update } from "./utils/process.js";
 export function pathRepair(path) {
     return path.replaceAll("//", "/");
 }
@@ -20,31 +18,28 @@ export class CustomFileCpu {
     async find(file, config) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        const { search, context = {}, findOpts = {} } = config;
-        const results = entries.filter(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
-        return results.length ?
-            results.map(res => updateFindObject(res, findOpts)) :
-            [];
+        return entries
+            .map((entry) => findProcessLine(config, entry))
+            .filter(Boolean);
     }
     async findOne(file, config) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        const { search, context = {}, findOpts = {} } = config;
-        const result = entries.find(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
-        return result ?
-            updateFindObject(result, findOpts) :
-            false;
+        for (const entry of entries) {
+            const result = findProcessLine(config, entry);
+            if (result)
+                return result;
+        }
+        return false;
     }
     async remove(file, config, one) {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         const removed = [];
-        const { search, context = {} } = config;
-        entries = entries.filter(entry => {
+        entries = entries.filter((entry) => {
             if (removed.length && one)
                 return true;
-            let match = typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search);
-            if (match) {
+            if (match(config, entry)) {
                 removed.push(entry);
                 return false;
             }
@@ -58,13 +53,11 @@ export class CustomFileCpu {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         const updated = [];
-        const { search, updater, context = {} } = config;
-        entries = entries.map(entry => {
+        entries = entries.map((entry) => {
             if (updated.length && one)
                 return entry;
-            let match = typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search);
-            if (match) {
-                const updatedEntry = typeof updater === "function" ? updater(entry, context) : updateObjectAdvanced(entry, updater);
+            if (match(config, entry)) {
+                const updatedEntry = update(config, entry);
                 updated.push(updatedEntry);
                 return updatedEntry;
             }

package/dist/db/memory.d.ts

@@ -4,6 +4,7 @@ import { Data } from "../types/data.js";
 import { ValtheraClass } from "./valthera.js";
 export declare class MemoryAction extends CustomActionsBase {
     memory: Map<string, any[]>;
+    smartExecutor: boolean;
     constructor();
     _readMemory(key: string): any[];
     _writeMemory(key: string, data: any[]): void;

package/dist/db/memory.js

@@ -4,6 +4,7 @@ import { forgeValthera } from "../helpers/forge.js";
 import { ValtheraClass } from "./valthera.js";
 export class MemoryAction extends CustomActionsBase {
     memory;
+    smartExecutor = true;
     constructor() {
         super();
         this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this));

package/dist/db/valthera.d.ts

@@ -1,10 +1,10 @@
 import { VEE } from "@wxn0brp/event-emitter";
 import { ActionsBase } from "../base/actions.js";
 import { Collection } from "../helpers/collection.js";
-import { Executor } from "../helpers/executor.js";
+import { ExecutorInterface } from "../helpers/executor.js";
 import { Data } from "../types/data.js";
 import { DbOpts } from "../types/options.js";
-import { VQueryT, VQuery } from "../types/query.js";
+import { VQuery, VQueryT } from "../types/query.js";
 import { ValtheraCompatible } from "../types/valthera.js";
 /**
  * Represents a database management class for performing CRUD operations.
@@ -12,7 +12,7 @@ import { ValtheraCompatible } from "../types/valthera.js";
  */
 export declare class ValtheraClass implements ValtheraCompatible {
     dbAction: ActionsBase;
-    executor: Executor;
+    executor: ExecutorInterface;
     emiter: VEE<{
         [K in keyof ValtheraCompatible]: (query: VQuery, result: Awaited<ReturnType<ValtheraCompatible[K]>>) => void;
     } & {
@@ -20,7 +20,7 @@ export declare class ValtheraClass implements ValtheraCompatible {
     }>;
     version: string;
     constructor(options: DbOpts);
-    init(...args: any[]): Promise<unknown>;
+    init(...args: any[]): Promise<any>;
     execute<T>(name: keyof ValtheraCompatible, query: VQuery<any> | string): Promise<T>;
     /**
      * Create a new instance of a Collection class.

package/dist/db/valthera.js

@@ -1,6 +1,6 @@
 import { VEE } from "@wxn0brp/event-emitter";
 import { Collection } from "../helpers/collection.js";
-import { Executor } from "../helpers/executor.js";
+import { Executor, SmartExecutor } from "../helpers/executor.js";
 import { version } from "../version.js";
 /**
  * Represents a database management class for performing CRUD operations.
@@ -13,7 +13,7 @@ export class ValtheraClass {
     version = version;
     constructor(options) {
         this.dbAction = options.dbAction;
-        this.executor = options.executor || new Executor();
+        this.executor = options.executor || new (this.dbAction.smartExecutor ? SmartExecutor : Executor)();
         if (options.numberId)
             this.dbAction.numberId = true;
     }
@@ -30,7 +30,7 @@ export class ValtheraClass {
     }
     async execute(name, query) {
         await this.init();
-        const result = await this.executor.addOp(this.dbAction[name].bind(this.dbAction), query);
+        const result = await this.executor.addOp(this.dbAction[name].bind(this.dbAction), query, typeof query === "string" ? query : query.collection);
         this.emiter.emit(name, query, result);
         return result;
     }

package/dist/helpers/executor.d.ts

@@ -4,18 +4,35 @@ export interface Task {
     resolve: Function;
     reject: Function;
 }
+export interface ExecutorInterface {
+    addOp(func: Function, query?: any, collection?: string): Promise<any>;
+}
+export interface SmartExecutorEntry {
+    executor: Executor;
+    interval: ReturnType<typeof setTimeout> | null;
+}
 /**
  * A simple executor for queuing and executing asynchronous operations sequentially.
  */
-export declare class Executor {
-    quote: Task[];
+export declare class Executor implements ExecutorInterface {
+    queue: Task[];
     isExecuting: boolean;
     /**
      * Add an asynchronous operation to the execution queue.
      */
-    addOp(func: Function, ...param: any[]): Promise<unknown>;
+    addOp(func: Function, query: any): Promise<any>;
     /**
      * Execute the queued asynchronous operations sequentially.
      */
     execute(): Promise<void>;
 }
+/**
+ * A smart executor for queuing and executing asynchronous operations with a TTL.
+ */
+export declare class SmartExecutor implements ExecutorInterface {
+    ttl: number;
+    collections: Map<string, SmartExecutorEntry>;
+    constructor(ttl?: number);
+    addOp(func: Function, query: any, collection: string): Promise<any>;
+    scheduleCleanup(key: string, entry: SmartExecutorEntry): number;
+}

package/dist/helpers/executor.js

@@ -2,16 +2,16 @@
  * A simple executor for queuing and executing asynchronous operations sequentially.
  */
 export class Executor {
-    quote = [];
+    queue = [];
     isExecuting = false;
     /**
      * Add an asynchronous operation to the execution queue.
      */
-    async addOp(func, ...param) {
+    async addOp(func, query) {
         return await new Promise((resolve, reject) => {
-            this.quote.push({
+            this.queue.push({
                 func,
-                param,
+                param: [query],
                 resolve,
                 reject
             });
@@ -25,11 +25,52 @@ export class Executor {
         if (this.isExecuting)
             return;
         this.isExecuting = true;
-        while (this.quote.length > 0) {
-            let q = this.quote.shift();
+        while (this.queue.length > 0) {
+            let q = this.queue.shift();
             let res = await q.func(...q.param);
             q.resolve(res);
         }
         this.isExecuting = false;
     }
 }
+/**
+ * A smart executor for queuing and executing asynchronous operations with a TTL.
+ */
+export class SmartExecutor {
+    ttl;
+    collections = new Map();
+    constructor(ttl = 5 * 60 * 1000) {
+        this.ttl = ttl;
+    }
+    async addOp(func, query, collection) {
+        const key = collection ?? "__default__";
+        let entry = this.collections.get(key);
+        if (!entry) {
+            entry = {
+                executor: new Executor(),
+                interval: null
+            };
+            this.collections.set(key, entry);
+        }
+        else if (entry.interval)
+            clearTimeout(entry.interval);
+        entry.interval = this.scheduleCleanup(key, entry);
+        return entry.executor.addOp(func, query);
+    }
+    scheduleCleanup(key, entry) {
+        const interval = setTimeout(() => {
+            const current = this.collections.get(key);
+            if (!current || current !== entry)
+                return;
+            if (current.executor.isExecuting) {
+                current.interval = this.scheduleCleanup(key, current);
+            }
+            else {
+                this.collections.delete(key);
+            }
+        }, this.ttl);
+        if (typeof interval === "object" && "unref" in interval)
+            interval.unref();
+        return interval;
+    }
+}

package/dist/types/arg.d.ts

@@ -1,3 +1,4 @@
+import { Data } from "./data.js";
 import { SearchOptions } from "./searchOpts.js";
 import { VContext } from "./types.js";
 import { UpdaterArg } from "./updater.js";
@@ -5,6 +6,6 @@ export type Arg<T = any> = {
     [K in keyof T]?: any;
 } & Record<string, any>;
 export type SearchFunc<T = any> = (data: T, context: VContext) => boolean;
-export type UpdaterFunc<T = any> = (data: T, context: VContext) => boolean;
+export type UpdaterFunc<T = any> = (data: T, context: VContext) => Data | void;
 export type Search<T = any> = SearchOptions<T> | SearchFunc<T>;
-export type Updater<T = any> = UpdaterArg<T> | UpdaterArg<T>[] | UpdaterFunc<T>;
+export type Updater<T = any> = UpdaterArg<T> | UpdaterFunc<T>;

package/dist/utils/process.d.ts

@@ -0,0 +1,5 @@
+import { Data } from "../types/data.js";
+import { VQuery, VQueryT } from "../types/query.js";
+export declare function findProcessLine(config: VQueryT.Find | VQueryT.FindOne, obj: Data): Object;
+export declare function match(config: VQuery, obj: Data): boolean;
+export declare function update(config: VQueryT.Update, obj: Data): Data;

package/dist/utils/process.js

@@ -0,0 +1,30 @@
+import { hasFieldsAdvanced } from "./hasFieldsAdvanced.js";
+import { updateFindObject } from "./updateFindObject.js";
+import { updateObjectAdvanced } from "./updateObject.js";
+export function findProcessLine(config, obj) {
+    if (match(config, obj))
+        return updateFindObject(obj, config.findOpts || {});
+    return null;
+}
+export function match(config, obj) {
+    const { search, context } = config;
+    if (search === undefined || search === null)
+        return true;
+    if (typeof search === "function" && search(obj, context))
+        return true;
+    if (typeof search === "object" && !Array.isArray(search) && hasFieldsAdvanced(obj, search))
+        return true;
+    return false;
+}
+export function update(config, obj) {
+    const { updater, context } = config;
+    if (typeof updater === "object" && !Array.isArray(updater))
+        return updateObjectAdvanced(obj, updater);
+    if (typeof updater === "function") {
+        const updateObjValue = updater(obj, context);
+        if (updateObjValue)
+            return updateObjValue;
+        return obj;
+    }
+    return obj;
+}

package/dist/utils/updateObject.js

@@ -5,12 +5,10 @@ import { _deepMerge } from "./merge.js";
  * @param field - An object containing new values to update in the target object.
  */
 export function updateObjectAdvanced(obj, field) {
-    if (typeof field !== "object" || field === null) {
-        throw new Error("Fields must be an object or object array");
-    }
-    if (Object.keys(field).length === 0) {
+    if (typeof field !== "object" || Array.isArray(field) || field === null)
+        throw new Error("Fields must be an object");
+    if (Object.keys(field).length === 0)
         return obj;
-    }
     const newObj = structuredClone(obj);
     const $fields = {};
     const subsetFields = {};
@@ -106,11 +104,9 @@ function mainUpdate(obj, fields) {
  * @param newVal - An object containing new values to update in the target object.
  */
 function updateObject(obj, newVal) {
-    for (let key in newVal) {
-        if (newVal.hasOwnProperty(key)) {
+    for (let key in newVal)
+        if (newVal.hasOwnProperty(key))
             obj[key] = newVal[key];
-        }
-    }
     return obj;
 }
 function _for(fields, obj, opts) {

package/dist/version.js

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

package/package.json

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