@internetderdinge/api 1.229.0 → 1.229.1

package/dist/src/middlewares/checkJwt.cjs

@@ -0,0 +1,17 @@
+"use strict";
+const jwt = require('express-jwt');
+const jwtAuthz = require('express-jwt-authz');
+const jwksRsa = require('jwks-rsa');
+const checkJwt = jwt({
+    secret: jwksRsa.expressJwtSecret({
+        cache: true,
+        rateLimit: true,
+        jwksRequestsPerMinute: 5,
+        jwksUri: `https://${process.env.AUTH0_DOMAIN}/.well-known/jwks.json`,
+    }),
+    // Validate the audience and the issuer.
+    audience: process.env.AUTH0_AUDIENCE,
+    issuer: `https://${process.env.AUTH0_DOMAIN}/`,
+    algorithms: ['RS256'],
+});
+module.exports = checkJwt;

package/dist/src/middlewares/error.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import mongoose from "mongoose";
+import httpStatus from "http-status";
+import config from "../config/config";
+import logger from "../config/logger";
+import ApiError from "../utils/ApiError";
+export const errorConverter = (err, req, res, next) => {
+    let error = err;
+    if (!(error instanceof ApiError)) {
+        const statusCode = error.statusCode ||
+            (error instanceof mongoose.Error
+                ? httpStatus.BAD_REQUEST
+                : httpStatus.INTERNAL_SERVER_ERROR);
+        const message = error.message || httpStatus[statusCode];
+        error = new ApiError(statusCode, message, false, err.stack);
+    }
+    next(error);
+};
+// eslint-disable-next-line no-unused-vars
+export const errorHandler = (err, req, res, next) => {
+    let { statusCode, message } = err;
+    if (config.env === "production" && !err.isOperational) {
+        statusCode = httpStatus.INTERNAL_SERVER_ERROR;
+        message = httpStatus[httpStatus.INTERNAL_SERVER_ERROR];
+    }
+    res.locals.errorMessage = err.message;
+    const response = {
+        code: statusCode,
+        message,
+        ...(config.env === "development" && { stack: err.stack }),
+    };
+    if (config.env === "development") {
+        logger.error(err);
+    }
+    res.status(statusCode).send({ ...response, raw: err.raw || null });
+};

package/dist/src/middlewares/mongooseValidations/ensureSameOrganization.js

@@ -0,0 +1,13 @@
+// @ts-nocheck
+/**
+ * Throws if patient doesn’t exist or isn’t in the given org.
+ */
+export async function ensureSameOrganization(patientId, organizationId, UserModel) {
+    // console.log('ensureSameOrganization', patientId, organizationId);
+    const user = await UserModel.findById(patientId).select("organization");
+    if (!user)
+        throw new Error("Patient not found");
+    if (!user.organization.equals(organizationId)) {
+        throw new Error("Patient must belong to the same organization");
+    }
+}

package/dist/src/middlewares/rateLimiter.js

@@ -0,0 +1,7 @@
+import rateLimit from 'express-rate-limit';
+const authLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    max: 20,
+    skipSuccessfulRequests: true,
+});
+export { authLimiter };

package/dist/src/middlewares/validate.js

@@ -0,0 +1,18 @@
+import Joi from 'joi';
+import httpStatus from 'http-status';
+import pick from '../utils/pick';
+import ApiError from '../utils/ApiError';
+const validate = (schema) => (req, res, next) => {
+    const validSchema = pick(schema, ['params', 'query', 'body']);
+    const object = pick(req, Object.keys(validSchema));
+    const { value, error } = Joi.compile(validSchema)
+        .prefs({ errors: { label: 'key' } })
+        .validate(object);
+    if (error) {
+        const errorMessage = error.details.map((details) => details.message).join(', ');
+        return next(new ApiError(httpStatus.BAD_REQUEST, errorMessage));
+    }
+    Object.assign(req, value);
+    return next();
+};
+export default validate;

