@codenameryuu/adonis-datatable/build/src/processor.js

Server side datatables package for Adonis JS

import lodash from "lodash";
import Helper from "./utils/helper.js";
export default class DataProcessor {
    $results;
    templates;
    start;
    config;
    $output = [];
    $appendColumns = {};
    $editColumns = {};
    $rawColumns = [];
    $onlyColumns = [];
    $excessColumns = [];
    $escapeColumns = [];
    $includeIndex = false;
    $exceptions = ["DT_RowId", "DT_RowClass", "DT_RowData", "DT_RowAttr"];
    constructor($results, columnDef, templates, start = 0, config) {
        this.$results = $results;
        this.templates = templates;
        this.start = start;
        this.config = config;
        this.$appendColumns = columnDef["append"] ?? {};
        this.$editColumns = columnDef["edit"] ?? {};
        this.$rawColumns = columnDef["raw"] ?? [];
        this.$onlyColumns = columnDef["only"] ?? [];
        this.$excessColumns = columnDef["excess"] ?? [];
        this.$escapeColumns = columnDef["escape"] ?? [];
        this.$includeIndex = columnDef["index"] ?? false;
    }
    process(isObject = true) {
        const indexColumn = this.config.get("index_column", "DT_RowIndex");
        for (const row of Object.values(this.$results)) {
            const data = Helper.serializeToObject(row);
            let value = this.addColumns(data, row);
            value = this.editColumns(value, row);
            value = this.setupRowVariables(value, row);
            value = this.selectOnlyNeededColumns(value);
            value = this.removeExcessColumns(value);
            if (this.$includeIndex) {
                value[indexColumn] = ++this.start;
            }
            this.$output.push(isObject ? value : this.convertToArray(value));
        }
        return this.escapeColumns(this.$output);
    }
    addColumns(data, row) {
        for (const value of Object.values(this.$appendColumns)) {
            const content = value["content"];
            const resultContent = Helper.compileContent(content, data, row);
            data = Helper.objectIncludeIn({ ...value, content: resultContent }, data);
        }
        return data;
    }
    editColumns(data, row) {
        for (const value of Object.values(this.$editColumns)) {
            const resultContent = Helper.compileContent(value["content"], data, row);
            lodash.set(data, value["name"], resultContent);
        }
        return data;
    }
    setupRowVariables(data, row) {
        return new RowProcessor(data, row)
            .rowValue("DT_RowId", this.templates["DT_RowId"])
            .rowValue("DT_RowClass", this.templates["DT_RowClass"])
            .rowData("DT_RowData", this.templates["DT_RowData"])
            .rowData("DT_RowAttr", this.templates["DT_RowAttr"])
            .getData();
    }
    selectOnlyNeededColumns(data) {
        if (!this.$onlyColumns.length) {
            return data;
        }
        else {
            const results = {};
            for (const value of Object.values(this.$onlyColumns)) {
                lodash.set(results, value, lodash.get(data, value));
            }
            for (const value of Object.values(this.$exceptions)) {
                if (lodash.get(data, value)) {
                    lodash.set(results, value, lodash.get(data, value));
                }
            }
            return results;
        }
    }
    removeExcessColumns(data) {
        for (const value of Object.values(this.$excessColumns)) {
            lodash.unset(data, value);
        }
        return data;
    }
    convertToArray(array) {
        const data = [];
        for (const [key, value] of Object.entries(array)) {
            if (!data.includes(value)) {
                data[key] = value;
            }
        }
        return data;
    }
    escapeColumns(output) {
        return output.map((row) => {
            if (this.$escapeColumns === "*") {
                row = this.escapeRow(row);
            }
            else if (Array.isArray(this.$escapeColumns)) {
                const columns = this.$escapeColumns.filter((col) => !this.$rawColumns.includes(col));
                for (const key of columns) {
                    const content = lodash.get(row, key);
                    lodash.set(row, key, Helper.escape(content));
                }
            }
            return row;
        });
    }
    escapeRow(row) {
        const rawColumns = this.$rawColumns;
        const arrayDot = lodash.transform(row, (result, value, key) => {
            if (value) {
                result[key] = value;
            }
        });
        Object.keys(arrayDot).forEach((key) => {
            if (!rawColumns.includes(key)) {
                const value = lodash.get(arrayDot, key);
                if (lodash.isString(value) || lodash.isElement(value)) {
                    arrayDot[key] = Helper.escape(value);
                }
            }
        });
        Object.keys(arrayDot).forEach((key) => {
            lodash.set(row, key, arrayDot[key]);
        });
        return row;
    }
}
class RowProcessor {
    data;
    row;
    constructor(data, row) {
        this.data = data;
        this.row = row;
    }
    rowValue(attribute, template) {
        if (template) {
            if (typeof template !== "function" && lodash.get(this.data, template)) {
                this.data[attribute] = lodash.get(this.data, template);
            }
            else {
                this.data[attribute] = Helper.compileContent(template, this.data, this.row);
            }
        }
        return this;
    }
    rowData(attribute, template) {
        if (Object.keys(template).length) {
            let data = {};
            for (const [index, value] of Object.entries(template)) {
                data[index] = Helper.compileContent(value, this.data, this.row);
            }
            this.data[attribute] = data;
        }
        return this;
    }
    getData() {
        return this.data;
    }
}