speedly 1.2.48 → 2.0.5

package/dist/cjs/kit/uploader/uploader.js

@@ -0,0 +1,148 @@
+"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_1 = __importDefault(require("../../util/getConfig"));
+let configs = {
+    saveInDb: false,
+    prefix: "",
+    limit: 5,
+    format: /png|jpg|webp|jpeg/i,
+    path: "../../../public",
+    ...(0, getConfig_1.default)("uploader"),
+};
+exports.default = (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(configs.path);
+                    splitPath.forEach((folder) => {
+                        currentPath = path_1.default.join(currentPath, folder);
+                        if (!fs_1.default.existsSync(currentPath)) {
+                            fs_1.default.mkdirSync(currentPath);
+                        }
+                    });
+                    cb(null, path_1.default.join(configs.path, 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(configs.path, dest, fileName);
+                    try {
+                        fs_1.default.existsSync(filePath);
+                    }
+                    catch (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,
+                            });
+                            req.mediaId = mediaDoc.insertedId;
+                        }
+                        req.body[fieldName] = path_1.default
+                            .join("/static", path_1.default.relative(path_1.default.join(configs.path), 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(configs.path), 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/kit/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;
+};
+declare const validator: <T extends ValidationSchema>(schemas: T) => RequestHandler;
+export default validator;

package/dist/cjs/kit/validator/validator.js

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

package/dist/cjs/model/index.d.ts

@@ -0,0 +1,2 @@
+import translation from "./translation";
+export { translation };

package/dist/cjs/model/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translation = void 0;
+const translation_1 = __importDefault(require("./translation"));
+exports.translation = translation_1.default;

package/dist/cjs/model/translation.d.ts

@@ -1,39 +1,57 @@
 import mongoose from 'mongoose';
 declare const model: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     text: string;
     lang: string;
     translatedText: string;
-} & mongoose.DefaultTimestampProps, {}, {}, {}, mongoose.Document<unknown, {}, {
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     text: string;
     lang: string;
     translatedText: string;
-} & mongoose.DefaultTimestampProps, {}, {
+}, {}, {
     timestamps: true;
 }> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     text: string;
     lang: string;
     translatedText: string;
-} & mongoose.DefaultTimestampProps & {
+} & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
 }, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
     timestamps: true;
 }, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     text: string;
     lang: string;
     translatedText: string;
-} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     text: string;
     lang: string;
     translatedText: string;
-} & mongoose.DefaultTimestampProps>, {}, mongoose.ResolveSchemaOptions<{
+}>, {}, mongoose.ResolveSchemaOptions<{
     timestamps: true;
 }>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     text: string;
     lang: string;
     translatedText: string;
-} & mongoose.DefaultTimestampProps> & {
+}> & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;

package/dist/cjs/modules/index.d.ts

@@ -0,0 +1,2 @@
+import translation from "./translation/translation.routes";
+export { translation };

package/dist/cjs/modules/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translation = void 0;
+const translation_routes_1 = __importDefault(require("./translation/translation.routes"));
+exports.translation = translation_routes_1.default;

package/dist/cjs/modules/translation/translation.routes.js

@@ -4,17 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
-const auth_1 = __importDefault(require("../../auth/auth"));
-const db_1 = __importDefault(require("../../db/db"));
-const validator_1 = __importDefault(require("../../validator/validator"));
-const v = require('./translation.validator');
+const auth_1 = __importDefault(require("../../kit/auth/auth"));
+const db_1 = __importDefault(require("../../kit/db/db"));
+const validator_1 = __importDefault(require("../../kit/validator/validator"));
+const v = require("./translation.validator");
 const router = express_1.default.Router();
