speedly 2.0.38 → 2.0.42

package/dist/esm/db/db.js

@@ -1,594 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-let __path = "./models/";
-const path_1 = __importDefault(require("path"));
-const strToObj_1 = __importDefault(require("../util/strToObj"));
-const getConfig_1 = __importDefault(require("../util/getConfig"));
-const translator_1 = __importDefault(require("../util/translator"));
-const utils_1 = require("./utils");
-let configs = {
-    dbType: "mongodb",
-    path: "../models",
-    type: "external",
-    dbEnv: "DB_URL",
-    ...(0, getConfig_1.default)("db"),
-};
-const usingMongoDb = (collectionName, config = { type: "external" }) => {
-    let model;
-    let queryState = {
-        queries: [],
-    };
-    if (config?.path)
-        __path = config.path;
-    model = require(path_1.default.join(...(config.type == "external"
-        ? [require.main?.filename || "./", __path]
-        : ["../model"]), collectionName));
-    if (model.default)
-        model = model.default;
-    const actionHandler = {
-        find: (match = {}) => {
-            queryState.action = "find";
-            queryState.match = match;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        create: (body = {}) => {
-            queryState.action = "create";
-            queryState.body = body;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        updateOne: (match = {}, body = {}) => {
-            queryState.action = "updateOne";
-            queryState.match = match;
-            queryState.body = body;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        updateMany: (match = {}, body = {}) => {
-            queryState.action = "updateMany";
-            queryState.match = match;
-            queryState.body = body;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        deleteOne: (match = {}) => {
-            queryState.action = "deleteOne";
-            queryState.match = match;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        deleteMany: (match = {}) => {
-            queryState.action = "deleteMany";
-            queryState.match = match;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        findOne: (match = {}) => {
-            queryState.action = "findOne";
-            queryState.match = match;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        findOneAndUpdate: (match = {}, body = {}) => {
-            queryState.action = "findOneAndUpdate";
-            queryState.match = match;
-            queryState.body = body;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        aggregate: (pipeline = []) => {
-            queryState.action = "aggregate";
-            queryState.pipeline = pipeline;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        findOneAndDelete: (match = {}) => {
-            queryState.action = "findOneAndDelete";
-            queryState.match = match;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        findById: (id = "") => {
-            queryState.action = "findById";
-            queryState.id = id;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        findByIdAndUpdate: (id = "", body = {}) => {
-            queryState.action = "findByIdAndUpdate";
-            queryState.id = id;
-            queryState.body = body;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-        findByIdAndDelete: (id = "") => {
-            queryState.action = "findByIdAndDelete";
-            queryState.id = id;
-            Object.defineProperty(handler, "name", {
-                value: `model:${queryState.action}:${collectionName}`,
-            });
-            return handler;
-        },
-    };
-    /**
-     * Handles database operations for the specified model based on the action and query parameters.
-     * @param {object} req - Express request object containing query and body data.
-     * @param {object} res - Express response object used to send responses.
-     * @param {function} next - Express next middleware function for error handling.
-     */
-    const handler = async (req, res, next) => {
-        let data = undefined, detail = {};
-        let match = {};
-        let realTimeQueries = [...queryState.queries];
-        const { sort, limit, page, select } = req.query;
-        if (req.query.search) {
-            const searchStr = Array.isArray(req.query.search)
-                ? req.query.search[0]
-                : req.query.search;
-            if (typeof searchStr === "string") {
-                const splittedSearch = searchStr.trim().split(/\s|‌/g);
-                const searchValue = splittedSearch
-                    .map((word) => `(?=.*${word.split("").join("\\s?")})`)
-                    .join("");
-                match.$or = [
-                    { name: { $regex: searchValue } },
-                    { title: { $regex: searchValue } },
-                    { subTitle: { $regex: searchValue } },
-                ];
-            }
-        }
-        if (req.query.filters) {
-            const filtersStr = Array.isArray(req.query.filters)
-                ? req.query.filters[0]
-                : req.query.filters;
-            if (typeof filtersStr === "string") {
-                match = { ...match, ...JSON.parse(filtersStr) };
-            }
-        }
-        if (typeof queryState.match == "function")
-            match = { ...match, ...queryState.match(req) };
-        if (typeof queryState.match == "object")
-            match = { ...match, ...queryState.match };
-        {
-            if (req.query.sort && queryState.action !== "aggregate") {
-                const sortQueryIndex = realTimeQueries.findIndex((q) => "type" in q && q.type == "sort");
-                const sortStr = Array.isArray(req.query.sort)
-                    ? req.query.sort[0]
-                    : req.query.sort;
-                const sortObject = typeof sortStr === "string" ? (0, strToObj_1.default)(sortStr) : {};
-                if (sortQueryIndex == -1)
-                    realTimeQueries.push({
-                        type: "sort",
-                        value: (typeof sortStr === "string" ? sortStr : "") + " _id",
-                    });
-                else
-                    realTimeQueries.splice(sortQueryIndex, 1, {
-                        type: "sort",
-                        value: {
-                            ...(realTimeQueries[sortQueryIndex] &&
-                                "value" in realTimeQueries[sortQueryIndex] &&
-                                typeof realTimeQueries[sortQueryIndex].value === "object" &&
-                                realTimeQueries[sortQueryIndex].value !== null
-                                ? realTimeQueries[sortQueryIndex].value
-                                : {}),
-                            ...sortObject,
-                            _id: 1,
-                        },
-                    });
-            }
-            if (req.query.page && queryState.action !== "aggregate") {
-                const pageStr = Array.isArray(req.query.page)
-                    ? req.query.page[0]
-                    : typeof req.query.page === "string"
-                        ? req.query.page
-                        : "";
-                const limitStr = Array.isArray(req.query.limit)
-                    ? req.query.limit[0]
-                    : typeof req.query.limit === "string"
-                        ? req.query.limit
-                        : "";
-                const pageNum = parseInt(typeof pageStr === "string" ? pageStr : "") || 1;
-                const limitNum = parseInt(typeof limitStr === "string" ? limitStr : "") ||
-                    configs?.pagination?.quantity ||
-                    20;
-                if (realTimeQueries.findIndex((q) => "type" in q && q.type == "skip") ==
-                    -1)
-                    realTimeQueries.push({
-                        type: "skip",
-                        value: (pageNum - 1) * limitNum,
-                    });
-                if (realTimeQueries.findIndex((q) => "type" in q && q.type == "limit") ==
-                    -1)
-                    realTimeQueries.push({
-                        type: "limit",
-                        value: limitNum,
-                    });
-            }
-            else if (req.query.limit && queryState.action !== "aggregate") {
-                const pageStrAgg = Array.isArray(req.query.page)
-                    ? req.query.page[0]
-                    : typeof req.query.page === "string"
-                        ? req.query.page
-                        : "";
-                const limitStrAgg = Array.isArray(req.query.limit)
-                    ? req.query.limit[0]
-                    : typeof req.query.limit === "string"
-                        ? req.query.limit
-                        : "";
-                const pageNumAgg = parseInt(typeof pageStrAgg === "string" ? pageStrAgg : "") || 1;
-                const limitNumAgg = parseInt(typeof limitStrAgg === "string" ? limitStrAgg : "") || 20;
-                realTimeQueries.push({ $skip: (pageNumAgg - 1) * limitNumAgg }, {
-                    $limit: parseInt(Array.isArray(req.query.limit)
-                        ? String(req.query.limit[0])
-                        : typeof req.query.limit === "string"
-                            ? req.query.limit
-                            : req.query.limit !== undefined
-                                ? String(req.query.limit)
-                                : ""),
-                });
-            }
-            else if (req.query.limit && queryState.action == "aggregate") {
-                realTimeQueries.push({ $limit: parseInt(String(req.query.limit)) });
-            }
-            if (req.query.select && queryState.action !== "aggregate") {
-                const selectQueryIndex = realTimeQueries.findIndex((q) => "type" in q && q.type == "select");
-                if (selectQueryIndex == -1)
-                    realTimeQueries.push({ type: "select", value: req.query.select });
-            }
-        }
-        try {
-            const page = parseInt(Array.isArray(req.query.page)
-                ? String(req.query.page[0])
-                : typeof req.query.page === "string"
-                    ? req.query.page
-                    : "") || 1;
-            const limit = parseInt(Array.isArray(req.query.limit)
-                ? String(req.query.limit[0])
-                : typeof req.query.limit === "string"
-                    ? req.query.limit
-                    : req.query.limit !== undefined
-                        ? String(req.query.limit)
-                        : "") ||
-                configs.pagination?.quantity ||
-                20;
-            switch (queryState.action) {
-                case "find":
-                    if (configs.pagination?.detailed && req.query.page) {
-                        const page = parseInt(Array.isArray(req.query.page)
-                            ? String(req.query.page[0])
-                            : typeof req.query.page === "string"
-                                ? req.query.page
-                                : "") || 1;
-                        const limit = parseInt(Array.isArray(req.query.limit)
-                            ? String(req.query.limit[0])
-                            : typeof req.query.limit === "string"
-                                ? req.query.limit
-                                : req.query.limit !== undefined
-                                    ? String(req.query.limit)
-                                    : "") ||
-                            configs.pagination?.quantity ||
-                            20;
-                        console.log("db", 261, model, config.path);
-                        const totalPages = Math.ceil((await model.countDocuments(match)) / limit);
-                        detail = {
-                            ...detail,
-                            page,
-                            limit,
-                            totalPages,
-                        };
-                    }
-                    data = model?.find?.call(model, match);
-                    break;
-                case "create":
-                    req.body = Array.isArray(req.body)
-                        ? req.body.map((item) => ({
-                            ...item,
-                            ...(typeof queryState.body == "function"
-                                ? queryState.body(req)
-                                : queryState.body),
-                        }))
-                        : {
-                            ...req.body,
-                            ...(typeof queryState.body == "function"
-                                ? queryState.body(req)
-                                : queryState.body),
-                        };
-                    data = model?.[queryState.action]?.call(model, req.body);
-                    break;
-                case "updateOne":
-                    data = model?.[queryState.action]?.call(model, match, {
-                        ...req.body,
-                        ...(typeof queryState.body == "function"
-                            ? queryState.body(req)
-                            : queryState.body),
-                    });
-                    break;
-                case "updateMany":
-                    data = model?.[queryState.action]?.call(model, match, {
-                        ...req.body,
-                        ...(typeof queryState.body == "function"
-                            ? queryState.body(req)
-                            : queryState.body),
-                    });
-                    break;
-                case "deleteOne":
-                    data = model?.[queryState.action]?.call(model, match);
-                    break;
-                case "deleteMany":
-                    data = model?.[queryState.action]?.call(model, match);
-                    break;
-                case "findOne":
-                    data = model?.[queryState.action]?.call(model, match);
-                    break;
-                case "findOneAndUpdate":
-                    req.document = await model.findOne(match);
-                    data = model?.[queryState.action]?.call(model, match, (0, utils_1.createUpdateObject)(req, queryState.body || {}), { new: true });
-                    break;
-                case "findOneAndDelete":
-                    data = model?.[queryState.action]?.call(model, match);
-                    break;
-                case "findById":
-                    data = model?.[queryState.action]?.call(model, queryState.id || req.params.id);
-                    break;
-                case "aggregate":
-                    if (configs.pagination?.detailed && req.query.page) {
-                        const page = parseInt(req.query.page) || 1;
-                        const limit = parseInt(req.query.limit) ||
-                            configs.pagination?.quantity ||
-                            20;
-                        realTimeQueries = [
-                            {
-                                $facet: {
-                                    content: [...realTimeQueries],
-                                    detail: [
-                                        { $group: { _id: null, count: { $sum: 1 } } },
-                                        {
-                                            $addFields: {
-                                                totalPages: { $ceil: { $divide: ["$count", limit] } },
-                                                page,
-                                                limit,
-                                            },
-                                        },
-                                        {
-                                            $unset: ["_id", "count"],
-                                        },
-                                    ],
-                                },
-                            },
-                            {
-                                $unwind: "$detail",
-                            },
-                        ];
-                    }
-                    else {
-                        realTimeQueries = [
-                            {
-                                $facet: {
-                                    content: [...realTimeQueries],
-                                },
-                            },
-                        ];
-                    }
-                    // res.status(200).json([...queryState.pipeline , ...realTimeQueries])
-                    if (typeof queryState.pipeline == "function") {
-                        data = model?.[queryState.action]?.call(model, [
-                            ...queryState.pipeline(req),
-                            ...realTimeQueries,
-                        ]);
-                    }
-                    else {
-                        data = model?.[queryState.action]?.call(model, [
-                            ...(queryState.pipeline || []),
-                            ...realTimeQueries,
-                        ]);
-                    }
-                    break;
-                case "findByIdAndUpdate":
-                    req.document = await model.findByIdAndUpdate(queryState.id || req.params.id);
-                    data = model?.[queryState.action]?.call(model, queryState.id || req.params.id, Object.entries({
-                        ...req.body,
-                        ...(typeof queryState.body == "function"
-                            ? queryState.body(req)
-                            : queryState.body),
-                    }).reduce((acc, [key, value]) => {
-                        if (value == "$$REMOVE") {
-                            return { ...acc, $unset: { ...acc?.$unset, [key]: value } };
-                        }
-                        return { ...acc, $set: { ...acc?.$set, [key]: value } };
-                    }, {}), { new: true });
-                    break;
-                case "findByIdAndDelete":
-                    data = model?.[queryState.action]?.call(model, queryState.id || req.params.id);
-                    break;
-            }
-            if (queryState.action != "aggregate")
-                realTimeQueries.forEach((q) => {
-                    if ("type" in q && typeof data?.[q.type] === "function") {
-                        data = data[q.type].call(data, q.value);
-                    }
-                });
-            // if(req.query.select) data = data.select(req.query.select)
-            data = await data;
-            if (!data) {
-                next({
-                    status: 404,
-                    json: {
-                        message: `${collectionName} not found.`,
-                    },
-                });
-            }
-            else {
-                if (res.logger && req.user) {
-                    if (queryState.action &&
-                        queryState.action.match(/create|update|delete/i)?.[0]) {
-                        res.logger(`${{ log: "لاگ‌ها" }[collectionName] ||
-                            (await (0, translator_1.default)(`${collectionName}`))} ${data.name || data.title || data.id || data._id || ""} توسط ${(req.user?.firstName ? req.user?.firstName + " " : "") +
-                            (req.user?.lastName || "") ||
-                            `ادمین با شماره ${req.user.phoneNumber}`} ${{
-                            create: "ایجاد",
-                            update: "بروزرسانی",
-                            delete: "حذف",
-                            nothing: "",
-                        }[queryState.action
-                            .match(/create|update|delete/i)?.[0]
-                            ?.toLowerCase() || "nothing"] || queryState.action} شد`, queryState.action.match(/update/i)?.[0]
-                            ? (await Promise.all(Object.entries(data._doc)
-                                .filter(([key, value]) => ["_id", "__v", "updatedAt"].includes(key)
-                                ? false
-                                : req.document._doc[key] == undefined ||
-                                    req.document._doc[key]?.toString?.() !==
-                                        value?.toString?.())
-                                .map(async (item) => {
-                                const translatedField = await (0, translator_1.default)(item[0], "fa");
-                                if (req.document[item[0]] == undefined) {
-                                    return `فیلد ${translatedField} اضافه شد`;
-                                }
-                                else {
-                                    return `فیلد ${translatedField} از ${req.document[item[0]]} به ${item[1]} تغییر یافت`;
-                                }
-                            }))).concat(await Promise.all(Object.entries(req.document._doc)
-                                .filter(([key, value]) => ["_id", "__v", "updatedAt"].includes(key)
-                                ? false
-                                : data._doc[key] == undefined)
-                                .map(async (item) => {
-                                const translatedField = await (0, translator_1.default)(item[0], "fa");
-                                return `فیلد ${translatedField} حذف شد`;
-                            })))
-                            : []);
-                    }
-                }
-                const action = queryState.action?.match(/create|update|delet/i)?.[0] || "find";
-                const resBody = queryState.action == "aggregate"
-                    ? {
-                        message: config?.message ||
-                            `the ${collectionName} was found successfully`,
-                        content: [],
-                        ...data[0],
-                    }
-                    : {
-                        content: data,
-                        ...{ detail: Object.keys(detail).length ? detail : undefined },
-                        message: config?.message ||
-                            `the ${collectionName} was ${action == "find" ? "found" : action + "ed"}`,
-                    };
-                res.success ? res.success(200, resBody) : res.status(200).json(resBody);
-            }
-        }
-        catch (err) {
-            if (err &&
-                typeof err === "object" &&
-                "errorResponse" in err &&
-                err.errorResponse?.code == 11000)
-                return next({
-                    status: 405,
-                    json: {
-                        message: `(${Object.entries(err.errorResponse.keyValue)[0][0]}) already exists; write a unique value`,
-                    },
-                });
-            console.error("Error : model", err);
-            return next({
-                status: 500,
-                json: {
-                    message: (err instanceof Error ? err.message : String(err)) ||
-                        "internal server error",
-                },
-            });
-        }
-    };
-    handler.select = (value) => {
-        queryState.queries.push({
-            type: "select",
-            value: typeof value == "string" ? (0, strToObj_1.default)(value, 0) : value,
-        });
-        return handler;
-    };
-    handler.sort = (value) => {
-        queryState.queries.push({
-            type: "sort",
-            value: typeof value == "string" ? (0, strToObj_1.default)(value) : value,
-        });
-        return handler;
-    };
-    handler.skip = (value) => {
-        queryState.queries.push({ type: "skip", value });
-        return handler;
-    };
-    handler.limit = (value) => {
-        queryState.queries.push({ type: "limit", value });
-        return handler;
-    };
-    handler.populate = (value) => {
-        queryState.queries.push({ type: "populate", value });
-        return handler;
-    };
-    return actionHandler;
-};
-// const usingMySql = (tableName, config) => {
-//   const mysqlConnection = mysql.createConnection(process.env[configs.dbEnv]);
-//   mysqlConnection.connect((err) => {
-//     if (err) console.log("DB ERR: ", err.message);
-//     else console.log("database connected successfully ");
-//   });
-//   const db = mysqlConnection.promise()
-//   let queryState = {
-//     queryString: "select * from ?",
-//     variables: [{ tableName }],
-//   };
-//   const requestHandler = async (req, res, next) => {
-//     const [result] = await db.query(queryState.queryString, queryState.variables);
-//   };
-//   const chainActions = {
-//     query: (query = "select * from ?", ...variables) => {
-//       queryState = { queryString: query, variables };
-//       return requestHandler;
-//     },
-//   };
-//   return chainActions;
-// };
-const db = (collectionName, config = configs) => {
-    let generatedConfig = {
-        dbType: "mongodb",
-        path: "../models",
-        dbEnv: "DB_URL",
-        type: "external",
-        ...(0, getConfig_1.default)("db"),
-    };
-    Object.entries(config).forEach(([key, value]) => {
-        generatedConfig[key] = value;
-    });
-    switch (generatedConfig.dbType) {
-        case "mongodb":
-            return usingMongoDb(collectionName, generatedConfig);
-        case "mysql":
-        // return usingMySql(collectionName, generatedConfig);
-    }
-};
-exports.default = db;

package/dist/esm/db/utils.d.ts

@@ -1,3 +0,0 @@
-import { Request } from "express";
-declare const createUpdateObject: (req: Request, additionalFields: Record<string, any> | ((req: Request) => Record<string, any>)) => Record<string, any>;
-export { createUpdateObject };

package/dist/esm/db/utils.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUpdateObject = void 0;
-const createUpdateObject = (req, additionalFields) => {
-    let updateObject = { $set: { ...req.body } };
-    const additionalObject = typeof additionalFields === "function"
-        ? additionalFields(req)
-        : additionalFields;
-    if (Object.keys(additionalObject).find((key) => key.startsWith("$")))
-        updateObject = { ...updateObject, ...additionalObject };
-    else
-        updateObject.$set = { ...updateObject.$set, ...additionalObject };
-    return updateObject;
-};
-exports.createUpdateObject = createUpdateObject;

package/dist/esm/uploader/uploader.d.ts

@@ -1,24 +0,0 @@
-import multer from 'multer';
-import { NextFunction, Request, Response } from "express";
-declare global {
-    namespace Express {
-        interface Request {
-            mediaId?: any;
-        }
-    }
-}
-declare const _default: (destination?: string | ((req: Request, file: Express.Multer.File) => string), config?: {
-    [key: string]: any;
-    saveInDb: boolean;
-    prefix: string;
-    limit: number;
-    format: RegExp;
-    path: string;
-}) => {
-    single: (fieldName: string) => (req: Request, res: Response, next: NextFunction) => void;
-    array: (fieldName: string, maxCount?: number) => (req: Request, res: Response, next: NextFunction) => void;
-    fields: (fields: multer.Field[]) => (req: Request, res: Response, next: NextFunction) => void;
-    any: () => (req: Request, res: Response, next: NextFunction) => void;
-    none: () => (req: Request, res: Response, next: NextFunction) => void;
-} | undefined;
-export default _default;

package/dist/esm/validator/validator.d.ts

@@ -1,9 +0,0 @@
-import { RequestHandler } from "express";
-import * as yup from "yup";
-type ValidationSchema = {
-    body?: yup.AnyObjectSchema;
-    params?: yup.AnyObjectSchema;
-    query?: yup.AnyObjectSchema;
-};
-declare const validator: <T extends ValidationSchema>(schemas: T) => RequestHandler;
-export default validator;

package/dist/esm/validator/validator.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// این تابع validator generic هست
-const validator = (schemas) => {
-    const mw = async (req, res, next) => {
-        try {
-            if (schemas.body) {
-                req.body = (await schemas.body.validate(req.body, {
-                    stripUnknown: true,
-                }));
-            }
-            if (schemas.params) {
-                req.params = (await schemas.params.validate(req.params, {
-                    stripUnknown: true,
-                }));
-            }
-            if (schemas.query) {
-                req.query = (await schemas.query.validate(req.query, {
-                    stripUnknown: true,
-                }));
-            }
-            next();
-        }
-        catch (err) {
-            return next({
-                status: 405,
-                json: { message: err.message },
-                section: "validation",
-            });
-        }
-    };
-    Object.defineProperty(mw, "__validationSchema", { value: schemas });
-    Object.defineProperty(mw, "name", { value: `validator` });
-    return mw;
-};
-exports.default = validator;