@wxn0brp/db-core 0.0.7 → 0.1.1

package/dist/base/actions.d.ts

@@ -1,8 +1,10 @@
 import Data from "../types/data.js";
 import { VQuery } from "../types/query.js";
-declare class dbActionBase {
+declare class ActionsBase {
+    _inited: boolean;
+    init(...args: any[]): Promise<void>;
     getCollections(): Promise<string[]>;
-    checkCollection(config: VQuery): Promise<boolean>;
+    ensureCollection(config: VQuery): Promise<boolean>;
     issetCollection(config: VQuery): Promise<boolean>;
     add(config: VQuery): Promise<Data>;
     find(config: VQuery): Promise<Data[]>;
@@ -14,4 +16,4 @@ declare class dbActionBase {
     removeCollection(config: VQuery): Promise<boolean>;
     updateOneOrAdd(config: VQuery): Promise<boolean>;
 }
-export default dbActionBase;
+export default ActionsBase;

package/dist/base/actions.js

@@ -1,10 +1,12 @@
 import { setDataUsingUpdateOneOrAdd } from "../helpers/updateOneOrAdd.js";
-class dbActionBase {
+class ActionsBase {
+    _inited = true;
+    async init(...args) { }
     async getCollections() {
         throw new Error("Not implemented");
         return [];
     }
-    async checkCollection(config) {
+    async ensureCollection(config) {
         throw new Error("Not implemented");
         return false;
     }
@@ -53,4 +55,4 @@ class dbActionBase {
         return res;
     }
 }
-export default dbActionBase;
+export default ActionsBase;

package/dist/base/custom.d.ts

@@ -0,0 +1,36 @@
+import CustomFileCpu from "../customFileCpu.js";
+import Data from "../types/data.js";
+import { VQuery } from "../types/query.js";
+import ActionsBase from "./actions.js";
+export declare class CustomActionsBase extends ActionsBase {
+    fileCpu: CustomFileCpu;
+    constructor();
+    /**
+     * Add a new entry to the specified database.
+     */
+    add({ collection, data, id_gen }: VQuery): Promise<import("../types/arg.js").Arg>;
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    find(query: VQuery): Promise<Data[]>;
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    remove({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
+}

package/dist/base/custom.js

@@ -0,0 +1,63 @@
+import genId from "../helpers/gen.js";
+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.
+     */
+    async add({ collection, data, id_gen = true }) {
+        await this.ensureCollection(arguments[0]);
+        if (id_gen)
+            data._id = data._id || genId();
+        await this.fileCpu.add(collection, data);
+        return data;
+    }
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    async find(query) {
+        await this.ensureCollection(query);
+        const data = await findUtil(query, this.fileCpu, [query.collection]);
+        return data;
+    }
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    async findOne({ collection, search, context = {}, findOpts = {} }) {
+        await this.ensureCollection(arguments[0]);
+        let data = await this.fileCpu.findOne(collection, search, context, findOpts);
+        return data || null;
+    }
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    async update({ collection, search, updater, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.update(collection, false, search, updater, context);
+    }
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    async updateOne({ collection, search, updater, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.update(collection, true, search, updater, context);
+    }
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    async remove({ collection, search, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, false, search, context);
+    }
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    async removeOne({ collection, search, context = {} }) {
+        await this.ensureCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, true, search, context);
+    }
+}

package/dist/db/memory.d.ts

@@ -1,70 +1,21 @@
-import ValtheraClass from "./valthera.js";
-import dbActionBase from "../base/actions.js";
+import { CustomActionsBase } from "../base/custom.js";
+import CollectionManager from "../helpers/CollectionManager.js";
 import Data from "../types/data.js";
-import FileCpu from "../types/fileCpu.js";
-import { DbOpts } from "../types/options.js";
 import { VQuery } from "../types/query.js";
-export declare class MemoryAction extends dbActionBase {
-    folder: string;
-    options: DbOpts;
-    fileCpu: FileCpu;
+import ValtheraClass from "./valthera.js";
+export declare class MemoryAction extends CustomActionsBase {
     memory: Map<string, any[]>;
-    /**
-     * Creates a new instance of dbActionC.
-     * @constructor
-     * @param folder - The folder where database files are stored.
-     * @param options - The options object.
-     */
     constructor();
     _readMemory(key: string): any[];
     _writeMemory(key: string, data: any[]): void;
-    _getCollectionPath(collection: string): string;
-    /**
-     * Get a list of available databases in the specified folder.
-     */
     getCollections(): Promise<string[]>;
-    /**
-     * Check and create the specified collection if it doesn't exist.
-     */
-    checkCollection({ collection }: VQuery): Promise<boolean>;
-    /**
-     * Check if a collection exists.
-     */
+    ensureCollection({ collection }: VQuery): Promise<boolean>;
     issetCollection({ collection }: VQuery): Promise<boolean>;
-    /**
-     * Add a new entry to the specified database.
-     */
-    add({ collection, data, id_gen }: VQuery): Promise<import("../types/arg.js").Arg>;
-    /**
-     * Find entries in the specified database based on search criteria.
-     */
-    find(query: VQuery): Promise<Data[]>;
-    /**
-     * Find the first matching entry in the specified database based on search criteria.
-     */
-    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
-    /**
-     * Update entries in the specified database based on search criteria and an updater function or object.
-     */
-    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
-    /**
-     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
-     */
-    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
-    /**
-     * Remove entries from the specified database based on search criteria.
-     */
-    remove({ collection, search, context }: VQuery): Promise<boolean>;
-    /**
-     * Remove the first matching entry from the specified database based on search criteria.
-     */
-    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
-    /**
-     * Removes a database collection from the file system.
-     */
     removeCollection({ collection }: VQuery): Promise<boolean>;
 }
 export default class ValtheraMemory extends ValtheraClass {
     constructor(...args: any[]);
 }
-export declare function createMemoryValthera<T extends Record<string, Data[]>>(data?: T): ValtheraMemory;
+export declare function createMemoryValthera<T extends Record<string, Data[]>>(data?: T): ValtheraMemory & {
+    [K in keyof T]: CollectionManager<T[K][number]>;
+};

package/dist/db/memory.js

@@ -1,23 +1,13 @@
-import ValtheraClass from "./valthera.js";
+import { CustomActionsBase } from "../base/custom.js";
 import CustomFileCpu from "../customFileCpu.js";
-import genId from "../helpers/gen.js";
-import dbActionBase from "../base/actions.js";
-import { findUtil } from "../utils/action.js";
-export class MemoryAction extends dbActionBase {
-    folder;
-    options;
-    fileCpu;
+import { forgeValthera } from "../utils/forge.js";
+import ValtheraClass from "./valthera.js";
+export class MemoryAction extends CustomActionsBase {
     memory;
-    /**
-     * Creates a new instance of dbActionC.
-     * @constructor
-     * @param folder - The folder where database files are stored.
-     * @param options - The options object.
-     */
     constructor() {
         super();
-        this.memory = new Map();
         this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this));
+        this.memory = new Map();
     }
     _readMemory(key) {
         if (!this.memory.has(key))
@@ -27,88 +17,19 @@ export class MemoryAction extends dbActionBase {
     _writeMemory(key, data) {
         this.memory.set(key, data);
     }
-    _getCollectionPath(collection) {
-        return this.folder + "/" + collection + "/";
-    }
-    /**
-     * Get a list of available databases in the specified folder.
-     */
     async getCollections() {
         const collections = Array.from(this.memory.keys());
         return collections;
     }
-    /**
-     * Check and create the specified collection if it doesn't exist.
-     */
-    async checkCollection({ collection }) {
+    async ensureCollection({ collection }) {
         if (this.issetCollection(collection))
             return;
         this.memory.set(collection, []);
         return true;
     }
-    /**
-     * Check if a collection exists.
-     */
     async issetCollection({ collection }) {
         return this.memory.has(collection);
     }
-    /**
-     * Add a new entry to the specified database.
-     */
-    async add({ collection, data, id_gen = true }) {
-        await this.checkCollection(arguments[0]);
-        if (id_gen)
-            data._id = data._id || genId();
-        await this.fileCpu.add(collection, data);
-        return data;
-    }
-    /**
-     * Find entries in the specified database based on search criteria.
-     */
-    async find(query) {
-        await this.checkCollection(query);
-        const data = await findUtil(query, this.fileCpu, [query.collection]);
-        return data;
-    }
-    /**
-     * Find the first matching entry in the specified database based on search criteria.
-     */
-    async findOne({ collection, search, context = {}, findOpts = {} }) {
-        await this.checkCollection(arguments[0]);
-        let data = await this.fileCpu.findOne(collection, search, context, findOpts);
-        return data || null;
-    }
-    /**
-     * Update entries in the specified database based on search criteria and an updater function or object.
-     */
-    async update({ collection, search, updater, context = {} }) {
-        await this.checkCollection(arguments[0]);
-        return await this.fileCpu.update(collection, false, search, updater, context);
-    }
-    /**
-     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
-     */
-    async updateOne({ collection, search, updater, context = {} }) {
-        await this.checkCollection(arguments[0]);
-        return await this.fileCpu.update(collection, true, search, updater, context);
-    }
-    /**
-     * Remove entries from the specified database based on search criteria.
-     */
-    async remove({ collection, search, context = {} }) {
-        await this.checkCollection(arguments[0]);
-        return await this.fileCpu.remove(collection, false, search, context);
-    }
-    /**
-     * Remove the first matching entry from the specified database based on search criteria.
-     */
-    async removeOne({ collection, search, context = {} }) {
-        await this.checkCollection(arguments[0]);
-        return await this.fileCpu.remove(collection, true, search, context);
-    }
-    /**
-     * Removes a database collection from the file system.
-     */
     async removeCollection({ collection }) {
         this.memory.delete(collection);
         return true;
@@ -122,9 +43,9 @@ export default class ValtheraMemory extends ValtheraClass {
 export function createMemoryValthera(data) {
     const db = new ValtheraMemory();
     if (!data)
-        return db;
+        return forgeValthera(db);
     for (const collection of Object.keys(data)) {
         db.dbAction.memory.set(collection, data[collection]);
     }
-    return db;
+    return forgeValthera(db);
 }

package/dist/db/valthera.d.ts

@@ -1,5 +1,5 @@
 import { UniversalEventEmitter } from "../helpers/eventEmiter.js";
-import dbActionBase from "../base/actions.js";
+import ActionsBase from "../base/actions.js";
 import CollectionManager from "../helpers/CollectionManager.js";
 import executorC from "../helpers/executor.js";
 import { Arg, Search, Updater } from "../types/arg.js";
@@ -12,16 +12,17 @@ import { ValtheraCompatible } from "../types/valthera.js";
  * @class
  */
 declare class ValtheraClass implements ValtheraCompatible {
-    dbAction: dbActionBase;
+    dbAction: ActionsBase;
     executor: executorC;
     emiter: UniversalEventEmitter;
     version: string;
     constructor(options?: DbOpts);
+    init(...args: any[]): Promise<unknown>;
     private execute;
     /**
      * Create a new instance of a CollectionManager class.
      */
-    c(collection: string): CollectionManager;
+    c<T = Data>(collection: string): CollectionManager<T>;
     /**
      * Get the names of all available databases.
      */
@@ -29,7 +30,7 @@ declare class ValtheraClass implements ValtheraCompatible {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    checkCollection(collection: string): Promise<boolean>;
+    ensureCollection(collection: string): Promise<boolean>;
     /**
      * Check if a collection exists.
      */

package/dist/db/valthera.js

@@ -1,6 +1,6 @@
 import { version } from "../version.js";
 import { UniversalEventEmitter } from "../helpers/eventEmiter.js";
-import dbActionBase from "../base/actions.js";
+import ActionsBase from "../base/actions.js";
 import CollectionManager from "../helpers/CollectionManager.js";
 import executorC from "../helpers/executor.js";
 /**
@@ -13,16 +13,26 @@ class ValtheraClass {
     emiter;
     version = version;
     constructor(options = {}) {
-        this.dbAction = options.dbAction || new dbActionBase();
+        this.dbAction = options.dbAction || new ActionsBase();
         this.executor = options.executor || new executorC();
         this.emiter = new UniversalEventEmitter();
     }
+    async init(...args) {
+        if (this.dbAction._inited)
+            return;
+        const self = this;
+        return await this.executor.addOp(async () => {
+            if (self.dbAction._inited)
+                return;
+            await self.dbAction.init(...args);
+            self.dbAction._inited = true;
+        });
+    }
     async execute(name, ...args) {
+        await this.init();
         const result = await this.executor.addOp(this.dbAction[name].bind(this.dbAction), ...args);
-        if (this.emiter.listenerCount(name) !== 0)
-            this.emiter.emit(name, args, result);
-        if (this.emiter.listenerCount("*") !== 0)
-            this.emiter.emit("*", name, args, result);
+        this.emiter.emit(name, args, result);
+        this.emiter.emit("*", name, args, result);
         return result;
     }
     /**
@@ -40,8 +50,8 @@ class ValtheraClass {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    async checkCollection(collection) {
-        return await this.execute("checkCollection", { collection });
+    async ensureCollection(collection) {
+        return await this.execute("ensureCollection", { collection });
     }
     /**
      * Check if a collection exists.

package/dist/helpers/CollectionManager.d.ts

@@ -3,41 +3,41 @@ import { DbFindOpts, FindOpts } from "../types/options.js";
 import { VContext } from "../types/types.js";
 import Data from "../types/data.js";
 import { ValtheraCompatible } from "../types/valthera.js";
-declare class CollectionManager {
+declare class CollectionManager<D = Data> {
     private db;
     private collection;
     constructor(db: ValtheraCompatible, collection: string);
     /**
      * Add data to a database.
      */
-    add<T = Data>(data: Arg, id_gen?: boolean): Promise<T>;
+    add<T = D>(data: Arg<T>, id_gen?: boolean): Promise<T>;
     /**
      * Find data in a database.
      */
-    find<T = Data>(search: Search, context?: VContext, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    find<T = D>(search?: Search<T>, context?: VContext, options?: DbFindOpts<T>, findOpts?: FindOpts<T>): Promise<T[]>;
     /**
      * Find one data entry in a database.
      */
-    findOne<T = Data>(search: Search, context?: VContext, findOpts?: FindOpts): Promise<T>;
+    findOne<T = D>(search?: Search<T>, context?: VContext, findOpts?: FindOpts<T>): Promise<T>;
     /**
      * Update data in a database.
      */
-    update(search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    update<T = D>(search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
     /**
      * Update one data entry in a database.
      */
-    updateOne(search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    updateOne<T = D>(search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
     /**
      * Remove data from a database.
      */
-    remove(search: Search, context?: VContext): Promise<boolean>;
+    remove<T = D>(search: Search<T>, context?: VContext): Promise<boolean>;
     /**
      * Remove one data entry from a database.
      */
-    removeOne(search: Search, context?: VContext): Promise<boolean>;
+    removeOne<T = D>(search: Search<T>, context?: VContext): Promise<boolean>;
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd(search: Search, updater: Updater, add_arg?: Arg, context?: VContext, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = D>(search: Search<T>, updater: Updater<T>, add_arg?: Arg<T>, context?: VContext, id_gen?: boolean): Promise<boolean>;
 }
 export default CollectionManager;

package/dist/helpers/CollectionManager.js

@@ -14,13 +14,13 @@ class CollectionManager {
     /**
      * Find data in a database.
      */
-    async find(search, context = {}, options = {}, findOpts = {}) {
+    async find(search = {}, context = {}, options = {}, findOpts = {}) {
         return await this.db.find(this.collection, search, context, options, findOpts);
     }
     /**
      * Find one data entry in a database.
      */
-    async findOne(search, context = {}, findOpts = {}) {
+    async findOne(search = {}, context = {}, findOpts = {}) {
         return await this.db.findOne(this.collection, search, context, findOpts);
     }
     /**

package/dist/index.d.ts

@@ -1,11 +1,12 @@
+import CustomFileCpu from "./customFileCpu.js";
+import ValtheraMemory, { createMemoryValthera } from "./db/memory.js";
+import ValtheraClass from "./db/valthera.js";
 import genId from "./helpers/gen.js";
 import Relation from "./helpers/relation.js";
+import { ValtheraTypes } from "./types/export.js";
 import { RelationTypes } from "./types/relation.js";
 import { ValtheraCompatible } from "./types/valthera.js";
-import { ValtheraTypes } from "./types/export.js";
-import CustomFileCpu from "./customFileCpu.js";
-import ValtheraClass from "./db/valthera.js";
-import ValtheraMemory, { createMemoryValthera } from "./db/memory.js";
-export { ValtheraClass, ValtheraMemory, createMemoryValthera, Relation, genId, CustomFileCpu, };
-export type { ValtheraCompatible, RelationTypes, ValtheraTypes };
+import { forgeValthera } from "./utils/forge.js";
+export { createMemoryValthera, CustomFileCpu, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory };
+export type { RelationTypes, ValtheraCompatible, ValtheraTypes };
 export type Id = import("./types/Id.js").Id;

package/dist/index.js

@@ -1,6 +1,7 @@
-import genId from "./helpers/gen.js";
-import Relation from "./helpers/relation.js";
 import CustomFileCpu from "./customFileCpu.js";
-import ValtheraClass from "./db/valthera.js";
 import ValtheraMemory, { createMemoryValthera } from "./db/memory.js";
-export { ValtheraClass, ValtheraMemory, createMemoryValthera, Relation, genId, CustomFileCpu, };
+import ValtheraClass from "./db/valthera.js";
+import genId from "./helpers/gen.js";
+import Relation from "./helpers/relation.js";
+import { forgeValthera } from "./utils/forge.js";
+export { createMemoryValthera, CustomFileCpu, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory };

package/dist/types/options.d.ts

@@ -1,9 +1,9 @@
-import dbActionBase from "../base/actions.js";
+import ActionsBase from "../base/actions.js";
 import executorC from "../helpers/executor.js";
 import { KeysMatching } from "./utils.js";
 export interface DbOpts {
     maxFileSize?: number;
-    dbAction?: dbActionBase;
+    dbAction?: ActionsBase;
     executor?: executorC;
 }
 export interface DbFindOpts<T = any> {

package/dist/types/valthera.d.ts

@@ -7,7 +7,7 @@ import { VContext } from "./types.js";
 export interface ValtheraCompatible {
     c(collection: string): CollectionManager;
     getCollections(): Promise<string[]>;
-    checkCollection(collection: string): Promise<boolean>;
+    ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
     add<T = Data>(collection: string, data: Arg<T>, id_gen?: boolean): Promise<T>;
     find<T = Data>(collection: string, search: Search<T>, context?: VContext, options?: DbFindOpts<T>, findOpts?: FindOpts<T>): Promise<T[]>;
@@ -22,7 +22,7 @@ export interface ValtheraCompatible {
 export interface ValtheraCompatibleInternal {
     c(config: VQuery): CollectionManager;
     getCollections(): Promise<string[]>;
-    checkCollection(config: VQuery): Promise<boolean>;
+    ensureCollection(config: VQuery): Promise<boolean>;
     issetCollection(config: VQuery): Promise<boolean>;
     add<T = Data>(config: VQuery): Promise<T>;
     find<T = Data>(config: VQuery): Promise<T[]>;

package/dist/utils/forge.d.ts

@@ -0,0 +1,3 @@
+import CollectionManager from "../helpers/CollectionManager.js";
+import { ValtheraCompatible } from "../types/valthera.js";
+export declare function forgeValthera<T extends string>(target: ValtheraCompatible): ValtheraCompatible & { [K in T]: CollectionManager; };

package/dist/utils/forge.js

@@ -0,0 +1,17 @@
+import CollectionManager from "../helpers/CollectionManager.js";
+export function forgeValthera(target) {
+    return new Proxy(target, {
+        get(target, prop, receiver) {
+            if (prop in target) {
+                return Reflect.get(target, prop, receiver);
+            }
+            const collection = new CollectionManager(target, prop);
+            target[prop] = collection;
+            return collection;
+        },
+        set(target, prop, value, receiver) {
+            return Reflect.set(target, prop, value, receiver);
+        }
+    });
+}
+;

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.0.7";
+export const version = "0.1.1";

package/package.json

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

package/dist/base/db.d.ts

@@ -1,21 +0,0 @@
-import CollectionManager from "../helpers/CollectionManager.js";
-import Data from "../types/data.js";
-import { VQuery } from "../types/query.js";
-import { ValtheraCompatibleInternal } from "../types/valthera.js";
-declare class ValtheraBase implements ValtheraCompatibleInternal {
-    version: string;
-    c(config: VQuery): CollectionManager;
-    getCollections(): Promise<any[]>;
-    checkCollection(config: VQuery): Promise<boolean>;
-    issetCollection(config: VQuery): Promise<boolean>;
-    add<T = Data>(config: VQuery): Promise<T>;
-    find<T = Data>(config: VQuery): Promise<T[]>;
-    findOne<T = Data>(config: VQuery): Promise<T>;
-    remove(config: VQuery): Promise<boolean>;
-    removeCollection(config: VQuery): Promise<boolean>;
-    removeOne(config: VQuery): Promise<boolean>;
-    update(config: VQuery): Promise<boolean>;
-    updateOne(config: VQuery): Promise<boolean>;
-    updateOneOrAdd(config: VQuery): Promise<boolean>;
-}
-export default ValtheraBase;

package/dist/base/db.js

@@ -1,56 +0,0 @@
-import { version } from "../version.js";
-class ValtheraBase {
-    version = version;
-    c(config) {
-        throw new Error("Not implemented");
-    }
-    async getCollections() {
-        throw new Error("Not implemented");
-        return [];
-    }
-    async checkCollection(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async issetCollection(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async add(config) {
-        throw new Error("Not implemented");
-        return {};
-    }
-    async find(config) {
-        throw new Error("Not implemented");
-        return [];
-    }
-    async findOne(config) {
-        throw new Error("Not implemented");
-        return {};
-    }
-    async remove(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async removeCollection(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async removeOne(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async update(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async updateOne(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-    async updateOneOrAdd(config) {
-        throw new Error("Not implemented");
-        return false;
-    }
-}
-export default ValtheraBase;