package/dist/src/middlewares/validateAction.js

@@ -0,0 +1,35 @@
+import httpStatus from 'http-status';
+import ApiError from '../utils/ApiError';
+import { isAdmin } from './validateAdmin';
+export const validateOrganizationUpdate = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        if (!req.currentUser) {
+            next(new ApiError(httpStatus.INTERNAL_SERVER_ERROR, 'Current user not set in request'));
+            return;
+        }
+        if (req.currentUser.role && req.currentUser.role === 'onlyself') {
+            next(new ApiError(httpStatus.FORBIDDEN, 'User does not have sufficient permissions in the organization to update'));
+            return;
+        }
+        next();
+    }
+};
+export const validateOrganizationDelete = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        if (!req.currentUser) {
+            next(new ApiError(httpStatus.INTERNAL_SERVER_ERROR, 'Current user not set in request'));
+            return;
+        }
+        if (req.currentUser.role && req.currentUser.role === 'onlyself') {
+            next(new ApiError(httpStatus.FORBIDDEN, 'User does not have sufficient permissions in the organization to update'));
+            return;
+        }
+        next();
+    }
+};

package/dist/src/middlewares/validateAdmin.js

@@ -0,0 +1,18 @@
+import httpStatus from 'http-status';
+import ApiError from '../utils/ApiError';
+const isAdmin = (user) => {
+    //return false;
+    if (!user)
+        return false;
+    // return false; // TODO: Remove this line when the user object is properly defined
+    return user['https://memo.wirewire.de/roles'] ? user['https://memo.wirewire.de/roles'].includes('admin') : false;
+};
+const validateAdmin = async (req, res, next) => {
+    if (isAdmin(req.auth)) {
+        next();
+    }
+    else {
+        next(new ApiError(httpStatus.FORBIDDEN, 'User is not part of the admin group (validateAdmin)'));
+    }
+};
+export { isAdmin, validateAdmin };

package/dist/src/middlewares/validateAi.js

@@ -0,0 +1,16 @@
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError"; // keep .cjs import
+// you can adjust the User source if your auth payload differs
+export const isAiRole = (user) => {
+    if (!user)
+        return false;
+    return user["https://memo.wirewire.de/roles"]?.includes("ai") ?? false;
+};
+export const validateAiRole = async (req, res, next) => {
+    // assuming the auth payload is attached to req.auth
+    console.log("Validating AI role for user:", req.auth);
+    if (isAiRole(req.auth)) {
+        return next();
+    }
+    return next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the ai group (validateAi)"));
+};

package/dist/src/middlewares/validateCurrentAuthUser.js

@@ -0,0 +1,17 @@
+import httpStatus from 'http-status';
+import ApiError from '../utils/ApiError';
+const getCurrentAuthUser = async (req, res, next) => {
+    if (res.req.auth.sub !== req.params.notificationId) {
+        next(new ApiError(httpStatus.BAD_REQUEST, 'Not allowed to access'));
+        return;
+    }
+    next();
+};
+export const validateParamsAccount = async (req, res, next) => {
+    if (res.req.auth.sub !== req.params.accountId) {
+        next(new ApiError(httpStatus.BAD_REQUEST, 'Not allowed to access'));
+        return;
+    }
+    next();
+};
+export default getCurrentAuthUser;

package/dist/src/middlewares/validateCurrentUser.js

@@ -0,0 +1,20 @@
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import userService from "../users/users.service";
+const getCurrentUser = async (req, res, next) => {
+    try {
+        // TODO: Check if the user is logged in
+        const currentUser = await userService.getUserByOwner(res.req.auth.sub, req.body.organization);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.BAD_REQUEST, "User does not exist"));
+            return;
+        }
+        req.currentUser = currentUser;
+        next();
+    }
+    catch (error) {
+        console.error("Error validating user service:", error);
+        next(new ApiError(httpStatus.INTERNAL_SERVER_ERROR, "Failed to validate user service"));
+    }
+};
+export default getCurrentUser;

