equipped 4.0.2 → 4.1.0

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [4.1.0](https://github.com/kevinand11/equipped/compare/v4.0.2-alpha.3...v4.1.0) (2023-03-07)
+
+
+### Features
+
+* access db name from mongoose ([febdee0](https://github.com/kevinand11/equipped/commit/febdee0264fe0f7d2de02fcd08a380a8c93df68c))
+* add fanout option for event subscribers ([4f0c060](https://github.com/kevinand11/equipped/commit/4f0c060aa2d99fd6128499d49e1f163d1e93a721))
+* add helmet and supertest ([71ddcad](https://github.com/kevinand11/equipped/commit/71ddcad4e2b191913a890e7480619f1df527fde1))
+* add Id to mongo db ([55a8728](https://github.com/kevinand11/equipped/commit/55a872827a427a65a9be25ce464468935a4c5674))
+* add kafka eventbus ([22f79d4](https://github.com/kevinand11/equipped/commit/22f79d48e48cc7c5695a43089f6a724f479ed81c))
+* automatically start subscribers in Instance.startConnections ([96a07c9](https://github.com/kevinand11/equipped/commit/96a07c923a90b9203920ab490c4554098dfab5e8))
+* enable defaults, getters and virtuals on lean docs ([69f9d2b](https://github.com/kevinand11/equipped/commit/69f9d2b5f26072e91d411cc1dd5e676264a6a586))
+* enable lean documents for query ([ce04a8a](https://github.com/kevinand11/equipped/commit/ce04a8a326025916a32ce017634328c37c09a7e0))
+* enable pre images for all collections ([710457d](https://github.com/kevinand11/equipped/commit/710457d1132cd380a0890b191f98fece4473729f))
+* hydrate cs docs with getters and virtuals ([c93809a](https://github.com/kevinand11/equipped/commit/c93809ab8f2f4597fb310c68dc8d95b9f901aedd))
+* new changestream api ([923660b](https://github.com/kevinand11/equipped/commit/923660b11c1ab6f799c030b37dc6ce06c3b90ebb))
+* server request ip ([371dac1](https://github.com/kevinand11/equipped/commit/371dac18ef729c88da0e8885e1e63e581e8b979b))
+* socket emitters fanout ([65a36db](https://github.com/kevinand11/equipped/commit/65a36db9671205a30fe8aabd3b1763714e94f886))
+
+
+### Bug Fixes
+
+* hydrate _id from changes ([65e6539](https://github.com/kevinand11/equipped/commit/65e6539bfc9644421152af3ad5c0436a2b4ed3dc))
+* loop over db connections ([eb3f548](https://github.com/kevinand11/equipped/commit/eb3f548f2e7a2f172cb4ead8ff655df0fc8f3b95))
+* remove cache setInTransaction ([4f1b3c0](https://github.com/kevinand11/equipped/commit/4f1b3c0db37621162065c69fc24eab744675da27))
+* setup debezium connection to mongo ([3d36283](https://github.com/kevinand11/equipped/commit/3d3628349910d8ba0633578b6578f09e682b8145))
+
+### [4.0.2-alpha.3](https://github.com/kevinand11/equipped/compare/v4.0.2-alpha.2...v4.0.2-alpha.3) (2023-02-19)
+
+### [4.0.2-alpha.2](https://github.com/kevinand11/equipped/compare/v4.0.2-alpha.1...v4.0.2-alpha.2) (2023-02-19)
+
+### [4.0.2-alpha.1](https://github.com/kevinand11/equipped/compare/v4.0.2...v4.0.2-alpha.1) (2023-02-19)
+
+
+### Features
+
+* make db change abstract ([e747c3f](https://github.com/kevinand11/equipped/commit/e747c3f2f74dc178521c3ee4d9a79efc8b160d32))
+
 ### [4.0.2](https://github.com/kevinand11/equipped/compare/v4.0.1...v4.0.2) (2023-02-16)
 
 ### [4.0.1](https://github.com/kevinand11/equipped/compare/v4.0.0-alpha-10...v4.0.1) (2023-02-16)

package/README.md

@@ -0,0 +1,68 @@
+# Equipped
+
+<br>
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the [npm registry](https://www.npmjs.com/package/equipped).
+Before installing, [download and install Node.js](https://nodejs.org/en/download/). Node.js 4.2.4 or higher is required.
+If this is a brand new project, make sure to create a `package.json` first with the [`npm init` command](https://docs.npmjs.com/creating-a-package-json-file).
+Installation is done using the [`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+### Using npm:
+    npm install equipped
+
+### Using yarn:
+    yarn add equipped
+
+### Using CDN:
+
+[Equipped jsDelivr CDN](https://www.jsdelivr.com/package/npm/equipped)
+
+<br>
+
+## Basic Usage
+Before use, the package must be initialized in the entry point into your application, with the required settings.
+```ts
+import { Instance } from 'equipped'
+
+Instance.initialize({
+    isDev: true, // Are you running in a dev environment
+    appId: 'testing', // An id to identify your application
+    mongoDbURI: 'mongodb://...', // A mongodb url if you want to use a database
+    redisURI: 'redis://localhost:6379', // A redis url if you want to use a redis cache. Confirm all other functionality you intend to use do not depend on the cache, even if you are not using a cache directly
+    ...other settings
+})
+```
+
+<br>
+
+After the app has been initialized, the Instance class returns a singleton that provides access to most functionality provided by Equipped
+```ts
+import { Instance } from 'equipped'
+
+const appInstance = Instance.get()
+```
+
+<br>
+
+To start a server
+```ts
+import { makeController, StatusCodes } from 'equipped'
+
+// Aggregate all your routes into an array. This can be defined in the file or imported from your controllers etc
+appInstance.server.routes = [
+    {
+        path: '/',
+        method: 'get',
+        controllers: [makeController(async () => {
+            return {
+                result: 'Hello world',
+                status: StatusCodes.Ok
+            }
+        })]
+    }
+]
+
+await appInstance.server.start(8080)
+```

package/lib/cache/cache.d.ts

@@ -1,7 +1,7 @@
 export declare abstract class Cache {
-    abstract connect(): Promise<void>;
+    abstract start(): Promise<void>;
+    abstract close(): Promise<void>;
     abstract set(key: string, data: string, ttlInSecs: number): Promise<void>;
-    abstract setInTransaction(key: string, data: string, ttlInSecs: number): Promise<[string, string]>;
     abstract get(key: string): Promise<string | null>;
     abstract delete(key: string): Promise<void>;
 }

package/lib/cache/types/redis-cache.d.ts

@@ -2,10 +2,10 @@ import { createClient } from 'redis';
 import { Cache } from '../cache';
 export declare class RedisCache extends Cache {
     client: ReturnType<typeof createClient>;
-    constructor(connection: string);
-    connect(): Promise<void>;
+    constructor();
+    start(): Promise<void>;
+    close(): Promise<void>;
     delete(key: string): Promise<void>;
     get(key: string): Promise<string | null>;
     set(key: string, data: string, ttlInSecs: number): Promise<void>;
-    setInTransaction(key: string, data: string, ttlInSecs: number): Promise<[string, string]>;
 }

package/lib/cache/types/redis-cache.js

@@ -6,18 +6,19 @@ const exit_1 = require("../../exit");
 const instance_1 = require("../../instance");
 const cache_1 = require("../cache");
 class RedisCache extends cache_1.Cache {
-    constructor(connection) {
+    constructor() {
         super();
-        this.client = (0, redis_1.createClient)({ url: connection });
+        this.client = (0, redis_1.createClient)({ url: instance_1.Instance.get().settings.redisURI });
         this.client.on('error', async (error) => {
-            await instance_1.Instance.get().logger.error('Redis failed with error:', error);
-            process.exit(1);
+            (0, exit_1.exit)(`Redis failed with error: ${error}`);
         });
-        (0, exit_1.addWaitBeforeExit)(() => this.client.quit());
     }
-    async connect() {
+    async start() {
         await this.client.connect();
     }
+    async close() {
+        this.client.quit();
+    }
     async delete(key) {
         await this.client.del(key);
     }
@@ -30,11 +31,5 @@ class RedisCache extends cache_1.Cache {
         else
             this.client.set(key, data);
     }
-    async setInTransaction(key, data, ttlInSecs) {
-        return await this.client.multi()
-            .get(key)
-            .setEx(key, ttlInSecs, data)
-            .exec();
-    }
 }
 exports.RedisCache = RedisCache;

package/lib/db/_instance.d.ts

@@ -0,0 +1,39 @@
+import { BaseEntity } from '../structure';
+import { DebeziumSetup } from './debezium';
+import { QueryParams, QueryResults } from './query';
+export declare abstract class Db {
+    #private;
+    abstract change<Model, Entity extends BaseEntity>(collection: any, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): DbChange<Model, Entity>;
+    abstract query<Model>(collection: any, params: QueryParams): Promise<QueryResults<Model>>;
+    protected _addToDbChanges(dbChange: DbChange<any, any>): this;
+    startAllDbChanges(): Promise<void>;
+    abstract start(): Promise<void>;
+    abstract close(): Promise<void>;
+}
+export declare abstract class DbChange<Model, Entity extends BaseEntity> {
+    #private;
+    constructor(callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null);
+    abstract start(): Promise<void>;
+    get callbacks(): Readonly<DbChangeCallbacks<Model, Entity>>;
+    get mapper(): (model: Model | null) => Entity | null;
+    protected _setup(key: string, data: DebeziumSetup): Promise<boolean>;
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export type DbChangeCallbacks<Model, Entity> = {
+    created?: (data: {
+        before: null;
+        after: Entity;
+    }) => Promise<void>;
+    updated?: (data: {
+        before: Entity;
+        after: Entity;
+        changes: DeepPartial<Model>;
+    }) => Promise<void>;
+    deleted?: (data: {
+        before: Entity;
+        after: null;
+    }) => Promise<void>;
+};
+export {};

package/lib/db/_instance.js

@@ -0,0 +1,65 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Db_dbChanges, _DbChange_callbacks, _DbChange_mapper;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbChange = exports.Db = void 0;
+const axios_1 = __importDefault(require("axios"));
+const exit_1 = require("../exit");
+const instance_1 = require("../instance");
+const debezium_1 = require("./debezium");
+class Db {
+    constructor() {
+        _Db_dbChanges.set(this, []);
+    }
+    _addToDbChanges(dbChange) {
+        __classPrivateFieldGet(this, _Db_dbChanges, "f").push(dbChange);
+        return this;
+    }
+    async startAllDbChanges() {
+        await Promise.all(__classPrivateFieldGet(this, _Db_dbChanges, "f").map((change) => change.start()));
+    }
+}
+exports.Db = Db;
+_Db_dbChanges = new WeakMap();
+class DbChange {
+    constructor(callbacks, mapper) {
+        _DbChange_callbacks.set(this, {});
+        _DbChange_mapper.set(this, void 0);
+        __classPrivateFieldSet(this, _DbChange_callbacks, callbacks, "f");
+        __classPrivateFieldSet(this, _DbChange_mapper, mapper, "f");
+    }
+    get callbacks() {
+        return Object.freeze(__classPrivateFieldGet(this, _DbChange_callbacks, "f"));
+    }
+    get mapper() {
+        return __classPrivateFieldGet(this, _DbChange_mapper, "f");
+    }
+    async _setup(key, data) {
+        data = { ...debezium_1.DefaultDebeziumSetup, ...data };
+        const topics = await axios_1.default.put(`/connectors/${key}/config`, data, { baseURL: instance_1.Instance.get().settings.debeziumUrl })
+            .then(async () => {
+            const res = await axios_1.default.get(`/connectors/${key}/topics`, { baseURL: instance_1.Instance.get().settings.debeziumUrl });
+            return res.data[key]?.topics ?? [];
+        })
+            .catch((err) => {
+            (0, exit_1.exit)(`Failed to setup debezium for ${key}: ${err.message}`);
+            return [];
+        });
+        return topics[0] === key;
+    }
+}
+exports.DbChange = DbChange;
+_DbChange_callbacks = new WeakMap(), _DbChange_mapper = new WeakMap();

package/lib/db/debezium.d.ts

@@ -0,0 +1,10 @@
+export type DebeziumSetup = Partial<{
+    'connector.class': string;
+    'topic.prefix': string;
+    'key.converter': string;
+    'key.converter.schemas.enable': string;
+    'value.converter': string;
+    'value.converter.schemas.enable': string;
+}> & Record<string, string>;
+export declare const TopicPrefix = "equipped";
+export declare const DefaultDebeziumSetup: DebeziumSetup;

package/lib/db/debezium.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDebeziumSetup = exports.TopicPrefix = void 0;
+exports.TopicPrefix = 'equipped';
+exports.DefaultDebeziumSetup = {
+    'topic.prefix': exports.TopicPrefix,
+    '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'
+};

package/lib/db/index.d.ts

@@ -0,0 +1,2 @@
+export * from './query';
+export { DbChangeCallbacks } from './_instance';

package/lib/{mongoose → db}/index.js

@@ -13,12 +13,5 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mongoose = void 0;
-const mongoose_1 = __importDefault(require("mongoose"));
-exports.mongoose = mongoose_1.default;
 __exportStar(require("./query"), exports);
-__exportStar(require("./changeStreams"), exports);

package/lib/db/mongoose/changes.d.ts

@@ -0,0 +1,8 @@
+import mongoose from 'mongoose';
+import { BaseEntity } from '../../structure';
+import { DbChange, DbChangeCallbacks } from '../_instance';
+export declare class MongoDbChange<Model, Entity extends BaseEntity> extends DbChange<Model, Entity> {
+    #private;
+    constructor(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null);
+    start(): Promise<void>;
+}

package/lib/db/mongoose/changes.js

@@ -0,0 +1,99 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _MongoDbChange_started, _MongoDbChange_model;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDbChange = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const exit_1 = require("../../exit");
+const instance_1 = require("../../instance");
+const retry_1 = require("../../utils/retry");
+const validations_1 = require("../../validations");
+const debezium_1 = require("../debezium");
+const _instance_1 = require("../_instance");
+class MongoDbChange extends _instance_1.DbChange {
+    constructor(model, callbacks, mapper) {
+        super(callbacks, mapper);
+        _MongoDbChange_started.set(this, false);
+        _MongoDbChange_model.set(this, void 0);
+        __classPrivateFieldSet(this, _MongoDbChange_model, model, "f");
+    }
+    async start() {
+        if (__classPrivateFieldGet(this, _MongoDbChange_started, "f"))
+            return;
+        __classPrivateFieldSet(this, _MongoDbChange_started, true, "f");
+        const model = __classPrivateFieldGet(this, _MongoDbChange_model, "f");
+        const dbName = model.db.name;
+        const colName = model.collection.name;
+        const dbColName = `${dbName}.${colName}`;
+        const topic = `${debezium_1.TopicPrefix}.${dbColName}`;
+        (0, retry_1.retry)(async () => {
+            const { hosts, replicaSet, credentials } = model.collection.conn.getClient().options;
+            const started = await this._setup(topic, {
+                'connector.class': 'io.debezium.connector.mongodb.MongoDbConnector',
+                'capture.mode': 'change_streams_update_full_with_pre_image',
+                'mongodb.hosts': `${replicaSet}/` + hosts.map((h) => `${h.host}:${h.port}`).join(','),
+                ...(credentials ? {
+                    'mongodb.user': credentials.username,
+                    'mongodb.pass': credentials.password,
+                    'mongodb.auth-source': credentials.source
+                } : {}),
+                'collection.include.list': dbColName
+            });
+            const TestId = new mongoose_1.default.Types.ObjectId('__equipped__');
+            if (!started) {
+                await model.findByIdAndUpdate(TestId, { $set: { colName } }, { upsert: true });
+                await model.findByIdAndDelete(TestId);
+                throw new Error(`Wait a few minutes for db changes for ${colName} to initialize...`);
+            }
+            const hydrate = (data) => model.hydrate({
+                ...data, _id: new mongoose_1.default.Types.ObjectId(data._id['$oid'])
+            }).toObject({ getters: true, virtuals: true });
+            if (started)
+                await instance_1.Instance.get().eventBus
+                    .createSubscriber(topic, async (data) => {
+                    const op = data.op;
+                    let before = JSON.parse(data.before ?? 'null');
+                    let after = JSON.parse(data.after ?? 'null');
+                    if (before?.__id === TestId || after?.__id === TestId)
+                        return;
+                    if (before)
+                        before = hydrate(before);
+                    if (after)
+                        after = hydrate(after);
+                    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)
+                        await this.callbacks.updated({
+                            before: this.mapper(before),
+                            after: this.mapper(after),
+                            changes: validations_1.Validation.Differ.from(validations_1.Validation.Differ.diff(before, after))
+                        });
+                    else if (op === 'd' && this.callbacks.deleted && before)
+                        await this.callbacks.deleted({
+                            before: this.mapper(before),
+                            after: null
+                        });
+                })
+                    .subscribe();
+        }, 10, 60000)
+            .catch((err) => (0, exit_1.exit)(err.message));
+    }
+}
+exports.MongoDbChange = MongoDbChange;
+_MongoDbChange_started = new WeakMap(), _MongoDbChange_model = new WeakMap();

package/lib/db/mongoose/index.d.ts

@@ -0,0 +1,15 @@
+import mongoose from 'mongoose';
+import { BaseEntity } from '../../structure';
+import { QueryParams, QueryResults } from '../query';
+import { Db, DbChangeCallbacks } from '../_instance';
+import { MongoDbChange } from './changes';
+export declare class MongoDb extends Db {
+    #private;
+    get Schema(): typeof mongoose.Schema;
+    get Id(): mongoose.Types.ObjectId;
+    use(dbName?: string): mongoose.Connection;
+    change<Model, Entity extends BaseEntity>(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): MongoDbChange<Model, Entity>;
+    query<Model>(model: mongoose.Model<Model>, params: QueryParams): Promise<QueryResults<Model>>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/db/mongoose/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _MongoDb_instances, _MongoDb_started, _MongoDb_connections_get;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDb = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const mongoose_lean_defaults_1 = __importDefault(require("mongoose-lean-defaults"));
+const mongoose_lean_getters_1 = __importDefault(require("mongoose-lean-getters"));
+const mongoose_lean_virtuals_1 = __importDefault(require("mongoose-lean-virtuals"));
+const instance_1 = require("../../instance");
+const _instance_1 = require("../_instance");
+const changes_1 = require("./changes");
+const query_1 = require("./query");
+class MongoDb extends _instance_1.Db {
+    constructor() {
+        super(...arguments);
+        _MongoDb_instances.add(this);
+        _MongoDb_started.set(this, false);
+    }
+    get Schema() {
+        return mongoose_1.default.Schema;
+    }
+    get Id() {
+        return new mongoose_1.default.Types.ObjectId();
+    }
+    use(dbName = 'default') {
+        const conn = dbName === 'default' ? mongoose_1.default.connection : mongoose_1.default.connection.useDb(dbName, { useCache: true });
+        conn.plugin(mongoose_lean_defaults_1.default).plugin(mongoose_lean_virtuals_1.default).plugin(mongoose_lean_getters_1.default);
+        return conn;
+    }
+    change(model, callbacks, mapper) {
+        const change = new changes_1.MongoDbChange(model, callbacks, mapper);
+        this._addToDbChanges(change);
+        return change;
+    }
+    async query(model, params) {
+        return await (0, query_1.parseMongodbQueryParams)(model, params);
+    }
+    async start() {
+        if (__classPrivateFieldGet(this, _MongoDb_started, "f"))
+            return;
+        __classPrivateFieldSet(this, _MongoDb_started, true, "f");
+        mongoose_1.default.set('strictQuery', true);
+        await mongoose_1.default.connect(instance_1.Instance.get().settings.mongoDbURI);
+        await Promise.all([mongoose_1.default.connection, ...__classPrivateFieldGet(this, _MongoDb_instances, "a", _MongoDb_connections_get)].map((conn) => {
+            return Object.values(conn.models)
+                .map(async (model) => {
+                await conn.db.command({ collMod: model.collection.name, changeStreamPreAndPostImages: { enabled: true } });
+            });
+        }).flat());
+    }
+    async close() {
+        await Promise.all(__classPrivateFieldGet(this, _MongoDb_instances, "a", _MongoDb_connections_get).map(async (conn) => conn.close()));
+        await mongoose_1.default.disconnect();
+    }
+}
+exports.MongoDb = MongoDb;
+_MongoDb_started = new WeakMap(), _MongoDb_instances = new WeakSet(), _MongoDb_connections_get = function _MongoDb_connections_get() {
+    return mongoose_1.default.connection.otherDbs ?? [];
+};

package/lib/db/mongoose/query.d.ts

@@ -0,0 +1,3 @@
+import mongoose from 'mongoose';
+import { QueryParams, QueryResults } from '../query';
+export declare const parseMongodbQueryParams: <Model>(model: mongoose.Model<Model, {}, {}, {}, mongoose.IfAny<Model, any, mongoose.Document<unknown, {}, Model> & Omit<mongoose.Require_id<Model>, never>>, any>, params: QueryParams) => Promise<QueryResults<Model>>;

package/lib/{mongoose → db/mongoose}/query.js

@@ -1,28 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseQueryParams = exports.Conditions = exports.QueryKeys = void 0;
-const instance_1 = require("../instance");
-var QueryKeys;
-(function (QueryKeys) {
-    QueryKeys["and"] = "and";
-    QueryKeys["or"] = "or";
-})(QueryKeys = exports.QueryKeys || (exports.QueryKeys = {}));
-var Conditions;
-(function (Conditions) {
-    Conditions["lt"] = "lt";
-    Conditions["lte"] = "lte";
-    Conditions["gt"] = "gt";
-    Conditions["gte"] = "gte";
-    Conditions["eq"] = "eq";
-    Conditions["ne"] = "ne";
-    Conditions["in"] = "in";
-    Conditions["nin"] = "nin";
-    Conditions["exists"] = "exists";
-})(Conditions = exports.Conditions || (exports.Conditions = {}));
-const parseQueryParams = async (collection, params) => {
+exports.parseMongodbQueryParams = void 0;
+const instance_1 = require("../../instance");
+const query_1 = require("../query");
+const parseMongodbQueryParams = async (model, params) => {
     const query = [];
-    const whereType = Object.values(QueryKeys).indexOf(params.whereType) !== -1 ? params.whereType : QueryKeys.and;
-    const authType = Object.values(QueryKeys).indexOf(params.authType) !== -1 ? params.authType : QueryKeys.and;
+    const whereType = Object.values(query_1.QueryKeys).indexOf(params.whereType) !== -1 ? params.whereType : query_1.QueryKeys.and;
+    const authType = Object.values(query_1.QueryKeys).indexOf(params.authType) !== -1 ? params.authType : query_1.QueryKeys.and;
     const where = buildWhereQuery(params.where ?? [], whereType);
     if (where)
         query.push(where);
@@ -46,8 +30,8 @@ const parseQueryParams = async (collection, params) => {
     const limit = Number(params.limit) <= settings.paginationDefaultLimit ? Number(params.limit) : settings.paginationDefaultLimit;
     let page = Number.isNaN(Number(params.page)) ? 0 : Number(params.page);
     page = page < 1 ? 1 : page;
-    const total = await collection.countDocuments(totalClause).exec();
-    let builtQuery = collection.find(totalClause);
+    const total = await model.countDocuments(totalClause);
+    let builtQuery = model.find(totalClause).lean({ virtuals: true, getters: true, defaults: true });
     if (sort.length)
         builtQuery = builtQuery.sort(Object.fromEntries(sort));
     if (!all && limit) {
@@ -55,7 +39,7 @@ const parseQueryParams = async (collection, params) => {
         if (page)
             builtQuery = builtQuery.skip((page - 1) * limit);
     }
-    const results = await builtQuery.exec();
+    const results = await builtQuery;
     const start = 1;
     const last = Math.ceil(total / limit) || 1;
     const next = page >= last ? null : page + 1;
@@ -67,18 +51,18 @@ const parseQueryParams = async (collection, params) => {
         docs: {
             limit, total, count: results.length
         },
-        results: results.map((r) => r.toJSON())
+        results: results
     };
 };
-exports.parseQueryParams = parseQueryParams;
-const buildWhereQuery = (params, key = QueryKeys.and) => {
+exports.parseMongodbQueryParams = parseMongodbQueryParams;
+const buildWhereQuery = (params, key = query_1.QueryKeys.and) => {
     const where = params.map((param) => {
-        if (Object.values(QueryKeys).includes(param.condition))
+        if (Object.values(query_1.QueryKeys).includes(param.condition))
             return buildWhereQuery(param.value, param.condition);
         const { field } = param;
         const checkedField = field === 'id' ? '_id' : (field ?? '');
         const checkedValue = param.value === undefined ? '' : param.value;
-        const checkedCondition = Object.keys(Conditions).indexOf(param.condition) > -1 ? param.condition : Conditions.eq;
+        const checkedCondition = Object.keys(query_1.Conditions).indexOf(param.condition) > -1 ? param.condition : query_1.Conditions.eq;
         return ({
             field: checkedField,
             value: checkedValue,