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

package/dist/base/actions.d.ts

@@ -1,10 +1,15 @@
 import { ActionsBaseInterface } from "../types/action.js";
 import { DataInternal } from "../types/data.js";
+import { AdapterOpts } from "../types/options.js";
 import { VQueryT } from "../types/query.js";
 export declare abstract class ActionsBase implements ActionsBaseInterface {
     _inited: boolean;
-    numberId: boolean;
+    adapterOpts: AdapterOpts;
     smartExecutor: boolean;
+    get numberId(): boolean;
+    set numberId(value: boolean);
+    get idKey(): string;
+    set idKey(value: string);
     init(...args: any[]): Promise<void>;
     close(...args: any[]): Promise<void>;
     abstract getCollections(): Promise<string[]>;

package/dist/base/actions.js

@@ -1,8 +1,23 @@
-import { setDataForToggleOne, setDataForUpdateOneOrAdd } from "../helpers/assignDataPush.js";
+import { setDataForToggleOne, setDataForUpdateOneOrAdd, } from "../helpers/assignDataPush.js";
 export class ActionsBase {
     _inited = true;
-    numberId = false;
+    adapterOpts = {
+        numberId: false,
+        idKey: "_id",
+    };
     smartExecutor = false;
+    get numberId() {
+        return this.adapterOpts.numberId ?? false;
+    }
+    set numberId(value) {
+        this.adapterOpts.numberId = value;
+    }
+    get idKey() {
+        return this.adapterOpts.idKey ?? "_id";
+    }
+    set idKey(value) {
+        this.adapterOpts.idKey = value;
+    }
     async init(...args) { }
     async close(...args) { }
     async updateOneOrAdd(config) {
@@ -10,13 +25,13 @@ export class ActionsBase {
         if (res)
             return {
                 data: res,
-                type: "updated"
+                type: "updated",
             };
         // transform UpdateOneQuery to AddQuery
         setDataForUpdateOneOrAdd(config);
         return {
             data: await this.add(config),
-            type: "added"
+            type: "added",
         };
     }
     async toggleOne(config) {
@@ -24,13 +39,13 @@ export class ActionsBase {
         if (res)
             return {
                 data: res,
-                type: "removed"
+                type: "removed",
             };
         // transform ToggleOneQuery to AddQuery
         setDataForToggleOne(config);
         return {
             data: await this.add(config),
-            type: "added"
+            type: "added",
         };
     }
 }

package/dist/base/custom.d.ts

@@ -4,7 +4,6 @@ import { VQueryT } from "../types/query.js";
 import { ActionsBase } from "./actions.js";
 export declare abstract class CustomActionsBase extends ActionsBase {
     fileCpu: CustomFileCpu;
-    constructor();
     /**
      * Add a new entry to the specified database.
      */

package/dist/base/custom.js

@@ -3,9 +3,6 @@ import { findUtil } from "../utils/action.js";
 import { ActionsBase } from "./actions.js";
 export class CustomActionsBase extends ActionsBase {
     fileCpu;
-    constructor() {
-        super();
-    }
     /**
      * Add a new entry to the specified database.
      */
@@ -21,7 +18,9 @@ export class CustomActionsBase extends ActionsBase {
      */
     async find(query) {
         await this.ensureCollection(query.collection);
-        const data = await findUtil(query, this.fileCpu, [query.collection]);
+        const data = await findUtil(query, this.fileCpu, [
+            query.collection,
+        ]);
         return data;
     }
     /**
@@ -29,7 +28,7 @@ export class CustomActionsBase extends ActionsBase {
      */
     async findOne(query) {
         await this.ensureCollection(query.collection);
-        let data = await this.fileCpu.findOne(query.collection, query);
+        const data = (await this.fileCpu.findOne(query.collection, query));
         return data || null;
     }
     /**

package/dist/customFileCpu.js

@@ -11,16 +11,14 @@ export class CustomFileCpu {
     }
     async add(file, config) {
         file = pathRepair(file);
-        let entries = await this._readFile(file);
+        const entries = await this._readFile(file);
         entries.push(config.data);
         await this._writeFile(file, entries);
     }
     async find(file, config) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        return entries
-            .map((entry) => findObj(config, entry))
-            .filter(Boolean);
+        return entries.map(entry => findObj(config, entry)).filter(Boolean);
     }
     async findOne(file, config) {
         file = pathRepair(file);
@@ -36,7 +34,7 @@ export class CustomFileCpu {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         const removed = [];
-        entries = entries.filter((entry) => {
+        entries = entries.filter(entry => {
             if (removed.length && one)
                 return true;
             if (matchObj(config, entry)) {
@@ -53,7 +51,7 @@ export class CustomFileCpu {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         const updated = [];
-        entries = entries.map((entry) => {
+        entries = entries.map(entry => {
             if (updated.length && one)
                 return entry;
             if (matchObj(config, entry)) {

package/dist/db/memory.js

@@ -1,6 +1,6 @@
 import { CustomActionsBase } from "../base/custom.js";
 import { CustomFileCpu } from "../customFileCpu.js";
-import { forgeValthera } from "../helpers/forge.js";
+import { forgeTypedValthera } from "../helpers/forge.js";
 import { ValtheraClass } from "./valthera.js";
 export class MemoryAction extends CustomActionsBase {
     memory;
@@ -13,10 +13,10 @@ export class MemoryAction extends CustomActionsBase {
     _readMemory(key) {
         if (!this.memory.has(key))
             return [];
-        return this.memory.get(key);
+        return structuredClone(this.memory.get(key));
     }
     _writeMemory(key, data) {
-        this.memory.set(key, data);
+        this.memory.set(key, structuredClone(data));
     }
     async getCollections() {
         const collections = Array.from(this.memory.keys());
@@ -40,15 +40,17 @@ export class MemoryAction extends CustomActionsBase {
 }
 export class ValtheraMemory extends ValtheraClass {
     constructor(...args) {
-        super({ adapter: new MemoryAction() });
+        super({
+            adapter: new MemoryAction(),
+        });
     }
 }
 export function createMemoryValthera(data) {
     const db = new ValtheraMemory();
     if (!data)
-        return forgeValthera(db);
+        return forgeTypedValthera(db);
     for (const collection of Object.keys(data)) {
         db.adapter.memory.set(collection, data[collection]);
     }
-    return forgeValthera(db);
+    return forgeTypedValthera(db);
 }

package/dist/db/multiStorage.js

@@ -14,57 +14,65 @@ export class MultiBackend extends ActionsBase {
         await Promise.all(this.backends.map(b => b.close(...args)));
     }
     async add(config) {
-        return await this.primaryBackend.add({ ...config });
+        return await this.primaryBackend.add({
+            ...config,
+        });
     }
     async find(config) {
-        const results = await Promise.all(this.backends.map(b => b.find({ ...config })));
+        const results = await Promise.all(this.backends.map(b => b.find({
+            ...config,
+        })));
         return results.flat();
     }
     async findOne(config) {
         for (const backend of this.backends) {
             try {
-                const result = await backend.findOne({ ...config });
+                const result = await backend.findOne({
+                    ...config,
+                });
                 if (result !== null && result !== undefined) {
                     return result;
                 }
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
         return null;
     }
     async update(config) {
-        const results = await Promise.all(this.backends.map(b => b.update({ ...config })));
+        const results = await Promise.all(this.backends.map(b => b.update({
+            ...config,
+        })));
         return results.flat();
     }
     async updateOne(config) {
         for (const backend of this.backends) {
             try {
-                const result = await backend.updateOne({ ...config });
+                const result = await backend.updateOne({
+                    ...config,
+                });
                 if (result)
                     return result;
             }
-            catch (error) {
-                continue;
-            }
+            catch (error) { }
         }
         return null;
     }
     async remove(config) {
-        const results = await Promise.all(this.backends.map(b => b.remove({ ...config })));
+        const results = await Promise.all(this.backends.map(b => b.remove({
+            ...config,
+        })));
         return results.flat();
     }
     async removeOne(config) {
         for (const backend of this.backends) {
             try {
-                const result = await backend.removeOne({ ...config });
+                const result = await backend.removeOne({
+                    ...config,
+                });
                 if (result)
                     return result;
             }
-            catch (error) {
-                continue;
-            }
+            catch (error) { }
         }
         return null;
     }

package/dist/db/routedStorage.js

@@ -5,14 +5,19 @@ export class RoutedStorage extends ActionsBase {
     constructor(rules, defaultBackend) {
         super();
         this.rules = rules;
-        this.defaultBackend = Array.isArray(defaultBackend) ? defaultBackend : [defaultBackend];
+        this.defaultBackend = Array.isArray(defaultBackend)
+            ? defaultBackend
+            : [
+                defaultBackend,
+            ];
     }
     _matchBackends(config) {
         const matched = [];
         const { collection } = config;
         for (const rule of this.rules) {
             const { match, backends } = rule;
-            if ((typeof match === "string" && (match === collection) || match === "*") ||
+            if ((typeof match === "string" && match === collection) ||
+                match === "*" ||
                 (match instanceof RegExp && match.test(collection)) ||
                 (typeof match === "function" && match(config))) {
                 matched.push(...backends);
@@ -44,13 +49,19 @@ export class RoutedStorage extends ActionsBase {
     async close(...args) {
         const all = new Set([
             ...this.rules.flatMap(r => r.backends),
-            ...this.defaultBackend
+            ...this.defaultBackend,
         ]);
         await Promise.all(Array.from(all).map(b => b.close(...args)));
     }
     async add(config) {
         const res = await this._withFirst(config, b => b.add(config));
-        await this._withAll({ ...config, data: res }, b => b.add({ ...config, data: res }));
+        await this._withAll({
+            ...config,
+            data: res,
+        }, b => b.add({
+            ...config,
+            data: res,
+        }));
         return res;
     }
     async find(config) {
@@ -81,8 +92,7 @@ export class RoutedStorage extends ActionsBase {
         return this._withAll(collection, b => b.removeCollection(collection), true);
     }
     async getCollections() {
-        const all = await Promise.all(Array.from(new Set(this.rules.flatMap(r => r.backends)))
-            .map(b => b.getCollections()));
+        const all = await Promise.all(Array.from(new Set(this.rules.flatMap(r => r.backends))).map(b => b.getCollections()));
         const merged = new Set(all.flat());
         return Array.from(merged);
     }

package/dist/db/valthera.d.ts

@@ -20,32 +20,10 @@ export declare class ValtheraClass implements ValtheraCompatible {
     } & {
         "*": (name: keyof ValtheraCompatible, query: VQuery, result: any) => void;
     }>;
-    /** @deprecated typo */
-    emiter: VEE<{
-        c: (query: VQuery, result: Collection<unknown>) => void;
-        getCollections: (query: VQuery, result: string[]) => void;
-        ensureCollection: (query: VQuery, result: boolean) => void;
-        issetCollection: (query: VQuery, result: boolean) => void;
-        add: (query: VQuery, result: unknown) => void;
-        find: (query: VQuery, result: unknown[]) => void;
-        findOne: (query: VQuery, result: unknown) => void;
-        update: (query: VQuery, result: unknown[]) => void;
-        updateOne: (query: VQuery, result: unknown) => void;
-        remove: (query: VQuery, result: unknown[]) => void;
-        removeOne: (query: VQuery, result: unknown) => void;
-        removeCollection: (query: VQuery, result: boolean) => void;
-        updateOneOrAdd: (query: VQuery, result: VQueryT.UpdateOneOrAddResult<unknown>) => void;
-        toggleOne: (query: VQuery, result: VQueryT.ToggleOneResult<unknown>) => void;
-    } & {
-        "*": (name: keyof ValtheraCompatible, query: VQuery, result: any) => void;
-    }>;
     version: string;
     _plugins: ValtheraPlugin[];
+    _collections: Map<string, Collection<any>>;
     plugin(p: ValtheraPlugin): () => void;
-    /** @deprecated use `adapter` */
-    get dbAction(): ActionsBase;
-    /** @deprecated use `adapter` */
-    set dbAction(action: ActionsBase);
     constructor(options: DbOpts);
     init(...args: any[]): Promise<any>;
     close(...args: any[]): Promise<any>;
@@ -100,9 +78,6 @@ export declare class ValtheraClass implements ValtheraCompatible {
     updateOneOrAdd<T = Data>(query: VQueryT.UpdateOneOrAdd<T>): Promise<VQueryT.UpdateOneOrAddResult<T>>;
     /**
      * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
-     * Returns a promise resolving to `false` if the entry was found and removed,
-     * or `true` if the entry was added. The returned value reflects the state of the database
-     * after the operation.
      */
     toggleOne<T = Data>(query: VQueryT.ToggleOne<T>): Promise<VQueryT.ToggleOneResult<T>>;
     /**

package/dist/db/valthera.js

@@ -11,10 +11,9 @@ export class ValtheraClass {
     adapter;
     executor;
     emitter = new VEE();
-    /** @deprecated typo */
-    emiter = this.emitter;
     version = version;
     _plugins = [];
+    _collections = new Map();
     plugin(p) {
         p.init?.(this);
         this._plugins.push(p);
@@ -24,23 +23,17 @@ export class ValtheraClass {
                 this._plugins.splice(i, 1);
         };
     }
-    /** @deprecated use `adapter` */
-    get dbAction() {
-        return this.adapter;
-    }
-    /** @deprecated use `adapter` */
-    set dbAction(action) {
-        this.adapter = action;
-    }
     constructor(options) {
         this.options = options;
         this.executor = options.executor || new SmartExecutor(undefined, false);
-        options.adapter ??= options.dbAction;
-        options.dbAction ??= options.adapter;
         if (typeof options.adapter === "function")
             return;
-        else
+        else {
             this.adapter = options.adapter;
+            if (options.adapterOpts) {
+                this.adapter.adapterOpts = options.adapterOpts;
+            }
+        }
     }
     async init(...args) {
         if (this.adapter?._inited)
@@ -52,10 +45,16 @@ export class ValtheraClass {
             if (typeof self.options.adapter === "function")
                 self.adapter = await self.options.adapter();
             // if the executor is not set, and the action wants a smart executor
-            if (!self.options.executor && self.adapter.smartExecutor && self.executor instanceof SmartExecutor)
+            if (!self.options.executor &&
+                self.adapter.smartExecutor &&
+                self.executor instanceof SmartExecutor)
                 self.executor.aware = true;
-            if (self.options.numberId)
-                self.adapter.numberId = true;
+            if (self.options.adapterOpts) {
+                self.adapter.adapterOpts = {
+                    ...self.adapter.adapterOpts,
+                    ...self.options.adapterOpts,
+                };
+            }
             await self.adapter.init(...args);
             self.adapter._inited = true;
         });
@@ -83,7 +82,7 @@ export class ValtheraClass {
                 if (idx < plugins.length)
                     return plugins[idx++].execute(ctx);
                 return self.executor.addOp(self.adapter[ctx.op].bind(self.adapter), ctx.query, typeof ctx.query === "string" ? ctx.query : ctx.query.collection);
-            }
+            },
         };
         const result = await ctx.next();
         this.emitter.emit(ctx.op, ctx.query, result);
@@ -93,7 +92,11 @@ export class ValtheraClass {
      * Create a new instance of a Collection class.
      */
     c(collection) {
-        return new Collection(this, collection);
+        if (this._collections.has(collection))
+            return this._collections.get(collection);
+        const col = new Collection(this, collection);
+        this._collections.set(collection, col);
+        return col;
     }
     /**
      * Get the names of all available databases.
@@ -185,9 +188,6 @@ export class ValtheraClass {
     }
     /**
      * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
-     * Returns a promise resolving to `false` if the entry was found and removed,
-     * or `true` if the entry was added. The returned value reflects the state of the database
-     * after the operation.
      */
     toggleOne(query) {
         query.data ||= {};

package/dist/helpers/addId.js

@@ -2,22 +2,31 @@ import { genId } from "./gen.js";
 export async function addId(query, actions, defaultGen = true) {
     const { collection, data } = query;
     const id_gen = query.id_gen ?? defaultGen;
+    const { idKey = "_id", numberId } = actions.adapterOpts;
     if (!id_gen)
         return data;
-    if (data._id)
+    if (data[idKey])
         return data;
-    const { numberId } = actions;
     if (!numberId) {
-        data._id = genId();
+        data[idKey] = genId();
         return;
     }
-    const find = await actions.findOne({ collection: "__vdb_id", search: { c: collection } });
-    data._id = find?.i ? find.i + 1 : 1;
+    const find = (await actions.findOne({
+        collection: "__vdb_id",
+        search: {
+            c: collection,
+        },
+    }));
+    data[idKey] = find?.i ? find.i + 1 : 1;
     await actions.updateOneOrAdd({
         collection: "__vdb_id",
-        search: { c: collection },
+        search: {
+            c: collection,
+        },
         updater: {
-            $inc: { i: 1 }
+            $inc: {
+                i: 1,
+            },
         },
         id_gen: false,
     });

package/dist/helpers/assignDataPush.js

@@ -14,7 +14,7 @@ export function assignDataPush(data) {
         const dk = data[key];
         if (Array.isArray(dk))
             continue;
-        Object.keys(dk).forEach((k) => obj[k] = dk[k]);
+        Object.keys(dk).forEach(k => (obj[k] = dk[k]));
     }
     return obj;
 }

package/dist/helpers/collection.d.ts

@@ -46,9 +46,6 @@ export declare class Collection<D = Data> {
     updateOneOrAdd(search: Search<D>, updater: Updater<D>, { add_arg, context, id_gen }?: UpdateOneOrAdd<D>): Promise<VQueryT.UpdateOneOrAddResult<D>>;
     /**
      * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
-     * Returns a promise resolving to `false` if the entry was found and removed,
-     * or `true` if the entry was added. The returned value reflects the state of the database
-     * after the operation.
      */
     toggleOne(search: Search<D>, data?: Arg<D>, context?: VContext): Promise<VQueryT.ToggleOneResult<D>>;
 }

package/dist/helpers/collection.js

@@ -6,57 +6,99 @@ export class Collection {
         this.collection = collection;
     }
     add(data, id_gen) {
-        return this.db.add({ collection: this.collection, data, id_gen });
+        return this.db.add({
+            collection: this.collection,
+            data,
+            id_gen,
+        });
     }
     /**
      * Find data in a database.
      */
     find(search = {}, options = {}, findOpts = {}, context = {}) {
-        return this.db.find({ collection: this.collection, search, dbFindOpts: options, findOpts, context });
+        return this.db.find({
+            collection: this.collection,
+            search,
+            dbFindOpts: options,
+            findOpts,
+            context,
+        });
     }
     /**
      * Find one data entry in a database.
      */
     findOne(search = {}, findOpts = {}, context = {}) {
-        return this.db.findOne({ collection: this.collection, search, findOpts, context });
+        return this.db.findOne({
+            collection: this.collection,
+            search,
+            findOpts,
+            context,
+        });
     }
     /**
      * Update data in a database.
      */
     update(search, updater, context = {}) {
-        return this.db.update({ collection: this.collection, search, updater, context });
+        return this.db.update({
+            collection: this.collection,
+            search,
+            updater,
+            context,
+        });
     }
     /**
      * Update one data entry in a database.
      */
     updateOne(search, updater, context = {}) {
-        return this.db.updateOne({ collection: this.collection, search, updater, context });
+        return this.db.updateOne({
+            collection: this.collection,
+            search,
+            updater,
+            context,
+        });
     }
     /**
      * Remove data from a database.
      */
     remove(search, context = {}) {
-        return this.db.remove({ collection: this.collection, search, context });
+        return this.db.remove({
+            collection: this.collection,
+            search,
+            context,
+        });
     }
     /**
      * Remove one data entry from a database.
      */
     removeOne(search, context = {}) {
-        return this.db.removeOne({ collection: this.collection, search, context });
+        return this.db.removeOne({
+            collection: this.collection,
+            search,
+            context,
+        });
     }
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
     updateOneOrAdd(search, updater, { add_arg = {}, context = {}, id_gen = true } = {}) {
-        return this.db.updateOneOrAdd({ collection: this.collection, search, updater, add_arg, context, id_gen });
+        return this.db.updateOneOrAdd({
+            collection: this.collection,
+            search,
+            updater,
+            add_arg,
+            context,
+            id_gen,
+        });
     }
     /**
      * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
-     * Returns a promise resolving to `false` if the entry was found and removed,
-     * or `true` if the entry was added. The returned value reflects the state of the database
-     * after the operation.
      */
     toggleOne(search, data = {}, context = {}) {
-        return this.db.toggleOne({ collection: this.collection, search, data, context });
+        return this.db.toggleOne({
+            collection: this.collection,
+            search,
+            data,
+            context,
+        });
     }
 }