@wxn0brp/db-core 0.12.9 → 0.12.10-alpha.0

package/dist/base/actions.d.ts

@@ -1,4 +1,4 @@
-import { ActionsBaseInterface } from "../types/action.js";
+import { ActionsBaseInterface, AdapterCapabilities } from "../types/action.js";
 import { DataInternal } from "../types/data.js";
 import { Id } from "../types/Id.js";
 import { AdapterOpts } from "../types/options.js";
@@ -8,6 +8,7 @@ export declare abstract class ActionsBase implements ActionsBaseInterface {
     _inited: boolean;
     adapterOpts: AdapterOpts;
     smartExecutor: boolean;
+    capabilities: AdapterCapabilities;
     version: string;
     init(...args: any[]): Promise<void>;
     close(...args: any[]): Promise<void>;

package/dist/base/actions.js

@@ -1,3 +1,4 @@
+import { UnsupportedOperationError } from "../errors.js";
 import { setDataForToggleOne, setDataForUpdateOneOrAdd, } from "../helpers/assignDataPush.js";
 import { version } from "../version.js";
 export class ActionsBase {
@@ -7,17 +8,22 @@ export class ActionsBase {
         idKey: "_id",
     };
     smartExecutor = false;
+    capabilities = {
+        transactions: false,
+        indexes: false,
+        persistent: true,
+    };
     version = "ActionsBase-core-" + version;
     async init(...args) { }
     async close(...args) { }
     async beginTransaction(id) {
-        throw new Error("Transactions are not supported for ActionsBase");
+        throw new UnsupportedOperationError("beginTransaction");
     }
     async commitTransaction(handle) {
-        throw new Error("Transactions are not supported for ActionsBase");
+        throw new UnsupportedOperationError("commitTransaction");
     }
     async rollbackTransaction(handle) {
-        throw new Error("Transactions are not supported for ActionsBase");
+        throw new UnsupportedOperationError("rollbackTransaction");
     }
     async createIndex(config) {
         // No-op: adapter does not use indexes internally

package/dist/db/memory.d.ts

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

package/dist/db/memory.js

@@ -6,6 +6,11 @@ import { ValtheraClass } from "./valthera.js";
 export class MemoryAction extends CustomActionsBase {
     memory;
     smartExecutor = true;
+    capabilities = {
+        transactions: false,
+        indexes: false,
+        persistent: false,
+    };
     constructor() {
         super();
         this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this), true);

package/dist/db/multiStorage.js

@@ -1,4 +1,5 @@
 import { ActionsBase } from "../base/actions.js";
+import { UnsupportedOperationError } from "../errors.js";
 export class MultiBackend extends ActionsBase {
     backends;
     primaryBackend;
@@ -107,12 +108,18 @@ export class MultiBackend extends ActionsBase {
         return Array.from(uniqueCollections);
     }
     async beginTransaction() {
-        throw new Error("Transactions are not supported for MultiBackend");
+        throw new UnsupportedOperationError("beginTransaction", {
+            adapter: "MultiBackend",
+        });
     }
     async commitTransaction() {
-        throw new Error("Transactions are not supported for MultiBackend");
+        throw new UnsupportedOperationError("commitTransaction", {
+            adapter: "MultiBackend",
+        });
     }
     async rollbackTransaction() {
-        throw new Error("Transactions are not supported for MultiBackend");
+        throw new UnsupportedOperationError("rollbackTransaction", {
+            adapter: "MultiBackend",
+        });
     }
 }

package/dist/db/routedStorage.js

@@ -1,4 +1,5 @@
 import { ActionsBase } from "../base/actions.js";
+import { UnsupportedOperationError } from "../errors.js";
 export class RoutedStorage extends ActionsBase {
     rules;
     defaultBackend;
@@ -110,12 +111,18 @@ export class RoutedStorage extends ActionsBase {
         return Array.from(merged);
     }
     async beginTransaction() {
-        throw new Error("Transactions are not supported for RoutedStorage");
+        throw new UnsupportedOperationError("beginTransaction", {
+            adapter: "RoutedStorage",
+        });
     }
     async commitTransaction() {
-        throw new Error("Transactions are not supported for RoutedStorage");
+        throw new UnsupportedOperationError("commitTransaction", {
+            adapter: "RoutedStorage",
+        });
     }
     async rollbackTransaction() {
-        throw new Error("Transactions are not supported for RoutedStorage");
+        throw new UnsupportedOperationError("rollbackTransaction", {
+            adapter: "RoutedStorage",
+        });
     }
 }

package/dist/db/transaction.d.ts

@@ -13,7 +13,7 @@ export declare class Transaction {
     constructor(handle: TransactionHandle, _parent: ValtheraClass);
     c<T = Data>(name: string): Collection<T>;
     add<T = Data>(q: VQueryT.Add<T>): Promise<T>;
-    bulkAdd<T = Data>(q: VQueryT.BulkAdd<T>): Promise<import("../types/data.js").DataInternal[]>;
+    bulkAdd<T = Data>(q: VQueryT.BulkAdd<T>): Promise<T[]>;
     find<T = Data>(q: VQueryT.Find<T, true>): Promise<T[]>;
     findOne<T = Data>(q: VQueryT.FindOne<T>): Promise<T | null>;
     update<T = Data>(q: VQueryT.Update<T>): Promise<T[]>;

package/dist/db/transaction.js

@@ -1,3 +1,4 @@
+import { wrapAdapterError } from "../errors.js";
 import { Collection } from "../helpers/collection.js";
 import { applyAddDefaults, applyBulkAddDefaults, applyCountDefaults, applyFindDefaults, applyFindOneDefaults, applyRemoveDefaults, applyToggleOneDefaults, applyUpdateDefaults, applyUpdateOneOrAddDefaults, } from "../helpers/queryDefaults.js";
 /**
@@ -20,7 +21,7 @@ export class Transaction {
     }
     bulkAdd(q) {
         applyBulkAddDefaults(q);
-        return this._parent.adapter.bulkAdd(q);
+        return this._parent.execute("bulkAdd", q, this.handle);
     }
     find(q) {
         applyFindDefaults(q);
@@ -56,24 +57,40 @@ export class Transaction {
     }
     count(q) {
         applyCountDefaults(q);
-        return this._parent.adapter.count(q);
+        return this._parent.execute("count", q, this.handle);
     }
     ensureCollection(collection) {
-        return this._parent.adapter.ensureCollection(collection);
+        return this._parent.execute("ensureCollection", collection, this.handle);
     }
     issetCollection(collection) {
-        return this._parent.adapter.issetCollection(collection);
+        return this._parent.execute("issetCollection", collection, this.handle);
     }
     getCollections() {
-        return this._parent.adapter.getCollections();
+        return this._parent.execute("getCollections", {}, this.handle);
     }
     removeCollection(collection) {
-        return this._parent.adapter.removeCollection(collection);
+        return this._parent.execute("removeCollection", collection, this.handle);
     }
     async commit() {
-        await this._parent.adapter.commitTransaction(this.handle);
+        try {
+            await this._parent.adapter.commitTransaction(this.handle);
+        }
+        catch (err) {
+            throw wrapAdapterError(err, {
+                op: "commitTransaction",
+                adapter: this._parent.adapter?.version,
+            });
+        }
     }
     async rollback() {
-        await this._parent.adapter.rollbackTransaction(this.handle);
+        try {
+            await this._parent.adapter.rollbackTransaction(this.handle);
+        }
+        catch (err) {
+            throw wrapAdapterError(err, {
+                op: "rollbackTransaction",
+                adapter: this._parent.adapter?.version,
+            });
+        }
     }
 }

package/dist/db/valthera.d.ts

@@ -2,6 +2,7 @@ import { VEE } from "@wxn0brp/event-emitter";
 import { ActionsBase } from "../base/actions.js";
 import { Collection } from "../helpers/collection.js";
 import { ExecutorInterface } from "../helpers/executor.js";
+import { AdapterCapabilities } from "../types/action.js";
 import { Data } from "../types/data.js";
 import { IndexOpts } from "../types/idx.js";
 import { DbOpts } from "../types/options.js";
@@ -97,6 +98,10 @@ export declare class ValtheraClass implements ValtheraCompatible {
      */
     removeIndex(collection: string, fields: string[]): Promise<void>;
     count(query: VQueryT.Count): Promise<number>;
+    /**
+     * Describe what the underlying adapter supports.
+     */
+    capabilities(): Promise<AdapterCapabilities>;
     /**
      * @experimental
      *

package/dist/db/valthera.js

@@ -1,8 +1,9 @@
 import { VEE } from "@wxn0brp/event-emitter";
+import { AdapterCloseError, AdapterInitError, ErrorCodes, isValtheraError, QueryValidationError, TransactionError, wrapAdapterError, } from "../errors.js";
 import { Collection } from "../helpers/collection.js";
 import { SmartExecutor } from "../helpers/executor.js";
 import { genId } from "../helpers/gen.js";
-import { applyAddDefaults, applyCountDefaults, applyBulkAddDefaults, applyFindDefaults, applyFindOneDefaults, applyRemoveDefaults, applyToggleOneDefaults, applyUpdateDefaults, applyUpdateOneOrAddDefaults, } from "../helpers/queryDefaults.js";
+import { applyAddDefaults, applyBulkAddDefaults, applyCountDefaults, applyFindDefaults, applyFindOneDefaults, applyRemoveDefaults, applyToggleOneDefaults, applyUpdateDefaults, applyUpdateOneOrAddDefaults, } from "../helpers/queryDefaults.js";
 import { version } from "../version.js";
 import { Transaction } from "./transaction.js";
 /**
@@ -48,11 +49,24 @@ export class ValtheraClass {
         if (this.adapter?._inited)
             return;
         const self = this;
+        const failInit = (err) => {
+            if (isValtheraError(err))
+                throw err;
+            throw new AdapterInitError(err, {
+                adapter: self.adapter?.version,
+            });
+        };
         return await this.executor.addOp(async () => {
             if (self.adapter?._inited)
                 return;
-            if (typeof self.options.adapter === "function")
-                self.adapter = await self.options.adapter();
+            if (typeof self.options.adapter === "function") {
+                try {
+                    self.adapter = await self.options.adapter();
+                }
+                catch (err) {
+                    failInit(err);
+                }
+            }
             // if the executor is not set, and the action wants a smart executor
             if (!self.options.executor &&
                 self.options.executorAware &&
@@ -65,7 +79,12 @@ export class ValtheraClass {
                     ...self.options.adapterOpts,
                 };
             }
-            await self.adapter.init(...args);
+            try {
+                await self.adapter.init(...args);
+            }
+            catch (err) {
+                failInit(err);
+            }
             self.adapter._inited = true;
         });
     }
@@ -76,15 +95,28 @@ export class ValtheraClass {
         return await this.executor.addOp(async () => {
             if (!self.adapter?._inited)
                 return;
-            await self.adapter.close(...args);
+            try {
+                await self.adapter.close(...args);
+            }
+            catch (err) {
+                if (isValtheraError(err))
+                    throw err;
+                throw new AdapterCloseError(err, {
+                    adapter: self.adapter?.version,
+                });
+            }
             self.adapter._inited = false;
         });
     }
     async execute(name, query, txHandle) {
         await this.init();
-        if (txHandle && typeof query === "object")
+        const collection = typeof query === "string" ? query : query?.collection;
+        if (!collection && name !== "getCollections")
+            throw new QueryValidationError(`Missing "collection" for operation "${String(name)}"`, {
+                op: name,
+            });
+        if (txHandle && query && typeof query === "object")
             query.transaction = txHandle;
-        const collection = typeof query === "string" ? query : query.collection;
         const plugins = this._plugins.filter(p => !p.collections || p.collections.includes(collection));
         const self = this;
         let idx = 0;
@@ -94,9 +126,18 @@ export class ValtheraClass {
             next: async () => {
                 if (idx < plugins.length)
                     return plugins[idx++].execute(ctx);
-                if (txHandle)
-                    return self.adapter[ctx.op](query, txHandle);
-                return self.executor.addOp(self.adapter[ctx.op].bind(self.adapter), ctx.query, typeof ctx.query === "string" ? ctx.query : ctx.query.collection);
+                try {
+                    if (txHandle)
+                        return await self.adapter[ctx.op](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,
+                        adapter: self.adapter?.version,
+                    });
+                }
             },
         };
         const result = await ctx.next();
@@ -236,6 +277,15 @@ export class ValtheraClass {
         applyCountDefaults(query);
         return this.execute("count", query);
     }
+    /**
+     * Describe what the underlying adapter supports.
+     */
+    async capabilities() {
+        await this.init();
+        return {
+            ...this.adapter.capabilities,
+        };
+    }
     /**
      * @experimental
      *
@@ -264,7 +314,16 @@ export class ValtheraClass {
         });
         await Promise.all(promises);
         try {
-            const handle = await this.adapter.beginTransaction(genId());
+            let handle;
+            try {
+                handle = await this.adapter.beginTransaction(genId());
+            }
+            catch (err) {
+                throw wrapAdapterError(err, {
+                    op: "beginTransaction",
+                    adapter: this.adapter?.version,
+                });
+            }
             const tx = new Transaction(handle, this);
             try {
                 const result = await fn(tx);
@@ -276,10 +335,16 @@ export class ValtheraClass {
                     await tx.rollback();
                 }
                 catch (rollbackErr) {
-                    throw new AggregateError([
-                        err,
-                        rollbackErr,
-                    ], "Transaction failed and rollback failed");
+                    throw new TransactionError("Transaction failed and rollback failed", {
+                        code: ErrorCodes.TRANSACTION_ROLLBACK_FAILED,
+                        cause: new AggregateError([
+                            err,
+                            rollbackErr,
+                        ], "Transaction failed and rollback failed"),
+                        context: {
+                            collections,
+                        },
+                    });
                 }
                 throw err;
             }

package/dist/errors.d.ts

@@ -0,0 +1,71 @@
+export declare const ErrorCodes: {
+    readonly UNSUPPORTED_OPERATION: "UNSUPPORTED_OPERATION";
+    readonly ADAPTER_ERROR: "ADAPTER_ERROR";
+    readonly ADAPTER_INIT: "ADAPTER_INIT";
+    readonly ADAPTER_CLOSE: "ADAPTER_CLOSE";
+    readonly QUERY_INVALID: "QUERY_INVALID";
+    readonly TRANSACTION_FAILED: "TRANSACTION_FAILED";
+    readonly TRANSACTION_ROLLBACK_FAILED: "TRANSACTION_ROLLBACK_FAILED";
+    readonly REMOTE_ERROR: "REMOTE_ERROR";
+    readonly REMOTE_UNKNOWN: "REMOTE_UNKNOWN";
+};
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+export interface ValtheraErrorOpts {
+    code: string;
+    cause?: unknown;
+    suggestion?: string;
+    context?: Record<string, unknown>;
+}
+export interface ValtheraErrorWire {
+    code?: string;
+    message?: string;
+    suggestion?: string;
+    context?: Record<string, unknown>;
+}
+export declare class ValtheraError extends Error {
+    code: string;
+    suggestion?: string;
+    context?: Record<string, unknown>;
+    constructor(message: string, opts: ValtheraErrorOpts);
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+        suggestion?: string | undefined;
+        context?: Record<string, unknown> | undefined;
+    };
+}
+export declare class UnsupportedOperationError extends ValtheraError {
+    constructor(operation: string, context?: Record<string, unknown>);
+}
+export declare class QueryValidationError extends ValtheraError {
+    constructor(reason: string, context?: Record<string, unknown>);
+}
+export declare class AdapterError extends ValtheraError {
+    constructor(cause: unknown, context?: Record<string, unknown>);
+}
+export declare class AdapterInitError extends ValtheraError {
+    constructor(cause: unknown, context?: Record<string, unknown>);
+}
+export declare class AdapterCloseError extends ValtheraError {
+    constructor(cause: unknown, context?: Record<string, unknown>);
+}
+export declare class TransactionError extends ValtheraError {
+    constructor(message: string, opts?: {
+        cause?: unknown;
+        context?: Record<string, unknown>;
+        code?: string;
+    });
+}
+export declare class RemoteError extends ValtheraError {
+    constructor(cause: unknown, context?: Record<string, unknown>);
+}
+export declare function isValtheraError(e: unknown): e is ValtheraError;
+/**
+ * Adapter errors: keep ValtheraError codes, else wrap into AdapterError.
+ */
+export declare function wrapAdapterError(cause: unknown, context?: Record<string, unknown>): ValtheraError;
+/**
+ * Rebuild a ValtheraError from a server response; match by `code`, not class.
+ */
+export declare function errorFromWire(payload: ValtheraErrorWire): ValtheraError;

package/dist/errors.js

@@ -0,0 +1,156 @@
+export const ErrorCodes = {
+    UNSUPPORTED_OPERATION: "UNSUPPORTED_OPERATION",
+    ADAPTER_ERROR: "ADAPTER_ERROR",
+    ADAPTER_INIT: "ADAPTER_INIT",
+    ADAPTER_CLOSE: "ADAPTER_CLOSE",
+    QUERY_INVALID: "QUERY_INVALID",
+    TRANSACTION_FAILED: "TRANSACTION_FAILED",
+    TRANSACTION_ROLLBACK_FAILED: "TRANSACTION_ROLLBACK_FAILED",
+    REMOTE_ERROR: "REMOTE_ERROR",
+    REMOTE_UNKNOWN: "REMOTE_UNKNOWN",
+};
+export class ValtheraError extends Error {
+    code;
+    suggestion;
+    context;
+    constructor(message, opts) {
+        super(message, {
+            cause: opts.cause,
+        });
+        this.name = "ValtheraError";
+        this.code = opts.code;
+        this.suggestion = opts.suggestion;
+        this.context = opts.context;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            ...(this.suggestion
+                ? {
+                    suggestion: this.suggestion,
+                }
+                : {}),
+            ...(this.context
+                ? {
+                    context: this.context,
+                }
+                : {}),
+        };
+    }
+}
+export class UnsupportedOperationError extends ValtheraError {
+    constructor(operation, context = {}) {
+        super(`Operation "${operation}" is not supported`, {
+            code: ErrorCodes.UNSUPPORTED_OPERATION,
+            context: {
+                op: operation,
+                ...context,
+            },
+            suggestion: "Check the adapter capabilities before calling this operation",
+        });
+        this.name = "UnsupportedOperationError";
+    }
+}
+export class QueryValidationError extends ValtheraError {
+    constructor(reason, context = {}) {
+        super(reason, {
+            code: ErrorCodes.QUERY_INVALID,
+            context,
+            suggestion: "Check the query shape and the collection name",
+        });
+        this.name = "QueryValidationError";
+    }
+}
+export class AdapterError extends ValtheraError {
+    constructor(cause, context = {}) {
+        super(errorMessage(cause), {
+            code: ErrorCodes.ADAPTER_ERROR,
+            cause,
+            context,
+        });
+        this.name = "AdapterError";
+    }
+}
+export class AdapterInitError extends ValtheraError {
+    constructor(cause, context = {}) {
+        super(`Adapter init failed: ${errorMessage(cause)}`, {
+            code: ErrorCodes.ADAPTER_INIT,
+            cause,
+            context,
+        });
+        this.name = "AdapterInitError";
+    }
+}
+export class AdapterCloseError extends ValtheraError {
+    constructor(cause, context = {}) {
+        super(`Adapter close failed: ${errorMessage(cause)}`, {
+            code: ErrorCodes.ADAPTER_CLOSE,
+            cause,
+            context,
+        });
+        this.name = "AdapterCloseError";
+    }
+}
+export class TransactionError extends ValtheraError {
+    constructor(message, opts = {}) {
+        super(message, {
+            code: opts.code ?? ErrorCodes.TRANSACTION_FAILED,
+            cause: opts.cause,
+            context: opts.context,
+        });
+        this.name = "TransactionError";
+    }
+}
+export class RemoteError extends ValtheraError {
+    constructor(cause, context = {}) {
+        super(errorMessage(cause), {
+            code: ErrorCodes.REMOTE_ERROR,
+            cause,
+            context,
+        });
+        this.name = "RemoteError";
+    }
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+export function isValtheraError(e) {
+    return e instanceof ValtheraError;
+}
+/**
+ * Copy a ValtheraError with merged context; keeps `instanceof` and `cause`
+ */
+function cloneWithContext(err, context) {
+    const clone = Object.create(Object.getPrototypeOf(err));
+    Object.assign(clone, err);
+    clone.message = err.message;
+    clone.stack = err.stack;
+    clone.cause = err.cause;
+    clone.context = {
+        ...context,
+        ...err.context,
+    };
+    return clone;
+}
+/**
+ * Adapter errors: keep ValtheraError codes, else wrap into AdapterError.
+ */
+export function wrapAdapterError(cause, context = {}) {
+    if (cause instanceof ValtheraError)
+        return Object.keys(context).length
+            ? cloneWithContext(cause, context)
+            : cause;
+    return new AdapterError(cause, context);
+}
+/**
+ * Rebuild a ValtheraError from a server response; match by `code`, not class.
+ */
+export function errorFromWire(payload) {
+    return new ValtheraError(payload.message ?? "Unknown remote error", {
+        code: payload.code ?? ErrorCodes.REMOTE_UNKNOWN,
+        suggestion: payload.suggestion,
+        context: payload.context,
+    });
+}

package/dist/helpers/relation.js

@@ -1,3 +1,4 @@
+import { QueryValidationError } from "../errors.js";
 export function pickByPath(obj, paths) {
     const result = {};
     for (const path of paths) {
@@ -160,7 +161,10 @@ export 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 QueryValidationError(`Relation type "nm" requires a defined "through" in "${key}"`, {
+                    op: "relation",
+                    key,
+                });
             const allSourceIds = targets.map(i => i[pk]);
             const pivotDb = dbs[through.db || dbKey];
             const allPivots = await pivotDb.find({
@@ -248,7 +252,10 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
             }
         }
         else {
-            throw new Error(`Unknown relation type: ${type}`);
+            throw new QueryValidationError(`Unknown relation type: ${type}`, {
+                op: "relation",
+                type,
+            });
         }
     }
 }

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 export { CustomFileCpu } from "./customFileCpu.js";
 export { createMemoryValthera, ValtheraMemory } from "./db/memory.js";
 export { ValtheraClass } from "./db/valthera.js";
+export * from "./errors.js";
 export { forgeTypedValthera } from "./helpers/forge.js";
 export { genId } from "./helpers/gen.js";
 export { Relation } from "./helpers/relation.js";
 export { convertIdToUnix, sortByIds } from "./utils/id.js";
+export type { AdapterCapabilities } from "./types/action.js";
 export type { ValtheraTypes } from "./types/export.js";
 export type { Id } from "./types/Id.js";
 export type { RelationTypes } from "./types/relation.js";

package/dist/index.js

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

package/dist/types/action.d.ts

@@ -3,10 +3,16 @@ import { Id } from "./Id.js";
 import { AdapterOpts } from "./options.js";
 import { VQueryT } from "./query.js";
 import { TransactionHandle } from "./transaction.js";
+export interface AdapterCapabilities {
+    transactions: boolean;
+    indexes: boolean;
+    persistent: boolean;
+}
 export interface ActionsBaseInterface {
     _inited: boolean;
     adapterOpts: AdapterOpts;
     smartExecutor: boolean;
+    capabilities: AdapterCapabilities;
     init(...args: any[]): Promise<void>;
     close(...args: any[]): Promise<void>;
     getCollections(): Promise<string[]>;

package/dist/types/export.d.ts

@@ -6,6 +6,7 @@ export declare namespace ValtheraTypes {
     type FindOpts = import("./options.js").FindOpts;
     type DbOpts = import("./options.js").DbOpts;
     type AdapterOpts = import("./options.js").AdapterOpts;
+    type AdapterCapabilities = import("./action.js").AdapterCapabilities;
     type Data = import("./data.js").Data;
     type SearchOptions = import("./searchOpts.js").SearchOptions;
     type Id = import("./Id.js").Id;

package/dist/types/valthera.d.ts

@@ -1,4 +1,5 @@
 import { Collection } from "../helpers/collection.js";
+import { AdapterCapabilities } from "./action.js";
 import { Data } from "./data.js";
 import { IndexOpts } from "./idx.js";
 import { VQueryT } from "./query.js";
@@ -21,4 +22,5 @@ export interface ValtheraCompatible {
     removeIndex(collection: string, fields: string[]): Promise<void>;
     count(query: VQueryT.Count): Promise<number>;
     bulkAdd<T = Data>(query: VQueryT.BulkAdd<T>): Promise<T[]>;
+    capabilities(): Promise<AdapterCapabilities>;
 }

package/dist/utils/hasFieldsAdvanced.js

@@ -1,3 +1,4 @@
+import { QueryValidationError } from "../errors.js";
 import { hasFields } from "./hasFields.js";
 import { compareIds } from "./id.js";
 /**
@@ -5,7 +6,9 @@ import { compareIds } from "./id.js";
  */
 export function hasFieldsAdvanced(obj, fields) {
     if (typeof fields !== "object" || fields === null) {
-        throw new Error("Fields must be an object");
+        throw new QueryValidationError("Fields must be an object", {
+            op: "search",
+        });
     }
     if (Object.keys(fields).length === 0)
         return true;

package/dist/utils/updateObject.js

@@ -1,3 +1,4 @@
+import { QueryValidationError } from "../errors.js";
 import { _deepMerge } from "./merge.js";
 /**
  * Updates an object with new values.
@@ -6,7 +7,9 @@ import { _deepMerge } from "./merge.js";
  */
 export function updateObjectAdvanced(obj, field) {
     if (typeof field !== "object" || Array.isArray(field) || field === null)
-        throw new Error("Fields must be an object");
+        throw new QueryValidationError("Fields must be an object", {
+            op: "update",
+        });
     if (Object.keys(field).length === 0)
         return;
     const $fields = {};
@@ -97,7 +100,10 @@ function mainUpdate(obj, fields) {
             }
             if (!(key in deepObj))
                 return updater;
-            throw new Error(`Cannot increment non-numeric value at key: ${key}`);
+            throw new QueryValidationError(`Cannot increment non-numeric value at key: ${key}`, {
+                op: "update",
+                key,
+            });
         },
         dec: (item, updater, key, deepObj) => {
             if (typeof item === "number" && typeof updater === "number") {
@@ -105,7 +111,10 @@ function mainUpdate(obj, fields) {
             }
             if (!(key in deepObj))
                 return -updater;
-            throw new Error(`Cannot decrement non-numeric value at key: ${key}`);
+            throw new QueryValidationError(`Cannot decrement non-numeric value at key: ${key}`, {
+                op: "update",
+                key,
+            });
         },
         rename: (_, newKey, oldKey, deepObj) => {
             if (oldKey in deepObj) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.12.9";
+export declare const version = "0.12.10-alpha.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.12.9";
+export const version = "0.12.10-alpha.0";

package/package.json

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