@wxn0brp/db-core 0.1.5 → 0.2.0

package/README.md

@@ -12,6 +12,10 @@ It is **not recommended** to install this module separately unless you plan to c
 npm install @wxn0brp/db-core
 ```
 
+## Documentation
+
+See the [documentation](docs/README.md) for more information about the API and usage.
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/db/routedStorage.d.ts

@@ -0,0 +1,27 @@
+import ActionsBase from "../base/actions.js";
+import { VQuery } from "../types/query.js";
+export type MatchRule = string | RegExp | ((query: VQuery) => boolean);
+export interface RouteEntry {
+    match: MatchRule;
+    backends: ActionsBase[];
+}
+export declare class RoutedStorage extends ActionsBase {
+    rules: RouteEntry[];
+    defaultBackend: ActionsBase[];
+    constructor(rules: RouteEntry[], defaultBackend: ActionsBase | ActionsBase[]);
+    _matchBackends(config: VQuery): ActionsBase[];
+    _withAll<T>(config: VQuery, fn: (b: ActionsBase) => Promise<T>, gather?: boolean): Promise<T>;
+    _withFirst<T>(config: VQuery, fn: (b: ActionsBase) => Promise<T>): Promise<T>;
+    init(...args: any[]): Promise<void>;
+    add(config: VQuery): Promise<import("../types/data.js").Data>;
+    find(config: VQuery): Promise<import("../types/data.js").Data[]>;
+    findOne(config: VQuery): Promise<import("../types/data.js").Data>;
+    update(config: VQuery): Promise<boolean>;
+    updateOne(config: VQuery): Promise<boolean>;
+    remove(config: VQuery): Promise<boolean>;
+    removeOne(config: VQuery): Promise<boolean>;
+    ensureCollection(config: VQuery): Promise<boolean>;
+    issetCollection(config: VQuery): Promise<boolean>;
+    removeCollection(config: VQuery): Promise<boolean>;
+    getCollections(): Promise<string[]>;
+}

package/dist/db/routedStorage.js

@@ -0,0 +1,82 @@
+import ActionsBase from "../base/actions.js";
+export class RoutedStorage extends ActionsBase {
+    rules;
+    defaultBackend;
+    constructor(rules, defaultBackend) {
+        super();
+        this.rules = rules;
+        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 === "*") ||
+                (match instanceof RegExp && match.test(collection)) ||
+                (typeof match === "function" && match(config))) {
+                matched.push(...backends);
+            }
+        }
+        if (matched.length === 0)
+            matched.push(...this.defaultBackend);
+        return matched;
+    }
+    async _withAll(config, fn, gather = false) {
+        const backends = this._matchBackends(config);
+        if (gather) {
+            return await Promise.all(backends.map(fn)).then(res => res[0]);
+        }
+        else {
+            for (const b of backends)
+                await fn(b);
+            return undefined;
+        }
+    }
+    async _withFirst(config, fn) {
+        const [first] = this._matchBackends(config);
+        return await fn(first);
+    }
+    async init(...args) {
+        const all = new Set(this.rules.flatMap(r => r.backends));
+        await Promise.all(Array.from(all).map(b => b.init?.(...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 }));
+        return res;
+    }
+    async find(config) {
+        return this._withFirst(config, b => b.find(config));
+    }
+    async findOne(config) {
+        return this._withFirst(config, b => b.findOne(config));
+    }
+    async update(config) {
+        return this._withAll(config, b => b.update(config), true);
+    }
+    async updateOne(config) {
+        return this._withAll(config, b => b.updateOne(config), true);
+    }
+    async remove(config) {
+        return this._withAll(config, b => b.remove(config), true);
+    }
+    async removeOne(config) {
+        return this._withAll(config, b => b.removeOne(config), true);
+    }
+    async ensureCollection(config) {
+        return this._withAll(config, b => b.ensureCollection(config), true);
+    }
+    async issetCollection(config) {
+        return this._withFirst(config, b => b.issetCollection(config));
+    }
+    async removeCollection(config) {
+        return this._withAll(config, b => b.removeCollection(config), true);
+    }
+    async 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

@@ -2,12 +2,12 @@ import { VEE } from "@wxn0brp/event-emitter";
 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";
+import { Search, Updater } from "../types/arg.js";
 import Data from "../types/data.js";
 import { DbFindOpts, DbOpts, FindOpts } from "../types/options.js";
 import { VQuery } from "../types/query.js";
 import { VContext } from "../types/types.js";
-import { ValtheraCompatible } from "../types/valthera.js";
+import { UpdateOneOrAdd, ValtheraCompatible } from "../types/valthera.js";
 type DbActionsFns = keyof {
     [K in keyof ActionsBase as ActionsBase[K] extends (...args: any[]) => any ? K : never]: any;
 };
@@ -49,11 +49,11 @@ declare class ValtheraClass implements ValtheraCompatible {
     /**
      * Find data in a database.
      */
-    find<T = Data>(collection: string, search?: Search<T>, context?: VContext, dbFindOpts?: DbFindOpts<T>, findOpts?: FindOpts<T>): Promise<T[]>;
+    find<T = Data>(collection: string, search?: Search<T>, dbFindOpts?: DbFindOpts<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T[]>;
     /**
      * Find one data entry in a database.
      */
-    findOne<T = Data>(collection: string, search?: Search<T>, context?: VContext, findOpts?: FindOpts<T>): Promise<T>;
+    findOne<T = Data>(collection: string, search?: Search<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T>;
     /**
      * Update data in a database.
      */
@@ -73,7 +73,7 @@ declare class ValtheraClass implements ValtheraCompatible {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, add_arg?: Arg, context?: VContext, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, { add_arg, context, id_gen }: UpdateOneOrAdd<T>): Promise<boolean>;
     /**
      * Removes a database collection from the file system.
      */

package/dist/db/valthera.js

@@ -66,13 +66,13 @@ class ValtheraClass {
     /**
      * Find data in a database.
      */
-    async find(collection, search = {}, context = {}, dbFindOpts = {}, findOpts = {}) {
+    async find(collection, search = {}, dbFindOpts = {}, findOpts = {}, context = {}) {
         return await this.execute("find", { collection, search, context, dbFindOpts, findOpts });
     }
     /**
      * Find one data entry in a database.
      */
-    async findOne(collection, search = {}, context = {}, findOpts = {}) {
+    async findOne(collection, search = {}, findOpts = {}, context = {}) {
         return await this.execute("findOne", { collection, search, context, findOpts });
     }
     /**
@@ -102,7 +102,7 @@ class ValtheraClass {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    async updateOneOrAdd(collection, search, updater, add_arg = {}, context = {}, id_gen = true) {
+    async updateOneOrAdd(collection, search, updater, { add_arg = {}, context = {}, id_gen = true }) {
         return await this.execute("updateOneOrAdd", { collection, search, updater, add_arg, context, id_gen });
     }
     /**

package/dist/helpers/CollectionManager.d.ts

@@ -2,7 +2,7 @@ import { Arg, Search, Updater } from "../types/arg.js";
 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";
+import { UpdateOneOrAdd, ValtheraCompatible } from "../types/valthera.js";
 declare class CollectionManager<D = Data> {
     private db;
     private collection;
@@ -14,11 +14,11 @@ declare class CollectionManager<D = Data> {
     /**
      * Find data in a database.
      */
-    find<T = Data>(search?: Search<T & D>, context?: VContext, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>): Promise<T[]>;
+    find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T[]>;
     /**
      * Find one data entry in a database.
      */
-    findOne<T = Data>(search?: Search<T & Data>, context?: VContext, findOpts?: FindOpts<T & Data>): Promise<T>;
+    findOne<T = Data>(search?: Search<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T>;
     /**
      * Update data in a database.
      */
@@ -38,6 +38,6 @@ declare class CollectionManager<D = Data> {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, add_arg?: Arg<T & Data>, context?: VContext, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, { add_arg, context, id_gen }: UpdateOneOrAdd<T & Data>): Promise<boolean>;
 }
 export default CollectionManager;

package/dist/helpers/CollectionManager.js

@@ -14,14 +14,14 @@ class CollectionManager {
     /**
      * Find data in a database.
      */
-    async find(search = {}, context = {}, options = {}, findOpts = {}) {
-        return await this.db.find(this.collection, search, context, options, findOpts);
+    async find(search = {}, options = {}, findOpts = {}, context = {}) {
+        return await this.db.find(this.collection, search, options, findOpts, context);
     }
     /**
      * Find one data entry in a database.
      */
-    async findOne(search = {}, context = {}, findOpts = {}) {
-        return await this.db.findOne(this.collection, search, context, findOpts);
+    async findOne(search = {}, findOpts = {}, context = {}) {
+        return await this.db.findOne(this.collection, search, findOpts, context);
     }
     /**
      * Update data in a database.
@@ -50,8 +50,8 @@ class CollectionManager {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    async updateOneOrAdd(search, updater, add_arg = {}, context = {}, id_gen = true) {
-        return await this.db.updateOneOrAdd(this.collection, search, updater, add_arg, context, id_gen);
+    async updateOneOrAdd(search, updater, { add_arg = {}, context = {}, id_gen = true }) {
+        return await this.db.updateOneOrAdd(this.collection, search, updater, { add_arg, context, id_gen });
     }
 }
 export default CollectionManager;

package/dist/helpers/relation.d.ts

@@ -5,6 +5,6 @@ declare class Relation {
     dbs: RelationTypes.DBS;
     constructor(dbs: RelationTypes.DBS);
     findOne(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>): Promise<any>;
-    find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>, findOpts?: DbFindOpts): Promise<any[]>;
+    find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>, dbFindOpts?: DbFindOpts): Promise<any[]>;
 }
 export default Relation;

package/dist/helpers/relation.js

@@ -32,7 +32,7 @@ function convertSearchObjToSearchArray(obj, parentKeys = []) {
         if (!value) {
             return acc;
         }
-        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
             return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
         }
         else {
@@ -87,7 +87,7 @@ async function processRelations(dbs, cfg, data, parentList = null) {
         else if (type === "1n") {
             const ids = targets.map(i => i[pk]);
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
-            const results = await db.find(coll, { $in: { [fk]: ids } }, {}, findOpts || {}, { select: selectSafe });
+            const results = await db.find(coll, { $in: { [fk]: ids } }, findOpts || {}, { select: selectSafe });
             const grouped = results.reduce((acc, row) => {
                 const id = row[fk];
                 (acc[id] ||= []).push(row);
@@ -105,7 +105,7 @@ async function processRelations(dbs, cfg, data, parentList = null) {
         }
         else if (type === "nm") {
             if (!through || !through.table || !through.pk || !through.fk) {
-                throw new Error(`Relation type "nm" requires a defined 'through' in '${key}'`);
+                throw new Error(`Relation type "nm" requires a defined "through" in "${key}"`);
             }
             for (const item of targets) {
                 const pivotDb = dbs[through.db || dbKey];
@@ -140,10 +140,10 @@ class Relation {
         await processRelations(this.dbs, relations, data);
         return select ? pickByPath(data, select) : data;
     }
-    async find(path, search, relations, select, findOpts = {}) {
+    async find(path, search, relations, select, dbFindOpts = {}) {
         const [dbKey, coll] = path;
         const db = this.dbs[dbKey];
-        const data = await db.find(coll, search, {}, findOpts);
+        const data = await db.find(coll, search, dbFindOpts);
         if (relations)
             await processRelations(this.dbs, relations, null, data);
         if (typeof select === "object" && !Array.isArray(select)) {

package/dist/index.d.ts

@@ -7,7 +7,7 @@ import { ValtheraTypes } from "./types/export.js";
 import { RelationTypes } from "./types/relation.js";
 import { ValtheraCompatible } from "./types/valthera.js";
 import { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
-import { sortByIds } from "./utils/sortId.js";
-export { createMemoryValthera, CustomFileCpu, forgeTypedValthera, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory, sortByIds, };
+import { sortByIds, convertIdToUnix } from "./utils/id.js";
+export { createMemoryValthera, CustomFileCpu, forgeTypedValthera, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory, sortByIds, convertIdToUnix, };
 export type { RelationTypes, ValtheraCompatible, ValtheraTypes, };
 export type Id = import("./types/Id.js").Id;

package/dist/index.js

@@ -4,5 +4,5 @@ import ValtheraClass from "./db/valthera.js";
 import genId from "./helpers/gen.js";
 import Relation from "./helpers/relation.js";
 import { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
-import { sortByIds } from "./utils/sortId.js";
-export { createMemoryValthera, CustomFileCpu, forgeTypedValthera, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory, sortByIds, };
+import { sortByIds, convertIdToUnix } from "./utils/id.js";
+export { createMemoryValthera, CustomFileCpu, forgeTypedValthera, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory, sortByIds, convertIdToUnix, };

package/dist/types/valthera.d.ts

@@ -10,14 +10,19 @@ export interface ValtheraCompatible {
     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[]>;
-    findOne<T = Data>(collection: string, search: Search<T>, context?: VContext, findOpts?: FindOpts<T>): Promise<T | null>;
+    find<T = Data>(collection: string, search?: Search<T>, options?: DbFindOpts<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T[]>;
+    findOne<T = Data>(collection: string, search?: Search<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T | null>;
     update<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
     updateOne<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
     remove<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
     removeOne<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
     removeCollection(collection: string): Promise<boolean>;
-    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, add_arg?: Arg<T>, context?: VContext, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, opts: UpdateOneOrAdd<T>): Promise<boolean>;
+}
+export interface UpdateOneOrAdd<T> {
+    add_arg?: Arg<T>;
+    id_gen?: boolean;
+    context?: VContext;
 }
 export interface ValtheraCompatibleInternal {
     c(config: VQuery): CollectionManager;

package/dist/utils/{sortId.d.ts → id.d.ts}

@@ -1,3 +1,4 @@
+export declare function convertIdToUnix(id: string): number;
 export declare function sortByIds<T extends {
     _id: string;
 }>(objects: T[]): T[];

package/dist/utils/id.js

@@ -0,0 +1,8 @@
+export function convertIdToUnix(id) {
+    return parseInt(id.split("-")[0], 36);
+}
+export function sortByIds(objects) {
+    return objects.slice().sort((a, b) => {
+        return convertIdToUnix(a._id) - convertIdToUnix(b._id) || a._id.localeCompare(b._id);
+    });
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.1.5";
+export const version = "0.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-core",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "wxn0brP",
@@ -12,6 +12,9 @@
     "url": "https://github.com/wxn0brP/ValtheraDB-core.git"
   },
   "homepage": "https://github.com/wxn0brP/ValtheraDB",
+  "dependencies": {
+    "@wxn0brp/event-emitter": "^0.0.2"
+  },
   "devDependencies": {
     "@types/node": "^24.2.0",
     "tsc-alias": "^1.8.10",
@@ -31,8 +34,5 @@
       "import": "./dist/*.js",
       "default": "./dist/*.js"
     }
-  },
-  "dependencies": {
-    "@wxn0brp/event-emitter": "^0.0.2"
   }
 }

package/dist/utils/sortId.js

@@ -1,7 +0,0 @@
-export function sortByIds(objects) {
-    return objects.slice().sort((a, b) => {
-        const [timestampA] = a._id.split("-");
-        const [timestampB] = b._id.split("-");
-        return timestampA.localeCompare(timestampB) || a._id.localeCompare(b._id);
-    });
-}