@wxn0brp/db-core 0.12.14 → 0.12.16

package/dist/db/transaction.d.ts

@@ -1,5 +1,6 @@
 import { Collection } from "../helpers/collection.js";
 import { Data } from "../types/data.js";
+import { IndexOpts } from "../types/idx.js";
 import { VQueryT } from "../types/query.js";
 import { TransactionHandle } from "../types/transaction.js";
 import { ValtheraClass } from "./valthera.js";
@@ -27,6 +28,9 @@ export declare class Transaction {
     issetCollection(collection: string | VQueryT.Collection): Promise<boolean>;
     getCollections(): Promise<string[]>;
     removeCollection(target: string | VQueryT.Collection): Promise<boolean>;
+    createIndex(collection: string, fields: string[], opts?: IndexOpts): Promise<unknown>;
+    removeIndex(collection: string, fields: string[]): Promise<unknown>;
+    capabilities(): Promise<import("../index.js").AdapterCapabilities>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
 }

package/dist/db/transaction.js

@@ -69,7 +69,33 @@ export class Transaction {
         return this._parent.execute("getCollections", {}, this.handle);
     }
     removeCollection(target) {
-        return this._parent.execute("removeCollection", resolveCollection(target), this.handle);
+        const collection = resolveCollection(target);
+        this._parent._collections.delete(collection);
+        return this._parent.execute("removeCollection", collection, this.handle);
+    }
+    createIndex(collection, fields, opts) {
+        const index = {
+            collection,
+            fields,
+            opts,
+        };
+        return this._parent.execute("createIndex", {
+            collection,
+            index,
+        }, this.handle);
+    }
+    removeIndex(collection, fields) {
+        const index = {
+            collection,
+            fields,
+        };
+        return this._parent.execute("removeIndex", {
+            collection,
+            index,
+        }, this.handle);
+    }
+    capabilities() {
+        return this._parent.capabilities();
     }
     async commit() {
         try {

package/dist/db/valthera.d.ts

@@ -10,6 +10,7 @@ import { ValtheraPlugin } from "../types/plugin.js";
 import { VQuery, VQueryT } from "../types/query.js";
 import { TransactionHandle } from "../types/transaction.js";
 import { ValtheraCompatible } from "../types/valthera.js";
+import { type DbOp } from "../utils/opKind.js";
 import { Transaction } from "./transaction.js";
 /**
  * Represents a database management class for performing CRUD operations.
@@ -20,9 +21,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]>>, collection?: string) => void;
+        [K in DbOp]: (query: VQuery, result: Awaited<ReturnType<ValtheraClass[K]>>, collection?: string) => void;
     } & {
-        "*": (name: keyof Omit<ValtheraCompatible, "c">, query: VQuery, result: any, collection?: string) => void;
+        "*": (name: DbOp, query: VQuery, result: any, collection?: string) => void;
     }>;
     version: string;
     _plugins: ValtheraPlugin[];
@@ -31,7 +32,7 @@ export declare class ValtheraClass implements ValtheraCompatible {
     constructor(options: DbOpts);
     init(...args: any[]): Promise<any>;
     close(...args: any[]): Promise<any>;
-    execute<T>(name: keyof ValtheraCompatible, query: VQuery<any> | string, txHandle?: TransactionHandle): Promise<T>;
+    execute<T>(name: DbOp, query: VQuery<any> | string, txHandle?: TransactionHandle): Promise<T>;
     /**
      * Create a new instance of a Collection class.
      */

package/dist/db/valthera.js

@@ -321,17 +321,23 @@ export class ValtheraClass {
     async transaction(collections, fn) {
         await this.init();
         const releases = [];
-        const promises = collections.map(collection => {
-            let started;
-            const startedPromise = new Promise(r => (started = r));
-            this.executor.addOp(async () => {
-                started();
-                await new Promise(resolve => releases.push(resolve));
-            }, undefined, collection);
-            return startedPromise;
-        });
-        await Promise.all(promises);
+        const keys = this.executor instanceof SmartExecutor && this.executor.aware
+            ? [
+                ...new Set(collections),
+            ]
+            : [
+                undefined,
+            ];
+        if (!keys.length)
+            keys.push(undefined);
+        const acquire = (collection) => new Promise((resolve, reject) => this.executor
+            .addOp(async () => {
+            resolve();
+            await new Promise(release => releases.push(release));
+        }, undefined, collection)
+            .catch(reject));
         try {
+            await Promise.all(keys.map(acquire));
             let handle;
             try {
                 handle = await this.adapter.beginTransaction(genId(), collections);

package/dist/helpers/collection.js

@@ -51,7 +51,7 @@ export class Collection {
     count(search = {}) {
         return this.db.count({
             collection: this.collection,
-            search,
+            search: search,
         });
     }
     /**

package/dist/types/arg.d.ts

@@ -1,10 +1,17 @@
 import { Data } from "./data.js";
+import { IsStrict } from "./config.js";
 import { SearchOptions } from "./searchOpts.js";
 import { VContext } from "./types.js";
 import { UpdaterArg } from "./updater.js";
-export type Arg<T = any> = {
+import { FieldsOf, WithId } from "./utils.js";
+type LooseArg<T = any> = {
     [K in keyof T]?: any;
 } & Record<string, any>;
+/**
+ * Data payload (e.g. for `add`).
+ * In strict mode fields and nested objects of `T` are allowed; otherwise any key is accepted.
+ */
+export type Arg<T = any> = IsStrict extends true ? FieldsOf<WithId<T>> : LooseArg<T>;
 /**
  * Function-based search.
  * @deprecated Use operator objects or a plugin instead.
@@ -17,3 +24,4 @@ export type SearchFunc<T = any> = (data: T, context: VContext) => boolean;
 export type UpdaterFunc<T = any> = (data: T, context: VContext) => Data | void;
 export type Search<T = any, AllowFn extends boolean = true> = AllowFn extends true ? SearchOptions<T> | SearchFunc<T> : SearchOptions<T>;
 export type Updater<T = any, AllowFn extends boolean = true> = AllowFn extends true ? UpdaterArg<T> | UpdaterFunc<T> : UpdaterArg<T>;
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enable strict mode.
+ * Currently opt-in, but will be enabled by default later.
+ *
+ * ```
+ * declare module "@wxn0brp/db-core/types/config" {
+ *   interface TypeConfig {
+ *     strict: true;
+ *   }
+ * }
+ * ```
+ */
+export interface TypeConfig {
+}
+export type IsStrict = TypeConfig extends {
+    strict: false;
+} ? false : TypeConfig extends {
+    strict: true;
+} ? true : false;

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/query.d.ts

@@ -47,40 +47,40 @@ export declare namespace VQueryT {
         id_gen?: boolean;
     };
     type Find<T = Data, AllowFn extends boolean = true> = QueryBase<T> & {
-        search?: Search<T, AllowFn>;
+        search?: NoInfer<Search<T, AllowFn>>;
         findOpts?: FindOpts<T>;
         dbFindOpts?: DbFindOpts<T>;
         /** @deprecated */
         context?: VContext;
     };
     type FindOne<T = Data, AllowFn extends boolean = true> = QueryBase<T> & {
-        search: Search<T, AllowFn>;
+        search: NoInfer<Search<T, AllowFn>>;
         findOpts?: FindOpts<T>;
         /** @deprecated */
         context?: VContext;
     };
     type Update<T = Data, AllowFn extends boolean = true> = QueryBase<T> & {
-        search: Search<T, AllowFn>;
-        updater: Updater<T, AllowFn>;
+        search: NoInfer<Search<T, AllowFn>>;
+        updater: NoInfer<Updater<T, AllowFn>>;
         /** @deprecated */
         context?: VContext;
     };
     type Remove<T = Data, AllowFn extends boolean = true> = QueryBase<T> & {
-        search: Search<T, AllowFn>;
+        search: NoInfer<Search<T, AllowFn>>;
         /** @deprecated */
         context?: VContext;
     };
     type UpdateOneOrAdd<T = Data, AllowFn extends boolean = true> = QueryBase<T> & {
-        search: Search<T, AllowFn>;
-        updater: Updater<T, AllowFn>;
-        add_arg?: Arg<T>;
+        search: NoInfer<Search<T, AllowFn>>;
+        updater: NoInfer<Updater<T, AllowFn>>;
+        add_arg?: NoInfer<Arg<T>>;
         id_gen?: boolean;
         /** @deprecated */
         context?: VContext;
     };
     type ToggleOne<T = Data, AllowFn extends boolean = true> = QueryBase<T> & {
-        search: Search<T, AllowFn>;
-        data: Arg<T>;
+        search: NoInfer<Search<T, AllowFn>>;
+        data: NoInfer<Arg<T>>;
         /** @deprecated */
         context?: VContext;
     };
@@ -99,7 +99,7 @@ export declare namespace VQueryT {
         index: IndexDefinition;
     };
     type Count<T = Data> = QueryBase<T> & {
-        search: Search<T, false>;
+        search: NoInfer<Search<T, false>>;
     };
     interface Collection {
         collection: string;

package/dist/types/searchOpts.d.ts

@@ -1,4 +1,5 @@
-import { DeepPartial, NestedValue } from "./utils.js";
+import { IsStrict } from "./config.js";
+import { DeepPartial, FieldsOf, NestedValue, WithId } from "./utils.js";
 export type JSPrimitiveType = "string" | "number" | "boolean" | "bigint" | "symbol" | "undefined" | "function" | "object";
 /** Logical Operators */
 export type LogicalOperators<T = any> = {
@@ -102,7 +103,4 @@ export type OtherOperators<T = any> = {
 };
 /** Predefined Search Operators */
 export type PredefinedSearchOperators<T = any> = LogicalOperators<T> & ComparisonOperators<T> & TypeAndExistenceOperators<T> & ArrayOperators<T> & StringOperators<T> & OtherOperators<T>;
-/**
- * SearchOptions can be either a function or an object with predefined operators.
- */
-export type SearchOptions<T = any> = PredefinedSearchOperators<T> & DeepPartial<T> & Record<string, any>;
+export type SearchOptions<T = any> = IsStrict extends true ? FieldsOf<WithId<T>> & PredefinedSearchOperators<WithId<T>> : PredefinedSearchOperators<T> & DeepPartial<T> & Record<string, any>;

package/dist/types/updater.d.ts

@@ -1,4 +1,5 @@
-import { DeepPartial, NestedValue } from "./utils.js";
+import { IsStrict } from "./config.js";
+import { DeepPartial, FieldsOf, NestedValue, WithId } from "./utils.js";
 /** Arrays */
 export type ArrayUpdater<T = any> = {
     /** [1,2] -> $push 3 -> [1,2,3] */
@@ -34,6 +35,6 @@ export type ValueUpdater<T = any> = {
      *
      * Note: same as { name: value }
      */
-    $set?: NestedValue<T, any>;
+    $set?: IsStrict extends true ? FieldsOf<T> : NestedValue<T, any>;
 };
-export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & DeepPartial<T> & Record<string, any>;
+export type UpdaterArg<T = any> = IsStrict extends true ? ArrayUpdater<WithId<T>> & ObjectUpdater<WithId<T>> & ValueUpdater<WithId<T>> & FieldsOf<WithId<T>> : ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & DeepPartial<T> & Record<string, any>;

package/dist/types/utils.d.ts

@@ -7,6 +7,17 @@ export type PartialPickMatching<T, V, C = V> = Partial<Pick<T, KeysMatching<T, V
 export type NestedValue<T, V, C = V> = {
     [K in keyof T as T[K] extends C ? K : T[K] extends object ? K : never]?: T[K] extends C ? V : T[K] extends object ? NestedValue<T[K], V, C> : never;
 };
+export type Leaf = Date | RegExp | Function | readonly unknown[];
+export type WithId<T> = T & {
+    _id?: string;
+};
+/**
+ * Plain fields of `T`: keys and nested partials.
+ * `$` operators are added on top of it by the query types.
+ */
+export type FieldsOf<T> = {
+    [K in keyof T]?: T[K] extends Leaf ? T[K] : T[K] extends object ? FieldsOf<T[K]> | T[K] : T[K];
+};
 /** Helper type for nested path structure */
 export type DeepPartial<T> = {
     [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];

package/dist/utils/opKind.d.ts

@@ -1,9 +1,36 @@
-export type PluginOpKind = "read" | "write" | "delete" | "collection" | "index" | "meta" | "control";
+export type PluginOpKind = "read" | "write" | "delete" | "collection" | "index" | "meta" | "unknown" | "control";
+export declare const OP_KINDS: {
+    readonly find: "read";
+    readonly findOne: "read";
+    readonly count: "read";
+    readonly add: "write";
+    readonly bulkAdd: "write";
+    readonly update: "write";
+    readonly updateOne: "write";
+    readonly updateOneOrAdd: "write";
+    readonly toggleOne: "write";
+    readonly remove: "delete";
+    readonly removeOne: "delete";
+    readonly ensureCollection: "collection";
+    readonly issetCollection: "collection";
+    readonly removeCollection: "collection";
+    readonly createIndex: "index";
+    readonly removeIndex: "index";
+    readonly getCollections: "meta";
+    readonly capabilities: "meta";
+    readonly beginTransaction: "control";
+    readonly commitTransaction: "control";
+    readonly rollbackTransaction: "control";
+};
+/** Every operation name known to the adapter contract. */
+export type OpName = keyof typeof OP_KINDS;
+/**
+ * Operations routed through {@link ValtheraClass.execute}.
+ */
+export type DbOp = Exclude<OpName, "beginTransaction" | "commitTransaction" | "rollbackTransaction" | "capabilities">;
 export declare function getOpKind(op: string): PluginOpKind;
 export declare function isKnownOp(op: string): boolean;
-export declare function isMutation(kind: PluginOpKind): kind is "delete" | "write";
+/** db[collection][op] */
 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;
+/** db[op] */
+export declare function isDbOp(op: string): boolean;

package/dist/utils/opKind.js

@@ -1,4 +1,4 @@
-const OP_KINDS = {
+export const OP_KINDS = {
     find: "read",
     findOne: "read",
     count: "read",
@@ -22,27 +22,22 @@ const OP_KINDS = {
     rollbackTransaction: "control",
 };
 export function getOpKind(op) {
-    return Object.hasOwn(OP_KINDS, op) ? OP_KINDS[op] : "write";
+    return Object.hasOwn(OP_KINDS, op) ? OP_KINDS[op] : "unknown";
 }
 export function isKnownOp(op) {
     return Object.hasOwn(OP_KINDS, op);
 }
-export function isMutation(kind) {
-    return kind === "write" || kind === "delete";
-}
+const COLLECTION_OP_KINDS = new Set([
+    "read",
+    "write",
+    "delete",
+    "index",
+]);
+/** db[collection][op] */
 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";
+    return isKnownOp(op) && COLLECTION_OP_KINDS.has(getOpKind(op));
 }
-export function isNoQueryOp(op) {
-    const kind = getOpKind(op);
-    return kind === "collection" || kind === "meta";
+/** db[op] */
+export function isDbOp(op) {
+    return isKnownOp(op) && getOpKind(op) !== "control";
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.12.14";
+export declare const version = "0.12.16";

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.12.14";
+export const version = "0.12.16";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-core",
-  "version": "0.12.14",
+  "version": "0.12.16",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "wxn0brP",
@@ -13,7 +13,7 @@
   },
   "homepage": "https://github.com/wxn0brP/ValtheraDB",
   "dependencies": {
-    "@wxn0brp/event-emitter": "0.0.7"
+    "@wxn0brp/event-emitter": "0.0.9"
   },
   "devDependencies": {
     "@types/bun": "*",