equipped 4.0.0-alpha-10

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+export * from './emails';
+export * from './enums';
+export { Enum } from './enums/types';
+export * from './errors';
+export { Events } from './events/events';
+export * from './exit';
+export * from './express';
+export * from './instance';
+export * from './listeners';
+export * from './mongoose';
+export * from './storage';
+export * from './structure';
+export * from './utils/auth';
+export * from './utils/authUser';
+export * from './utils/tokens';
+export * from './utils/utils';
+export * from './validations';
+export declare const getEnvOrFail: (key: string) => string;

package/lib/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.getEnvOrFail = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+__exportStar(require("./emails"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./exit"), exports);
+__exportStar(require("./express"), exports);
+__exportStar(require("./instance"), exports);
+__exportStar(require("./listeners"), exports);
+__exportStar(require("./mongoose"), exports);
+__exportStar(require("./storage"), exports);
+__exportStar(require("./structure"), exports);
+__exportStar(require("./utils/auth"), exports);
+__exportStar(require("./utils/authUser"), exports);
+__exportStar(require("./utils/tokens"), exports);
+__exportStar(require("./utils/utils"), exports);
+__exportStar(require("./validations"), exports);
+const getEnvOrFail = (key) => {
+    const value = process.env[key];
+    if (value)
+        return value;
+    console.error(`Environment variable not found: ${key}`);
+    process.exit(1);
+};
+exports.getEnvOrFail = getEnvOrFail;

package/lib/instance.d.ts

@@ -0,0 +1,43 @@
+import { BullJob } from './bull';
+import { Cache } from './cache/cache';
+import { EventBus } from './events/events';
+import { Server } from './express/app';
+import { Logger } from './logger';
+type Settings = {
+    isDev: boolean;
+    accessTokenKey: string;
+    accessTokenTTL: number;
+    refreshTokenKey: string;
+    refreshTokenTTL: number;
+    mongoDbURI: string;
+    rabbitURI: string;
+    redisURI: string;
+    appId: string;
+    bullQueueName: string;
+    rabbitColumnName: string;
+    maxFileUploadSizeInMb: number;
+    useRateLimit: boolean;
+    rateLimitPeriodInMs: number;
+    rateLimit: number;
+    useSlowDown: boolean;
+    slowDownPeriodInMs: number;
+    slowDownAfter: number;
+    slowDownDelayInMs: number;
+    hashSaltRounds: number;
+    paginationDefaultLimit: number;
+};
+export declare class Instance {
+    #private;
+    private constructor();
+    get logger(): Logger;
+    get job(): BullJob;
+    get cache(): Cache;
+    get eventBus(): EventBus;
+    get server(): Server;
+    get listener(): import("./listeners").Listener;
+    get settings(): Settings;
+    static initialize(settings: Partial<Settings>): void;
+    static get(): Instance;
+    startDbConnection(): Promise<void>;
+}
+export {};

package/lib/instance.js

@@ -0,0 +1,115 @@
+"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 _a, _Instance_initialized, _Instance_instance, _Instance_settings, _Instance_logger, _Instance_job, _Instance_cache, _Instance_eventBus, _Instance_server;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instance = void 0;
+const bull_1 = require("./bull");
+const redis_cache_1 = require("./cache/types/redis-cache");
+const events_1 = require("./events/events");
+const exit_1 = require("./exit");
+const app_1 = require("./express/app");
+const logger_1 = require("./logger");
+const mongoose_1 = require("./mongoose");
+const setting = {
+    isDev: false,
+    accessTokenKey: 'accessTokenKey',
+    accessTokenTTL: 60 * 60,
+    refreshTokenKey: 'refreshTokenKey',
+    refreshTokenTTL: 14 * 24 * 60 * 60,
+    mongoDbURI: '',
+    rabbitURI: '',
+    redisURI: '',
+    appId: 'appId',
+    bullQueueName: 'appTasksQueue',
+    rabbitColumnName: 'appEventsColumn',
+    maxFileUploadSizeInMb: 500,
+    useRateLimit: false,
+    rateLimitPeriodInMs: 60 * 60 * 1000,
+    rateLimit: 2500,
+    useSlowDown: false,
+    slowDownPeriodInMs: 10 * 60 * 1000,
+    slowDownAfter: 1000,
+    slowDownDelayInMs: 500,
+    hashSaltRounds: 10,
+    paginationDefaultLimit: 100
+};
+class Instance {
+    constructor() {
+        _Instance_logger.set(this, null);
+        _Instance_job.set(this, null);
+        _Instance_cache.set(this, null);
+        _Instance_eventBus.set(this, null);
+        _Instance_server.set(this, null);
+    }
+    get logger() {
+        if (!__classPrivateFieldGet(this, _Instance_logger, "f"))
+            __classPrivateFieldSet(this, _Instance_logger, new logger_1.ConsoleLogger(), "f");
+        return __classPrivateFieldGet(this, _Instance_logger, "f");
+    }
+    get job() {
+        if (!__classPrivateFieldGet(this, _Instance_job, "f"))
+            __classPrivateFieldSet(this, _Instance_job, new bull_1.BullJob(), "f");
+        return __classPrivateFieldGet(this, _Instance_job, "f");
+    }
+    get cache() {
+        if (!__classPrivateFieldGet(this, _Instance_cache, "f"))
+            __classPrivateFieldSet(this, _Instance_cache, new redis_cache_1.RedisCache(this.settings.redisURI), "f");
+        return __classPrivateFieldGet(this, _Instance_cache, "f");
+    }
+    get eventBus() {
+        if (!__classPrivateFieldGet(this, _Instance_eventBus, "f"))
+            __classPrivateFieldSet(this, _Instance_eventBus, new events_1.EventBus(), "f");
+        return __classPrivateFieldGet(this, _Instance_eventBus, "f");
+    }
+    get server() {
+        if (!__classPrivateFieldGet(this, _Instance_server, "f"))
+            __classPrivateFieldSet(this, _Instance_server, new app_1.Server(), "f");
+        return __classPrivateFieldGet(this, _Instance_server, "f");
+    }
+    get listener() {
+        return this.server.listener;
+    }
+    get settings() {
+        return __classPrivateFieldGet(Instance, _a, "f", _Instance_settings);
+    }
+    static initialize(settings) {
+        Object.entries(settings).forEach(([key, value]) => __classPrivateFieldGet(this, _a, "f", _Instance_settings)[key] = value);
+        __classPrivateFieldSet(Instance, _a, true, "f", _Instance_initialized);
+    }
+    static get() {
+        if (!__classPrivateFieldGet(this, _a, "f", _Instance_initialized)) {
+            console.error('Has not been initialized. Make sure initialize is called before you get an instance');
+            process.exit(1);
+        }
+        if (!__classPrivateFieldGet(Instance, _a, "f", _Instance_instance))
+            __classPrivateFieldSet(Instance, _a, new Instance(), "f", _Instance_instance);
+        return __classPrivateFieldGet(Instance, _a, "f", _Instance_instance);
+    }
+    async startDbConnection() {
+        try {
+            await mongoose_1.mongoose.connect(this.settings.mongoDbURI);
+            await Instance.get().cache.connect();
+            await (0, mongoose_1.startAllChangeStreams)();
+            (0, exit_1.addWaitBeforeExit)(mongoose_1.mongoose.disconnect);
+        }
+        catch (error) {
+            await Instance.get().logger.error('MongoDb failed with error:', error);
+            process.exit(1);
+        }
+    }
+}
+exports.Instance = Instance;
+_a = Instance, _Instance_logger = new WeakMap(), _Instance_job = new WeakMap(), _Instance_cache = new WeakMap(), _Instance_eventBus = new WeakMap(), _Instance_server = new WeakMap();
+_Instance_initialized = { value: false };
+_Instance_instance = { value: void 0 };
+_Instance_settings = { value: setting };

package/lib/listeners/emitter.d.ts

@@ -0,0 +1,20 @@
+import io from 'socket.io';
+import { BaseEntity } from '../structure';
+import { AuthUser } from '../utils/authUser';
+export type OnJoinFn = (data: {
+    channel: string;
+    user: AuthUser | null;
+}, params: Record<string, any>) => Promise<string | null>;
+export type SocketCallers = {
+    onConnect: (userId: string, socketId: string) => Promise<void>;
+    onDisconnect: (userId: string, socketId: string) => Promise<void>;
+};
+export declare class Listener {
+    #private;
+    constructor(socket: io.Server, callers: SocketCallers);
+    created(channel: string, data: BaseEntity): Promise<void>;
+    updated(channel: string, data: BaseEntity): Promise<void>;
+    deleted(channel: string, data: BaseEntity): Promise<void>;
+    set callers(callers: SocketCallers);
+    register(channel: string, onJoin?: OnJoinFn): this;
+}

package/lib/listeners/emitter.js

@@ -0,0 +1,132 @@
+"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 _Listener_instances, _Listener_socket, _Listener_callers, _Listener_routes, _Listener_getJoinCb, _Listener_emit, _Listener_setupSocketConnection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+const express_1 = require("../express");
+const tokens_1 = require("../utils/tokens");
+var EmitTypes;
+(function (EmitTypes) {
+    EmitTypes["created"] = "created";
+    EmitTypes["updated"] = "updated";
+    EmitTypes["deleted"] = "deleted";
+})(EmitTypes || (EmitTypes = {}));
+class Listener {
+    constructor(socket, callers) {
+        _Listener_instances.add(this);
+        _Listener_socket.set(this, void 0);
+        _Listener_callers.set(this, void 0);
+        _Listener_routes.set(this, {});
+        _Listener_setupSocketConnection.set(this, () => {
+            const event = 'connection';
+            __classPrivateFieldGet(this, _Listener_socket, "f").removeAllListeners(event);
+            __classPrivateFieldGet(this, _Listener_socket, "f").on(event, async (socket) => {
+                const socketId = socket.id;
+                let user = null;
+                if (socket.handshake.auth.token)
+                    user = await (0, tokens_1.verifyAccessToken)(socket.handshake.auth.token ?? '').catch(() => null);
+                socket.on('leave', async (data, callback) => {
+                    if (!data.channel)
+                        return typeof (callback) === 'function' && callback({
+                            code: express_1.StatusCodes.ValidationError,
+                            message: 'channel is required',
+                            channel: ''
+                        });
+                    socket.leave(data.channel);
+                    return typeof (callback) === 'function' && callback({
+                        code: express_1.StatusCodes.Ok,
+                        message: '',
+                        channel: data.channel
+                    });
+                });
+                socket.on('join', async (data, callback) => {
+                    if (!data.channel)
+                        return typeof (callback) === 'function' && callback({
+                            code: express_1.StatusCodes.ValidationError,
+                            message: 'channel is required',
+                            channel: ''
+                        });
+                    const channel = data.channel;
+                    const route = __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_getJoinCb).call(this, channel) ?? null;
+                    if (!route)
+                        return typeof (callback) === 'function' && callback({
+                            code: express_1.StatusCodes.BadRequest,
+                            message: 'unknown channel',
+                            channel
+                        });
+                    const newChannel = await route.onJoin({ channel, user }, route.params);
+                    if (!newChannel)
+                        return typeof (callback) === 'function' && callback({
+                            code: express_1.StatusCodes.NotAuthorized,
+                            message: 'restricted access',
+                            channel
+                        });
+                    socket.join(newChannel);
+                    return typeof (callback) === 'function' && callback({
+                        code: express_1.StatusCodes.Ok,
+                        message: '',
+                        channel: newChannel
+                    });
+                });
+                if (user)
+                    await __classPrivateFieldGet(this, _Listener_callers, "f").onConnect(user.id, socketId);
+                socket.on('disconnect', async () => {
+                    if (user)
+                        await __classPrivateFieldGet(this, _Listener_callers, "f").onDisconnect(user.id, socketId);
+                });
+            });
+        });
+        __classPrivateFieldSet(this, _Listener_socket, socket, "f");
+        __classPrivateFieldSet(this, _Listener_callers, callers, "f");
+        __classPrivateFieldGet(this, _Listener_setupSocketConnection, "f").call(this);
+    }
+    async created(channel, data) {
+        await __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_emit).call(this, channel, EmitTypes.created, data);
+    }
+    async updated(channel, data) {
+        await __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_emit).call(this, channel, EmitTypes.updated, data);
+    }
+    async deleted(channel, data) {
+        await __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_emit).call(this, channel, EmitTypes.deleted, data);
+    }
+    set callers(callers) {
+        __classPrivateFieldSet(this, _Listener_callers, callers, "f");
+        __classPrivateFieldGet(this, _Listener_setupSocketConnection, "f").call(this);
+    }
+    register(channel, onJoin) {
+        if (!onJoin)
+            onJoin = async ({ channel }) => channel;
+        __classPrivateFieldGet(this, _Listener_routes, "f")[channel] = onJoin;
+        __classPrivateFieldGet(this, _Listener_routes, "f")[channel + '/:id'] = onJoin;
+        return this;
+    }
+}
+exports.Listener = Listener;
+_Listener_socket = new WeakMap(), _Listener_callers = new WeakMap(), _Listener_routes = new WeakMap(), _Listener_setupSocketConnection = new WeakMap(), _Listener_instances = new WeakSet(), _Listener_getJoinCb = function _Listener_getJoinCb(channel) {
+    const matcher = (key) => (0, path_to_regexp_1.match)(key, { encode: encodeURI, decode: decodeURIComponent })(channel);
+    const matchedChannel = Object.keys(__classPrivateFieldGet(this, _Listener_routes, "f")).find(matcher) ?? null;
+    if (!matchedChannel)
+        return null;
+    const match = matcher(matchedChannel);
+    if (!match)
+        return null;
+    return {
+        onJoin: __classPrivateFieldGet(this, _Listener_routes, "f")[matchedChannel],
+        params: JSON.parse(JSON.stringify(match.params))
+    };
+}, _Listener_emit = async function _Listener_emit(channel, type, data) {
+    __classPrivateFieldGet(this, _Listener_socket, "f").to(channel).emit(channel, {
+        type, data, channel
+    });
+};

