@wxn0brp/db-core 0.12.10 → 0.12.12

package/dist/base/actions.d.ts

@@ -23,7 +23,7 @@ export declare abstract class ActionsBase implements ActionsBaseInterface {
     abstract updateOne(config: VQueryT.Update): Promise<DataInternal | null>;
     abstract remove(config: VQueryT.Remove): Promise<DataInternal[]>;
     abstract removeOne(config: VQueryT.Remove): Promise<DataInternal | null>;
-    beginTransaction(id: Id): Promise<TransactionHandle>;
+    beginTransaction(id: Id, collections: string[]): Promise<TransactionHandle>;
     commitTransaction(handle: TransactionHandle): Promise<void>;
     rollbackTransaction(handle: TransactionHandle): Promise<void>;
     createIndex(config: VQueryT.CreateIndex): Promise<void>;

package/dist/base/actions.js

@@ -16,7 +16,7 @@ export class ActionsBase {
     version = "ActionsBase-core-" + version;
     async init(...args) { }
     async close(...args) { }
-    async beginTransaction(id) {
+    async beginTransaction(id, collections) {
         throw new UnsupportedOperationError("beginTransaction");
     }
     async commitTransaction(handle) {

package/dist/db/transaction.d.ts

@@ -23,10 +23,10 @@ export declare class Transaction {
     updateOneOrAdd<T = Data>(q: VQueryT.UpdateOneOrAdd<T>): Promise<VQueryT.UpdateOneOrAddResult<T>>;
     toggleOne<T = Data>(q: VQueryT.ToggleOne<T>): Promise<VQueryT.ToggleOneResult<T>>;
     count<T = Data>(q: VQueryT.Count<T>): Promise<number>;
-    ensureCollection(collection: string): Promise<boolean>;
-    issetCollection(collection: string): Promise<boolean>;
+    ensureCollection(collection: string | VQueryT.Collection): Promise<boolean>;
+    issetCollection(collection: string | VQueryT.Collection): Promise<boolean>;
     getCollections(): Promise<string[]>;
-    removeCollection(collection: string): Promise<boolean>;
+    removeCollection(target: string | VQueryT.Collection): Promise<boolean>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
 }

package/dist/db/transaction.js

@@ -1,5 +1,5 @@
 import { wrapAdapterError } from "../errors.js";
-import { Collection } from "../helpers/collection.js";
+import { Collection, resolveCollection } from "../helpers/collection.js";
 import { applyAddDefaults, applyBulkAddDefaults, applyCountDefaults, applyFindDefaults, applyFindOneDefaults, applyRemoveDefaults, applyToggleOneDefaults, applyUpdateDefaults, applyUpdateOneOrAddDefaults, } from "../helpers/queryDefaults.js";
 /**
  * Transaction context. Operations are executed directly through the parent
@@ -60,16 +60,16 @@ export class Transaction {
         return this._parent.execute("count", q, this.handle);
     }
     ensureCollection(collection) {
-        return this._parent.execute("ensureCollection", collection, this.handle);
+        return this._parent.execute("ensureCollection", resolveCollection(collection), this.handle);
     }
     issetCollection(collection) {
-        return this._parent.execute("issetCollection", collection, this.handle);
+        return this._parent.execute("issetCollection", resolveCollection(collection), this.handle);
     }
     getCollections() {
         return this._parent.execute("getCollections", {}, this.handle);
     }
-    removeCollection(collection) {
-        return this._parent.execute("removeCollection", collection, this.handle);
+    removeCollection(target) {
+        return this._parent.execute("removeCollection", resolveCollection(target), this.handle);
     }
     async commit() {
         try {

package/dist/db/valthera.d.ts

@@ -20,9 +20,9 @@ export declare class ValtheraClass implements ValtheraCompatible {
     adapter: ActionsBase;
     executor: ExecutorInterface;
     emitter: VEE<{
-        [K in keyof Omit<ValtheraCompatible, "c">]: (query: VQuery, result: Awaited<ReturnType<ValtheraCompatible[K]>>) => void;
+        [K in keyof Omit<ValtheraCompatible, "c">]: (query: VQuery, result: Awaited<ReturnType<ValtheraCompatible[K]>>, collection?: string) => void;
     } & {
-        "*": (name: keyof Omit<ValtheraCompatible, "c">, query: VQuery, result: any) => void;
+        "*": (name: keyof Omit<ValtheraCompatible, "c">, query: VQuery, result: any, collection?: string) => void;
     }>;
     version: string;
     _plugins: ValtheraPlugin[];
@@ -43,11 +43,11 @@ export declare class ValtheraClass implements ValtheraCompatible {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    ensureCollection(collection: string): Promise<boolean>;
+    ensureCollection(collection: string | VQueryT.Collection): Promise<boolean>;
     /**
      * Check if a collection exists.
      */
-    issetCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string | VQueryT.Collection): Promise<boolean>;
     /**
      * Add data to a database.
      */
@@ -88,7 +88,7 @@ export declare class ValtheraClass implements ValtheraCompatible {
     /**
      * Removes a database collection from the database.
      */
-    removeCollection(collection: string): Promise<boolean>;
+    removeCollection(target: string | VQueryT.Collection): Promise<boolean>;
     /**
      * Create an index on a collection.
      */

package/dist/db/valthera.js

@@ -1,9 +1,11 @@
 import { VEE } from "@wxn0brp/event-emitter";
 import { AdapterCloseError, AdapterInitError, ErrorCodes, isValtheraError, QueryValidationError, TransactionError, wrapAdapterError, } from "../errors.js";
-import { Collection } from "../helpers/collection.js";
+import { Collection, resolveCollection } from "../helpers/collection.js";
 import { SmartExecutor } from "../helpers/executor.js";
 import { genId } from "../helpers/gen.js";
+import { rewriteOp } from "../helpers/plugin.js";
 import { applyAddDefaults, applyBulkAddDefaults, applyCountDefaults, applyFindDefaults, applyFindOneDefaults, applyRemoveDefaults, applyToggleOneDefaults, applyUpdateDefaults, applyUpdateOneOrAddDefaults, } from "../helpers/queryDefaults.js";
+import { getOpKind } from "../utils/opKind.js";
 import { version } from "../version.js";
 import { Transaction } from "./transaction.js";
 /**
@@ -122,26 +124,37 @@ export class ValtheraClass {
         let idx = 0;
         const ctx = {
             op: name,
+            kind: getOpKind(name),
+            collection,
             query,
             next: async () => {
                 if (idx < plugins.length)
                     return plugins[idx++].execute(ctx);
+                if (txHandle && ctx.query && typeof ctx.query === "object")
+                    ctx.query.transaction = txHandle;
                 try {
                     if (txHandle)
-                        return await self.adapter[ctx.op](query, txHandle);
+                        return await self.adapter[ctx.op](ctx.query, txHandle);
                     return await self.executor.addOp(self.adapter[ctx.op].bind(self.adapter), ctx.query, typeof ctx.query === "string" ? ctx.query : ctx.query.collection);
                 }
                 catch (err) {
                     throw wrapAdapterError(err, {
                         op: ctx.op,
-                        collection,
+                        collection: typeof ctx.query === "string" ? ctx.query : ctx.query?.collection,
                         adapter: self.adapter?.version,
                     });
                 }
             },
+            setOp(op, q) {
+                rewriteOp(ctx, op, q);
+            },
+            setQuery(q) {
+                rewriteOp(ctx, ctx.op, q);
+            },
         };
         const result = await ctx.next();
-        this.emitter.emit(ctx.op, ctx.query, result);
+        const emittedCollection = typeof ctx.query === "string" ? ctx.query : ctx.query?.collection;
+        this.emitter.emit(ctx.op, ctx.query, result, emittedCollection);
         return result;
     }
     /**
@@ -164,13 +177,13 @@ export class ValtheraClass {
      * Check and create the specified collection if it doesn't exist.
      */
     async ensureCollection(collection) {
-        return await this.execute("ensureCollection", collection);
+        return await this.execute("ensureCollection", resolveCollection(collection));
     }
     /**
      * Check if a collection exists.
      */
     async issetCollection(collection) {
-        return await this.execute("issetCollection", collection);
+        return await this.execute("issetCollection", resolveCollection(collection));
     }
     /**
      * Add data to a database.
@@ -242,7 +255,8 @@ export class ValtheraClass {
     /**
      * Removes a database collection from the database.
      */
-    removeCollection(collection) {
+    removeCollection(target) {
+        const collection = resolveCollection(target);
         this._collections.delete(collection);
         return this.execute("removeCollection", collection);
     }
@@ -316,7 +330,7 @@ export class ValtheraClass {
         try {
             let handle;
             try {
-                handle = await this.adapter.beginTransaction(genId());
+                handle = await this.adapter.beginTransaction(genId(), collections);
             }
             catch (err) {
                 throw wrapAdapterError(err, {

package/dist/helpers/collection.d.ts

@@ -6,6 +6,7 @@ import { DbFindOpts, FindOpts } from "../types/options.js";
 import { VQueryT } from "../types/query.js";
 import { VContext } from "../types/types.js";
 import { ValtheraCompatible } from "../types/valthera.js";
+export declare function resolveCollection(target: string | VQueryT.Collection): string;
 export declare class Collection<D = Data> {
     db: ValtheraCompatible;
     collection: string;

package/dist/helpers/collection.js

@@ -1,3 +1,6 @@
+export function resolveCollection(target) {
+    return typeof target === "string" ? target : target.collection;
+}
 export class Collection {
     db;
     collection;

package/dist/helpers/plugin.d.ts

@@ -0,0 +1,2 @@
+import { PluginContext } from "../types/plugin.js";
+export declare function rewriteOp(ctx: PluginContext, op: string, query?: any): void;

package/dist/helpers/plugin.js

@@ -0,0 +1,9 @@
+import { getOpKind } from "../utils/opKind.js";
+export function rewriteOp(ctx, op, query) {
+    ctx.op = op;
+    if (query !== undefined)
+        ctx.query = query;
+    ctx.kind = getOpKind(op);
+    const q = ctx.query;
+    ctx.collection = typeof q === "string" ? q : q?.collection;
+}

package/dist/types/action.d.ts

@@ -30,7 +30,7 @@ export interface ActionsBaseInterface {
     toggleOne(query: VQueryT.ToggleOne): Promise<VQueryT.ToggleOneResult<DataInternal>>;
     count(query: VQueryT.Count): Promise<number>;
     bulkAdd(query: VQueryT.BulkAdd): Promise<DataInternal[]>;
-    beginTransaction(id: Id): Promise<TransactionHandle>;
+    beginTransaction(id: Id, collections: string[]): Promise<TransactionHandle>;
     commitTransaction(handle: TransactionHandle): Promise<void>;
     rollbackTransaction(handle: TransactionHandle): Promise<void>;
     createIndex(config: VQueryT.CreateIndex): Promise<void>;

package/dist/types/plugin.d.ts

@@ -1,8 +1,13 @@
 import type { ValtheraClass } from "../db/valthera.js";
+import type { PluginOpKind } from "../utils/opKind.js";
 export interface PluginContext {
     op: string;
+    kind: PluginOpKind;
+    collection?: string;
     query: any;
     next: () => Promise<any>;
+    setOp(op: string, query?: any): void;
+    setQuery(query: any): void;
 }
 export interface ValtheraPlugin {
     name: string;

package/dist/types/query.d.ts

@@ -94,4 +94,7 @@ export declare namespace VQueryT {
     type Count<T = Data> = QueryBase<T> & {
         search: Search<T, false>;
     };
+    interface Collection {
+        collection: string;
+    }
 }

package/dist/types/valthera.d.ts

@@ -6,8 +6,8 @@ import { VQueryT } from "./query.js";
 export interface ValtheraCompatible {
     c<T = Data>(collection: string): Collection<T>;
     getCollections(): Promise<string[]>;
-    ensureCollection(collection: string): Promise<boolean>;
-    issetCollection(collection: string): Promise<boolean>;
+    ensureCollection(collection: string | VQueryT.Collection): Promise<boolean>;
+    issetCollection(collection: string | VQueryT.Collection): Promise<boolean>;
     add<T = Data>(query: VQueryT.Add<T>): Promise<T>;
     find<T = Data>(query: VQueryT.Find<T>): Promise<T[]>;
     findOne<T = Data>(query: VQueryT.FindOne<T>): Promise<T | null>;
@@ -15,7 +15,7 @@ export interface ValtheraCompatible {
     updateOne<T = Data>(query: VQueryT.Update<T>): Promise<T | null>;
     remove<T = Data>(query: VQueryT.Remove<T>): Promise<T[]>;
     removeOne<T = Data>(query: VQueryT.Remove<T>): Promise<T | null>;
-    removeCollection(collection: string): Promise<boolean>;
+    removeCollection(collection: string | VQueryT.Collection): Promise<boolean>;
     updateOneOrAdd<T = Data>(query: VQueryT.UpdateOneOrAdd<T>): Promise<VQueryT.UpdateOneOrAddResult<T>>;
     toggleOne<T = Data>(query: VQueryT.ToggleOne<T>): Promise<VQueryT.ToggleOneResult<T>>;
     createIndex(collection: string, fields: string[], opts?: IndexOpts): Promise<void>;

package/dist/utils/opKind.d.ts

@@ -0,0 +1,8 @@
+export type PluginOpKind = "read" | "write" | "delete" | "collection" | "index" | "meta" | "control";
+export declare function getOpKind(op: string): PluginOpKind;
+export declare function isMutation(kind: PluginOpKind): kind is "delete" | "write";
+export declare function isCollectionOp(op: string): boolean;
+export declare function isIndexOp(op: string): boolean;
+export declare function isMetaOp(op: string): boolean;
+export declare function isControlOp(op: string): boolean;
+export declare function isNoQueryOp(op: string): boolean;

package/dist/utils/opKind.js

@@ -0,0 +1,45 @@
+const OP_KINDS = {
+    find: "read",
+    findOne: "read",
+    count: "read",
+    add: "write",
+    bulkAdd: "write",
+    update: "write",
+    updateOne: "write",
+    updateOneOrAdd: "write",
+    toggleOne: "write",
+    remove: "delete",
+    removeOne: "delete",
+    ensureCollection: "collection",
+    issetCollection: "collection",
+    removeCollection: "collection",
+    createIndex: "index",
+    removeIndex: "index",
+    getCollections: "meta",
+    capabilities: "meta",
+    beginTransaction: "control",
+    commitTransaction: "control",
+    rollbackTransaction: "control",
+};
+export function getOpKind(op) {
+    return OP_KINDS[op] ?? "write";
+}
+export function isMutation(kind) {
+    return kind === "write" || kind === "delete";
+}
+export function isCollectionOp(op) {
+    return getOpKind(op) === "collection";
+}
+export function isIndexOp(op) {
+    return getOpKind(op) === "index";
+}
+export function isMetaOp(op) {
+    return getOpKind(op) === "meta";
+}
+export function isControlOp(op) {
+    return getOpKind(op) === "control";
+}
+export function isNoQueryOp(op) {
+    const kind = getOpKind(op);
+    return kind === "collection" || kind === "meta";
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.12.10";
+export declare const version = "0.12.12";

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.12.10";
+export const version = "0.12.12";

package/package.json

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