speedly 1.3.0 → 2.0.6

package/dist/cjs/auth/auth2.d.ts

@@ -0,0 +1,18 @@
+import { Request, Response, NextFunction } from "express";
+type Handler = (req: Request, res: Response, next: (errorMessage?: string) => unknown) => unknown;
+type UseAuth = (req: Request, res: Response, next: NextFunction) => UseAuth | {
+    user?: (...handlers: Handler[]) => unknown;
+    admin?: (...handlers: [{
+        permission: string;
+    }, ...Handler[]] | Handler[]) => unknown;
+    any?: (...handlers: Handler[]) => unknown;
+};
+declare const auth: (config?: {
+    admin: {
+        role: string;
+        model: string;
+    };
+    jwtSecretEnv: string;
+    customValidator: (req: Request, key: string) => boolean;
+}) => UseAuth;
+export default auth;

package/dist/cjs/auth/auth2.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 });
+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 holders = {};
+const auth = (config = gConfig) => {
+    // const adminModel = require('../models/admin')
+    let handlerState = {};
+    let 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;
+            }
+        }
+        catch (error) {
+            console.log("auth", 42, error);
+            next({
+                status: 403,
+                json: {
+                    message: error instanceof Error
+                        ? error.message
+                        : "error on authentication please login again",
+                },
+            });
+        }
+    };
+    holders.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;
+    };
+    holders.user = (...handlers) => {
+        if (!Array.isArray(handlers))
+            throw new Error("handlers must be an array");
+        handlerState.user = { handlers };
+        return useAuth;
+    };
+    holders.any = (...handlers) => {
+        if (!Array.isArray(handlers))
+            throw new Error("handlers must be an array");
+        handlerState.any = { handlers };
+        return useAuth;
+    };
+    useAuth = Object.assign(useAuth, holders);
+    return useAuth;
+};
+console.log("auth", 81, typeof auth);
+exports.default = auth;

package/dist/cjs/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/cjs/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;
+}

package/dist/cjs/db/db.d.ts

@@ -13,8 +13,6 @@ type ConfigsType = {
     dbType?: string;
     path?: string;
     dbEnv?: string;
-    response?: boolean;
-    first?: boolean;
     type: "internal" | "external";
     pagination?: {
         quantity?: number;
@@ -28,157 +26,157 @@ declare const db: (collectionName: string, config?: ConfigsType) => {
         (req: Request, res: Response, next: NextFunction): Promise<void>;
         select(value: string | {
             [key: string]: -1 | 1;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*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;
-        }): any;
+        }): /*elided*/ any;
         sort(value: string | {
             [key: string]: -1 | 1;
-        }): any;
-        skip(value: number): any;
-        limit(value: number): any;
-        populate(value: string | object | (string | object)[]): any;
+        }): /*elided*/ any;
+        skip(value: number): /*elided*/ any;
+        limit(value: number): /*elided*/ any;
+        populate(value: string | object | (string | object)[]): /*elided*/ any;
     };
 } | undefined;
 export default db;

package/dist/cjs/db/db.js

@@ -14,8 +14,6 @@ let configs = {
     path: "../models",
     type: "external",
     dbEnv: "DB_URL",
-    first: false,
-    response: true,
     ...(0, getConfig_1.default)("db"),
 };
 const usingMongoDb = (collectionName, config = { type: "external" }) => {
@@ -487,32 +485,21 @@ const usingMongoDb = (collectionName, config = { type: "external" }) => {
                             : []);
                     }
                 }
