speedly 2.0.38 → 2.0.42

package/dist/cjs/kit/db/db.js

@@ -236,6 +236,22 @@ const usingMongoDb = (collectionName, config = { type: "external" }) => {
                     });
             }
             else if (req.query.limit && queryState.action !== "aggregate") {
+                const limitStr = Array.isArray(req.query.limit)
+                    ? req.query.limit[0]
+                    : typeof req.query.limit === "string"
+                        ? req.query.limit
+                        : "";
+                const limitNum = parseInt(typeof limitStr === "string" ? limitStr : "") ||
+                    configs?.pagination?.quantity ||
+                    20;
+                if (realTimeQueries.findIndex((q) => "type" in q && q.type == "limit") ==
+                    -1)
+                    realTimeQueries.push({
+                        type: "limit",
+                        value: limitNum,
+                    });
+            }
+            else if (req.query.page && queryState.action == "aggregate") {
                 const pageStrAgg = Array.isArray(req.query.page)
                     ? req.query.page[0]
                     : typeof req.query.page === "string"

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

@@ -1,59 +1,71 @@
 import mongoose from 'mongoose';
 declare const model: mongoose.Model<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     text: string;
     lang: string;
     translatedText: string;
-}, {}, {}, {}, mongoose.Document<unknown, {}, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, {
     text: string;
     lang: string;
     translatedText: string;
-}, {}, {
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, {
     timestamps: true;
-}> & {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+}> & Omit<{
     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>, {}, {}, {}, {}, {
+}, "id"> & {
+    id: string;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
     timestamps: true;
 }, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     text: string;
     lang: string;
     translatedText: string;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
     text: string;
     lang: string;
     translatedText: string;
-}>, {}, mongoose.ResolveSchemaOptions<{
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, Omit<mongoose.DefaultSchemaOptions, "timestamps"> & {
     timestamps: true;
-}>> & mongoose.FlatRecord<{
+}> & Omit<{
+    text: string;
+    lang: string;
+    translatedText: string;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, unknown, {
+    text: string;
+    lang: string;
+    translatedText: string;
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>, {
     text: string;
     lang: string;
     translatedText: string;
-}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
-}>>;
+}>;
 export default model;

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

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

package/dist/config/init.d.ts

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

package/dist/config/init.js

@@ -0,0 +1,93 @@
+"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 path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const util_1 = require("../util");
+const document_1 = __importDefault(require("../document"));
+const defaultConfig = {
+    notFoundHandler: true,
+    errorHandler: true,
+    homeHandler: true,
+    jsonParser: true,
+    documentation: 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 founds. Please reinstall it to use cookieParser middleware.");
+            }
+        }
+    }
+    console.log("init", 48, fs_1.default.existsSync(path_1.default.join(process.cwd(), "src/module")));
+    if (finalConfig.documentation &&
+        fs_1.default.existsSync(path_1.default.join(process.cwd(), "src/module")))
+        (0, document_1.default)(app, path_1.default.join(process.cwd(), "src/module"), finalConfig.documentation === true
+            ? undefined
+            : finalConfig.documentation.servers);
+    if (finalConfig.staticFiles)
+        app.use("/static", express_1.default.static("public"));
+    if (finalConfig.homeHandler) {
+        app.get("/", (req, res) => {
+            res.send(`<h1>Welcome to ${require(path_1.default.join(process.cwd(), "package.json")).name} App</h1>
+      <p>Your app is running successfully.</p>
+     ${finalConfig.documentation
+                ? '<p>Visit <a href="/docs">/docs</a> for API documentation.</p>'
+                : ""}`);
+        });
+    }
+    // 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(async (err, req, res, _next) => {
+                console.log("app", 39, err);
+                const config = { translate: true, ...(err.config || {}) };
+                const body = err.json || {
+                    message: err.message || "internal error",
+                };
+                if (err?.status == 401)
+                    return res.status(err.status).json(body);
+                if (body.message && req.query.lang !== "en" && config.translate)
+                    try {
+                        body.message = await (0, util_1.translator)(body.message, (typeof req.query.lang === "string" ? req.query.lang : "fa") ||
+                            "fa");
+                    }
+                    catch (error) {
+                        console.error("Translation error:", error);
+                    }
+                res.status(err.status || 500).json(body);
+            });
+        }
+    };
+    // ⛔ 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;
+}

