speedly 1.0.0 → 1.1.1

package/dist/cjs/uploader/uploader.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const multer_1 = __importDefault(require("multer"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const getConfig = require("../util/getConfig");
+const relativePath = '../../../public';
+let configs = {
+    saveInDb: false,
+    prefix: "",
+    limit: 5,
+    format: /png|jpg|webp|jpeg/i,
+    ...getConfig("uploader")
+};
+console.log('uploader', 15, configs);
+module.exports = (destination = "/image", config = configs) => {
+    let dest;
+    try {
+        Object.entries(config).forEach(([key, val]) => {
+            configs[key] = val;
+        });
+        const storage = multer_1.default.diskStorage({
+            destination: function (req, file, cb) {
+                try {
+                    dest = typeof destination === "function"
+                        ? destination(req, file)
+                        : destination;
+                    const splitPath = dest.split("/");
+                    let currentPath = path_1.default.join(__dirname, relativePath);
+                    splitPath.forEach(folder => {
+                        currentPath = path_1.default.join(currentPath, folder);
+                        console.log('uploader', 39, currentPath, !fs_1.default.existsSync(currentPath));
+                        if (!fs_1.default.existsSync(currentPath)) {
+                            fs_1.default.mkdirSync(currentPath);
+                        }
+                    });
+                    cb(null, path_1.default.join(__dirname, relativePath, dest));
+                }
+                catch (err) {
+                    cb(err, "");
+                }
+            },
+            filename: function (req, file, cb) {
+                try {
+                    const ext = path_1.default.extname(file.originalname);
+                    if (!ext.slice(1).match(configs.format)) {
+                        return cb(new Error("File format not acceptable"), '');
+                    }
+                    const originalName = Buffer.from(file.originalname, "latin1").toString("utf8");
+                    const fileName = (configs.prefix ? configs.prefix + "-" : "") +
+                        originalName.replace(/\.\w+$/, "") + ext;
+                    const filePath = path_1.default.join(__dirname, relativePath, dest, fileName);
+                    console.log('uploader', 65, filePath);
+                    try {
+                        fs_1.default.existsSync(filePath);
+                    }
+                    catch (error) {
+                        console.log('uploader', 70, error);
+                    }
+                    if (fs_1.default.existsSync(filePath)) {
+                        return cb(new Error("File already exists in the destination folder"), '');
+                    }
+                    cb(null, fileName);
+                }
+                catch (err) {
+                    cb(err, '');
+                }
+            },
+        });
+        const uploader = (0, multer_1.default)({
+            storage,
+            limits: { fileSize: (configs.limit || 5) * 1024 * 1024 }, // MB
+        });
+        return {
+            single: (fieldName) => (req, res, next) => {
+                uploader.single(fieldName)(req, res, async (err) => {
+                    if (err) {
+                        console.log('uploader', 85, err);
+                        return next({ status: 405, json: { message: err.message } });
+                    }
+                    if (req.file) {
+                        if (configs.saveInDb) {
+                            const db = mongoose_1.default.connection;
+                            const collection = db.collection("media");
+                            const duplicate = await collection.findOne({ alt: req.body.alt });
+                            if (duplicate) {
+                                fs_1.default.rmSync(req.file.path);
+                                return res.status(405).json({ message: "alt is repetitive" });
+                            }
+                            const mediaDoc = await collection.insertOne({
+                                type: req.file.mimetype.split("/")[0],
+                                name: req.file.filename,
+                                dirPath: dest + "/",
+                                alt: req.body.alt,
+                                desc: req.body.desc,
+                                url: "/static/" + dest + "/" + req.file.filename,
+                            });
+                            console.log('uploader', 101, mediaDoc);
+                            req.mediaId = mediaDoc.insertedId;
+                        }
+                        req.body[fieldName] = path_1.default
+                            .join("/static", path_1.default.relative(path_1.default.join(__dirname, relativePath), req.file.path))
+                            .replaceAll(/\\/g, "/");
+                    }
+                    next();
+                });
+            },
+            array: (fieldName, maxCount = Infinity) => (req, res, next) => {
+                uploader.array(fieldName, maxCount)(req, res, (err) => {
+                    if (err)
+                        return res.status(405).json({ message: err.message });
+                    if (req.files && Array.isArray(req.files) && req.files.length) {
+                        req.body[fieldName] = req.files.map(file => path_1.default
+                            .join("/static", path_1.default.relative(path_1.default.join(__dirname, relativePath), file.path))
+                            .replaceAll(/\\/g, "/"));
+                    }
+                    next();
+                });
+            },
+            fields: (fields) => (req, res, next) => {
+                uploader.fields(fields)(req, res, (err) => {
+                    if (err)
+                        return res.status(405).json({ message: err.message });
+                    next();
+                });
+            },
+            any: () => (req, res, next) => {
+                uploader.any()(req, res, (err) => {
+                    if (err)
+                        return res.status(405).json({ message: err.message });
+                    next();
+                });
+            },
+            none: () => (req, res, next) => {
+                uploader.none()(req, res, (err) => {
+                    if (err)
+                        return res.status(405).json({ message: err.message });
+                    next();
+                });
+            },
+        };
+    }
+    catch (error) {
+        console.log("uploader init error", error);
+    }
+};

package/dist/cjs/util/getConfig.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (configField: string) => {
+    [key: string]: unknown;
+};
+export default _default;

package/dist/cjs/util/getConfig.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+// const { path } = require('../../app');
+exports.default = (configField) => {
+    const stackPath = new Error().stack?.split('\n')[2].trim().match(/\(.+\)/)?.[0].replace(/([\(\)]|\:\d+\:\d+)/g, '');
+    for (let i = 1; i < 4; i++) {
+        const filePath = stackPath?.replace(/\\/g, '/').split('/').slice(0, -i).join('/') + '/speedly.config.js';
+        if (fs_1.default.existsSync(filePath)) {
+            const config = require(filePath);
+            if (config && config[configField]) {
+                return config[configField];
+            }
+            return {};
+        }
+    }
+    return {};
+};

package/dist/cjs/util/strToObj.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (value: string, falseValue?: number, splitValue?: string) => {};
+export default _default;

package/dist/cjs/util/strToObj.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (value, falseValue = -1, splitValue = ' ') => {
+    return value.split(splitValue).reduce((prev, curr) => {
+        if (curr[0] == '-')
+            return { ...prev, [curr.slice(1)]: falseValue };
+        return { ...prev, [curr]: 1 };
+    }, {});
+};

package/dist/cjs/util/translator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (text?: string, lang?: string) => Promise<unknown>;
+export default _default;

package/dist/cjs/util/translator.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const translation_1 = __importDefault(require("./../model/translation"));
+const getConfig_1 = __importDefault(require("./getConfig"));
+const configs = { ...(0, getConfig_1.default)('translate') };
+async function firstSuccessful(promises) {
+    return new Promise((resolve, reject) => {
+        let rejections = 0;
+        const total = promises.length;
+        promises.forEach((p) => {
+            Promise.resolve(p)
+                .then(resolve)
+                .catch(() => {
+                rejections++;
+                if (rejections === total) {
+                    reject(new Error("همه ترجمه‌ها شکست خوردند"));
+                }
+            });
+        });
+    });
+}
+exports.default = async (text = "unspecified text", lang = "fa") => {
+    const formattedText = text
+        .replaceAll(/[\-\_]/g, " ")
+        .replaceAll(/[A-Z]/g, " $&");
+    const translationDoc = await translation_1.default.findOne({ text: formattedText, lang });
+    if (translationDoc)
+        return translationDoc.translatedText;
+    const translationPromises = [];
+    translationPromises.push((async () => {
+        const res = await axios_1.default.get(`https://655.mtis.workers.dev/translate?text=${encodeURIComponent(formattedText)}&source_lang=en&target_lang=${lang}`, { timeout: 2000 });
+        if (!res.data?.response?.translated_text)
+            throw new Error("Translation failed");
+        return res.data.response.translated_text;
+    })());
+    if (configs.one_api_token)
+        translationPromises.push((async () => {
+            const res = await axios_1.default.post("https://api.one-api.ir/translate/v1/microsoft", {
+                text: formattedText,
+                target: lang,
+            }, {
+                timeout: 2000,
+                headers: {
+                    "one-api-token": configs.one_api_token
+                },
+            });
+            if (res.data.status === 200) {
+                return res.data.result;
+            }
+            else {
+                throw new Error(res.data.message);
+            }
+        })());
+    try {
+        const result = await firstSuccessful(translationPromises);
+        await translation_1.default.create({ text: formattedText, lang, translatedText: result });
+        return result;
+    }
+    catch (err) {
+        console.error("translator error:", err);
+        return formattedText;
+    }
+};

package/dist/cjs/validator/validator.d.ts

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

package/dist/cjs/validator/validator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = void 0;
+// این تابع validator generic هست
+const validator = (schemas) => 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",
+        });
+    }
+};
+exports.validator = validator;

