@aptana/multichannel-common 2.9.12

package/domain/TransactionMessaging.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionMessagingStatus = void 0;
+var TransactionMessagingStatus;
+(function (TransactionMessagingStatus) {
+    TransactionMessagingStatus["Created"] = "created";
+    TransactionMessagingStatus["Paid"] = "paid";
+    TransactionMessagingStatus["Published"] = "published";
+    TransactionMessagingStatus["Succeeded"] = "succeeded";
+    TransactionMessagingStatus["Failed"] = "failed";
+})(TransactionMessagingStatus = exports.TransactionMessagingStatus || (exports.TransactionMessagingStatus = {}));

package/domain/TransactionMessagingStatusUpdate.d.ts

@@ -0,0 +1,6 @@
+export interface TransactionMessagingStatusUpdate {
+    sourceId?: string;
+    sourceStatus?: string;
+    sourceReason?: string;
+}
+export default TransactionMessagingStatusUpdate;

package/domain/TransactionMessagingStatusUpdate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/domain/User.d.ts

@@ -0,0 +1,25 @@
+export declare enum RoleEnum {
+    Admin = "admin",
+    Finance = "finance",
+    Operational = "operational",
+    Member = "member"
+}
+export declare enum StatusEnum {
+    Active = "active",
+    Archived = "archived"
+}
+export declare enum ProviderEnum {
+    Email = "email"
+}
+interface User {
+    id?: string;
+    provider: ProviderEnum;
+    uid: string;
+    password: string | undefined;
+    name: string;
+    email: string;
+    accountId: string | undefined;
+    token: string | undefined;
+    status: StatusEnum;
+}
+export default User;

package/domain/User.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderEnum = exports.StatusEnum = exports.RoleEnum = void 0;
+var RoleEnum;
+(function (RoleEnum) {
+    RoleEnum["Admin"] = "admin";
+    RoleEnum["Finance"] = "finance";
+    RoleEnum["Operational"] = "operational";
+    RoleEnum["Member"] = "member";
+})(RoleEnum = exports.RoleEnum || (exports.RoleEnum = {}));
+var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum["Active"] = "active";
+    StatusEnum["Archived"] = "archived";
+})(StatusEnum = exports.StatusEnum || (exports.StatusEnum = {}));
+var ProviderEnum;
+(function (ProviderEnum) {
+    ProviderEnum["Email"] = "email";
+})(ProviderEnum = exports.ProviderEnum || (exports.ProviderEnum = {}));

package/domain/index.d.ts

@@ -0,0 +1,10 @@
+export * from './TransactionMessaging';
+export * from './TransactionMessagingStatusUpdate';
+export * from './MessageTemplate';
+export * from './MessageTemplateStatusUpdate';
+export * from './MessageTemplateCategoryUpdate';
+export * from './ChannelWhatsapp';
+export * from './Payment';
+export * from './BalanceMutation';
+export * from './Report';
+export * from './User';

package/domain/index.js

@@ -0,0 +1,26 @@
+"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("./TransactionMessaging"), exports);
+__exportStar(require("./TransactionMessagingStatusUpdate"), exports);
+__exportStar(require("./MessageTemplate"), exports);
+__exportStar(require("./MessageTemplateStatusUpdate"), exports);
+__exportStar(require("./MessageTemplateCategoryUpdate"), exports);
+__exportStar(require("./ChannelWhatsapp"), exports);
+__exportStar(require("./Payment"), exports);
+__exportStar(require("./BalanceMutation"), exports);
+__exportStar(require("./Report"), exports);
+__exportStar(require("./User"), exports);

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+export * from './domain';
+export * from './shared';

package/index.js

