speedly 1.0.0 → 1.1.1

package/dist/esm/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/esm/util/getConfig.d.ts

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

package/dist/esm/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/esm/util/strToObj.d.ts

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

package/dist/esm/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/esm/util/translator.d.ts

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

package/dist/esm/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/esm/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/esm/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/package.json

@@ -1,25 +1,38 @@
 {
   "name": "speedly",
-  "version": "1.0.0",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "1.1.1",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc"
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "dev": "ts-node src/index.ts"
   },
-  "keywords": ["mongodb", "aggregation", "builder", "fluent", "typescript"],
-  "author": "Mahserin",
+  "author": "MAHSERIN",
   "license": "MIT",
-  "description": "A powerful backend module that lets you build and run advanced MongoDB aggregation queries with blazing speed and ultimate simplicity.",
+  "description": "",
+  "devDependencies": {
+    "@types/express": "^5.0.3",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^24.5.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2"
+  },
   "dependencies": {
-    "@types/express": "^5.0.1",
-    "@types/node": "^22.15.17",
+    "axios": "^1.11.0",
     "express": "^5.1.0",
     "jsonwebtoken": "^9.0.2",
-    "typescript": "^5.8.3",
-    "yup": "^1.6.1"
-  },
-  "devDependencies": {
-    "@types/multer": "^1.4.12"
+    "mongoose": "^8.18.2",
+    "multer": "^2.0.2",
+    "translate": "^3.0.1",
+    "yup": "^1.7.1"
   }
 }

package/dist/index.js

@@ -1 +0,0 @@
-"use strict";

package/dist/modules/auth.js

@@ -1,68 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const jwt = require('jsonwebtoken');
-const adminModel = require('./../models/admin');
-const auth = (config = { admin: { role: 'ADMIN' } }) => {
-    let handlerState = {};
-    const useAuth = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g;
-        console.log('auth 6 ', req.cookies);
-        try {
-            const nextFunc = (handlers, index = 0) => (errorMessage = '') => {
-                if (!handlers.length || !handlers[index + 1])
-                    return next();
-                if (errorMessage)
-                    return next(errorMessage);
-                handlers[index + 1](req, res, nextFunc(handlers, index + 1));
-            };
-            if (!req.cookies.AT_SECRET) {
-                if (!handlerState.user || !((_b = (_a = handlerState.user) === null || _a === void 0 ? void 0 : _a.handlers) === null || _b === void 0 ? void 0 : _b.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 || !((_d = (_c = handlerState.admin) === null || _c === void 0 ? void 0 : _c.handlers) === null || _d === void 0 ? void 0 : _d.length)) {
-                    if (!handlerState.user || !((_f = (_e = handlerState.user) === null || _e === void 0 ? void 0 : _e.handlers) === null || _f === void 0 ? void 0 : _f.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.ACCESS_TOKEN_SECRET);
-                    const adminDoc = yield adminModel.findById(tokenPayload.id);
-                    if (!adminDoc)
-                        return res.status(403).json({ message: 'you dont have access for this section' });
-                    if (adminDoc.role != 'OWNER' && adminDoc.role != ((_g = config === null || config === void 0 ? void 0 : config.admin) === null || _g === void 0 ? void 0 : _g.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) {
-        }
-    });
-    useAuth.admin = (...handlers) => {
-        var _a;
-        if (!Array.isArray(handlers))
-            throw new Error('handlers must be an array');
-        handlerState.admin = { role: ((_a = config === null || config === void 0 ? void 0 : config.admin) === null || _a === void 0 ? void 0 : _a.role) || 'admin', handlers };
-        return useAuth;
-    };
-    useAuth.user = (...handlers) => {
-        if (!Array.isArray(handlers))
-            throw new Error('handlers must be an array');
-        handlerState.user = { handlers };
-        return useAuth;
-    };
-    return useAuth;
-};
-module.exports = auth;

package/dist/modules/db/aggregation.js

@@ -1 +0,0 @@
-"use strict";

package/dist/modules/db/aggregation.types.d.ts

@@ -1,56 +0,0 @@
-export interface IAggregationBuilder {
-    match(filter: object): this;
-    group(id: any, fn: (op: IAggregationOperators) => object): this;
-    project(fields: object): this;
-    addFields(fields: object): this;
-    sort(sort: object): this;
-    limit(n: number): this;
-    skip(n: number): this;
-    unwind(field: string | object): this;
-    lookup(config: ILookupConfig): this;
-    count(field: string): this;
-    sortByCount(field: string): this;
-    facet(facets: {
-        [key: string]: any[];
-    }): this;
-    bucket(params: IBucketConfig): this;
-    bucketAuto(params: IBucketAutoConfig): this;
-    replaceRoot(newRoot: object): this;
-    redact(expression: any): this;
-    sample(size: number): this;
-    merge(output: string | object): this;
-    out(collection: string): this;
-    raw(stage: object): this;
-    toArray(): Promise<any[]>;
-    first(): Promise<any | null>;
-}
-export interface IAggregationOperators {
-    sum(field: string | number): object;
-    avg(field: string | number): object;
-    min(field: string | number): object;
-    max(field: string | number): object;
-    first(field: string): object;
-    last(field: string): object;
-    push(field: string): object;
-    addToSet(field: string): object;
-    count(): object;
-}
-export interface ILookupConfig {
-    from: string;
-    localField?: string;
-    foreignField?: string;
-    as: string;
-    let?: object;
-    pipeline?: any[];
-}
-export interface IBucketConfig {
-    groupBy: any;
-    boundaries: any[];
-    default?: any;
-    output?: object;
-}
-export interface IBucketAutoConfig {
-    groupBy: any;
-    buckets: number;
-    output?: object;
-}

package/dist/modules/db/aggregation.types.js

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

package/dist/modules/db/db.js

@@ -1 +0,0 @@
-"use strict";

package/dist/modules/db/db.type.js

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