package/dist/esm/auth/auth.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getConfig_1 = __importDefault(require("../util/getConfig"));
+const gConfig = { admin: { role: 'ADMIN', model: '../models/admin' }, jwtSecretEnv: 'JWT_KEY', customValidator: (req, key) => { return true; }, ...(0, getConfig_1.default)('auth') };
+const auth = (config = gConfig) => {
+    // const adminModel = require('../models/admin')
+    let handlerState = {};
+    const useAuth = async (req, res, next) => {
+        try {
+            const nextFunc = (handlers, index = 0) => (errorMessage = '') => {
+                if (errorMessage)
+                    return next(errorMessage);
+                if (!handlers.length || !handlers[index + 1])
+                    return next();
+                handlers[index + 1](req, res, nextFunc(handlers, index + 1));
+            };
+            const keys = Object.keys(handlerState);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                if (!handlerState[key]?.handlers?.length)
+                    continue;
+                if (await gConfig?.customValidator?.(req, key)) {
+                    return await handlerState[key].handlers[0](req, res, nextFunc(handlerState[key].handlers));
+                }
+                else if (await gConfig?.customValidator?.(req, key) == null) {
+                    return next({ status: 401, json: { message: 'unauthorized' } });
+                }
+                else if (i === keys.length - 1) {
+                    next({ status: 405, json: { message: 'you don\'t have access to this section' } });
+                }
+                else
+                    continue;
+            }
+            // اینجا اگر i === keys.length - 1 باشد یعنی آخرین آیتم هستی
+            // }else if (!req.cookies.AT_SECRET) {
+            //     if (!handlerState.user || !handlerState.user?.handlers?.length) return res.status(403).json({ message: 'you dont have access for this section' })
+            //     handlerState.user.handlers[0](req ,res , nextFunc(handlerState.user.handlers))
+            // }else {
+            //     if(!handlerState.admin || !handlerState.admin?.handlers?.length) {
+            //         if (!handlerState.user || !handlerState.user?.handlers?.length) return res.status(404).json({ message: 'route not found  :(' })
+            //             handlerState.user.handlers[0](req ,res , nextFunc(handlerState.user.handlers))
+            //     } else {
+            //         const tokenPayload = jwt.verify(req.cookies.AT_SECRET , process.env[gConfig.jwtSecretEnv])
+            //         const adminDoc = await adminModel.findById(tokenPayload.id)
+            //         if(!adminDoc)return res.status(403).json({ message: 'you don\'t have access for this section' })
+            //         if(adminDoc.role !='OWNER' && adminDoc.role != config?.admin?.role ) return res.status(403).json({ message: 'you dont have access for this section' })
+            //         req.admin = adminDoc
+            //         handlerState.admin.handlers[0](req , res , nextFunc(handlerState.admin.handlers))
+            //     }
+            // }
+        }
+        catch (error) {
+            console.log('auth', 42, error);
+            next({ status: 403, json: { message: (error instanceof Error ? error.message : 'error on authentication please login again') } });
+        }
+    };
+    useAuth.admin = (...handlers) => {
+        if (!Array.isArray(handlers))
+            throw new Error('handlers must be an array');
+        const hasConfig = typeof handlers[0] === 'object' && 'permission' in handlers[0];
+        const configObj = hasConfig ? handlers[0] : undefined;
+        const handlerFns = hasConfig ? handlers.slice(1) : handlers;
+        handlerState[`admin${configObj?.permission ? `:${configObj.permission}` : ''}`] = {
+            ...(configObj ? { config: configObj } : {}),
+            handlers: handlerFns
+        };
+        return useAuth;
+    };
+    useAuth.user = (...handlers) => {
+        if (!Array.isArray(handlers))
+            throw new Error('handlers must be an array');
+        handlerState.user = { handlers };
+        return useAuth;
+    };
+    useAuth.any = (...handlers) => {
+        if (!Array.isArray(handlers))
+            throw new Error('handlers must be an array');
+        handlerState.any = { handlers };
+        return useAuth;
+    };
+    return useAuth;
+};
+module.exports = auth;

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

@@ -0,0 +1,181 @@
+import { Request, Response, NextFunction } from 'express';
+declare module 'express-serve-static-core' {
+    interface Request {
+        document?: any;
+        user?: any;
+    }
+    interface Response {
+        logger?: (message: string, details?: any) => void;
+        success?: (statusCode: number, body: any) => void;
+    }
+}
+type ConfigsType = {
+    dbType?: string;
+    path?: string;
+    dbEnv?: string;
+    pagination?: {
+        quantity?: number;
+        detailed?: boolean;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+declare const db: (collectionName: string, config?: ConfigsType) => {
+    find: (match?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    create: (body?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    updateOne: (match?: {}, body?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    updateMany: (match?: {}, body?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    deleteOne: (match?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    deleteMany: (match?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    findOne: (match?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    findOneAndUpdate: (match?: {}, body?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    aggregate: (pipeline?: never[]) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    findOneAndDelete: (match?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    findById: (id?: string) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    findByIdAndUpdate: (id?: string, body?: {}) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+    findByIdAndDelete: (id?: string) => {
+        (req: Request, res: Response, next: NextFunction): Promise<void>;
+        select(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        sort(value: string | {
+            [key: string]: -1 | 1;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
+    };
+} | undefined;
+export default db;