@@ -0,0 +1,19 @@
+"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("./core"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./shared"), exports);

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@aptana/multichannel-common",
+  "version": "2.9.12",
+  "license": "MIT",
+  "description": "",
+  "keywords": [
+    "waba"
+  ],
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aptana/multichannel-common.git"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "prebuild": "rimraf dist",
+    "postbuild": "cp package.json readme.md dist"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.10.6",
+    "@grpc/proto-loader": "^0.7.12",
+    "amqp-connection-manager": "^4.1.11",
+    "axios": "^1.7.4",
+    "axios-curlirize": "1.3.7",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "express-async-errors": "^3.1.1",
+    "helmet": "^7.0.0",
+    "ioredis": "^5.4.1",
+    "lodash": "^4.17.21",
+    "mongoose": "^7.0.0",
+    "morgan": "^1.10.0",
+    "morgan-json": "^1.1.0",
+    "protobufjs": "^7.2.6",
+    "sequelize": "^6.37.3",
+    "typedi": "^0.10.0",
+    "winston": "^3.8.2"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.1",
+    "@types/axios-curlirize": "^1.3.2",
+    "@types/compression": "^1.7.2",
+    "@types/cors": "^2.8.13",
+    "@types/express": "^4.17.17",
+    "@types/lodash": "^4.17.6",
+    "@types/morgan": "^1.9.4",
+    "@types/morgan-json": "^1.1.3",
+    "@types/node": "^18.13.1",
+    "npm": "^9.8.1",
+    "rimraf": "^4.1.2",
+    "tsc-alias": "^1.8.7",
+    "typescript": "^4.9.5"
+  }
+}

package/readme.md

