equipped 4.0.2-alpha.3 → 4.1.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 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)

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,8 +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,11 +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

@@ -3,16 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCache = void 0;
 const redis_1 = require("redis");
 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) => {
             (0, exit_1.exit)(`Redis failed with error: ${error}`);
         });
     }
-    async connect() {
+    async start() {
         await this.client.connect();
     }
     async close() {
@@ -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

@@ -1,18 +1,22 @@
 import { BaseEntity } from '../structure';
+import { DebeziumSetup } from './debezium';
 import { QueryParams, QueryResults } from './query';
 export declare abstract class Db {
     #private;
-    abstract generateDbChange<Model, Entity extends BaseEntity>(collection: any, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): DbChange<Model, Entity>;
-    abstract parseQueryParams<Model>(collection: any, params: QueryParams): Promise<QueryResults<Model>>;
+    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(url: string): Promise<void>;
+    abstract start(): Promise<void>;
     abstract close(): Promise<void>;
 }
 export declare abstract class DbChange<Model, Entity extends BaseEntity> {
-    _cbs: DbChangeCallbacks<Model, Entity>;
-    abstract start(...args: any[]): Promise<void>;
-    setCallbacks(callbacks: DbChangeCallbacks<Model, Entity>): this;
+    #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]>;

package/lib/db/_instance.js

@@ -4,9 +4,22 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Db_dbChanges;
+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, []);
@@ -22,14 +35,31 @@ class Db {
 exports.Db = Db;
 _Db_dbChanges = new WeakMap();
 class DbChange {
-    constructor() {
-        this._cbs = {};
+    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");
     }
-    setCallbacks(callbacks) {
-        this._cbs.created = callbacks.created;
-        this._cbs.updated = callbacks.updated;
-        this._cbs.deleted = callbacks.deleted;
-        return this;
+    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

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

package/lib/db/index.js

@@ -13,11 +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);

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

@@ -1,16 +1,15 @@
 import mongoose from 'mongoose';
 import { BaseEntity } from '../../structure';
 import { QueryParams, QueryResults } from '../query';
-import { Db, DbChange, DbChangeCallbacks } from '../_instance';
+import { Db, DbChangeCallbacks } from '../_instance';
+import { MongoDbChange } from './changes';
 export declare class MongoDb extends Db {
-    generateDbChange<Model, Entity extends BaseEntity>(collection: mongoose.Model<Model | any>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): MongoDbChange<Model, Entity>;
-    parseQueryParams<Model>(collection: mongoose.Model<Model | any>, params: QueryParams): Promise<QueryResults<Model>>;
-    start(url: string): Promise<void>;
-    close(): Promise<void>;
-}
-declare class MongoDbChange<Model, Entity extends BaseEntity> extends DbChange<Model, Entity> {
     #private;
-    constructor(collection: mongoose.Model<Model | any>, mapper: (model: Model | null) => Entity | null);
-    start(skipResume?: boolean): Promise<void>;
+    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>;
 }
-export {};

package/lib/db/mongoose/index.js

@@ -1,125 +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 __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_col, _MongoDbChange_mapper;
+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 exit_1 = require("../../exit");
+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 validations_1 = require("../../validations");
 const _instance_1 = require("../_instance");
+const changes_1 = require("./changes");
 const query_1 = require("./query");
 class MongoDb extends _instance_1.Db {
-    generateDbChange(collection, callbacks, mapper) {
-        const change = new MongoDbChange(collection, mapper)
-            .setCallbacks(callbacks);
+    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 parseQueryParams(collection, params) {
-        return (0, query_1.parseMongodbQueryParams)(collection, params);
+    async query(model, params) {
+        return await (0, query_1.parseMongodbQueryParams)(model, params);
     }
-    async start(url) {
-        await mongoose_1.default.connect(url);
+    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;
-class MongoDbChange extends _instance_1.DbChange {
-    constructor(collection, mapper) {
-        super();
-        _MongoDbChange_started.set(this, false);
-        _MongoDbChange_col.set(this, void 0);
-        _MongoDbChange_mapper.set(this, void 0);
-        __classPrivateFieldSet(this, _MongoDbChange_col, collection, "f");
-        __classPrivateFieldSet(this, _MongoDbChange_mapper, mapper, "f");
-        this._cbs = {};
-    }
-    async start(skipResume = false) {
-        if (__classPrivateFieldGet(this, _MongoDbChange_started, "f"))
-            return;
-        __classPrivateFieldSet(this, _MongoDbChange_started, true, "f");
-        const dbName = __classPrivateFieldGet(this, _MongoDbChange_col, "f").collection.collectionName;
-        const cloneName = dbName + '_streams_clone';
-        const getClone = () => __classPrivateFieldGet(this, _MongoDbChange_col, "f").collection.conn.db.collection(cloneName);
-        const getStreamTokens = () => __classPrivateFieldGet(this, _MongoDbChange_col, "f").collection.conn.db.collection('stream-tokens');
-        const res = await getStreamTokens().findOne({ _id: dbName });
-        const resumeToken = skipResume ? undefined : res?.resumeToken;
-        const changeStream = __classPrivateFieldGet(this, _MongoDbChange_col, "f")
-            .watch([], { fullDocument: 'updateLookup', startAfter: resumeToken })
-            .on('change', async (data) => {
-            const streamId = data._id._data;
-            const cacheName = `streams-${streamId}`;
-            const cached = await instance_1.Instance.get().cache.setInTransaction(cacheName, streamId, 15);
-            if (cached[0])
-                return;
-            (0, exit_1.addWaitBeforeExit)((async () => {
-                await getStreamTokens().findOneAndUpdate({ _id: dbName }, { $set: { resumeToken: data._id } }, { upsert: true });
-                if (data.operationType === 'insert') {
-                    const _id = data.documentKey._id;
-                    const after = data.fullDocument;
-                    const { value } = await getClone().findOneAndUpdate({ _id }, { $set: { ...after, _id } }, {
-                        upsert: true,
-                        returnDocument: 'after'
-                    });
-                    if (value)
-                        this._cbs.created?.({
-                            before: null,
-                            after: __classPrivateFieldGet(this, _MongoDbChange_mapper, "f").call(this, new (__classPrivateFieldGet(this, _MongoDbChange_col, "f"))(after))
-                        });
-                }
-                if (data.operationType === 'delete') {
-                    const _id = data.documentKey._id;
-                    const { value: before } = await getClone().findOneAndDelete({ _id });
-                    if (before)
-                        this._cbs.deleted?.({
-                            before: __classPrivateFieldGet(this, _MongoDbChange_mapper, "f").call(this, new (__classPrivateFieldGet(this, _MongoDbChange_col, "f"))(before)),
-                            after: null
-                        });
-                }
-                if (data.operationType === 'update') {
-                    const _id = data.documentKey._id;
-                    const after = data.fullDocument;
-                    const { value: before } = await getClone().findOneAndUpdate({ _id }, { $set: after }, { returnDocument: 'before' });
-                    const { updatedFields = {}, removedFields = [], truncatedArrays = [] } = data.updateDescription ?? {};
-                    const changed = removedFields
-                        .map((f) => f.toString())
-                        .concat(truncatedArrays.map((a) => a.field))
-                        .concat(Object.keys(updatedFields));
-                    const changes = validations_1.Validation.Differ.from(changed);
-                    if (before)
-                        this._cbs.updated?.({
-                            before: __classPrivateFieldGet(this, _MongoDbChange_mapper, "f").call(this, new (__classPrivateFieldGet(this, _MongoDbChange_col, "f"))(before)),
-                            after: __classPrivateFieldGet(this, _MongoDbChange_mapper, "f").call(this, new (__classPrivateFieldGet(this, _MongoDbChange_col, "f"))(after)),
-                            changes
-                        });
-                }
-            })());
-        })
-            .on('error', async (err) => {
-            await instance_1.Instance.get().logger.error(`Change Stream errored out: ${dbName}: ${err.message}`);
-            changeStream.close();
-            return this.start(true);
-        });
-        (0, exit_1.addWaitBeforeExit)(async () => {
-            changeStream.close();
-            __classPrivateFieldSet(this, _MongoDbChange_started, false, "f");
-        });
-    }
-}
-_MongoDbChange_started = new WeakMap(), _MongoDbChange_col = new WeakMap(), _MongoDbChange_mapper = new WeakMap();
+_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

@@ -1,3 +1,3 @@
-import { QueryParams, QueryResults } from '../query';
 import mongoose from 'mongoose';
-export declare const parseMongodbQueryParams: <Model>(collection: mongoose.Model<any, {}, {}, {}, any>, params: QueryParams) => Promise<QueryResults<Model>>;
+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>>;