@warlock.js/core 4.0.48 → 4.0.59

package/esm/http/request.js

@@ -0,0 +1,733 @@
+import {colors}from'@mongez/copper';import events from'@mongez/events';import {trans,transFrom}from'@mongez/localization';import {Random,rtrim,set,only,except,get,unset}from'@mongez/reinforcements';import {isEmpty}from'@mongez/supportive-is';import {log}from'@warlock.js/logger';import {v}from'@warlock.js/seal';import {config}from'../config/config-getter.js';import {validateAll}from'../validation/validateAll.js';import {createRequestStore}from'./middleware/inject-request-context.js';import {Response}from'./response.js';import {UploadedFile}from'./uploaded-file.js';class Request {
+    /**
+     * Fastify Request object
+     */
+    baseRequest;
+    /**
+     * Response Object
+     */
+    response;
+    /**
+     * Route Object
+     */
+    route;
+    /**
+     * Parsed Request Payload
+     */
+    payload = {};
+    /**
+     * Current user
+     */
+    user;
+    /**
+     * Decoded access token payload (set by auth middleware)
+     */
+    decodedAccessToken;
+    /**
+     * 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 = "";
+    /**
+     * Validated data
+     */
+    validatedData;
+    /**
+     * Request id
+     */
+    id = Random.string(32);
+    /**
+     * 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.query["locale"] ||
+                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.key("app.localeCode") || "en") {
+        return this.locale || defaultLocaleCode;
+    }
+    /**
+     * Get http protocol
+     */
+    get protocol() {
+        return this.baseRequest.protocol;
+    }
+    /**
+     * Validate the given validation schema
+     */
+    async validate(validation, selectedInputs) {
+        return await v.validate(validation, selectedInputs ? this.only(selectedInputs) : this.all());
+    }
+    /**
+     * Clear current user
+     */
+    clearCurrentUser() {
+        this.user = undefined;
+    }
+    /**
+     * Get value of the given header
+     */
+    header(name, defaultValue = null) {
+        return this.baseRequest.headers[name.toLocaleLowerCase()] ?? 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 "";
+        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;
+        const [type, value] = authorization.split(" ");
+        if (type.toLowerCase() !== "bearer")
+            return;
+        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.parseValue(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.parseValue.bind(this)) : this.parseValue(value));
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    set(body, key, value.map(this.parseValue.bind(this)));
+                }
+                else if (isArrayKey) {
+                    if (body[key]) {
+                        body[key].push(this.parseValue(value));
+                    }
+                    else {
+                        body[key] = [this.parseValue(value)];
+                        continue;
+                    }
+                }
+                else {
+                    set(body, key, this.parseValue(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
+     */
+    parseValue(data) {
+        // data.value appears only in the multipart form data
+        // if it json, then just return the data
+        if (data?.file)
+            return new UploadedFile(data);
+        if (data?.value !== undefined && data?.fields && data?.type) {
+            data = data.value;
+        }
+        if (data === "false")
+            return false;
+        if (data === "true")
+            return true;
+        if (data === "null")
+            return null;
+        if (typeof data === "string")
+            return data.trim();
+        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.subscribe(eventName, callback);
+    }
+    /**
+     * Make a log message
+     */
+    log(message, level = "info") {
+        if (!config.key("http.log"))
+            return;
+        log({
+            module: "request",
+            action: this.route.method + " " + this.route.path.replace("/*", "") + `:${this.id}`,
+            message,
+            type: level,
+            context: {
+                request: this,
+            },
+        });
+    }
+    /**
+     * 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
+     * You can also pass an array of inputs to get only the validated inputs
+     */
+    validated(inputs) {
+        if (this.validatedData) {
+            return inputs ? only(this.validatedData, inputs) : this.validatedData;
+        }
+        return {};
+    }
+    /**
+     * Get inputs that has been validated except the given inputs
+     */
+    validatedExcept(...inputs) {
+        return except(this.validated(), inputs);
+    }
+    /**
+     * Set validated data
+     */
+    setValidatedData(data) {
+        this.validatedData = data;
+    }
+    /**
+     * Execute the request
+     */
+    async execute() {
+        try {
+            // call executingAction event
+            this.log("Executing the request");
+            return await createRequestStore(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), "success");
+            if (output !== undefined) {
+                this.log(colors.yellow("request intercepted by middleware ") + colors.cyanBright(middleware.name), "warn");
+                this.trigger("executedMiddleware");
+                this.log("Request middlewares executed", "success");
+                return output;
+            }
+        }
+        this.log("Request middlewares executed", "success");
+        // trigger the executedMiddleware event
+        this.trigger("executedMiddleware", middlewares, this.route);
+    }
+    /**
+     * Collect middlewares for current route
+     */
+    collectMiddlewares() {
+        const middlewaresList = [];
+        // collect 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);
+    }
+    /**
+     * Get email input value, this will lowercase the value
+     */
+    email(key = "email", defaultValue = "") {
+        return this.input(key, defaultValue)?.toLowerCase() || 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;
+    }
+    /**
+     * Set request body value
+     */
+    setBody(key, value) {
+        set(this.payload.body, key, value);
+        return this;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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) {
+        return this.input(name) || [];
+    }
+    /**
+     * Get request params
+     */
+    get params() {
+        return this.payload.params;
+    }
+    /**
+     * Set request params value
+     */
+    setParam(key, value) {
+        set(this.payload.params, key, value);
+        return this;
+    }
+    /**
+     * Get request query
+     */
+    get query() {
+        return this.payload.query;
+    }
+    /**
+     * Set request query value
+     */
+    setQuery(key, value) {
+        set(this.payload.query, key, value);
+        return this;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Get only the given keys from the request data
+     */
+    only(keys) {
+        return only(this.all(), keys);
+    }
+    /**
+     * Pluck the given keys from the request data
+     */
+    pluck(keys) {
+        const data = this.only(keys);
+        this.unset(...keys);
+        return data;
+    }
+    /**
+     * 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;
+        }
+        if (value === 0) {
+            return false;
+        }
+        return Boolean(value);
+    }
+    /**
+     * Get integer input value
+     */
+    int(key, defaultValue = 0) {
+        const value = this.input(key, defaultValue);
+        return parseInt(value);
+    }
+    /**
+     * Shorthand getter to get id param
+     */
+    get idParam() {
+        return this.int("id");
+    }
+    /**
+     * 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) || 0;
+    }
+    /**
+     * 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