@warlock.js/core 1.0.11 → 1.0.12

package/esm/http/request.js

@@ -0,0 +1,711 @@
+import config from'@mongez/config';import {colors}from'@mongez/copper';import events from'@mongez/events';import {trans,transFrom}from'@mongez/localization';import {rtrim,set,get,unset,only,except}from'@mongez/reinforcements';import {isEmpty}from'@mongez/supportive-is';import {log}from'@warlock.js/logger';import'../validator/locales.js';import'@warlock.js/cascade';import {createuseRequestStore}from'./middleware/inject-request-context.js';import'../modules/uploads/models/upload.js';import {getValidationSchema}from'../validator/utils.js';import {validateAll}from'../validator/validateAll.js';import {ValidationSchema}from'../validator/validation-schema.js';import {Validator}from'../validator/validator.js';import {UploadedFile}from'./UploadedFile.js';import {httpConfig}from'./config.js';import {Response}from'./response.js';class Request {
+    /**
+     * Fastify Request object
+     */
+    baseRequest;
+    /**
+     * Response Object
+     */
+    response;
+    /**
+     * Route Object
+     */
+    route;
+    /**
+     * Parsed Request Payload
+     */
+    payload = {};
+    /**
+     * Current user
+     */
+    user;
+    /**
+     * Current request instance
+     */
+    static current;
+    /**
+     * Translation method
+     * Type of it is the same as the type of trans function
+     */
+    trans = trans;
+    /**
+     * Alias to trans method
+     */
+    t = trans;
+    /**
+     * Locale code
+     */
+    _locale = "";
+    /**
+     * Set request handler
+     */
+    setRequest(request) {
+        this.baseRequest = request;
+        this.parsePayload();
+        const localeCode = this.getLocaleCode();
+        this.trans = this.t = transFrom.bind(null, localeCode);
+        return this;
+    }
+    /**
+     * Translate from the given locale code
+     */
+    transFrom(localeCode, keyword, placeholders) {
+        return transFrom(localeCode, keyword, placeholders);
+    }
+    /**
+     * Get current locale code
+     */
+    get locale() {
+        if (this._locale)
+            return this._locale;
+        return this.header("translation-locale-code") || this.localized;
+    }
+    /**
+     * Set locale code
+     */
+    set locale(localeCode) {
+        this._locale = localeCode;
+    }
+    /**
+     * Get locale code that will be used for translation
+     */
+    get localized() {
+        if (this._locale)
+            return this._locale;
+        return (this._locale =
+            this.header("locale-code") ||
+                this.header("locale") ||
+                this.header("localeCode") ||
+                this.query["locale"] ||
+                this.query["localeCode"] ||
+                this.query["locale-code"]);
+    }
+    /**
+     * Set locale code
+     */
+    setLocaleCode(localeCode) {
+        this._locale = localeCode;
+        return this;
+    }
+    /**
+     * Get current locale code or return default locale code
+     */
+    getLocaleCode(defaultLocaleCode = config.get("app.localeCode") || "en") {
+        return this.locale || defaultLocaleCode;
+    }
+    /**
+     * Get http protocol
+     */
+    get protocol() {
+        return this.baseRequest.protocol;
+    }
+    /**
+     * Validate the given validation schema
+     */
+    async validate(validation) {
+        const validationSchema = getValidationSchema(validation);
+        const validator = new Validator(this);
+        validator.setValidationSchema(validationSchema);
+        await validator.scan();
+        validator.triggerValidationUpdateEvent();
+        return validator;
+    }
+    /**
+     * Clear current user
+     */
+    clearCurrentUser() {
+        this.user = undefined;
+    }
+    /**
+     * Get value of the given header
+     */
+    header(name, defaultValue = null) {
+        return this.baseRequest.headers[name] ?? defaultValue;
+    }
+    /**
+     * Get the current request domain
+     */
+    get domain() {
+        return this.baseRequest.hostname.replace(/^www\./, "");
+    }
+    /**
+     * Get hostname
+     */
+    get hostname() {
+        return this.domain;
+    }
+    /**
+     * Get request origin
+     */
+    get origin() {
+        return this.baseRequest.headers.origin;
+    }
+    /**
+     * Get the domain of the origin
+     */
+    get originDomain() {
+        const domain = this.origin ? new URL(this.origin).hostname : null;
+        if (domain?.startsWith("www.")) {
+            return domain.replace(/^www\./, "");
+        }
+        return domain;
+    }
+    /**
+     * Get authorization header value
+     */
+    get authorizationValue() {
+        const authorization = this.header("authorization");
+        if (!authorization)
+            return null;
+        const [type, value] = authorization.split(" ");
+        if (!["bearer", "key"].includes(type.toLowerCase()))
+            return "";
+        return value || "";
+    }
+    /**
+     * Get access token from Authorization header
+     *
+     * If the Authorization header does not start with `Bearer` value then return null
+     */
+    get accessToken() {
+        const authorization = this.header("authorization");
+        if (!authorization)
+            return null;
+        const [type, value] = authorization.split(" ");
+        if (type.toLowerCase() !== "bearer")
+            return null;
+        return value;
+    }
+    /**
+     * Get the authorization header
+     */
+    get authorization() {
+        return this.header("authorization");
+    }
+    /**
+     * Get current request method
+     */
+    get method() {
+        return this.baseRequest.method;
+    }
+    /**
+     * Parse the payload and merge it from the request body, params and query string
+     */
+    parsePayload() {
+        this.payload.body = this.parseBody(this.baseRequest.body);
+        this.payload.query = this.parseBody(this.baseRequest.query);
+        this.payload.params = { ...this.baseRequest.params };
+        this.payload.all = {
+            ...this.payload.body,
+            ...this.payload.query,
+            ...this.payload.params,
+        };
+    }
+    /**
+     * Parse body payload
+     */
+    parseBody(data) {
+        try {
+            if (!data)
+                return {};
+            const body = {};
+            const arrayOfObjectValues = {};
+            for (let key in data) {
+                const value = data[key];
+                let isArrayKey = false;
+                if (key.endsWith("[]")) {
+                    isArrayKey = true;
+                }
+                key = rtrim(key, "[]");
+                // check if the key is has a square brackets, then convert it into object
+                // i.e user[email] => user: {email: "value"}
+                // also check if its an array of objects
+                if (key.includes("[")) {
+                    // check if its an array of objects
+                    if (key.includes("][")) {
+                        const keyParts = key.split("[");
+                        const keyName = keyParts[0];
+                        if (!arrayOfObjectValues[keyName]) {
+                            arrayOfObjectValues[keyName] = [];
+                        }
+                        const keyNameParts = keyParts[1].split("]");
+                        const index = Number(keyNameParts[0]);
+                        if (!arrayOfObjectValues[keyName][index]) {
+                            arrayOfObjectValues[keyName][index] = {};
+                        }
+                        // now get the key after the index
+                        const keyNameParts2 = keyParts[2].split("]");
+                        const keyName2 = keyNameParts2[0];
+                        arrayOfObjectValues[keyName][index][keyName2] =
+                            this.parseInputValue(value);
+                        continue;
+                    }
+                    const keyParts = key.split("[");
+                    const keyName = keyParts[0];
+                    const keyNameParts = keyParts[1].split("]");
+                    set(body, keyName + "." + keyNameParts[0], Array.isArray(value)
+                        ? value.map(this.parseInputValue.bind(this))
+                        : this.parseInputValue(value));
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    body[key] = value.map(this.parseInputValue.bind(this));
+                }
+                else if (isArrayKey) {
+                    if (body[key]) {
+                        body[key].push(this.parseInputValue(value));
+                    }
+                    else {
+                        body[key] = [this.parseInputValue(value)];
+                        continue;
+                    }
+                }
+                else {
+                    body[key] = this.parseInputValue(value);
+                }
+            }
+            // now merge the array of objects into the body
+            for (const key in arrayOfObjectValues) {
+                body[key] = arrayOfObjectValues[key];
+            }
+            return body;
+        }
+        catch (error) {
+            console.log(error);
+            this.log(error, "error");
+        }
+    }
+    /**
+     * Parse the given data
+     */
+    parseInputValue(data) {
+        // data.value appears only in the multipart form data
+        // if it json, then just return the data
+        if (data?.file)
+            return data;
+        // this should not be considered used because the value key could be used as an actual input key
+        // if (data.value !== undefined) return data.value;
+        if (data === "false")
+            return false;
+        if (data === "true")
+            return true;
+        if (data === "null")
+            return null;
+        // if (isNumeric(data) && !String(data).startsWith("0")) return Number(data);
+        if (typeof data === "string")
+            return data.trim();
+        if (data?.value && data?.fields && data?.type)
+            return data.value;
+        return data;
+    }
+    /**
+     * Set route handler
+     */
+    setRoute(route) {
+        this.route = route;
+        // pass the route to the response object
+        this.response.setRoute(route);
+        return this;
+    }
+    /**
+     * Trigger an http event
+     */
+    trigger(eventName, ...args) {
+        return events.trigger(`request.${eventName}`, ...args, this);
+    }
+    /**
+     * Listen to the given event
+     */
+    on(eventName, callback) {
+        return this.trigger(eventName, callback);
+    }
+    /**
+     * Make a log message
+     */
+    log(message, level = "info") {
+        if (!config.get("http.log"))
+            return;
+        log("request", this.route.method + " " + this.route.path.replace("/*", ""), message, level);
+    }
+    /**
+     * Get current request path
+     */
+    get path() {
+        return this.baseRequest.url;
+    }
+    /**
+     * {@alias}
+     */
+    get url() {
+        return this.baseRequest.url;
+    }
+    /**
+     * Get full url
+     */
+    get fullUrl() {
+        return this.protocol + "://" + this.hostname + this.path;
+    }
+    /**
+     * Run middleware
+     */
+    async runMiddleware() {
+        // measure request time
+        // check for middleware first
+        const middlewareOutput = await this.executeMiddleware();
+        if (middlewareOutput !== undefined) {
+            // 👇🏻 make sure first its not a response instance
+            if (middlewareOutput instanceof Response)
+                return middlewareOutput;
+            // 👇🏻 send the response
+            return this.response.send(middlewareOutput);
+        }
+        const handler = this.route.handler;
+        if (!handler.validation)
+            return;
+        // 👇🏻 check for validation using validateAll helper function
+        const validationOutput = await validateAll(handler.validation, this, this.response);
+        return validationOutput;
+    }
+    /**
+     * Get route handler
+     */
+    getHandler() {
+        return this.route.handler;
+    }
+    /**
+     * Get inputs that has been validated only
+     */
+    validated() {
+        let rules = this.getHandler()?.validation?.rules || {};
+        if (rules instanceof ValidationSchema) {
+            rules = rules.inputs;
+        }
+        return this.only(Object.keys(rules));
+    }
+    /**
+     * Execute the request
+     */
+    async execute() {
+        try {
+            // call executingAction event
+            this.log("Executing the request");
+            await createuseRequestStore(this, this.response);
+        }
+        catch (error) {
+            this.log(error, "error");
+            throw error;
+        }
+    }
+    /**
+     * Execute middleware list of current route
+     */
+    async executeMiddleware() {
+        // collect all middlewares for current route
+        const middlewares = this.collectMiddlewares();
+        // check if there are no middlewares, then return
+        if (middlewares.length === 0)
+            return;
+        this.log("About to execute request middlewares");
+        // trigger the executingMiddleware event
+        this.trigger("executingMiddleware", middlewares, this.route);
+        for (const middleware of middlewares) {
+            this.log("Executing middleware " + colors.yellowBright(middleware.name));
+            const output = await middleware(this, this.response);
+            this.log("Executed middleware " + colors.yellowBright(middleware.name));
+            if (output !== undefined) {
+                this.log(colors.yellow("request intercepted by middleware ") +
+                    colors.cyanBright(middleware.name), "warn");
+                this.trigger("executedMiddleware");
+                this.log("Request middlewares executed");
+                return output;
+            }
+        }
+        this.log("Request middlewares executed");
+        // trigger the executedMiddleware event
+        this.trigger("executedMiddleware", middlewares, this.route);
+    }
+    /**
+     * Collect middlewares for current route
+     */
+    collectMiddlewares() {
+        // we'll collect middlewares from 4 places
+        // We'll collect from http configurations under `http.middleware` config
+        // it has 3 middlewares types, `all` `only` and `except`
+        // and the final one will be the middlewares in the route itself
+        // so the order of collecting and executing will be: `all` `only` `except` and `route`
+        const middlewaresList = [];
+        // 1- collect all middlewares as they will be executed first
+        const allMiddlewaresConfigurations = httpConfig("middleware.all");
+        // check if it has middleware list
+        if (allMiddlewaresConfigurations) {
+            // now just push everything there
+            middlewaresList.push(...allMiddlewaresConfigurations);
+        }
+        // 2- check if there is `only` property
+        const onlyMiddlewaresConfigurations = httpConfig("middleware.only");
+        if (onlyMiddlewaresConfigurations?.middleware) {
+            // check if current route exists in the `routes` property
+            // or the route has a name and exists in `namedRoutes` property
+            if (onlyMiddlewaresConfigurations.routes?.includes(this.route.path) ||
+                (this.route.name &&
+                    onlyMiddlewaresConfigurations.namedRoutes?.includes(this.route.name))) {
+                middlewaresList.push(...onlyMiddlewaresConfigurations.middleware);
+            }
+        }
+        // 3- collect routes from except middlewares
+        const exceptMiddlewaresConfigurations = httpConfig("middleware.except");
+        if (exceptMiddlewaresConfigurations?.middleware) {
+            // first check if there is `routes` property and route path is not listed there
+            // then check if route has name and that name is not listed in `namedRoutes` property
+            if (!exceptMiddlewaresConfigurations.routes?.includes(this.route.path) &&
+                this.route.name &&
+                !exceptMiddlewaresConfigurations.namedRoutes?.includes(this.route.name)) {
+                middlewaresList.push(...exceptMiddlewaresConfigurations.middleware);
+            }
+        }
+        // 4- collect routes from route middlewares
+        if (this.route.middleware) {
+            middlewaresList.push(...this.route.middleware);
+        }
+        return middlewaresList;
+    }
+    /**
+     * Get request input value from query string, params or body
+     */
+    input(key, defaultValue) {
+        return get(this.payload.all, key, defaultValue);
+    }
+    /**
+     * @alias input
+     */
+    get(key, defaultValue) {
+        return this.input(key, defaultValue);
+    }
+    /**
+     * Determine if request has input value
+     */
+    has(key) {
+        return get(this.payload.all, key, undefined) !== undefined;
+    }
+    /**
+     * Set request input value
+     */
+    set(key, value) {
+        set(this.payload.all, key, value);
+        return this;
+    }
+    /**
+     * Set the given value if the request does not have the input
+     */
+    setDefault(key, value) {
+        if (this.has(key))
+            return this;
+        set(this.payload.all, key, value);
+        return this;
+    }
+    /**
+     * Unset request payload keys
+     */
+    unset(...keys) {
+        this.payload.all = unset(this.payload.all, keys);
+        return this;
+    }
+    /**
+     * Get request body
+     */
+    get body() {
+        return this.payload.body;
+    }
+    /**
+     * Get body inputs except files
+     */
+    get bodyInputs() {
+        const inputs = this.payload.body;
+        const bodyInputs = {};
+        for (const key in inputs) {
+            const value = inputs[key];
+            if (value.file && value.fieldname)
+                continue;
+            bodyInputs[key] = value;
+        }
+        return bodyInputs;
+    }
+    /**
+     * Get request file in UploadedFile instance
+     */
+    file(key) {
+        const file = this.input(key);
+        return file
+            ? Array.isArray(file)
+                ? file.map(file => new UploadedFile(file))
+                : new UploadedFile(file)
+            : null;
+    }
+    /**
+     * Get uploaded files from the request for the given name
+     * If the given name is not present in the request, return an empty array
+     */
+    files(name) {
+        const files = this.input(name);
+        return Array.isArray(files)
+            ? files.map(file => new UploadedFile(file))
+            : [];
+    }
+    /**
+     * Get request params
+     */
+    get params() {
+        return this.payload.params;
+    }
+    /**
+     * Get request query
+     */
+    get query() {
+        return this.payload.query;
+    }
+    /**
+     * Get all inputs
+     */
+    all() {
+        return this.payload.all;
+    }
+    /**
+     * Get all inputs except params
+     */
+    allExceptParams() {
+        return {
+            ...this.payload.query,
+            ...this.payload.body,
+        };
+    }
+    /**
+     * Get all heavy inputs except params
+     */
+    heavyExceptParams() {
+        const inputs = this.allExceptParams();
+        const heavyInputs = {};
+        for (const key in inputs) {
+            const value = inputs[key];
+            if (isEmpty(value) && value !== null)
+                continue;
+            heavyInputs[key] = value;
+        }
+        return heavyInputs;
+    }
+    /**
+     * Get only heavy inputs, the input with a value
+     */
+    heavy() {
+        const inputs = this.all();
+        const heavyInputs = {};
+        for (const key in inputs) {
+            const value = inputs[key];
+            if (isEmpty(value) && value !== null)
+                continue;
+            heavyInputs[key] = value;
+        }
+        return heavyInputs;
+    }
+    /**jobssr41@gmail.com
+     * Get only the given keys from the request data
+     */
+    only(keys) {
+        return only(this.all(), keys);
+    }
+    /**
+     * Get all request inputs except the given keys
+     */
+    except(keys) {
+        return except(this.all(), keys);
+    }
+    /**
+     * Get boolean input value
+     */
+    bool(key, defaultValue = false) {
+        const value = this.input(key, defaultValue);
+        if (value === "true") {
+            return true;
+        }
+        if (value === "false") {
+            return false;
+        }
+        return Boolean(value);
+    }
+    /**
+     * Get integer input value
+     */
+    int(key, defaultValue) {
+        const value = this.input(key, defaultValue);
+        return parseInt(value);
+    }
+    /**
+     * Get string input value
+     */
+    string(key, defaultValue = "") {
+        const value = this.input(key, defaultValue);
+        return String(value);
+    }
+    /**
+     * Get float input value
+     */
+    float(key, defaultValue = 0) {
+        const value = this.input(key, defaultValue);
+        return parseFloat(value);
+    }
+    /**
+     * Get number input value
+     */
+    number(key, defaultValue = 0) {
+        const value = Number(this.input(key, defaultValue));
+        return isNaN(value) ? defaultValue : value;
+    }
+    /**
+     * Get request ip
+     */
+    get ip() {
+        return this.baseRequest.ip;
+    }
+    /**
+     * Detect proper ip
+     */
+    detectIp() {
+        // as the server maybe used behind a proxy
+        // then we need to check first if there is a forwarded ip
+        // check for the real-ip header
+        const realIp = this.header("x-real-ip");
+        if (realIp)
+            return realIp;
+        const forwardedIp = this.header("x-forwarded-for");
+        return forwardedIp || this.baseRequest.ip;
+    }
+    /**
+     * An alias to detectIp
+     */
+    get realIp() {
+        return this.detectIp();
+    }
+    /**
+     * Get request ips
+     */
+    get ips() {
+        return this.baseRequest.ips;
+    }
+    /**
+     * Get request referer
+     */
+    get referer() {
+        return this.baseRequest.headers.referer;
+    }
+    /**
+     * Get user agent
+     */
+    get userAgent() {
+        return this.baseRequest.headers["user-agent"];
+    }
+    /**
+     * Get request headers
+     */
+    get headers() {
+        return this.baseRequest.headers;
+    }
+}export{Request};//# sourceMappingURL=request.js.map