package/lib/listeners/index.d.ts

@@ -0,0 +1 @@
+export * from './emitter';

package/lib/listeners/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./emitter"), exports);

package/lib/logger/index.d.ts

@@ -0,0 +1,16 @@
+export declare abstract class Logger {
+    abstract success(...args: any[]): Promise<void>;
+    abstract info(...args: any[]): Promise<void>;
+    abstract warn(...args: any[]): Promise<void>;
+    abstract error(...args: any[]): Promise<void>;
+}
+export declare class ConsoleLogger extends Logger {
+    log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    error(...args: any[]): Promise<void>;
+    success(...args: any[]): Promise<void>;
+    info(...args: any[]): Promise<void>;
+    warn(...args: any[]): Promise<void>;
+}

package/lib/logger/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = exports.Logger = void 0;
+class Logger {
+}
+exports.Logger = Logger;
+class ConsoleLogger extends Logger {
+    constructor() {
+        super(...arguments);
+        this.log = console.log;
+    }
+    async error(...args) {
+        this.log('LOG:ERROR:', ...args);
+    }
+    async success(...args) {
+        this.log('LOG:SUCCESS:', ...args);
+    }
+    async info(...args) {
+        this.log('LOG:INFO:', ...args);
+    }
+    async warn(...args) {
+        this.log('LOG:WARN:', ...args);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;

package/lib/mongoose/changeStreams.d.ts

@@ -0,0 +1,25 @@
+import { BaseEntity } from '../structure';
+import { mongoose } from './index';
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export type ChangeStreamCallbacks<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 declare const generateChangeStreams: <Model extends {
+    _id: string;
+}, Entity extends BaseEntity>(collection: mongoose.Model<any, {}, {}, {}, any>, callbacks: ChangeStreamCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null) => Promise<void>;
+export declare const startAllChangeStreams: () => Promise<void>;
+export {};

package/lib/mongoose/changeStreams.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAllChangeStreams = exports.generateChangeStreams = void 0;
+const exit_1 = require("../exit");
+const instance_1 = require("../instance");
+const collections = [];
+const startChangeStream = async (collection, callbacks, mapper, skipResume = false) => {
+    const dbName = collection.collection.collectionName;
+    const cloneName = dbName + '_streams_clone';
+    const getClone = () => collection.collection.conn.db.collection(cloneName);
+    const getStreamTokens = () => collection.collection.conn.db.collection('stream-tokens');
+    const res = await getStreamTokens().findOne({ _id: dbName });
+    const resumeToken = skipResume ? undefined : res?.resumeToken;
+    const changeStream = collection
+        .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)
+                    callbacks.created?.({
+                        before: null,
+                        after: mapper(new collection(after))
+                    });
+            }
+            if (data.operationType === 'delete') {
+                const _id = data.documentKey._id;
+                const { value: before } = await getClone().findOneAndDelete({ _id });
+                if (before)
+                    callbacks.deleted?.({
+                        before: mapper(new collection(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 = getObjectsFromKeys(changed);
+                if (before)
+                    callbacks.updated?.({
+                        before: mapper(new collection(before)),
+                        after: mapper(new collection(after)),
+                        changes
+                    });
+            }
+        })());
+    })
+        .on('error', async (err) => {
+        await instance_1.Instance.get().logger.error(`Change Stream errored out: ${dbName}: ${err.message}`);
+        changeStream.close();
+        return startChangeStream(collection, callbacks, mapper, true);
+    });
+    (0, exit_1.addWaitBeforeExit)(() => changeStream.close());
+    await instance_1.Instance.get().logger.info(`${dbName} changestream started`);
+};
+const generateChangeStreams = async (collection, callbacks, mapper) => {
+    collections.push({ collection, callbacks, mapper });
+};
+exports.generateChangeStreams = generateChangeStreams;
+const startAllChangeStreams = async () => {
+    await Promise.all(collections.map(async ({ collection, callbacks, mapper }) => {
+        await startChangeStream(collection, callbacks, mapper);
+    }));
+};
+exports.startAllChangeStreams = startAllChangeStreams;
+const deepMerge = (objFrom, objTo) => Object.keys(objFrom)
+    .reduce((merged, key) => {
+    merged[key] = objFrom[key] instanceof Object && !Array.isArray(objFrom[key])
+        ? deepMerge(objFrom[key], merged[key] ?? {})
+        : objFrom[key];
+    return merged;
+}, { ...objTo });
+const formObject = (key) => key.split('.').reverse().reduce((acc, value) => {
+    return { [value]: acc ?? true };
+}, null);
+const getObjectsFromKeys = (keys) => keys.map(formObject).reduce(deepMerge, {});