package/dist/src/middlewares/validateDevice.js

@@ -0,0 +1,98 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import devicesService from "../devices/devices.service";
+import { isAdmin } from "./validateAdmin";
+import usersService from "../users/users.service";
+const validateDeviceIsInOrganization = async (req, res, next) => {
+    const deviceId = (req.body?.deviceId ||
+        req.params?.deviceId ||
+        req.query?.deviceId);
+    if (!deviceId) {
+        next();
+        return;
+    }
+    const device = await devicesService.getById(deviceId);
+    if (!device) {
+        next(new ApiError(httpStatus.NOT_FOUND, "Device not found"));
+        return;
+    }
+    if (isAdmin(res.req.auth)) {
+        next();
+        return;
+    }
+    const currentUser = await usersService.getUserByOwner(res.req.auth.sub, device.organization);
+    if (!currentUser) {
+        next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization for this device"));
+        return;
+    }
+    if (req.body?.organization &&
+        req.body.organization.toString() !== device.organization?.toString()) {
+        next(new ApiError(httpStatus.FORBIDDEN, "Device is not part of the provided organization"));
+        return;
+    }
+    req.currentUser = currentUser;
+    next();
+};
+const validateDevice = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        const currentDevice = await devicesService.getById(req.params.deviceId);
+        if (!currentDevice) {
+            next(new ApiError(httpStatus.NOT_FOUND, "Device not found"));
+            return;
+        }
+        const currentUser = await usersService.getUserByOwner(res.req.auth.sub, currentDevice.organization);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization which has access to the device (validateDevice)"));
+            return;
+        }
+        req.currentUser = currentUser;
+        next();
+    }
+};
+const validateDeviceQuery = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        // console.log('Validating device query for user:', res.req.auth.sub, req.query);
+        const currentDevice = await devicesService.getById(req.query.deviceId);
+        if (!currentDevice) {
+            next(new ApiError(httpStatus.NOT_FOUND, "Device not found"));
+            return;
+        }
+        const currentUser = await usersService.getUserByOwner(res.req.auth.sub, currentDevice.organization);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization (validateDeviceOrOrganizationQuery)"));
+            return;
+        }
+        req.currentUser = currentUser;
+        next();
+    }
+};
+const validateDeviceOrOrganizationQuery = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+        return;
+    }
+    const deviceId = req.query.deviceId;
+    const organizationId = req.query.organization;
+    if (deviceId) {
+        return validateDeviceQuery(req, res, next);
+    }
+    if (organizationId) {
+        const currentUser = await usersService.getUserByOwner(res.req.auth.sub, organizationId);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization which has access to the device (validateDeviceQuery)"));
+            return;
+        }
+        req.currentUser = currentUser;
+        next();
+        return;
+    }
+    next(new ApiError(httpStatus.BAD_REQUEST, "deviceId or organization is required"));
+};
+export { validateDevice, validateDeviceQuery, validateDeviceOrOrganizationQuery, validateDeviceIsInOrganization, };

package/dist/src/middlewares/validateDeviceUserOrganization.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import devicesService from "../devices/devices.service";
+import { isAdmin } from "./validateAdmin";
+import userService from "../users/users.service";
+export const validateDeviceUserOrganization = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+        return;
+    }
+    if (req.body.patient) {
+        const currentDevice = await devicesService.getById(req.params.deviceId);
+        if (!currentDevice) {
+            next(new ApiError(httpStatus.FORBIDDEN, "Device was not found (validateDeviceUserOrganization)"));
+            return;
+        }
+        const currentUser = await userService.getUsersByOrganizationAndId(currentDevice.organization, req.body.patient);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization which has access to the device (validateDeviceUserOrganization)"));
+            return;
+        }
+        req.currentUser = currentUser;
+    }
+    next();
+};

package/dist/src/middlewares/validateOrganization.js