-                if (config?.response) {
-                    const action = queryState.action?.match(/create|update|delet/i)?.[0] || "find";
-                    if (queryState.action == "aggregate" && config.first && data[0]?.content.length)
-                        data[0].content.length = data[0].content[0];
-                    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);
-                }
-                else {
-                    next();
-                }
+                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) {
@@ -592,8 +579,6 @@ const db = (collectionName, config = configs) => {
         path: "../models",
         dbEnv: "DB_URL",
         type: "external",
-        first: false,
-        response: true,
         ...(0, getConfig_1.default)("db"),
     };
     Object.entries(config).forEach(([key, value]) => {

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

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

package/dist/cjs/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/cjs/index.d.ts

@@ -1,53 +1,3 @@
-import auth from "./auth/auth";
-import db from "./db/db";
-import uploader from "./uploader/uploader";
-import validator from "./validator/validator";
-import document from "./document/document";
-declare const utils: {
-    translator: (text?: string, lang?: string) => Promise<unknown>;
-};
-declare const models: {
-    translation: import("mongoose").Model<{
-        text: string;
-        lang: string;
-        translatedText: string;
-    } & import("mongoose").DefaultTimestampProps, {}, {}, {}, import("mongoose").Document<unknown, {}, {
-        text: string;
-        lang: string;
-        translatedText: string;
-    } & import("mongoose").DefaultTimestampProps, {}, {
-        timestamps: true;
-    }> & {
-        text: string;
-        lang: string;
-        translatedText: string;
-    } & import("mongoose").DefaultTimestampProps & {
-        _id: import("mongoose").Types.ObjectId;
-    } & {
-        __v: number;
-    }, import("mongoose").Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
-        timestamps: true;
-    }, {
-        text: string;
-        lang: string;
-        translatedText: string;
-    } & import("mongoose").DefaultTimestampProps, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
-        text: string;
-        lang: string;
-        translatedText: string;
-    } & import("mongoose").DefaultTimestampProps>, {}, import("mongoose").ResolveSchemaOptions<{
-        timestamps: true;
-    }>> & import("mongoose").FlatRecord<{
-        text: string;
-        lang: string;
-        translatedText: string;
-    } & import("mongoose").DefaultTimestampProps> & {
-        _id: import("mongoose").Types.ObjectId;
-    } & {
-        __v: number;
-    }>>;
-};
-declare const modules: {
-    translation: import("express-serve-static-core").Router;
-};
-export { auth, db, uploader, validator, models, modules, utils, document };
+import speedly from "./config/init";
+export { Request, Response, NextFunction, Application, Router, RequestHandler, ErrorRequestHandler, } from "express";
+export default speedly;

package/dist/cjs/index.js

@@ -3,25 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.document = exports.utils = exports.modules = exports.models = 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;
-const translation_1 = __importDefault(require("./model/translation"));
-const translation_routes_1 = __importDefault(require("./modules/translation/translation.routes"));
-const document_1 = __importDefault(require("./document/document"));
-exports.document = document_1.default;
-const translator_1 = __importDefault(require("./util/translator"));
-const utils = {
-    translator: translator_1.default,
-};
-exports.utils = utils;
-const models = { translation: translation_1.default };
-exports.models = models;
-const modules = { translation: translation_routes_1.default };
-exports.modules = modules;
+exports.Router = void 0;
+const init_1 = __importDefault(require("./config/init"));
+// Export express types and classes
+var express_1 = require("express");
+Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return express_1.Router; } });
+// Override the  default  express() with our speedly`s  functions
+exports.default = init_1.default;
+module.exports = init_1.default;
+module.exports.default = init_1.default;

package/dist/cjs/kit/auth/auth.d.ts

@@ -0,0 +1,3 @@
+import * as Types from "./types";
+declare const auth: Types.Auth;
+export default auth;

package/dist/cjs/kit/auth/auth.js

@@ -0,0 +1,38 @@
+"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 executer = (authType) => {
+    const mw = async (req, res, next) => {
+        const accessResult = await gConfig?.customValidator?.(req, authType);
+        if (accessResult == null)
+            return next({ status: 401, json: { message: "Unauthorized" } });
+        if (!accessResult)
+            return next({ status: 403, json: { message: "Forbidden" } });
+        return next();
+    };
+    Object.defineProperty(mw, "name", { value: `auth:${authType}` });
+    return mw;
+};
+const auth = {
+    user: () => {
+        return executer("user");
+    },
+    admin: (config) => {
+        return executer(`admin${config?.permission ? `:${config.permission}` : ""}`);
+    },
+    any: () => {
+        return executer("any");
+    },
+};
+exports.default = auth;

package/dist/cjs/kit/auth/types.d.ts

@@ -0,0 +1,19 @@
+import { Request, Response, NextFunction } from 'express';
+type Handler = (req: Request, res: Response, next: (errorMessage?: string) => unknown) => unknown;
+type Executer = (authField: string) => (req: Request, res: Response, next: NextFunction) => unknown;
+type Auth = {
+    user: () => Handler;
+    admin: (config?: {
+        permission: string;
+    }) => Handler;
+    any: () => Handler;
+};
+type ConfigType = {
+    customValidator?: (req: Request, key: string) => Promise<boolean | null>;
+    jwtSecretEnv?: string;
+    admin?: {
+        role: string;
+        model: string;
+    };
+};
+export { Handler, Executer, Auth, ConfigType };

package/dist/cjs/kit/auth/types.js

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