speedly 1.3.0 → 2.0.5

package/dist/esm/kit/db/db.js

@@ -0,0 +1,594 @@
+"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/kit/db/utils.d.ts

@@ -0,0 +1,3 @@
+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/kit/db/utils.js

@@ -0,0 +1,15 @@
+"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/kit/index.d.ts

@@ -0,0 +1,5 @@
+import auth from "./auth/auth";
+import db from "./db/db";
+import uploader from "./uploader/uploader";
+import validator from "./validator/validator";
+export { auth, db, uploader, validator };

package/dist/esm/kit/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = exports.uploader = exports.db = exports.auth = void 0;
+const auth_1 = __importDefault(require("./auth/auth"));
+exports.auth = auth_1.default;
+const db_1 = __importDefault(require("./db/db"));
+exports.db = db_1.default;
+const uploader_1 = __importDefault(require("./uploader/uploader"));
+exports.uploader = uploader_1.default;
+const validator_1 = __importDefault(require("./validator/validator"));
+exports.validator = validator_1.default;

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

@@ -0,0 +1,24 @@
+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;