@@ -0,0 +1,63 @@
+import userService from "../users/users.service";
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import { isAdmin } from "./validateAdmin";
+export const validateUser = async (req, res, next) => {
+    next();
+};
+export const validateOrganization = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        const currentUser = await userService.getUserByOwner(res.req.auth.sub, req.params.organizationId);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization (validateOrganization)"));
+            return;
+        }
+        /* if (currentUser.role && currentUser.role === 'onlyself') {
+          next(new ApiError(httpStatus.FORBIDDEN, 'User does not have sufficient permissions in the organization'));
+          return;
+        } */
+        req.currentUser = currentUser;
+        next();
+    }
+};
+export const validateQueryOrganization = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        const currentUser = await userService.getUserByOwner(res.req.auth.sub, req.query.organization);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization (validateQueryOrganization)"));
+            return;
+        }
+        /* if (currentUser.role && currentUser.role === 'onlyself') {
+          next(new ApiError(httpStatus.FORBIDDEN, 'User does not have sufficient permissions in the organization'));
+          return;
+        } */
+        req.currentUser = currentUser;
+        next();
+    }
+};
+export const validateBodyOrganization = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        const currentUser = await userService.getUserByOwner(res.req.auth.sub, req.body.organization);
+        if (!currentUser) {
+            next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization (validateBodyOrganization)"));
+            return;
+        }
+        req.currentUser = currentUser;
+        next();
+    }
+};
+export default {
+    validateOrganization,
+    validateQueryOrganization,
+    validateBodyOrganization,
+    validateUser,
+};

package/dist/src/middlewares/validateQuerySearchUserAndOrganization.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import { isAdmin } from "./validateAdmin";
+import userService from "../users/users.service";
+const validateQuerySearchUserAndOrganization = async (req, res, next) => {
+    if (isAdmin(res.req.auth)) {
+        next();
+    }
+    else {
+        console.log("validateQuerySearchUserAndOrganization", req.query);
+        if (req.query.organization) {
+            const currentUser = await userService.getUserByOwner(res.req.auth.sub, req.query.organization);
+            if (!currentUser) {
+                next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization (validateQuerySearchUserAndOrganization)"));
+                return;
+            }
+            /* if (currentUser.role && currentUser.role === 'onlyself') {
+              next(new ApiError(httpStatus.FORBIDDEN, 'User does not have sufficient permissions in the organization'));
+              return;
+            } */
+            req.currentUser = currentUser;
+            next();
+        }
+        else if (req.query.patient) {
+            const activeUser = await userService.getById(req.query.patient);
+            if (!activeUser) {
+                next(new ApiError(httpStatus.FORBIDDEN, "User not found (validateQuerySearchUserAndOrganization)"));
+                return;
+            }
+            const currentUser = await userService.getUserByOwner(res.req.auth.sub, activeUser.organization);
+            if (!currentUser) {
+                next(new ApiError(httpStatus.FORBIDDEN, "User is not part of the organization which has access to the device (validateDevice)"));
+                return;
+            }
+            req.currentUser = currentUser;
+            next();
+        }
+        else {
+            next(new ApiError(httpStatus.FORBIDDEN, "No filter defined (validateQuerySearchUserAndOrganization)"));
+        }
+    }
+};
+export { validateQuerySearchUserAndOrganization };

package/dist/src/middlewares/validateTokens.js

@@ -0,0 +1,23 @@
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import { getTokenById } from "../tokens/tokens.service";
+export async function validateParamsToken(req, res, next) {
+    // assume tokenId comes from req.params
+    const tokenId = req.params.tokenId;
+    if (!tokenId) {
+        return next(new ApiError(httpStatus.BAD_REQUEST, "Token ID is required"));
+    }
+    // fetch your token entity
+    const token = await getTokenById(tokenId);
+    if (!token) {
+        return next(new ApiError(httpStatus.NOT_FOUND, "Token not found"));
+    }
+    // compare owner vs. authenticated sub
+    const tokenOwner = token.owner;
+    if (!tokenOwner || tokenOwner !== res.req.auth?.sub) {
+        return next(new ApiError(httpStatus.FORBIDDEN, "You are not allowed to access this token"));
+    }
+    // attach for downstream handlers and continue
+    req.token = token;
+    next();
+}

