equipped 5.2.9 → 5.3.0

package/dist/types/{core-BrkNSwvc.d.ts → core-tNlIMH9Y.d.ts}

@@ -1,6 +1,27 @@
 import { Filter, UpdateFilter } from 'mongodb';
+import * as valleyed from 'valleyed';
 import { PipeOutput, Pipe, PipeInput, ConditionalObjectKeys, DistributiveOmit, DeepPartial } from 'valleyed';
-import { K as KafkaEventBus } from './kafka-Cf-TUJgv.js';
+import { KafkaEventBus } from './events/adapters/kafka/index.js';
+
+declare const dbChangeConfigPipe: () => valleyed.Pipe<{
+    debeziumUrl: string;
+    eventBus: KafkaEventBus;
+}, {
+    debeziumUrl: string;
+    eventBus: KafkaEventBus;
+}>;
+type DbChangeConfig = PipeOutput<ReturnType<typeof dbChangeConfigPipe>>;
+type DbConfig = {
+    changes?: DbChangeConfig;
+};
+
+declare abstract class DbChange<Model extends Model<IdType>, Entity extends Entity> {
+    protected config: DbChangeConfig;
+    protected callbacks: DbChangeCallbacks<Model, Entity>;
+    protected mapper: (model: Model) => Entity;
+    constructor(config: DbChangeConfig, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+    protected configureConnector(key: string, data: Record<string, string>): Promise<any>;
+}
 
 declare enum QueryKeys {
     and = "and",
@@ -14,8 +35,7 @@ declare enum Conditions {
     eq = "eq",
     ne = "ne",
     in = "in",
-    nin = "nin",
-    exists = "exists"
+    nin = "nin"
 }
 declare const queryKeys: Pipe<QueryKeys | undefined, QueryKeys>;
 declare const queryWhere: Pipe<{
@@ -48,6 +68,7 @@ declare function queryParamsPipe(): Pipe<{
         condition: PipeInput<typeof queryKeys>;
         value: PipeInput<typeof queryWhere>[];
     })[] | undefined;
+    select: string[] | undefined;
 }, {
     auth: ({
         field: string;
@@ -78,6 +99,7 @@ declare function queryParamsPipe(): Pipe<{
         condition: PipeOutput<typeof queryKeys>;
         value: PipeOutput<typeof queryWhere>[];
     })[];
+    select: string[] | undefined;
 }>;
 declare function queryResultsPipe<T>(model: Pipe<any, T>): Pipe<{
     pages: {
@@ -108,10 +130,13 @@ declare function queryResultsPipe<T>(model: Pipe<any, T>): Pipe<{
     };
     results: T[];
 }>;
-declare function wrapQueryParams(params: QueryParamsInput): QueryParams;
-type QueryParams = PipeOutput<ReturnType<typeof queryParamsPipe>>;
+declare function wrapQueryParams(params: QueryParamsInput): QueryParamsBase;
+type QueryParamsBase = PipeOutput<ReturnType<typeof queryParamsPipe>>;
+type QueryParams<T, S extends Select<T> | undefined = undefined> = Omit<QueryParamsBase, 'select'> & {
+    select?: S extends undefined ? QueryParamsBase['select'] : S;
+};
 type QueryParamsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof queryParamsPipe>>>;
-type QueryWhereClause = QueryParams['where'][number];
+type QueryWhereClause = QueryParamsBase['where'][number];
 type QueryWhere = Extract<QueryWhereClause, {
     field: string;
 }>;
@@ -119,28 +144,6 @@ type QueryWhereBlock = Exclude<QueryWhereClause, {
     field: string;
 }>;
 type QueryResults<T> = PipeOutput<ReturnType<typeof queryResultsPipe<T>>>;
-declare const mongoDbConfigPipe: () => Pipe<{
-    uri: string;
-}, {
-    uri: string;
-}>;
-type MongoDbConfig = PipeOutput<ReturnType<typeof mongoDbConfigPipe>>;
-
-type DbChangeConfig = {
-    eventBus: KafkaEventBus;
-    debeziumUrl: string;
-};
-type DbConfig = {
-    changes?: DbChangeConfig;
-};
-
-declare abstract class DbChange<Model extends Model<IdType>, Entity extends Entity> {
-    protected config: DbChangeConfig;
-    protected callbacks: DbChangeCallbacks<Model, Entity>;
-    protected mapper: (model: Model) => Entity;
-    constructor(config: DbChangeConfig, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
-    protected configureConnector(key: string, data: Record<string, string>): Promise<any>;
-}
 
 type IdType = {
     _id: string;
@@ -155,15 +158,22 @@ type Model<IdKey extends IdType> = IdKey & {
     createdAt?: number;
     updatedAt?: number;
 };
-type Sort = NonNullable<QueryParams['sort']>[number];
+type Select<T> = (keyof T)[];
+type SelectEntity<E, S> = S extends readonly (keyof E)[] ? (S[number] extends never ? E : Pick<E, S[number]>) : E;
+type Sort = NonNullable<QueryParamsBase['sort']>[number];
+type FindManyOptions<T, S extends Select<T> | undefined = undefined> = {
+    limit?: number;
+    sort?: Sort | Sort[];
+    select?: S;
+};
+type FindOneOptions<T, S extends Select<T> | undefined = undefined> = {
+    select?: S;
+};
 type Table<Id extends IdType, T extends Model<Id>, E extends Entity, Extras extends Record<string, unknown> = {}> = {
-    query: (query: QueryParams) => Promise<QueryResults<E>>;
-    findMany: (filter: Filter<T>, options?: {
-        limit?: number;
-        sort?: Sort | Sort[];
-    }) => Promise<E[]>;
-    findOne: (filter: Filter<T>) => Promise<E | null>;
-    findById: (id: ModelId<T>) => Promise<E | null>;
+    query: <const S extends Select<T> | undefined = undefined>(query: QueryParams<T, S>) => Promise<QueryResults<SelectEntity<E, S>>>;
+    findMany: <const S extends Select<T> | undefined = undefined>(filter: Filter<T>, options?: FindManyOptions<T, S>) => Promise<SelectEntity<E, S>[]>;
+    findOne: <const S extends Select<T> | undefined = undefined>(filter: Filter<T>, options?: FindOneOptions<T, S>) => Promise<SelectEntity<E, S> | null>;
+    findById: <const S extends Select<T> | undefined = undefined>(id: ModelId<T>, options?: FindOneOptions<T, S>) => Promise<SelectEntity<E, S> | null>;
     insertOne: (values: CreateInput<T>, options?: {
         makeId?: () => string;
         getTime?: () => Date;
@@ -244,10 +254,10 @@ type DbChangeCallbacks<M extends Model<IdType>, E extends Entity> = {
 type Config<M extends Model<IdType>, E extends Entity> = {
     db: string;
     col: string;
-    mapper: (model: M) => E;
+    mapper: (model: M, select?: Select<E>) => E;
     options?: {
         skipAudit?: boolean;
     };
 };
 
-export { type BulkWriteOperation as B, type CreateInput as C, DbChange as D, type Entity as E, type IdType as I, type Model as M, QueryKeys as Q, type Table as T, type UpdateInput as U, type MongoDbConfig as a, type DbChangeConfig as b, type DbChangeCallbacks as c, type EntityInput as d, type Config as e, type DbConfig as f, Conditions as g, queryResultsPipe as h, type QueryParams as i, type QueryParamsInput as j, type QueryWhereClause as k, type QueryWhere as l, type QueryWhereBlock as m, type QueryResults as n, mongoDbConfigPipe as o, queryParamsPipe as q, wrapQueryParams as w };
+export { type BulkWriteOperation as B, type Config as C, DbChange as D, type Entity as E, type IdType as I, type Model as M, QueryKeys as Q, type Select as S, type Table as T, type UpdateInput as U, type DbChangeConfig as a, type DbChangeCallbacks as b, type DbConfig as c, type EntityInput as d, type CreateInput as e, dbChangeConfigPipe as f, Conditions as g, queryResultsPipe as h, type QueryParamsBase as i, type QueryParams as j, type QueryParamsInput as k, type QueryWhereClause as l, type QueryWhere as m, type QueryWhereBlock as n, type QueryResults as o, queryParamsPipe as q, wrapQueryParams as w };

package/dist/types/dbs/adapters/mongodb/index.d.ts

@@ -0,0 +1,43 @@
+import { Collection, MongoClient, ObjectId } from 'mongodb';
+import * as valleyed from 'valleyed';
+import { PipeInput } from 'valleyed';
+import { M as Model, E as Entity, D as DbChange, a as DbChangeConfig, b as DbChangeCallbacks, c as DbConfig, C as Config, T as Table } from '../../../core-tNlIMH9Y.js';
+import { Db } from '../../index.js';
+import '../../../events/adapters/kafka/index.js';
+import '../../../overrides-6Hxg764S.js';
+import '../../../events/index.js';
+
+declare const mongoDbConfigPipe: () => valleyed.Pipe<{
+    uri: string;
+}, {
+    uri: string;
+}>;
+type MongoDbConfig = PipeInput<ReturnType<typeof mongoDbConfigPipe>>;
+
+declare class MongoDbChange<Model extends Model<{
+    _id: string;
+}>, Entity extends Entity> extends DbChange<Model, Entity> {
+    #private;
+    constructor(config: MongoDbConfig, change: DbChangeConfig, collection: Collection<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+}
+
+type IdType = {
+    _id: string;
+};
+declare class MongoDb extends Db<{
+    _id: string;
+}> {
+    #private;
+    private mongoConfig;
+    client: MongoClient;
+    constructor(mongoConfig: MongoDbConfig, dbConfig: DbConfig);
+    session<T>(callback: () => Promise<T>): Promise<T>;
+    id(): ObjectId;
+    use<Model extends Model<{
+        _id: string;
+    }>, Entity extends Entity>(config: Config<Model, Entity>): Table<IdType, Model, Entity, {
+        collection: Collection<Model>;
+    }>;
+}
+
+export { MongoDb, MongoDbChange, type MongoDbConfig, mongoDbConfigPipe };

package/dist/types/dbs/adapters/mongodb/index.js

@@ -0,0 +1,418 @@
+import {
+  Db,
+  QueryKeys,
+  dbChangeConfigPipe
+} from "../../../chunk-3M4PBZAQ.js";
+import "../../../chunk-XGGGAEET.js";
+import {
+  EquippedError,
+  Instance,
+  retry
+} from "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/dbs/adapters/mongodb/changes.ts
+import "mongodb";
+import { differ } from "valleyed";
+
+// src/dbs/adapters/base/changes.ts
+import axios from "axios";
+import { v } from "valleyed";
+var TopicPrefix = "db-changes";
+var DbChange = class {
+  constructor(config, callbacks, mapper) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.mapper = mapper;
+    this.config = v.assert(dbChangeConfigPipe(), config);
+  }
+  async configureConnector(key, data) {
+    const instance = axios.create({ baseURL: this.config.debeziumUrl });
+    return await instance.put(`/connectors/${key}/config`, {
+      "topic.prefix": TopicPrefix,
+      "topic.creation.enable": "false",
+      "topic.creation.default.replication.factor": `-1`,
+      "topic.creation.default.partitions": "-1",
+      "key.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "key.converter.schemas.enable": "false",
+      "value.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "value.converter.schemas.enable": "false",
+      ...data
+    }).then(async () => {
+      const topics = await instance.get(`/connectors/${key}/topics`);
+      return topics.data[key]?.topics?.includes?.(key) ?? false;
+    }).catch((err) => {
+      throw new EquippedError(`Failed to configure watcher`, { key }, err);
+    });
+  }
+};
+
+// src/dbs/adapters/mongodb/changes.ts
+var MongoDbChange = class extends DbChange {
+  #started = false;
+  constructor(config, change, collection, callbacks, mapper) {
+    super(change, callbacks, mapper);
+    const hydrate = (data) => data._id ? {
+      ...data,
+      _id: data._id["$oid"] ?? data._id
+    } : void 0;
+    const dbName = collection.dbName;
+    const colName = collection.collectionName;
+    const dbColName = `${dbName}.${colName}`;
+    const topic = `${TopicPrefix}.${dbColName}`;
+    const TestId = "5f5f65717569707065645f5f";
+    const condition = { _id: TestId };
+    change.eventBus.stream(topic, { skipScope: true }).subscribe(async (data) => {
+      const op = data.op;
+      let before = JSON.parse(data.before ?? "null");
+      let after = JSON.parse(data.after ?? "null");
+      if (before) before = hydrate(before);
+      if (after) after = hydrate(after);
+      if (before?._id === TestId || after?._id === TestId) return;
+      if (op === "c" && this.callbacks.created && after)
+        await this.callbacks.created({
+          before: null,
+          after: this.mapper(after)
+        });
+      else if (op === "u" && this.callbacks.updated && before && after)
+        await this.callbacks.updated({
+          before: this.mapper(before),
+          after: this.mapper(after),
+          changes: differ.from(differ.diff(before, after))
+        });
+      else if (op === "d" && this.callbacks.deleted && before)
+        await this.callbacks.deleted({
+          before: this.mapper(before),
+          after: null
+        });
+    });
+    Instance.on("start", async () => {
+      if (this.#started) return;
+      this.#started = true;
+      await retry(
+        async () => {
+          const started = await this.configureConnector(topic, {
+            "connector.class": "io.debezium.connector.mongodb.MongoDbConnector",
+            "capture.mode": "change_streams_update_full_with_pre_image",
+            "mongodb.connection.string": config.uri,
+            "collection.include.list": dbColName,
+            "snapshot.mode": "when_needed",
+            "capture.scope": "collection",
+            "capture.target": dbColName,
+            "heartbeat.interval.ms": "60000",
+            "errors.max.retries": "3"
+          });
+          if (started) return { done: true, value: true };
+          await collection.findOneAndUpdate(condition, { $set: { colName } }, { upsert: true });
+          await collection.findOneAndDelete(condition);
+          Instance.get().log.warn(`Waiting for db changes for ${dbColName} to start...`);
+          return { done: false };
+        },
+        6,
+        3e4
+      ).catch((err) => Instance.crash(new EquippedError(`Failed to start db changes`, { dbColName }, err)));
+    });
+  }
+};
+
+// src/dbs/adapters/mongodb/db.ts
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  MongoClient,
+  ObjectId
+} from "mongodb";
+import { v as v3 } from "valleyed";
+
+// src/dbs/adapters/mongodb/pipes.ts
+import { v as v2 } from "valleyed";
+var mongoDbConfigPipe = () => v2.meta(
+  v2.object({
+    uri: v2.string()
+  }),
+  { title: "Mongodb Config", $refId: "MongodbConfig" }
+);
+
+// src/dbs/adapters/mongodb/query.ts
+import "mongodb";
+var parseMongodbQueryParams = async (collection, params) => {
+  const query = [];
+  const where = buildWhereQuery(params.where, params.whereType);
+  if (where) query.push(where);
+  const auth = buildWhereQuery(params.auth, params.authType);
+  if (auth) query.push(auth);
+  if (params.search && params.search.fields.length > 0) {
+    const search = params.search.fields.map((field) => ({
+      [field]: {
+        $regex: new RegExp(params.search.value, "i")
+      }
+    }));
+    query.push({ $or: search });
+  }
+  const totalClause = {};
+  if (query.length > 0) totalClause["$and"] = query;
+  const sort = params.sort.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+  const all = params.all ?? false;
+  const limit = params.limit;
+  const page = params.page;
+  const total = await collection.countDocuments(totalClause);
+  const projection = params.select?.length ? Object.fromEntries(params.select.map((k) => [k, 1])) : void 0;
+  let builtQuery = collection.find(totalClause, { projection });
+  if (sort.length) builtQuery = builtQuery.sort(Object.fromEntries(sort));
+  if (!all && limit) {
+    builtQuery = builtQuery.limit(limit);
+    if (page) builtQuery = builtQuery.skip((page - 1) * limit);
+  }
+  const results = await builtQuery.toArray();
+  const start = 1;
+  const last = Math.ceil(total / limit) || 1;
+  const next = page >= last ? null : page + 1;
+  const previous = page <= start ? null : page - 1;
+  return {
+    pages: { start, last, next, previous, current: page },
+    docs: { limit, total, count: results.length },
+    results
+  };
+};
+function isWhereBlock(param) {
+  return Object.values(QueryKeys).includes(param.condition);
+}
+var buildWhereQuery = (params, key = "and" /* and */) => {
+  const where = (Array.isArray(params) ? params : []).map((param) => {
+    if (isWhereBlock(param)) return buildWhereQuery(param.value, param.condition);
+    const { field } = param;
+    const checkedField = field === "id" ? "_id" : field ?? "";
+    const checkedValue = param.value === void 0 ? "" : param.value;
+    return {
+      field: checkedField,
+      value: checkedValue,
+      condition: param.condition,
+      isWhere: true
+    };
+  }).filter((c) => !!c).map((c) => {
+    if (c.isWhere) return { [`${c.field}`]: { [`$${c.condition}`]: c.value } };
+    else return c;
+  });
+  return where.length > 0 ? { [`$${key}`]: where } : null;
+};
+
+// src/dbs/adapters/mongodb/db.ts
+var idKey = "_id";
+var sessionStore = new AsyncLocalStorage(void 0);
+var MongoDb = class extends Db {
+  constructor(mongoConfig, dbConfig) {
+    super(dbConfig);
+    this.mongoConfig = mongoConfig;
+    this.mongoConfig = v3.assert(mongoDbConfigPipe(), mongoConfig);
+    this.client = new MongoClient(mongoConfig.uri, { ignoreUndefined: true });
+    Instance.on("start", async () => {
+      await this.client.connect();
+      const grouped = this.#cols.reduce((acc, cur) => {
+        if (!acc[cur.db]) acc[cur.db] = [];
+        acc[cur.db].push(cur.col);
+        return acc;
+      }, {});
+      const options = {
+        changeStreamPreAndPostImages: { enabled: true }
+      };
+      await Promise.all(
+        Object.entries(grouped).map(async ([dbName, colNames]) => {
+          const db = this.client.db(dbName);
+          const collections = await db.listCollections().toArray();
+          return colNames.map(async (colName) => {
+            const existing = collections.find((collection) => collection.name === colName);
+            if (existing) {
+              if (existing.options?.changeStreamPreAndPostImages?.enabled !== options.changeStreamPreAndPostImages.enabled)
+                await db.command({ collMod: colName, ...options });
+            } else await db.createCollection(colName, options);
+          });
+        })
+      );
+    });
+    Instance.on("close", async () => this.client.close());
+  }
+  client;
+  #cols = [];
+  async session(callback) {
+    if (sessionStore.getStore()) return callback();
+    const session = await this.client.startSession();
+    return session.withTransaction(async () => sessionStore.run(session, callback));
+  }
+  id() {
+    return new ObjectId();
+  }
+  use(config) {
+    const db = this.getScopedDb(config.db);
+    this.#cols.push({ db, col: config.col });
+    return this.#getTable(config, this.client.db(db).collection(config.col));
+  }
+  #getTable(config, collection) {
+    function transform(doc, select) {
+      const docs = Array.isArray(doc) ? doc : [doc];
+      const mapped = docs.map((d) => config.mapper(d, select));
+      return Array.isArray(doc) ? mapped : mapped[0];
+    }
+    function prepInsertValue(value, id, now, skipUpdate) {
+      const base = {
+        [idKey]: id,
+        ...config.options?.skipAudit ? {} : {
+          createdAt: now.getTime(),
+          ...skipUpdate ? {} : { updatedAt: now.getTime() }
+        }
+      };
+      return {
+        ...value,
+        ...base
+      };
+    }
+    function prepUpdateValue(value, now, upsert = false) {
+      return {
+        ...value,
+        $set: {
+          ...value.$set,
+          ...upsert || Object.keys(value).length > 0 && !config.options?.skipAudit ? { updatedAt: now.getTime() } : {}
+        }
+      };
+    }
+    const dbThis = this;
+    const table = {
+      config,
+      extras: { collection },
+      query: async (params) => {
+        const results = await parseMongodbQueryParams(collection, params);
+        return {
+          ...results,
+          results: transform(results.results, params.select)
+        };
+      },
+      findMany: async (filter, options = {}) => {
+        const { select, ...rest } = options;
+        const projection = select?.length ? Object.fromEntries(select.map((k) => [k, 1])) : void 0;
+        const sortArray = Array.isArray(rest.sort) ? rest.sort : rest.sort ? [rest.sort] : [];
+        const sort = sortArray.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+        const docs = await collection.find(filter, {
+          session: sessionStore.getStore(),
+          limit: rest.limit,
+          sort,
+          projection
+        }).toArray();
+        return transform(docs, select);
+      },
+      findOne: async (filter, options = {}) => {
+        const result = await table.findMany(filter, { ...options, limit: 1 });
+        return result.at(0) ?? null;
+      },
+      findById: async (id, options = {}) => {
+        const result = await table.findOne({ [idKey]: id }, options);
+        return result;
+      },
+      insertMany: async (values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const payload = values.map((value, i) => prepInsertValue(value, options.makeId?.(i) ?? new ObjectId().toString(), now));
+        await collection.insertMany(payload, { session: sessionStore.getStore() });
+        const insertedData = await Promise.all(payload.map(async (data) => await table.findById(data[idKey])));
+        return insertedData.filter((value) => !!value);
+      },
+      insertOne: async (values, options = {}) => {
+        const result = await table.insertMany([values], options);
+        return result[0];
+      },
+      updateMany: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const session = sessionStore.getStore();
+        const data = await collection.find(filter, { session, projection: { [idKey]: 1 } }).toArray();
+        const ids = data.map((doc) => doc[idKey]);
+        const filterUpd = { [idKey]: { $in: ids } };
+        await collection.updateMany(filterUpd, prepUpdateValue(values, now), { session });
+        return table.findMany(filterUpd);
+      },
+      updateOne: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const doc = await collection.findOneAndUpdate(filter, prepUpdateValue(values, now), {
+          returnDocument: "after",
+          session: sessionStore.getStore()
+        });
+        return doc ? transform(doc, void 0) : null;
+      },
+      updateById: async (id, values, options = {}) => {
+        const result = await table.updateOne({ [idKey]: id }, values, options);
+        return result;
+      },
+      upsertOne: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const doc = await collection.findOneAndUpdate(
+          filter,
+          {
+            ...prepUpdateValue("update" in values ? values.update : {}, now, true),
+            // @ts-expect-error fighting ts
+            $setOnInsert: prepInsertValue(values.insert, options.makeId?.() ?? new ObjectId().toString(), now, true)
+          },
+          { returnDocument: "after", session: sessionStore.getStore(), upsert: true }
+        );
+        return transform(doc, void 0);
+      },
+      deleteMany: async (filter, options = {}) => {
+        const docs = await table.findMany(filter, options);
+        await collection.deleteMany(filter, { session: sessionStore.getStore() });
+        return docs;
+      },
+      deleteOne: async (filter) => {
+        const doc = await collection.findOneAndDelete(filter, { session: sessionStore.getStore() });
+        return doc ? transform(doc, void 0) : null;
+      },
+      deleteById: async (id) => {
+        const result = await table.deleteOne({ [idKey]: id });
+        return result;
+      },
+      bulkWrite: async (operations, options = {}) => {
+        if (!operations.length) return;
+        const bulk = collection.initializeUnorderedBulkOp({ session: sessionStore.getStore() });
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        operations.forEach((operation, i) => {
+          switch (operation.op) {
+            case "insert":
+              bulk.insert(prepInsertValue(operation.value, operation.makeId?.(i) ?? new ObjectId().toString(), now));
+              break;
+            case "delete":
+              bulk.find(operation.filter).delete();
+              break;
+            case "update":
+              bulk.find(operation.filter).update(prepUpdateValue(operation.value, now));
+              break;
+            case "upsert":
+              bulk.find(operation.filter).upsert().update({
+                ...prepUpdateValue("update" in operation ? operation.update : {}, now, true),
+                $setOnInsert: prepInsertValue(
+                  operation.insert,
+                  operation.makeId?.(i) ?? new ObjectId().toString(),
+                  now,
+                  true
+                )
+              });
+              break;
+            default:
+              throw new EquippedError(`Unknown bulkWrite operation`, { operation });
+          }
+        });
+        await bulk.execute({ session: sessionStore.getStore() });
+      },
+      watch(callbacks) {
+        if (!dbThis.config.changes)
+          Instance.crash(new EquippedError("Db changes are not enabled in the configuration.", { config }));
+        return new MongoDbChange(
+          dbThis.mongoConfig,
+          dbThis.config.changes,
+          collection,
+          callbacks,
+          (m) => config.mapper(m)
+        );
+      }
+    };
+    return table;
+  }
+};
+export {
+  MongoDb,
+  MongoDbChange,
+  mongoDbConfigPipe
+};

package/dist/types/dbs/index.d.ts

@@ -1,18 +1,20 @@
-import { M as Model, E as Entity, D as DbChange, a as MongoDbConfig, b as DbChangeConfig, c as DbChangeCallbacks } from '../core-BrkNSwvc.js';
-export { B as BulkWriteOperation, g as Conditions, e as Config, C as CreateInput, f as DbConfig, d as EntityInput, I as IdType, Q as QueryKeys, i as QueryParams, j as QueryParamsInput, n as QueryResults, l as QueryWhere, m as QueryWhereBlock, k as QueryWhereClause, T as Table, U as UpdateInput, o as mongoDbConfigPipe, q as queryParamsPipe, h as queryResultsPipe, w as wrapQueryParams } from '../core-BrkNSwvc.js';
-export { D as Db, T as TableOptions } from '../db-C8YY1yTO.js';
-import { Collection } from 'mongodb';
+import { I as IdType, c as DbConfig, M as Model, E as Entity, C as Config, T as Table } from '../core-tNlIMH9Y.js';
+export { B as BulkWriteOperation, g as Conditions, e as CreateInput, b as DbChangeCallbacks, a as DbChangeConfig, d as EntityInput, Q as QueryKeys, j as QueryParams, i as QueryParamsBase, k as QueryParamsInput, o as QueryResults, m as QueryWhere, n as QueryWhereBlock, l as QueryWhereClause, S as Select, U as UpdateInput, f as dbChangeConfigPipe, q as queryParamsPipe, h as queryResultsPipe, w as wrapQueryParams } from '../core-tNlIMH9Y.js';
 export { Filter } from 'mongodb';
-export { M as MongoDb } from '../db-Dj1SGto0.js';
 import 'valleyed';
-import '../kafka-Cf-TUJgv.js';
+import '../events/adapters/kafka/index.js';
 import '../overrides-6Hxg764S.js';
+import '../events/index.js';
 
-declare class MongoDbChange<Model extends Model<{
-    _id: string;
-}>, Entity extends Entity> extends DbChange<Model, Entity> {
-    #private;
-    constructor(config: MongoDbConfig, change: DbChangeConfig, collection: Collection<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+type TableOptions = {
+    skipAudit?: boolean;
+};
+declare abstract class Db<IdKey extends IdType> {
+    protected config: DbConfig;
+    constructor(config: DbConfig);
+    protected getScopedDb(db: string): string;
+    abstract use<Model extends Model<IdKey>, Entity extends Entity>(config: Config<Model, Entity>): Table<IdKey, Model, Entity>;
+    abstract session<T>(callback: () => Promise<T>): Promise<T>;
 }
 
-export { DbChangeCallbacks, DbChangeConfig, Entity, Model, MongoDbChange, MongoDbConfig };
+export { Config, Db, DbConfig, Entity, IdType, Model, Table, type TableOptions };

package/dist/types/dbs/index.js

@@ -1,6 +1,22 @@
-export * from "./base/core.js";
-export * from "./base/db.js";
-export * from "./base/types.js";
-export * from "./mongo/changes.js";
-export * from "./mongo/db.js";
-export * from "./pipes.js";
+import {
+  Conditions,
+  Db,
+  QueryKeys,
+  dbChangeConfigPipe,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+} from "../chunk-3M4PBZAQ.js";
+import "../chunk-XGGGAEET.js";
+import "../chunk-YTY3EFNB.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Conditions,
+  Db,
+  QueryKeys,
+  dbChangeConfigPipe,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+};

package/dist/types/equippedError-Cmo60Kn-.d.ts

@@ -0,0 +1,8 @@
+declare class EquippedError extends Error {
+    readonly message: string;
+    readonly context: Record<string, unknown>;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, context: Record<string, unknown>, cause?: unknown | undefined);
+}
+
+export { EquippedError as E };