package/lib/mongoose/index.d.ts

@@ -0,0 +1,4 @@
+import mongoose from 'mongoose';
+export * from './query';
+export * from './changeStreams';
+export { mongoose };

package/lib/mongoose/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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/mongoose/query.d.ts

@@ -0,0 +1,60 @@
+import { mongoose } from './index';
+export declare enum QueryKeys {
+    and = "and",
+    or = "or"
+}
+export declare enum Conditions {
+    lt = "lt",
+    lte = "lte",
+    gt = "gt",
+    gte = "gte",
+    eq = "eq",
+    ne = "ne",
+    in = "in",
+    nin = "nin",
+    exists = "exists"
+}
+type Where = {
+    field: string;
+    value: any;
+    condition?: Conditions;
+};
+type WhereBlock = {
+    condition: QueryKeys;
+    value: (Where | WhereBlock)[];
+};
+type WhereClause = Where | WhereBlock;
+export type QueryParams = {
+    where?: WhereClause[];
+    auth?: WhereClause[];
+    whereType?: QueryKeys;
+    authType?: QueryKeys;
+    sort?: [{
+        field: string;
+        desc?: boolean;
+    }];
+    limit?: number;
+    all?: boolean;
+    page?: number;
+    search?: {
+        value: string;
+        fields: string[];
+    };
+};
+export declare const parseQueryParams: <Model>(collection: mongoose.Model<any, {}, {}, {}, any>, params: QueryParams) => Promise<QueryResults<Model>>;
+export type QueryResults<Model> = {
+    pages: {
+        start: number;
+        last: number;
+        previous: number | null;
+        next: number | null;
+        current: number;
+    };
+    docs: {
+        limit: number;
+        total: number;
+        count: number;
+    };
+    results: Model[];
+};
+export {};