package/dist/src/middlewares/validateUser.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+import usersService from "../users/users.service";
+import { isAdmin } from "./validateAdmin";
+// extend makeValidateUser to accept an optional key (defaulting to 'patient')
+const makeValidateUser = (source, key = "patient") => async (req, res, next) => {
+    const context = `validate${source.charAt(0).toUpperCase() + source.slice(1)}User`;
+    if (isAdmin(res.req.auth)) {
+        return next();
+    }
+    // pull the configured key instead of hard‐coded 'patient'
+    const id = req[source][key];
+    if (!id) {
+        return next(new ApiError(httpStatus.FORBIDDEN, `No user (${context})`));
+    }
+    const patient = await usersService.getById(id);
+    if (!patient) {
+        return next(new ApiError(httpStatus.FORBIDDEN, `User was with id ${id} not found (${context})`));
+    }
+    const currentUser = await usersService.getUserByOwner(res.req.auth.sub, patient.organization);
+    if (!currentUser) {
+        return next(new ApiError(httpStatus.FORBIDDEN, `Current user is not part of the organization as the requested user (${context})`));
+    }
+    req.currentUser = currentUser;
+    next();
+};
+// query and body still use the default 'patient' key
+export function validateQueryUser(req, res, next) {
+    return makeValidateUser("query")(req, res, next);
+}
+export function validateBodyUser(req, res, next) {
+    return makeValidateUser("body")(req, res, next);
+}
+// params now pulls from req.params.userId
+export function validateParamsUser(req, res, next) {
+    return makeValidateUser("params", "userId")(req, res, next);
+}

package/dist/src/middlewares/validateZod.js

@@ -0,0 +1,33 @@
+import ApiError from '../utils/ApiError';
+import httpStatus from 'http-status';
+import z from 'zod';
+export const validateZod = (schema) => (req, res, next) => {
+    try {
+        schema.body || (schema.body = z.object({}));
+        schema.query || (schema.query = z.object({}));
+        schema.params || (schema.params = z.object({}));
+        // 1) run safeParse on each
+        const result = {
+            body: schema.body.strict().safeParse(req.body || {}),
+            query: schema.query.strict().safeParse(req.query),
+            params: schema.params.strict().safeParse(req.params),
+        };
+        // 2) if any failure, short-circuit
+        if (!result.body.success || !result.query.success || !result.params.success) {
+            if (process.env.NODE_ENV === 'development') {
+                return res.status(400).send(result);
+            }
+            return next(new ApiError(httpStatus.BAD_REQUEST, 'Validation error'));
+        }
+        // 3) merge parsed data back in
+        req.body = result.body.data;
+        Object.assign(req.query, result.query.data);
+        Object.assign(req.params, result.params.data);
+        return next();
+    }
+    catch (err) {
+        console.error('Zod validation error:', err);
+        return next(new ApiError(httpStatus.BAD_REQUEST, 'Validation error', undefined, undefined, process.env.NODE_ENV === 'development' ? err : undefined));
+    }
+};
+export default validateZod;

package/dist/src/models/plugins/index.js

@@ -0,0 +1,4 @@
+// import type { PaginateNewPlugin } from './paginateNew.plugin';
+export { default as toJSON } from "./toJSON.plugin";
+export { default as paginate } from "./paginate.plugin";
+// export { default as paginateNew } from './paginateNew.plugin';

package/dist/src/models/plugins/paginate.plugin.js

