@wxn0brp/db-core 0.12.15 → 0.12.17

package/dist/db/transaction.d.ts

@@ -1,13 +1,15 @@
 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 { ValtheraCompatible } from "../types/valthera.js";
 import { ValtheraClass } from "./valthera.js";
 /**
  * Transaction context. Operations are executed directly through the parent
  * database with the transaction handle passed to the executor.
  */
-export declare class Transaction {
+export declare class Transaction implements ValtheraCompatible {
     readonly handle: TransactionHandle;
     _parent: ValtheraClass;
     constructor(handle: TransactionHandle, _parent: ValtheraClass);
@@ -27,6 +29,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<void>;
+    removeIndex(collection: string, fields: string[]): Promise<void>;
+    capabilities(): Promise<import("../index.js").AdapterCapabilities>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
 }

package/dist/db/transaction.js

@@ -73,6 +73,30 @@ export class Transaction {
         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 {
             await this._parent.adapter.commitTransaction(this.handle);

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/helpers/addId.d.ts

@@ -1,4 +1,4 @@
 import { ActionsBase } from "../base/actions.js";
-import { VQuery, VQueryT } from "../types/query.js";
-export declare function addId(query: VQuery, actions: ActionsBase, defaultGen?: boolean): Promise<import("../types/arg.js").Arg<import("../types/data.js").Data> | undefined>;
+import { VQueryT } from "../types/query.js";
+export declare function addId(query: VQueryT.Add, actions: ActionsBase, defaultGen?: boolean): Promise<void>;
 export declare function addIdBulk(query: VQueryT.BulkAdd, actions: ActionsBase, defaultGen?: boolean): Promise<void>;

package/dist/helpers/addId.js

@@ -9,91 +9,57 @@ function assertSafeIdKey(idKey) {
         idKey,
     });
 }
-export async function addId(query, actions, defaultGen = true) {
-    const collection = query.collection;
-    const data = query.data;
-    const id_gen = query.id_gen ?? defaultGen;
-    const { idKey = "_id", numberId } = actions.adapterOpts;
-    if (!id_gen)
-        return data;
-    assertSafeIdKey(idKey);
-    if (data[idKey])
-        return data;
-    if (!numberId) {
-        data[idKey] = genId();
-        return;
-    }
-    const txOpts = query.transaction
+const defaultIdGen = (data, _collection, adapter) => data.map(() => genId(adapter.adapterOpts.idParts));
+const numberIdGen = async (data, collection, adapter, transaction) => {
+    const txOpts = transaction
         ? {
-            transaction: query.transaction,
+            transaction,
         }
         : {};
-    const find = (await actions.findOne({
+    const found = (await adapter.findOne({
         collection: "__vdb_id",
         search: {
             c: collection,
         },
         ...txOpts,
     }));
-    data[idKey] = find?.i ? find.i + 1 : 1;
-    await actions.updateOneOrAdd({
+    const start = found?.i ?? 0;
+    await adapter.updateOneOrAdd({
         collection: "__vdb_id",
         search: {
             c: collection,
         },
         updater: {
             $inc: {
-                i: 1,
+                i: data.length,
             },
         },
         id_gen: false,
         ...txOpts,
     });
-}
-export async function addIdBulk(query, actions, defaultGen = true) {
-    const collection = query.collection;
-    const id_gen = query.id_gen ?? defaultGen;
-    const { idKey = "_id", numberId } = actions.adapterOpts;
-    if (!id_gen)
+    return data.map((_, i) => (start + i + 1));
+};
+async function applyIdGen(records, collection, actions, idGenEnabled, transaction) {
+    if (!idGenEnabled)
         return;
+    const { idKey = "_id", numberId, idGen } = actions.adapterOpts;
     assertSafeIdKey(idKey);
-    if (!numberId) {
-        for (const data of query.datas) {
-            if (!data[idKey])
-                data[idKey] = genId();
-        }
+    const targets = records.filter(data => !data[idKey]);
+    if (!targets.length)
         return;
+    const generator = idGen ?? (numberId ? numberIdGen : defaultIdGen);
+    const ids = await generator(targets, collection, actions, transaction);
+    for (let i = 0; i < targets.length; i++) {
+        targets[i][idKey] = ids[i];
     }
-    const txOpts = query.transaction
-        ? {
-            transaction: query.transaction,
-        }
-        : {};
-    const find = (await actions.findOne({
-        collection: "__vdb_id",
-        search: {
-            c: collection,
-        },
-        ...txOpts,
-    }));
-    const start = find?.i ?? 0;
-    for (let i = 0; i < query.datas.length; i++) {
-        const data = query.datas[i];
-        if (!data[idKey]) {
-            data[idKey] = start + i + 1;
-        }
-    }
-    await actions.updateOneOrAdd({
-        collection: "__vdb_id",
-        search: {
-            c: collection,
-        },
-        updater: {
-            $inc: {
-                i: query.datas.length,
-            },
-        },
-        id_gen: false,
-        ...txOpts,
-    });
+}
+export async function addId(query, actions, defaultGen = true) {
+    const id_gen = query.id_gen ?? defaultGen;
+    await applyIdGen([
+        query.data,
+    ], query.collection, actions, id_gen, query.transaction);
+}
+export async function addIdBulk(query, actions, defaultGen = true) {
+    const id_gen = query.id_gen ?? defaultGen;
+    await applyIdGen(query.datas, query.collection, actions, id_gen, query.transaction);
 }

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/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 IdGen = import("./options.js").IdGen;
     type AdapterCapabilities = import("./action.js").AdapterCapabilities;
     type Data = import("./data.js").Data;
     type SearchOptions = import("./searchOpts.js").SearchOptions;

package/dist/types/options.d.ts

@@ -1,7 +1,15 @@
 import { ActionsBase } from "../base/actions.js";
 import { ExecutorInterface } from "../helpers/executor.js";
+import { Data } from "./data.js";
+import { Id } from "./Id.js";
+import { TransactionHandle } from "./transaction.js";
 import { KeysMatching } from "./utils.js";
 export type AdapterValue = ActionsBase | (() => Promise<ActionsBase>);
+/**
+ * Custom ID generator. Receives only records without the ID key set and
+ * returns generated IDs in the same order.
+ */
+export type IdGen = (data: Data[], collection: string, adapter: ActionsBase, transaction?: TransactionHandle) => Id[] | Promise<Id[]>;
 export interface DbOpts {
     adapter: AdapterValue;
     executor?: ExecutorInterface;
@@ -11,6 +19,9 @@ export interface DbOpts {
 export interface AdapterOpts {
     numberId?: boolean;
     idKey?: string;
+    idGen?: IdGen;
+    /** Parts lengths passed to `genId` for the default ID generator. */
+    idParts?: number[];
 }
 export type FieldPath<T = any> = KeysMatching<T, any> | (string & {}) | string[];
 export interface DbFindOpts<T = any> {

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.15";
+export declare const version = "0.12.17";

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.12.15";
+export const version = "0.12.17";

package/package.json

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