@@ -0,0 +1,4 @@
+![GitHub release](https://img.shields.io/github/v/release/amirmarmul/waba-common?style=flat-square)
+
+## About
+[NPM Package](https://npmjs.com) from Aptana Citra Solusindo

package/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../shared/plugins/axios';
+export * from '../shared/plugins/axios-logger-mongo';
+export * from '../shared/plugins/mongoose';
+export * from '../shared/plugins/cursor';
+export * from '../shared/resources/JsonResource';

package/shared/index.js

@@ -0,0 +1,21 @@
+"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("../shared/plugins/axios"), exports);
+__exportStar(require("../shared/plugins/axios-logger-mongo"), exports);
+__exportStar(require("../shared/plugins/mongoose"), exports);
+__exportStar(require("../shared/plugins/cursor"), exports);
+__exportStar(require("../shared/resources/JsonResource"), exports);

package/shared/plugins/axios-logger-mongo.d.ts

@@ -0,0 +1,5 @@
+import { AxiosInstance } from 'axios';
+export declare function useMongoLogger(axios: AxiosInstance, { mongoURL, collectionName }: {
+    mongoURL: string;
+    collectionName?: string;
+}): void;

package/shared/plugins/axios-logger-mongo.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMongoLogger = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const querystring_1 = __importDefault(require("querystring"));
+const lodash_1 = __importDefault(require("lodash"));
+const NAMESPACE = 'axios-logger-mongo';
+const logRequest = (logModel) => (axiosConfig) => {
+    axiosConfig[NAMESPACE] = Object.assign({
+        requestTimestamp: Date.now()
+    }, axiosConfig);
+    return axiosConfig;
+};
+function createRequestObject({ axiosConfig, axiosRequest }) {
+    const url = new URL(axiosConfig.url);
+    const requestHeaders = {
+        host: url.host,
+        ...lodash_1.default.mapKeys(axiosConfig.headers, (val, key) => key.toLowerCase()),
+    };
+    let requestBody;
+    if (requestHeaders['content-type'] &&
+        requestHeaders['content-type'].startsWith('application/json')) {
+        try {
+            requestBody = JSON.parse(axiosConfig.data);
+        }
+        catch (err) {
+            requestBody = requestBody || null;
+        }
+    }
+    else {
+        requestBody = axiosConfig.data || null;
+    }
+    return {
+        method: axiosRequest.method || axiosConfig.method.toUpperCase(),
+        path: axiosRequest.path || url.pathname,
+        headers: requestHeaders,
+        query: {
+            ...querystring_1.default.parse(url.search.replace('?', '')),
+            ...axiosConfig.params,
+        },
+        body: requestBody,
+    };
+}
+function createResponseObject({ axiosResponse }) {
+    let body = axiosResponse.data || null;
+    return {
+        status: axiosResponse.status,
+        statusText: axiosResponse.statusText,
+        headers: axiosResponse.headers,
+        body,
+    };
+}
+const logResponse = (logModel) => (axiosResponse) => {
+    const axiosConfig = axiosResponse.config;
+    const axiosRequest = axiosResponse.request;
+    const { requestTimestamp } = axiosConfig[NAMESPACE];
+    const responseTimestamp = Date.now();
+    const request = createRequestObject({
+        axiosConfig,
+        axiosRequest
+    });
+    const response = createResponseObject({
+        axiosResponse
+    });
+    logModel.create({
+        request,
+        response,
+        error: null,
+        requestTimestamp,
+        responseTimestamp,
+        duration: responseTimestamp - requestTimestamp
+    });
+    return axiosResponse;
+};
+const logError = (logModel) => (axiosError) => {
+    const axiosConfig = axiosError.config;
+    const axiosRequest = axiosError.request;
+    const { requestTimestamp } = axiosConfig[NAMESPACE];
+    const responseTimestamp = Date.now();
+    const request = createRequestObject({
+        axiosConfig,
+        axiosRequest,
+    });
+    const response = null;
+    const error = axiosError.message;
+    logModel.create({
+        request,
+        response,
+        error,
+        requestTimestamp,
+        responseTimestamp,
+        duration: responseTimestamp - requestTimestamp,
+    });
+    return Promise.reject(axiosError);
+};
+function useMongoLogger(axios, { mongoURL, collectionName }) {
+    mongoose_1.default.connect(mongoURL);
+    const logSchema = new mongoose_1.default.Schema({
+        request: mongoose_1.default.Schema.Types.Mixed,
+        response: mongoose_1.default.Schema.Types.Mixed,
+        error: mongoose_1.default.Schema.Types.Mixed,
+        requestTimestamp: mongoose_1.default.Schema.Types.Mixed,
+        responseTimestamp: mongoose_1.default.Schema.Types.Mixed,
+        duration: mongoose_1.default.Schema.Types.Mixed,
+    }, { timestamps: true });
+    const logModel = mongoose_1.default.model('AxiosLog', logSchema, collectionName);
+    axios.interceptors.request.use(logRequest(logModel));
+    axios.interceptors.response.use(logResponse(logModel), logError(logModel));
+}
+exports.useMongoLogger = useMongoLogger;

package/shared/plugins/axios.d.ts

@@ -0,0 +1 @@
+export declare const axios: import("axios").AxiosInstance;

package/shared/plugins/axios.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.axios = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_curlirize_1 = __importDefault(require("axios-curlirize"));
+exports.axios = axios_1.default.create({
+    headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+    }
+});
+exports.axios.interceptors.request.use(function (config) {
+    // Do something before request is sent
+    return config;
+}, function (error) {
+    // Do something with request error
+    return Promise.reject(error);
+});
+exports.axios.interceptors.response.use(function (response) {
+    // Any status code that lie within the range of 2xx cause this function to trigger
+    // Do something with response data
+    return response.data;
+}, function (error) {
+    // Any status codes that falls outside the range of 2xx cause this function to trigger
+    // Do something with response error
+    return Promise.reject(error);
+});
+(0, axios_curlirize_1.default)(exports.axios);

package/shared/plugins/cursor.d.ts

@@ -0,0 +1,29 @@
+import { Schema, Model } from 'mongoose';
+export declare class CursorPaginationModel<T> {
+    meta: {
+        cursors?: {
+            next?: string | undefined;
+            previous?: string | undefined;
+        };
+        limit: number;
+    };
+    docs: T[];
+}
+export interface CursorPaginationOptions {
+    query?: any;
+    aggregate?: any;
+    populate?: any;
+    select?: any;
+    search?: {
+        value: string | undefined;
+        fields: string[] | undefined;
+    };
+    sort?: any;
+    projection?: any;
+    cursor?: string;
+    limit?: string;
+}
+export interface CursorPagination<T> extends Model<T> {
+    cursor(options?: CursorPaginationOptions, onError?: Function): Promise<CursorPaginationModel<T> | undefined>;
+}
+export declare function mongooseCursorPaginate<T>(schema: Schema<T>): void;

package/shared/plugins/cursor.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongooseCursorPaginate = exports.CursorPaginationModel = void 0;
+const core_1 = require("../../core");
+const moment_1 = __importDefault(require("moment"));
+const mongoose_1 = __importDefault(require("mongoose"));
+class CursorPaginationModel {
+    meta = { limit: 0 };
+    docs = [];
+}
+exports.CursorPaginationModel = CursorPaginationModel;
+function mongooseCursorPaginate(schema) {
+    schema.statics.cursor = async function cursor(options, onError) {
+        let baseQuery = options?.query ? { ...options.query } : {};
+        let limit = parseInt(options?.limit ?? '10');
+        let fetchLimit = limit + 1;
+        let direction = 'next';
+        let sort = options?.sort ||
+            (options?.aggregate?.find((agg) => agg.$sort) || {}).$sort ||
+            { _id: -1 };
+        if (options?.cursor) {
+            try {
+                const decodedStr = core_1.Crypto.decrypt(options.cursor);
+                const decoded = JSON.parse(decodedStr);
+                core_1.logger.debug({ decoded });
+                direction = decoded.direction;
+                const sortQuery = decoded.query?.sort || {};
+                delete decoded.query?.sort;
+                for (const key of Object.keys(sort)) {
+                    let value = sortQuery[key];
+                    if (key.endsWith('At') && typeof value === 'string') {
+                        value = (0, moment_1.default)(value).toDate();
+                    }
+                    if (value !== undefined) {
+                        const operator = direction === 'next'
+                            ? (sort[key] === 1 ? '$gte' : '$lte')
+                            : (sort[key] === 1 ? '$lte' : '$gte');
+                        baseQuery.$or = [
+                            { [key]: { [operator]: value } },
+                            { [key]: { $exists: false } },
+                            { [key]: null }
+                        ];
+                        if (decoded.query?.[key]) {
+                            baseQuery.$or = baseQuery.$or.map((condition) => ({
+                                ...condition,
+                                ...decoded.query[key]
+                            }));
+                        }
+                    }
+                }
+                core_1.logger.debug({ baseQueryBeforeMerge: baseQuery, decodedQuery: decoded.query });
+                // Deep merge decoded.query ke baseQuery dengan handling khusus untuk aggregation
+                for (const key in decoded.query) {
+                    if (key === '_id') {
+                        // Merge _id conditions secara khusus
+                        baseQuery._id = baseQuery._id
+                            ? { ...baseQuery._id, ...decoded.query._id }
+                            : decoded.query._id;
+                    }
+                    else if (key !== 'sort') {
+                        // Skip $or karena sudah dibuat di loop sebelumnya
+                        // Untuk field lain, merge langsung
+                        if (key !== '$or') {
+                            baseQuery[key] = decoded.query[key];
+                        }
+                    }
+                }
+                core_1.logger.debug({ baseQueryAfterMerge: baseQuery });
+            }
+            catch (e) {
+                if (onError)
+                    onError(e);
+                core_1.logger.debug({ e, stack: e.stack });
+                return undefined;
+            }
+        }
+        if (baseQuery && baseQuery._id) {
+            ['gte', 'lte', 'ne'].forEach(op => {
+                if (baseQuery._id[`$${op}`] && typeof baseQuery._id[`$${op}`] === 'string') {
+                    baseQuery._id[`$${op}`] = new mongoose_1.default.Types.ObjectId(baseQuery._id[`$${op}`]);
+                }
+            });
+        }
+        let effectiveQuery = { ...baseQuery };
+        if (options?.search &&
+            options.search.value &&
+            options.search.fields &&
+            options.search.fields.length) {
+            const searchQuery = {
+                $regex: options.search.value,
+                $options: 'i',
+            };
+            if (options.search.fields.length === 1) {
+                effectiveQuery[options.search.fields[0]] = searchQuery;
+            }
+            else {
+                effectiveQuery.$or = options.search.fields.map(field => ({ [field]: searchQuery }));
+            }
+        }
+        if (direction === 'previous') {
+            sort = Object.fromEntries(Object.entries(sort).map(([key, value]) => [key, -value]));
+        }
+        else {
+            sort = Object.fromEntries(Object.entries(sort).map(([key, value]) => [key, parseInt(value)]));
+        }
+        const projection = options?.projection ?? {};
+        const populate = options?.populate;
+        core_1.logger.debug({ effectiveQuery });
+        let mQuery;
+        if (options?.aggregate) {
+            const aggregatePipeline = [...options.aggregate];
+            const matchIndex = aggregatePipeline.findIndex(stage => stage.$match);
+            if (matchIndex !== -1) {
+                aggregatePipeline[matchIndex].$match = {
+                    ...aggregatePipeline[matchIndex].$match,
+                    ...effectiveQuery
+                };
+            }
+            else if (Object.keys(effectiveQuery).length > 0) {
+                aggregatePipeline.unshift({ $match: effectiveQuery });
+            }
+            const sortIndex = aggregatePipeline.findIndex(stage => stage.$sort);
+            if (sortIndex !== -1) {
+                aggregatePipeline[sortIndex].$sort = sort;
+            }
+            else {
+                aggregatePipeline.unshift({ $sort: sort });
+            }
+            const limitIndex = aggregatePipeline.findIndex(stage => stage.$limit);
+            if (limitIndex !== -1) {
+                aggregatePipeline[limitIndex].$limit = fetchLimit;
+            }
+            else {
+                aggregatePipeline.unshift({ $limit: fetchLimit });
+            }
+            core_1.logger.debug({ aggregatePipeline });
+            mQuery = this.aggregate(aggregatePipeline);
+            if (options.select) {
+                mQuery = mQuery.project(options.select);
+            }
+        }
+        else {
+            mQuery = this.find(effectiveQuery, projection);
+            if (options?.select) {
+                mQuery = mQuery.select(options.select);
+            }
+            if (populate) {
+                mQuery = mQuery.populate(populate);
+            }
+            mQuery = mQuery.sort(sort).limit(fetchLimit);
+        }
+        try {
+            let docs = await mQuery.exec();
+            let hasMore = docs.length > fetchLimit - 1;
+            if (direction === 'next') {
+                if (hasMore) {
+                    docs.pop();
+                }
+            }
+            else if (direction === 'previous') {
+                if (hasMore) {
+                    docs.pop();
+                }
+                docs = docs.reverse();
+            }
+            const sortKeys = Object.keys(sort);
+            let newCursorNext = undefined;
+            let newCursorPrevious = undefined;
+            if (docs.length > 0) {
+                const lastDoc = docs[docs.length - 1];
+                const firstDoc = docs[0];
+                const buildSortValues = (doc) => {
+                    return sortKeys.reduce((acc, key) => {
+                        acc[key] = doc[key];
+                        return acc;
+                    }, {});
+                };
+                if ((direction === 'next' && hasMore) || direction === 'previous') {
+                    newCursorNext = core_1.Crypto.encrypt(JSON.stringify({
+                        query: {
+                            _id: { $ne: lastDoc._id },
+                            sort: buildSortValues(lastDoc)
+                        },
+                        direction: 'next'
+                    }));
+                }
+                if (options?.cursor) {
+                    if (direction === 'next' || (direction === 'previous' && hasMore)) {
+                        newCursorPrevious = core_1.Crypto.encrypt(JSON.stringify({
+                            query: {
+                                _id: { $ne: firstDoc._id },
+                                sort: buildSortValues(firstDoc)
+                            },
+                            direction: 'previous'
+                        }));
+                    }
+                }
+            }
+            let cursors = { next: newCursorNext, previous: newCursorPrevious };
+            if (!newCursorNext && !newCursorPrevious) {
+                cursors = undefined;
+            }
+            const result = new CursorPaginationModel();
+            result.meta = {
+                limit,
+                cursors
+            };
+            result.docs = docs;
+            return result;
+        }
+        catch (error) {
+            if (onError)
+                onError(error);
+            core_1.logger.debug({ error, stack: error.stack });
+            return undefined;
+        }
+    };
+    const toJSONOptions = {
+        virtuals: true,
+        transform: function (doc, ret) {
+            ret.id = ret._id;
+            delete ret.__v;
+        }
+    };
+    schema.set('toJSON', toJSONOptions);
+    schema.set('toObject', toJSONOptions);
+}
+exports.mongooseCursorPaginate = mongooseCursorPaginate;