-router.route('/').get((0, db_1.default)('translation', { type: 'internal' }).find())
+router
+    .route("/")
+    .get((0, db_1.default)("translation", { type: "internal" }).find())
     .post((req, res, next) => {
-    if (!req.body.auth || req.body.auth !== 'OKPJWSJD_Sdki') {
+    if (!req.body.auth || req.body.auth !== "OKPJWSJD_Sdki") {
         return res.status(403).json({ message: "Access Denied" });
     }
     next();
-}, (0, db_1.default)('translation', { type: 'internal' }).create());
-router.route('/:id').put(auth_1.default.admin(), (0, validator_1.default)(v.put), (0, db_1.default)('translation', { type: 'internal' }).findByIdAndUpdate());
+}, (0, db_1.default)("translation", { type: "internal" }).create());
+router
+    .route("/:id")
+    .put(auth_1.default.admin(), (0, validator_1.default)(v.put), (0, db_1.default)("translation", { type: "internal" }).findByIdAndUpdate());
 exports.default = router;

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

@@ -0,0 +1,2 @@
+import translator from "./translator";
+export { translator };

package/dist/cjs/util/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translator = void 0;
+const translator_1 = __importDefault(require("./translator"));
+exports.translator = translator_1.default;

package/dist/cjs/util/makeOptional.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const yup = __importStar(require("yup"));

package/dist/cjs/yup.config.d.ts

@@ -0,0 +1,2 @@
+import yup from "yup";
+export default yup;

package/dist/cjs/yup.config.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const yup_1 = __importDefault(require("yup"));
+yup_1.default.addMethod(yup_1.default.string, "oid", function (errorMessage = "آیدی درست نیست") {
+    return this.test({
+        name: "oid",
+        message: errorMessage,
+        test(value) {
+            if (!value)
+                return true;
+            if (value == "$$REMOVE")
+                return true;
+            if (!value || !(0, mongoose_1.isValidObjectId)(value)) {
+                return false; // Invalid ObjectId
+            }
+            return true; // Valid ObjectId
+        },
+    });
+});
+exports.default = yup_1.default;

package/dist/esm/config/init.d.ts

@@ -0,0 +1,15 @@
+import express from "express";
+type InitConfig = {
+    notFoundHandler?: boolean;
+    errorHandler?: boolean;
+    jsonParser?: boolean;
+    urlEncodedParser?: boolean;
+    cookieParser?: boolean;
+    staticFiles?: boolean;
+    [key: string]: any;
+};
+export default function speedly(config?: InitConfig): express.Express & {
+    speedlyConfig: InitConfig;
+    registerFallbacks: () => void;
+};
+export {};

package/dist/esm/config/init.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = speedly;
+const express_1 = __importDefault(require("express"));
+const defaultConfig = {
+    notFoundHandler: true,
+    errorHandler: true,
+    jsonParser: true,
+    urlEncodedParser: true,
+    cookieParser: true,
+    staticFiles: true,
+};
+function speedly(config = {}) {
+    const finalConfig = { ...defaultConfig, ...config };
+    const app = (0, express_1.default)();
+    if (finalConfig.jsonParser)
+        app.use(express_1.default.json());
+    if (finalConfig.urlEncodedParser)
+        app.use(express_1.default.urlencoded({ extended: true }));
+    if (finalConfig.cookieParser) {
+        try {
+            const cookieParser = require("cookie-parser");
+            app.use(cookieParser());
+        }
+        catch (error) {
+            if (error.code === "MODULE_NOT_FOUND") {
+                console.warn("cookie-parser module not found. Please install it to use cookieParser middleware.");
+            }
+        }
+    }
+    if (finalConfig.staticFiles)
+        app.use("/static", express_1.default.static("public"));
+    // user can call this manually if needed
+    const registerFallbacks = () => {
+        if (finalConfig.notFoundHandler) {
+            app.use((req, res) => res.status(404).json({ message: "Not Found" }));
+        }
+        if (finalConfig.errorHandler) {
+            app.use((error, req, res, next) => {
+                console.error("Speedly Error:", error);
+                res.status(500).json({ message: "Internal Server Error" });
+            });
+        }
+    };
+    // ⛔ we intercept listen, add fallback before server starts
+    const originalListen = app.listen.bind(app);
+    app.listen = (...args) => {
+        registerFallbacks();
+        return originalListen(...args);
+    };
+    // 🔓 expose config + extend points for override
+    app.speedlyConfig = finalConfig;
+    app.registerFallbacks = registerFallbacks;
+    return app;
+}