@@ -0,0 +1,117 @@
+// @ts-nocheck
+/* eslint-disable no-param-reassign */
+import { Types } from "mongoose";
+function paginate(schema) {
+    schema.statics.paginate = async function (filter, options = {}, plugin) {
+        let sort = "";
+        if (options.sortBy) {
+            const sortingCriteria = [];
+            options.sortBy.split(",").forEach((sortOption) => {
+                const [key, order] = sortOption.split(":");
+                sortingCriteria.push((order === "desc" ? "-" : "") + key);
+            });
+            sort = sortingCriteria.join(" ");
+        }
+        else {
+            sort = "createdAt";
+        }
+        const limit = options.limit && parseInt(String(options.limit), 10) > 0
+            ? parseInt(String(options.limit), 10)
+            : 10000;
+        const page = options.page && parseInt(String(options.page), 10) > 0
+            ? parseInt(String(options.page), 10)
+            : 1;
+        const skip = (page - 1) * limit;
+        let results = [];
+        let totalResults = 0;
+        let totalPages = 0;
+        if (options.fuzzySearch && options.fuzzySearch.search) {
+            // Fuzzy search branch
+            const fuzzyFields = options.fuzzySearch.fields;
+            const mustClauses = Object.entries(filter).map(([key, value]) => {
+                if (typeof value === "string" && value.match(/^[a-fA-F0-9]{24}$/)) {
+                    return { equals: { path: key, value: new Types.ObjectId(value) } };
+                }
+                return { equals: { path: key, value } };
+            });
+            const pipeline = [
+                {
+                    $search: {
+                        index: options.fuzzySearch.index,
+                        compound: {
+                            must: mustClauses,
+                            should: [
+                                {
+                                    text: {
+                                        query: options.fuzzySearch.search,
+                                        path: fuzzyFields,
+                                        fuzzy: {},
+                                    },
+                                },
+                            ],
+                            minimumShouldMatch: 1,
+                        },
+                    },
+                },
+                { $sort: { createdAt: -1 } },
+                { $skip: skip },
+                { $limit: limit },
+                {
+                    $facet: {
+                        results: [],
+                        totalCount: [{ $count: "count" }],
+                    },
+                },
+            ];
+            const aggResult = await this.aggregate(pipeline).exec();
+            results = (aggResult[0]?.results || []).map((doc) => new this(doc));
+            totalResults = aggResult[0]?.totalCount[0]?.count || 0;
+            totalPages = Math.ceil(totalResults / limit);
+        }
+        else {
+            // Regular find branch
+            const countPromise = this.countDocuments(filter).exec();
+            let docsPromise = this.find(filter)
+                .sort(sort)
+                .skip(skip)
+                .limit(limit);
+            if (options.populate) {
+                options.populate.split(",").forEach((populateOption) => {
+                    docsPromise = docsPromise.populate(populateOption
+                        .split(".")
+                        .reverse()
+                        .reduce((a, b) => ({ path: b, populate: a })));
+                });
+            }
+            if (plugin)
+                docsPromise = plugin(docsPromise);
+            docsPromise = docsPromise.exec();
+            const values = await Promise.all([countPromise, docsPromise]);
+            totalResults = values[0];
+            results = values[1];
+            totalPages = Math.ceil(totalResults / limit);
+        }
+        // Populate and plugin for both branches (if not already applied)
+        if (options.fuzzySearch && options.fuzzySearch.search) {
+            if (options.populate) {
+                results = await this.populate(results, options.populate.split(",").map((populateOption) => populateOption
+                    .split(".")
+                    .reverse()
+                    .reduce((a, b) => ({ path: b, populate: a }))));
+            }
+            if (plugin) {
+                // plugin expects a Query, so wrap results in a Query if needed
+                // Not possible for array, so skip plugin for fuzzySearch unless you have a custom handler
+            }
+        }
+        const result = {
+            results,
+            page,
+            limit,
+            totalPages,
+            totalResults,
+        };
+        return Promise.resolve(result);
+    };
+}
+export default paginate;