package/dist/document/document.d.ts

@@ -0,0 +1,5 @@
+import { Express } from "express";
+export default function swaggerLoader(app: Express, baseDir?: string, servers?: {
+    url: string;
+    description?: string;
+}[]): void;

package/dist/document/document.js

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = swaggerLoader;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const swagger_ui_express_1 = __importDefault(require("swagger-ui-express"));
+const swagger_themes_1 = require("swagger-themes");
+const parser_1 = require("./parser");
+const METHODS_WITH_BODY = ["post", "put", "patch"];
+/* ===================== HELPERS ======================= */
+function extractPath(layer) {
+    if (layer.regexp && layer.regexp.source !== "^\\/?$") {
+        return layer.regexp.source
+            .replace("^\\/", "/")
+            .replace("\\/?(?=\\/|$)", "")
+            .replace(/\\\//g, "/");
+    }
+    return "";
+}
+function splitRouteByMethod(route) {
+    const result = {};
+    route.stack.forEach((layer, idx) => {
+        if (layer.method) {
+            const method = layer.method.toLowerCase();
+            const middlewares = [];
+            for (let i = 0; i < idx; i++) {
+                if (route.stack[i].name !== "bound dispatch")
+                    middlewares.push(route.stack[i]);
+            }
+            result[method] = { middlewares, handler: layer };
+        }
+    });
+    return result;
+}
+/* ================== YUP → OPENAPI ==================== */
+function resolveYupSchema(schema) {
+    if (!schema)
+        return null;
+    if (schema?.type === "lazy" && typeof schema._resolve === "function") {
+        return schema._resolve({});
+    }
+    return schema;
+}
+function translateField(field) {
+    if (!field)
+        return { type: "string" };
+    return {
+        type: field.type === "array" ? "array" : field.type || "string",
+        nullable: field.nullable || false,
+    };
+}
+function translateYupSchema(schema) {
+    schema = resolveYupSchema(schema);
+    if (!schema)
+        return null;
+    const described = schema.describe();
+    const properties = Object.entries(described.fields ?? {}).reduce((acc, [name, field]) => {
+        acc[name] = translateField(field);
+        return acc;
+    }, {});
+    return {
+        type: "object",
+        properties,
+        required: Object.entries(described.fields ?? {})
+            .filter(([_, f]) => !(f.optional || f.nullable))
+            .map(([name]) => name),
+    };
+}
+function getAuthStatus(middlewares) {
+    for (const mw of middlewares) {
+        if (!mw.name)
+            continue;
+        if (mw.name.startsWith("auth")) {
+            const parts = mw.name.split(":");
+            if (parts[1] === "any")
+                return { type: "any", raw: mw.name };
+            return { type: "required", raw: mw.name };
+        }
+    }
+    return { type: "none", raw: null };
+}
+/* ==================== ROUTER SCANNER ==================== */
+function scanRouter(router, base = "") {
+    const routes = [];
+    router.stack.forEach((layer) => {
+        if (layer.route) {
+            routes.push({
+                path: base + layer.route.path,
+                methods: splitRouteByMethod(layer.route),
+            });
+        }
+        else if (layer.name === "router" && layer.handle?.stack) {
+            routes.push(...scanRouter(layer.handle, base + extractPath(layer)));
+        }
+    });
+    return routes;
+}
+/* ================== MAIN ANALYZER ===================== */
+function routeAnalyzer(route, routerName) {
+    const routerDetails = {};
+    const scanned = scanRouter(route);
+    scanned.forEach((route) => {
+        const fullPath = `/${routerName}${(0, parser_1.expressToSwagger)(route.path)}`;
+        routerDetails[fullPath] = {};
+        Object.entries(route.methods).forEach(([method, detail]) => {
+            const doc = {
+                tags: [routerName.replace("_", " ")],
+                description: "Public route",
+            };
+            const validation = detail.middlewares.find((mw) => mw.handle?.__validationSchema)?.handle.__validationSchema;
+            const pathParams = [...fullPath.matchAll(/{([^}]+)}/g)].map((m) => m[1]);
+            if (pathParams.length) {
+                doc.parameters = pathParams.map((name) => ({
+                    name,
+                    in: "path",
+                    required: validation?.params?.fields?.[name]?.spec?.optional == false ||
+                        !new RegExp(`\\{[^\\}]*${name}[^\\}]*\\}`).test(route.path),
+                    schema: { type: "string" },
+                }));
+            }
+            // If body exists
+            if (METHODS_WITH_BODY.includes(method)) {
+                if (validation?.body) {
+                    doc.requestBody = {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: translateYupSchema(validation.body),
+                            },
+                        },
+                    };
+                }
+            }
+            // Response
+            doc.responses = {
+                "200": {
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    message: { type: "string", example: "find successfully" },
+                                    content: {
+                                        oneOf: [
+                                            {
+                                                type: "array",
+                                                items: {
+                                                    type: "object",
+                                                    properties: {
+                                                        id: { type: "string" },
+                                                        name: { type: "string" },
+                                                    },
+                                                },
+                                            },
+                                            {
+                                                type: "object",
+                                                properties: {
+                                                    id: { type: "string" },
+                                                    name: { type: "string" },
+                                                },
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "400": {
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    message: { type: "string", example: "module not found" },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            // Auth
+            const auth = getAuthStatus(detail.middlewares);
+            if (auth.type === "required") {
+                doc.security = [{ bearerAuth: [] }];
+                doc.description = `Requires authentication (${auth.raw})`;
+            }
+            else if (auth.type === "any") {
+                doc.description = "Optional login route";
+            }
+            routerDetails[fullPath][method] = doc;
+        });
+    });
+    return routerDetails;
+}
+/* =================== LOAD MODULES ==================== */
+function findRoutersInDir(dir) {
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const routers = [];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            routers.push(...findRoutersInDir(fullPath));
+        }
+        else if (entry.isFile() &&
+            entry.name.match(/\.route(rs|r|s)?\.(js|ts)$/)) {
+            try {
+                if (require(fullPath)) {
+                    routers.push(fullPath);
+                }
+            }
+            catch (err) { }
+        }
+    }
+    return routers;
+}
+function RouterFetcher(baseDir, servers) {
+    const modules = findRoutersInDir(baseDir);
+    let paths = {};
+    const tags = [];
+    // Load each router and analyze
+    modules.forEach((routerPath) => {
+        const mf = [
+            ...new Set(path_1.default
+                .relative(baseDir, routerPath)
+                .replaceAll(path_1.default.sep, "/")
+                .replaceAll(/\.[^/]+/g, "")
+                .split("/")),
+        ]
+            .join("/")
+            .split(".")[0] || "default";
+        try {
+            const router = require(routerPath);
+            paths = { ...paths, ...routeAnalyzer(router, mf) };
+            tags.push({
+                name: mf.replace("_", " "),
+                description: `${mf} operations`,
+            });
+        }
+        catch (err) {
+            console.error("Swagger loading error:", err.message);
+        }
+    });
+    return {
+        openapi: "3.0.3",
+        info: {
+            title: `${require(path_1.default.join(process.cwd(), "package.json")).name} Documentation`,
+            version: "1.0.0",
+        },
+        servers,
+        paths,
+        tags,
+        components: {
+            securitySchemes: {
+                bearerAuth: { type: "http", scheme: "bearer", bearerFormat: "JWT" },
+            },
+        },
+    };
+}
+/* ==================== EXPORT HOOK ==================== */
+function swaggerLoader(app, baseDir = path_1.default.join(process.cwd(), "src/module"), servers = [{ url: "/api/v1" }]) {
+    const doc = RouterFetcher(baseDir, servers);
+    const theme = new swagger_themes_1.SwaggerTheme();
+    app.use("/docs", swagger_ui_express_1.default.serve, swagger_ui_express_1.default.setup(doc, {
+        customCss: theme.getBuffer(swagger_themes_1.SwaggerThemeNameEnum.DARK),
+    }));
+}

package/dist/document/index.d.ts

@@ -0,0 +1,2 @@
+import document from "./document";
+export default document;

package/dist/document/index.js

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

package/dist/document/parser.d.ts

@@ -0,0 +1 @@
+export declare function expressToSwagger(path: string): string;

package/dist/document/parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressToSwagger = expressToSwagger;
+function expressToSwagger(path) {
+    // مرحله 1: optional group ها رو unwrap کن
+    // {/:newName} -> /:newName
+    let normalized = path.replace(/\{([^}]+)\}/g, "$1");
+    // مرحله 2: :param رو تبدیل کن به {param}
+    normalized = normalized.replace(/:([A-Za-z0-9_]+)/g, "{$1}");
+    return normalized;
+}

package/dist/esm/config/init.js

@@ -47,8 +47,8 @@ function speedly(config = {}) {
         app.use("/static", express_1.default.static("public"));
     if (finalConfig.homeHandler) {
         app.get("/", (req, res) => {
-            res.send(`<h1>Welcome to ${require(path_1.default.join(process.cwd(), "package.json")).name} App</h1>
-      <p>Your app is running successfully.</p>
+            res.send(`<h1>Welcome to ${require(path_1.default.join(process.cwd(), "package.json")).name} App</h1>
+      <p>Your app is running successfully.</p>
      ${finalConfig.documentation
                 ? '<p>Visit <a href="/docs">/docs</a> for API documentation.</p>'
                 : ""}`);

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

@@ -236,6 +236,22 @@ const usingMongoDb = (collectionName, config = { type: "external" }) => {
                     });
             }
             else if (req.query.limit && queryState.action !== "aggregate") {
+                const limitStr = Array.isArray(req.query.limit)
+                    ? req.query.limit[0]
+                    : typeof req.query.limit === "string"
+                        ? req.query.limit
+                        : "";
+                const limitNum = parseInt(typeof limitStr === "string" ? limitStr : "") ||
+                    configs?.pagination?.quantity ||
+                    20;
+                if (realTimeQueries.findIndex((q) => "type" in q && q.type == "limit") ==
+                    -1)
+                    realTimeQueries.push({
+                        type: "limit",
+                        value: limitNum,
+                    });
+            }
+            else if (req.query.page && queryState.action == "aggregate") {
                 const pageStrAgg = Array.isArray(req.query.page)
                     ? req.query.page[0]
                     : typeof req.query.page === "string"

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

@@ -1,59 +1,71 @@
 import mongoose from 'mongoose';
 declare const model: mongoose.Model<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     text: string;
     lang: string;
     translatedText: string;
-}, {}, {}, {}, mongoose.Document<unknown, {}, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, {}, {}, {
+    id: string;
+}, mongoose.Document<unknown, {}, {
     text: string;
     lang: string;
     translatedText: string;
-}, {}, {
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, {
     timestamps: true;
-}> & {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+}> & Omit<{
     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>, {}, {}, {}, {}, {
+}, "id"> & {
+    id: string;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
     timestamps: true;
 }, {
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
     text: string;
     lang: string;
     translatedText: string;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
     text: string;
     lang: string;
     translatedText: string;
-}>, {}, mongoose.ResolveSchemaOptions<{
+} & mongoose.DefaultTimestampProps, {
+    id: string;
+}, Omit<mongoose.DefaultSchemaOptions, "timestamps"> & {
     timestamps: true;
-}>> & mongoose.FlatRecord<{
+}> & Omit<{
+    text: string;
+    lang: string;
+    translatedText: string;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, unknown, {
+    text: string;
+    lang: string;
+    translatedText: string;
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>, {
     text: string;
     lang: string;
     translatedText: string;
-}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
-}>>;
+}>;
 export default model;