zet-lib 6.0.2 → 6.1.1

package/lib/generatorModel.js

@@ -2,774 +2,464 @@
  * Created by sintret dev on 10/1/2021.
  */
 const path = require("path");
+const fs = require("fs-extra");
 const configGenerator = require("./config_generator");
 const Model = require("./Model");
-const fs = require("fs-extra");
-const connection = require('./connection');
-const Util = require('./Util');
-const zRoute = require('./zRoute');
+const Util = require("./Util");
+const zRoute = require("./zRoute");
 
 const me = {};
-let defaultValues = {};
-
-me.prepare = (MYMODEL) => {
-    const left = MYMODEL.left || [];
-    const right = MYMODEL.right || [];
-    const properties = MYMODEL.properties || {};
-    let details = MYMODEL.details || {};
-    let labels = MYMODEL.labels || {};
-
-    //remove custom type
-    let customs = [];
-    let visibles = [];
-    let visiblesArr = [];
-    let visiblesObj = {}
-    for (let key in properties) {
-        let propKey = properties[key].values
-        if (
-            Object.prototype.hasOwnProperty.call(
-                properties[key].values,
-                "defaultValue"
-            ) &&
-            properties[key].values.defaultValue
-        ) {
-            defaultValues[key] = properties[key].values.defaultValue;
-        }
-        if (properties[key].type == "custom") {
-            customs.push(key);
-        }
-        if (propKey.visibles ==1) {
-            visibles.push(key)
-            visiblesArr.push({key:key, value: +propKey.no_visible});
-            visiblesObj[key] = +propKey.no_visible
-        }
-    }
-    if (customs.length) {
-        customs.map((item) => {
-            for (var key in MYMODEL.details) {
-                details[key] = MYMODEL.details[key].filter((d) => !customs.includes(d));
-            }
-            delete labels[item];
-        });
+const asArray = (value) => (Array.isArray(value) ? value : []);
+const isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const hasOwn = (obj, key) => !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+const appRoot = () => Util.dirRoot || global.dirRoot || process.cwd();
+
+const flattenVisibleItems = (list, visibles) => {
+  asArray(list).forEach((item) => {
+    if (typeof item === "object" && item) {
+      Object.keys(item).forEach((key) => {
+        visibles.push(...asArray(item[key]));
+      });
+    } else if (item) {
+      visibles.push(item);
     }
+  });
+};
 
-    const datas = {};
-    const obj = {};
-    obj.table = MYMODEL.table;
-    obj.routeName = MYMODEL.route;
-    obj.title = MYMODEL.name;
-    obj.hasTabs =
-        Object.prototype.hasOwnProperty.call(MYMODEL, "tabs") &&
-        MYMODEL.tabs &&
-        MYMODEL.tabs.length > 0
-            ? true
-            : false;
-    obj.tabs = MYMODEL.tabs || [];
-    obj.tabsDetail = details || {};
-    obj.keys = Object.keys(labels).filter((item) => !customs.includes(item));
-    obj.keysExcel = obj.keys;
-    obj.labels = labels;
-    obj.labels.no = "#";
-    obj.labels.actionColumn = "Action";
-    obj.fields = me.fields(MYMODEL);
-    obj.options = {};
-    obj.hasApproval =
-        MYMODEL.hasOwnProperty("is_approval") && MYMODEL.is_approval ? true : false;
-
-    for (let key in obj.fields) {
-        obj.options[key] = obj.fields[key].search;
-        datas[key] = defaultValues[key] == "null" ? "" : defaultValues[key] || "";
-    }
+const writeRuntimeFile = (kind, table, key, content) => {
+  if (!table || !key || content == null || content === "") return;
+  const dir = path.join(appRoot(), "public", "runtime", kind, table);
+  fs.ensureDirSync(dir);
+  fs.writeFileSync(path.join(dir, `${key}.txt`), String(content));
+};
 
-    obj.grids = {
-        visibles: ["no"],
-        invisibles: [],
-    };
-    //old visibles
-    if(visibles.length == 0){
-        left.forEach(function (item) {
-            if (typeof item == "object") {
-                for (const key in item) {
-                    visibles = [...visibles, ...item[key]];
-                }
-            } else {
-                visibles.push(item);
-            }
-        });
-        if (visibles.length < 4) {
-            right.forEach(function (item) {
-                if (typeof item == "object") {
-                    for (const key in item) {
-                        visibles = [...visibles, ...item[key]];
-                    }
-                } else {
-                    visibles.push(item);
-                }
-            });
-        }
-        if (visibles.length == 0) {
-            let num = 1;
-            let nots = Util.nots;
-            nots.push("no");
-            for (let key in labels) {
-                if (!Util.in_array(key, nots)) {
-                    if (num < 6) {
-                        visibles.push(key);
-                    }
-                    num++;
-                }
-            }
-        }
-        obj.grids.visibles = [
-            ...["no"],
-            ...visibles.filter((item, index) => {
-                return index < 6;
-            }),
-            ...["actionColumn"],
-        ];
-
-    } else {
-        //new visibles
-        console.log(visiblesArr)
-        let sortVisibles = Util.sortArray(visiblesArr, "value")
-        visibles = sortVisibles.map((item) => item.key)
-        console.log(visibles)
-        obj.grids.visibles = [
-            ...["no"],
-            ...visibles,
-            ...["actionColumn"],
-        ];
-    }
+const modelType = (type) => (type && Model[type] ? Model[type] : null);
 
-    obj.grids.invisibles = Object.keys(labels).filter((item) => {
-        return !obj.grids.visibles.includes(item);
-    });
+const fieldDefaults = {
+  integer: { type: "int", category: "integer", length: 11, required: true, search: "=", key: "" },
+  datetime: { type: "datetime", category: "datetime", length: "", required: false, search: "ILIKE", key: "" },
+  lock: { type: "int", category: "integer", length: "1", required: false, search: "=", key: "" },
+  approval_status: { type: "select", category: "integer", length: "", required: false, search: "=", key: "" },
+  approval_history: { type: "json_array", category: "array", length: "2", required: false, search: "=", key: "" },
+};
 
-    obj.datas = datas;
+const mergeField = (base, extra = {}) => Object.assign({}, fieldDefaults[base] || {}, extra);
 
-    //define what are widgets
-    //except text,textarea,
-    //var nots = ['text','textarea'];
-    const widgets = {};
-    const labelsArray = Object.keys(obj.fields);
+const selectFields = (values) => asArray(values && values.select).reduce((result, item) => {
+  if (!item) return result;
+  result[item.value] = item.label;
+  return result;
+}, {});
 
-    widgets["id"] = {
-        name: "integer",
-        hidden: false,
-    };
-    if (Util.in_array("lock", labelsArray)) {
-        widgets["lock"] = {
-            name: "switch",
-            hidden: true,
-            hasInputGroup: false,
-            required: false,
-            float: false,
-            inline: false,
-            readonly: false,
-            fields: ["Unlock", "Locked"],
-        };
-    }
-    if (Util.in_array("approval_status", labelsArray)) {
-        widgets["approval_status"] = {
-            name: "select",
-            title: "Approval Status",
-            placeholder: "Approval Status",
-            type: "select",
-            category: "integer",
-            length: "",
-            required: false,
-            search: "=",
-            key: "",
-            hidden: false,
-            hasInputGroup: false,
-            float: false,
-            inline: false,
-            readonly: false,
-            fields: {
-                1: "New",
-                2: "Check",
-                11: "Approve 1",
-                12: "Approve 2",
-                13: "Approve 3",
-                14: "Approve 4",
-                15: "Approve 5",
-                16: "Approve 6",
-                17: "Approve 7",
-                18: "Approve 8",
-                19: "Approve 9",
-                20: "Approve 10",
-                21: "Final Approve",
-                22: "Reject",
-            },
-            array: [
-                { value: "1", label: "New" },
-                { value: "2", label: "Check" },
-                { value: "11", label: "Approve 1" },
-                { value: "12", label: "Approve 2" },
-                { value: "13", label: "Approve 3" },
-                { value: "14", label: "Approve 4" },
-                { value: "15", label: "Approve 5" },
-                { value: "16", label: "Approve 6" },
-                { value: "17", label: "Approve 7" },
-                { value: "18", label: "Approve 8" },
-                { value: "19", label: "Approve 9" },
-                { value: "20", label: "Approve 10" },
-                { value: "21", label: "Final Approve" },
-                { value: "22", label: "Reject" },
-            ],
-            please_select: "",
-        };
+me.prepare = (MYMODEL) => {
+  const model = isPlainObject(MYMODEL) ? MYMODEL : {};
+  const left = asArray(model.left);
+  const right = asArray(model.right);
+  const properties = isPlainObject(model.properties) ? model.properties : {};
+  const labels = isPlainObject(model.labels) ? { ...model.labels } : {};
+  const details = isPlainObject(model.details) ? { ...model.details } : {};
+  const defaultValues = {};
+  const customs = [];
+  let visibles = [];
+  const visiblesArr = [];
+
+  Object.keys(properties).forEach((key) => {
+    const property = properties[key] || {};
+    const values = isPlainObject(property.values) ? property.values : {};
+    if (hasOwn(values, "defaultValue") && values.defaultValue) {
+      defaultValues[key] = values.defaultValue;
     }
-    if (Util.in_array("approval_history", labelsArray)) {
-        widgets["approval_history"] = {
-            name: "json_array",
-            hidden: false,
-            hasInputGroup: false,
-            required: false,
-            float: false,
-            inline: false,
-            readonly: false,
-        };
+    if (property.type === "custom") customs.push(key);
+    if (values.visibles == 1) {
+      visibles.push(key);
+      visiblesArr.push({ key, value: +values.no_visible });
     }
-    if (Util.in_array("created_at", labelsArray)) {
-        widgets["created_at"] = {
-            name: "datetime",
-            hidden: true,
-        };
+  });
+
+  if (customs.length) {
+    Object.keys(details).forEach((key) => {
+      details[key] = asArray(model.details && model.details[key]).filter((item) => !customs.includes(item));
+    });
+    customs.forEach((item) => {
+      delete labels[item];
+    });
+  }
+
+  const obj = {
+    table: model.table,
+    routeName: model.route,
+    title: model.name,
+    hasTabs: asArray(model.tabs).length > 0,
+    tabs: asArray(model.tabs),
+    tabsDetail: details,
+    keys: Object.keys(labels).filter((item) => !customs.includes(item)),
+    labels,
+    fields: me.fields(model),
+    options: {},
+    hasApproval: !!model.is_approval,
+    grids: { visibles: ["no"], invisibles: [] },
+  };
+  obj.keysExcel = obj.keys;
+  obj.labels.no = "#";
+  obj.labels.actionColumn = "Action";
+
+  const datas = {};
+  Object.keys(obj.fields).forEach((key) => {
+    obj.options[key] = obj.fields[key].search;
+    datas[key] = defaultValues[key] === "null" ? "" : defaultValues[key] || "";
+  });
+  obj.datas = datas;
+
+  if (!visibles.length) {
+    flattenVisibleItems(left, visibles);
+    if (visibles.length < 4) flattenVisibleItems(right, visibles);
+    if (!visibles.length) {
+      const nots = asArray(Util.nots).concat(["no"]);
+      Object.keys(labels).forEach((key) => {
+        if (!Util.in_array(key, nots) && visibles.length < 5) visibles.push(key);
+      });
     }
-    if (Util.in_array("updated_at", labelsArray)) {
-        widgets["updated_at"] = {
-            name: "datetime",
-            hidden: true,
-        };
+    obj.grids.visibles = ["no", ...visibles.filter((_, index) => index < 6), "actionColumn"];
+  } else {
+    visibles = Util.sortArray(visiblesArr, "value").map((item) => item.key);
+    obj.grids.visibles = ["no", ...visibles, "actionColumn"];
+  }
+  obj.grids.invisibles = Object.keys(labels).filter((item) => !obj.grids.visibles.includes(item));
+
+  const labelsArray = Object.keys(obj.fields);
+  const widgets = {
+    id: { name: "integer", hidden: false },
+  };
+
+  if (Util.in_array("lock", labelsArray)) {
+    widgets.lock = {
+      name: "switch",
+      hidden: true,
+      hasInputGroup: false,
+      required: false,
+      float: false,
+      inline: false,
+      readonly: false,
+      fields: ["Unlock", "Locked"],
+    };
+  }
+  if (Util.in_array("approval_status", labelsArray)) {
+    widgets.approval_status = {
+      name: "select",
+      title: "Approval Status",
+      placeholder: "Approval Status",
+      type: "select",
+      category: "integer",
+      length: "",
+      required: false,
+      search: "=",
+      key: "",
+      hidden: false,
+      hasInputGroup: false,
+      float: false,
+      inline: false,
+      readonly: false,
+      fields: {
+        1: "New", 2: "Check", 11: "Approve 1", 12: "Approve 2", 13: "Approve 3",
+        14: "Approve 4", 15: "Approve 5", 16: "Approve 6", 17: "Approve 7",
+        18: "Approve 8", 19: "Approve 9", 20: "Approve 10", 21: "Final Approve", 22: "Reject",
+      },
+      array: [
+        { value: "1", label: "New" },
+        { value: "2", label: "Check" },
+        { value: "11", label: "Approve 1" },
+        { value: "12", label: "Approve 2" },
+        { value: "13", label: "Approve 3" },
+        { value: "14", label: "Approve 4" },
+        { value: "15", label: "Approve 5" },
+        { value: "16", label: "Approve 6" },
+        { value: "17", label: "Approve 7" },
+        { value: "18", label: "Approve 8" },
+        { value: "19", label: "Approve 9" },
+        { value: "20", label: "Approve 10" },
+        { value: "21", label: "Final Approve" },
+        { value: "22", label: "Reject" },
+      ],
+      please_select: "",
+    };
+  }
+  if (Util.in_array("approval_history", labelsArray)) {
+    widgets.approval_history = {
+      name: "json_array", hidden: false, hasInputGroup: false, required: false, float: false, inline: false, readonly: false,
+    };
+  }
+  if (Util.in_array("created_at", labelsArray)) widgets.created_at = { name: "datetime", hidden: true };
+  if (Util.in_array("updated_at", labelsArray)) widgets.updated_at = { name: "datetime", hidden: true };
+  if (Util.in_array("created_by", labelsArray)) {
+    widgets.created_by = { name: "relation", table: "zuser", fields: ["id", "fullname"], hidden: true };
+  }
+  if (Util.in_array("updated_by", labelsArray)) {
+    widgets.updated_by = { name: "relation", table: "zuser", fields: ["id", "fullname"], hidden: true };
+  }
+
+  Object.keys(properties).forEach((key) => {
+    const property = properties[key] || {};
+    const values = isPlainObject(property.values) ? property.values : {};
+    const type = property.type;
+    const widget = {
+      name: type,
+      hidden: values.hidden == "on",
+      hasInputGroup: false,
+      isAttributes: !!values.isAttributes,
+      onChange: !!(values.onChange && String(values.onChange).length > 4),
+      float: !!values.float,
+      inline: !!values.inline,
+      readonly: !!values.readonly,
+    };
+
+    if (values.inputGroupLeft) {
+      widget.inputGroupLeft = values.inputGroupLeft;
+      widget.hasInputGroup = true;
     }
-    if (Util.in_array("created_by", labelsArray)) {
-        widgets["created_by"] = {
-            name: "relation",
-            table: "zuser",
-            fields: ["id", "fullname"],
-            hidden: true,
-        };
+    if (values.inputGroupRight) {
+      widget.inputGroupRight = values.inputGroupRight;
+      widget.hasInputGroup = true;
     }
-    if (Util.in_array("updated_by", labelsArray)) {
-        widgets["updated_by"] = {
-            name: "relation",
-            table: "zuser",
-            fields: ["id", "fullname"],
-            hidden: true,
-        };
+    if (values.information) widget.information = JSON.stringify(values.information);
+    if (values.digitDecimal) widget.digitDecimal = values.digitDecimal;
+    if (values.thousandSeparator) widget.thousandSeparator = values.thousandSeparator;
+    if (values.decimalPlaces) widget.decimalPlaces = values.decimalPlaces;
+    if (values.defaultValue) widget.defaultValue = values.defaultValue;
+    if (hasOwn(values, "required")) widget.required = values.required;
+    if (hasOwn(values, "where")) widget.where = values.where || "";
+
+    switch (type) {
+      case "image":
+        widget.width = values.width || "300";
+        break;
+      case "datepicker":
+        widget.format = values.format || "YYYY-MM-DD";
+        break;
+      case "datetime":
+        widget.format = values.format || "YYYY-MM-DD HH:mm:ss";
+        break;
+      case "switch":
+        widget.fields = [values.notactive, values.active];
+        break;
+      case "table":
+        widget.table = values.table;
+        widget.hasCompanyId = true;
+        widget.search = values.search;
+        break;
+      case "multi_line_editor":
+        widget.table = values.table;
+        widget.fields = values.fields;
+        widget.description = values.description;
+        widget.hasCompanyId = true;
+        break;
+      case "select":
+      case "radio":
+        widget.fields = selectFields(values);
+        widget.array = asArray(values.select);
+        if (type === "select") widget.please_select = values.please_select;
+        break;
+      case "relation":
+        widget.table = values.table;
+        widget.fields = ["id", values.concat];
+        widget.isChain = values.isChain;
+        widget.isAttributes = !!values.isAttributes;
+        widget.isSearch = !!values.isSearch;
+        widget.chains = values.chains || [];
+        widget.hasCompanyId = true;
+        widget.please_select = values.please_select;
+        widget.order_by = values.order_by;
+        widget.import_field = values.import_field || "id";
+        widget.relation_info = !!values.relation_info;
+        if (widget.relation_info) writeRuntimeFile("info", model.table, key, values.relation_info);
+        if (widget.onChange) writeRuntimeFile("onchange", model.table, key, values.onChange);
+        break;
+      case "dragdrop":
+        widget.table = values.table;
+        widget.fields = ["id", values.concat];
+        widget.where = values.where || "";
+        widget.left = values.left || "";
+        widget.right = values.right || "";
+        widget.hasCompanyId = true;
+        widget.import_field = values.import_field || "id";
+        break;
+      case "typeahead":
+      case "dropdown_multi":
+        widget.table = values.table;
+        widget.fields = ["id", values.concat];
+        widget.hasCompanyId = true;
+        widget.order_by = values.order_by;
+        widget.import_field = values.import_field || "id";
+        if (type === "dropdown_multi") widget.hasChains = !!values.chains;
+        break;
+      case "dropdown_chain": {
+        const fieldValue = values.field || "";
+        widget.table = values.table;
+        widget.fields = ["id", values.concat];
+        widget.chains = fieldValue.indexOf(",") > -1 ? fieldValue.split(",") : [fieldValue];
+        widget.hasCompanyId = true;
+        break;
+      }
+      case "dropdown_checkbox": {
+        const fieldValue = values.array || "";
+        widget.fields = String(fieldValue).indexOf(",") > -1
+          ? String(fieldValue).split(",").map((item) => item.trim())
+          : [String(fieldValue).trim()];
+        break;
+      }
+      case "virtual":
+        widget.fields = values.sql || "";
+        break;
+      case "location":
+        widget.height = values.height || 250;
+        break;
+      case "custom":
+        widget.fields = values.code || "";
+        break;
+      case "ide_editor":
+        widget.language = values.languages || "";
+        widget.height = values.height || 400;
+        break;
+      case "html":
+        widget.code = !!values.code;
+        if (widget.code) writeRuntimeFile("html", model.table, key, values.code);
+        break;
+      case "money":
+        widget.symbol = values.symbol || "";
+        break;
+      default:
+        break;
     }
 
-    for (const key in properties) {
-        const property = properties[key];
-        const hidden = !property.values.hidden
-            ? false
-            : property.values.hidden == "on"
-                ? true
-                : false;
-        /* console.log("property start")
-                console.log(key)
-                console.log(JSON.stringify(property))
-                console.log("property end")*/
-        const type = property.type;
-        widgets[key] = {
-            name: type,
-            hidden: hidden,
-        };
-
-        widgets[key].hasInputGroup = false;
-        if (Object.prototype.hasOwnProperty.call(property.values, "inputGroupLeft") && property.values.inputGroupLeft) {
-            widgets[key].inputGroupLeft = property.values.inputGroupLeft;
-            widgets[key].hasInputGroup = true;
-        }
-        if (Object.prototype.hasOwnProperty.call(property.values,"inputGroupRight") && property.values.inputGroupRight) {
-            widgets[key].inputGroupRight = property.values.inputGroupRight;
-            widgets[key].hasInputGroup = true;
-        }
-        widgets[key].isAttributes = false;
-        if (Object.prototype.hasOwnProperty.call(property.values,"isAttributes") && property.values.isAttributes) {
-            widgets[key].isAttributes = true;
-        }
-        widgets[key].onChange = false;
-        if (Object.prototype.hasOwnProperty.call(property.values,"onChange") && property.values.onChange.length > 4) {
-            widgets[key].onChange = true;
-        }
-
-        if (property.values.information) {
-            widgets[key].information = JSON.stringify(property.values.information);
-        }
-
-        if (property.values.digitDecimal) {
-            widgets[key].digitDecimal = property.values.digitDecimal;
-        }
-
-        if (property.values.thousandSeparator) {
-            widgets[key].thousandSeparator = property.values.thousandSeparator;
-        }
-
-        if (property.values.decimalPlaces) {
-            widgets[key].decimalPlaces = property.values.decimalPlaces;
-        }
-
-        if (property.values.defaultValue) {
-            widgets[key].defaultValue = property.values.defaultValue;
-        }
-
-        if (Object.prototype.hasOwnProperty.call(property.values, "required")) {
-            widgets[key].required = property.values.required;
-        }
-
-        widgets[key].float = false;
-        if (Object.prototype.hasOwnProperty.call(property.values, "float")) {
-            widgets[key].float = property.values.float ? true : false;
-        }
-
-        widgets[key].inline = false;
-        if (Object.prototype.hasOwnProperty.call(property.values, "inline")) {
-            widgets[key].inline = property.values.inline ? true : false;
-        }
-
-        widgets[key].readonly = false;
-        if (Object.prototype.hasOwnProperty.call(property.values, "readonly")) {
-            widgets[key].readonly = property.values.readonly ? true : false;
-        }
-        if (Object.prototype.hasOwnProperty.call(property.values, "where")) {
-            widgets[key].where = property.values.where || "";
-        }
-
-        switch (type) {
-            case "image":
-                widgets[key].width = property.values.width || "300";
-                break;
-            case "datepicker":
-                widgets[key].format = !property.values.format
-                    ? "YYYY-MM-DD"
-                    : property.values.format;
-                break;
-            case "datetime":
-                widgets[key].format = !property.values.format
-                    ? "YYYY-MM-DD HH:mm:ss"
-                    : property.values.format;
-                break;
-            case "switch":
-                widgets[key].fields = [
-                    property.values.notactive,
-                    property.values.active,
-                ];
-                break;
-            case "table":
-                widgets[key].table = property.values.table;
-                widgets[key].hasCompanyId = true;
-                widgets[key].search = property.values.search;
-                break;
-            case "multi_line_editor":
-                widgets[key].table = property.values.table;
-                widgets[key].fields = property.values.fields;
-                widgets[key].description = property.values.description;
-                widgets[key].hasCompanyId = true;
-                break;
-            case "select":
-                var values = property.values.select || [];
-                widgets[key].fields = values.reduce((result, item) => {
-                    return { ...result, [item.value]: item.label };
-                }, {});
-                widgets[key].array = values;
-                widgets[key].please_select = property.values.please_select;
-                break;
-            case "radio":
-                var values = property.values.select || [];
-                widgets[key].fields = values.reduce((result, item) => {
-                    return { ...result, [item.value]: item.label };
-                }, {});
-                widgets[key].array = values;
-                break;
-            case "relation":
-                widgets[key].table = property.values.table;
-                widgets[key].fields = ["id", property.values.concat];
-                widgets[key].isChain = property.values.isChain;
-                widgets[key].isAttributes = property.values.isAttributes ? true : false;
-                widgets[key].isSearch = property.values.isSearch ? true : false;
-                widgets[key].chains = property.values.chains || [];
-                //widgets[key].chainsTable = property.values.chainsTable || {};
-                widgets[key].hasCompanyId = true;
-                widgets[key].please_select = property.values.please_select;
-                widgets[key].order_by = property.values.order_by;
-                widgets[key].import_field = property.values.import_field || "id";
-                widgets[key].relation_info = property.values.relation_info ? true : false;
-                if(widgets[key].relation_info) {
-                    //create file info to runtime
-                    let dirInfo = path.join(dirRoot, "public", "runtime", "info", MYMODEL.table);
-                    //Util.writeFile(path.join(dirRoot, "runtime", "info", MYMODEL.tab))
-                    if(!fs.existsSync(dirInfo)) {
-                        fs.mkdirSync(dirInfo, { recursive: true });
-                    }
-                    fs.writeFileSync(path.join(dirInfo, key + ".txt"), property.values.relation_info);
-                }
-                if(widgets[key].onChange) {
-                    //create file info to runtime
-                    let dirInfo = path.join(dirRoot, "public", "runtime", "onchange", MYMODEL.table);
-                    //Util.writeFile(path.join(dirRoot, "runtime", "info", MYMODEL.tab))
-                    if(!fs.existsSync(dirInfo)) {
-                        fs.mkdirSync(dirInfo, { recursive: true });
-                    }
-                    fs.writeFileSync(path.join(dirInfo, key + ".txt"), property.values.onChange);
-                }
-                break;
-            case "dragdrop":
-                widgets[key].table = property.values.table;
-                widgets[key].fields = ["id", property.values.concat];
-                widgets[key].where = property.values.where || "";
-                widgets[key].left = property.values.left || "";
-                widgets[key].right = property.values.right || "";
-                widgets[key].hasCompanyId = true;
-                widgets[key].import_field = property.values.import_field || "id";
-                break;
-            case "typeahead":
-                widgets[key].table = property.values.table;
-                widgets[key].fields = ["id", property.values.concat];
-                widgets[key].hasCompanyId = true;
-                widgets[key].order_by = property.values.order_by;
-                widgets[key].import_field = property.values.import_field || "id";
-                break;
-            case "dropdown_multi":
-                widgets[key].table = property.values.table;
-                widgets[key].fields = ["id", property.values.concat];
-                widgets[key].hasChains = property.values.chains ? true : false;
-                widgets[key].hasCompanyId = true;
-                widgets[key].order_by = property.values.order_by;
-                widgets[key].import_field = property.values.import_field || "id";
-                break;
-            case "dropdown_chain":
-                var fieldValue = property.values.field || "";
-                widgets[key].table = property.values.table;
-                widgets[key].fields = ["id", property.values.concat];
-                widgets[key].chains =
-                    fieldValue.indexOf(",") > -1 ? fieldValue.split(",") : [fieldValue];
-                widgets[key].hasCompanyId = true;
-                break;
-            case "dropdown_checkbox":
-                var fieldValue = property.values.array || "";
-                widgets[key].fields = fieldValue.indexOf(",")
-                    ? fieldValue.split(",").map((item) => {
-                        return item.trim();
-                    })
-                    : [fieldValue.trim()];
-                break;
-            case "virtual":
-                var fieldValue = property.values.sql || "";
-                widgets[key].fields = property.values.sql || "";
-                break;
-            case "location":
-                widgets[key].height = property.values.height || 250;
-                break;
-            case "custom":
-                widgets[key].fields = property.values.code || "";
-                break;
-            case "ide_editor":
-                widgets[key].language = property.values.languages || "";
-                widgets[key].height = !property.values.height
-                    ? 400
-                    : property.values.height;
-                break;
-            case "html":
-                widgets[key].code = property.values.code ? true : false;
-                if(widgets[key].code) {
-                    //create file info to runtime
-                    let dirInfo = path.join(dirRoot, "public", "runtime", "html", MYMODEL.table);
-                    //Util.writeFile(path.join(dirRoot, "runtime", "info", MYMODEL.tab))
-                    if(!fs.existsSync(dirInfo)) {
-                        fs.mkdirSync(dirInfo, { recursive: true });
-                    }
-                    fs.writeFileSync(path.join(dirInfo, key + ".txt"), property.values.code);
-                }
-                break;
-
-            case "money":
-                widgets[key].symbol = property.values.symbol || "";
-                break;
-
-            default:
-                break;
-        }
-    }
-    obj.widgets = widgets;
+    widgets[key] = widget;
+  });
 
-    return obj;
+  obj.widgets = widgets;
+  return obj;
 };
 
-me.build = (json, index = 0) => {
-    return zRoute.buildFileModel(json, index);
-};
+me.build = (json, index = 0) => zRoute.buildFileModel(json, index);
 
 me.create = async (ZFIELDS) => {
-    let jsonText = `module.exports = {${Util.newLine}`;
-
-    //CHECK IF HAS multi_line_editor
-    var properties = ZFIELDS.properties || {};
-    var labels = ZFIELDS.labels || {};
-    var multi_line_editors = [];
-    for (var key in properties) {
-        if (properties[key].type == "multi_line_editor") {
-            multi_line_editors.push(key);
-        }
-    }
-
-    //join into MYMODEL [JSON_MODEL]
-    if (multi_line_editors.length) {
-        // multi line editor skip
-        /*for(var i = 0; i < multi_line_editors.length;i++) {
-                    var item = multi_line_editors[i];
-                    var table = properties[item].table;
-                    var ZFIELDS_OTHER = await connection.result({
-                        table:"zfields",
-                        where:{table:table}
-                    })
-                    console.log("ZFIELDS_OTHER")
-                    console.log(ZFIELDS_OTHER)
-
-                    var JSON_MODEL_OTHER = me.prepare(ZFIELDS_OTHER);
-                }*/
-    }
-    const JSON_MODEL = me.prepare(ZFIELDS);
-    jsonText += me.build(JSON_MODEL);
-    jsonText += `}`;
-    const filename = path.join(dirRoot, "models", ZFIELDS.table + ".js");
-    fs.writeFile(filename, jsonText, function (err) {
-        if (err) {
-            return console.log(err.toString());
-        }
-        console.log("The file models of " + ZFIELDS.table + " is saved!");
-    });
-
-    return await me.build_sql(ZFIELDS);
+  if (!isPlainObject(ZFIELDS) || !ZFIELDS.table) throw new Error("ZFIELDS.table is required");
+  const JSON_MODEL = me.prepare(ZFIELDS);
+  const jsonText = `module.exports = {${Util.newLine}${me.build(JSON_MODEL)}}`;
+  const filename = path.join(appRoot(), "models", `${ZFIELDS.table}.js`);
+  await fs.outputFile(filename, jsonText, "utf-8");
+  return me.build_sql(ZFIELDS);
 };
 
-/*
-Create for API
- */
 me.createApi = async (columns, constraintList, ZFIELDS) => {
-    let jsonText = `module.exports = {${Util.newLine}`;
-
-    //CHECK IF HAS multi_line_editor
-    const properties = ZFIELDS.properties || {};
-    const labels = ZFIELDS.labels || {};
-    const multi_line_editors = [];
-    for (const key in properties) {
-        if (properties[key].type == "multi_line_editor") {
-            multi_line_editors.push(key);
-        }
-    }
-    //join into MYMODEL [JSON_MODEL]
-    const JSON_MODEL = me.prepare(ZFIELDS);
-    jsonText += me.build(JSON_MODEL);
-    jsonText += `}`;
-    const filename = `${ZFIELDS.table}.js`;
-    const datas = me.build_sql_api(columns, constraintList, ZFIELDS);
-    datas.content = jsonText;
-    datas.filename = filename;
-    datas.modelObj = JSON_MODEL;
-    return datas;
+  if (!isPlainObject(ZFIELDS) || !ZFIELDS.table) {
+    return { content: "", filename: "", modelObj: {}, sql: [], fk: [], alter: [], defaultValue: [], index: [], error: "ZFIELDS.table is required" };
+  }
+  const JSON_MODEL = me.prepare(ZFIELDS);
+  const datas = me.build_sql_api(columns, constraintList, ZFIELDS);
+  datas.content = `module.exports = {${Util.newLine}${me.build(JSON_MODEL)}}`;
+  datas.filename = `${ZFIELDS.table}.js`;
+  datas.modelObj = JSON_MODEL;
+  return datas;
 };
 
-me.build_sql_api = (columns, constraintList, MYMODEL) => {
-    const labels = MYMODEL.labels || {};
-    let properties = MYMODEL.properties || {};
-    const fields = columns.reduce((result, item) => {
-        return [...result, item.Field];
-    }, []);
-    const sql = [];
-    let error = "";
-    const datas = {
-        error: error,
-    };
+me.build_sql = async (ZFIELDS) => me.build_sql_api([], [], ZFIELDS);
 
-    for (let key in labels) {
-        if (!Util.in_array(key, fields)) {
-            let property = properties[key];
-            if (property) {
-                let sqlObject = Model[property.type].sql(key, MYMODEL, property.values);
-                if (sqlObject.column) {
-                    try {
-                        sql.push(sqlObject.column);
-                    } catch (err) {
-                        error += err.toString();
-                    }
-                }
-            }
-        }
+me.build_sql_api = (columns, constraintList, MYMODEL) => {
+  const model = isPlainObject(MYMODEL) ? MYMODEL : {};
+  const labels = isPlainObject(model.labels) ? model.labels : {};
+  const properties = isPlainObject(model.properties) ? model.properties : {};
+  const fields = asArray(columns).map((item) => item && item.Field).filter(Boolean);
+  const constraintObject = Util.arrayToObject(asArray(constraintList), "conname") || {};
+  const notAlters = ["virtual", "custom", "html"];
+  const datas = { error: "", sql: [], fk: [], alter: [], defaultValue: [], index: [] };
+
+  Object.keys(labels).forEach((key) => {
+    if (Util.in_array(key, fields)) return;
+    const property = properties[key];
+    const typeApi = property && modelType(property.type);
+    if (!typeApi || typeof typeApi.sql !== "function") return;
+    try {
+      const sqlObject = typeApi.sql(key, model, property.values || {});
+      if (sqlObject && sqlObject.column) datas.sql.push(sqlObject.column);
+    } catch (err) {
+      datas.error += err.toString();
     }
-    const constraintObject = Util.arrayToObject(constraintList, "conname");
-    const alter = [];
-    const index = [];
-    const defaultValue = [];
-    const fk = [];
-    const notAlters = ["virtual", "custom","html"];
-    for (const key in properties) {
-        const property = properties[key];
-        if (!notAlters.includes(property.type)) {
-            //required
-            const required = properties[key].values.required ? true : false;
-            if (required) {
-                alter.push(
-                    `ALTER TABLE "${MYMODEL.table}" ALTER COLUMN "${key}" SET NOT NULL; `
-                );
-            } else {
-                alter.push(
-                    `ALTER TABLE "${MYMODEL.table}" ALTER COLUMN "${key}" DROP NOT NULL; `
-                );
-            }
-            const sqlObject = Model[property.type].sql(key, MYMODEL, property.values);
-            //unique
-            const unique = properties[key].values.unique ? true : false;
-            const idx = `unique_${MYMODEL.table}_${key}`;
-            if (sqlObject.index) {
-                if (!constraintObject.hasOwnProperty(idx)) {
-                    //await connection.query(sqlObject.index);
-                    index.push(sqlObject.index);
-                }
-            } else {
-                if (constraintObject.hasOwnProperty(idx)) {
-                    //await connection.query(`DROP INDEX ${idx}; `);
-                    index.push(`DROP INDEX ${idx}; `);
-                }
-            }
-            if(property.type == "money"){
-                //ALTER TABLE nama_tabel
-                // ALTER COLUMN nama_kolom TYPE NUMERIC(15,2);
-                let digitDecimal = properties[key].values.digitDecimal || 0;
-                alter.push(
-                    `ALTER TABLE "${MYMODEL.table}" ALTER COLUMN "${key}" TYPE NUMERIC(15,${digitDecimal});; `
-                );
-            }
-            //relations foreign key
-            const fkx = `fk_${MYMODEL.table}_${key}`;
-            if (sqlObject.foreignKey) {
-                if (!constraintObject.hasOwnProperty(fkx)) {
-                    //await connection.query(sqlObject.foreignKey);
-                    fk.push(sqlObject.foreignKey);
-                }
-            }
-            //default value
-            if (sqlObject.defaultValue) {
-                //await connection.query(sqlObject.defaultValue);
-                defaultValue.push(sqlObject.defaultValue);
-            }
-        }
+  });
+
+  Object.keys(properties).forEach((key) => {
+    const property = properties[key] || {};
+    const typeApi = modelType(property.type);
+    if (!typeApi || notAlters.includes(property.type)) return;
+    const values = isPlainObject(property.values) ? property.values : {};
+    const table = model.table || "";
+    datas.alter.push(
+      values.required
+        ? `ALTER TABLE "${table}" ALTER COLUMN "${key}" SET NOT NULL; `
+        : `ALTER TABLE "${table}" ALTER COLUMN "${key}" DROP NOT NULL; `
+    );
+
+    let sqlObject = {};
+    try {
+      sqlObject = typeApi.sql(key, model, values) || {};
+    } catch (err) {
+      datas.error += err.toString();
+      return;
     }
 
-    datas.sql = sql;
-    datas.fk = fk;
-    datas.alter = alter;
-    datas.defaultValue = defaultValue;
-    datas.index = index;
-    return datas;
-};
-
-me.fields = (MYMODEL) => {
-    const obj = {};
-    const properties = MYMODEL.properties || {};
-    const labels = MYMODEL.labels || {};
-    for (const key in labels) {
-        obj[key] = {
-            name: key,
-            title: labels[key],
-            placeholder: labels[key],
-        };
-        if (key == "id") {
-            Object.assign(obj[key], me.integer({ key: "PRI" }));
-        } else if (key == "company_id") {
-            Object.assign(obj[key], me.integer({ key: "MUL" }));
-        } else if (key == "lock") {
-            Object.assign(obj[key], me.lock());
-        } else if (key == "approval_status") {
-            Object.assign(obj[key], me.approval_status());
-        } else if (key == "approval_history") {
-            Object.assign(obj[key], me.approval_history());
-        } else if (Util.in_array(key, configGenerator.createdUpdatedAt)) {
-            Object.assign(obj[key], me.datetime());
-        } else if (Util.in_array(key, configGenerator.createdUpdatedBy)) {
-            Object.assign(obj[key], me.integer());
-        } else {
-            if (properties.hasOwnProperty(key)) {
-                var property = properties[key];
-                var type = property.type;
-                //console.log(type)
-                obj[key].type = Model[type].columnType(property.values);
-                obj[key].category = Model[type].category;
-                obj[key].length = !property.length ? "" : property.length;
-                obj[key].required = property.values.required ? true : false;
-                obj[key].search = obj[key].category == "integer" ? "=" : "ILIKE";
-                obj[key].key = "";
-            }
-        }
+    const idx = `unique_${table}_${key}`;
+    if (sqlObject.index) {
+      if (!hasOwn(constraintObject, idx)) datas.index.push(sqlObject.index);
+    } else if (hasOwn(constraintObject, idx)) {
+      datas.index.push(`DROP INDEX ${idx}; `);
     }
 
-    return obj;
-};
-
-me.integer = (obj = {}) => {
-    var defaultObj = {
-        type: "int",
-        category: "integer",
-        length: 11,
-        required: true,
-        search: "=",
-        key: "",
-    };
-
-    return Object.assign(defaultObj, obj);
-};
-
-me.datetime = (obj = {}) => {
-    var defaultObj = {
-        type: "datetime",
-        category: "datetime",
-        length: "",
-        required: false,
-        search: "ILIKE",
-        key: "",
-    };
-
-    return Object.assign(defaultObj, obj);
-};
+    if (property.type === "money") {
+      const digitDecimal = values.digitDecimal || 0;
+      datas.alter.push(`ALTER TABLE "${table}" ALTER COLUMN "${key}" TYPE NUMERIC(15,${digitDecimal});; `);
+    }
 
-me.lock = (obj = {}) => {
-    var defaultObj = {
-        type: "int",
-        category: "integer",
-        length: "1",
-        required: false,
-        search: "=",
-        key: "",
-    };
+    const fkx = `fk_${table}_${key}`;
+    if (sqlObject.foreignKey && !hasOwn(constraintObject, fkx)) datas.fk.push(sqlObject.foreignKey);
+    if (sqlObject.defaultValue) datas.defaultValue.push(sqlObject.defaultValue);
+  });
 
-    return Object.assign(defaultObj, obj);
+  return datas;
 };
 
-me.approval_status = (obj = {}) => {
-    var defaultObj = {
-        type: "select",
-        category: "integer",
-        length: "",
-        required: false,
-        search: "=",
-        key: "",
-    };
+me.fields = (MYMODEL) => {
+  const obj = {};
+  const model = isPlainObject(MYMODEL) ? MYMODEL : {};
+  const properties = isPlainObject(model.properties) ? model.properties : {};
+  const labels = isPlainObject(model.labels) ? model.labels : {};
+
+  Object.keys(labels).forEach((key) => {
+    obj[key] = { name: key, title: labels[key], placeholder: labels[key] };
+    if (key === "id") Object.assign(obj[key], me.integer({ key: "PRI" }));
+    else if (key === "company_id") Object.assign(obj[key], me.integer({ key: "MUL" }));
+    else if (key === "lock") Object.assign(obj[key], me.lock());
+    else if (key === "approval_status") Object.assign(obj[key], me.approval_status());
+    else if (key === "approval_history") Object.assign(obj[key], me.approval_history());
+    else if (Util.in_array(key, configGenerator.createdUpdatedAt)) Object.assign(obj[key], me.datetime());
+    else if (Util.in_array(key, configGenerator.createdUpdatedBy)) Object.assign(obj[key], me.integer());
+    else if (hasOwn(properties, key)) {
+      const property = properties[key] || {};
+      const typeApi = modelType(property.type);
+      if (!typeApi) return;
+      const values = isPlainObject(property.values) ? property.values : {};
+      obj[key].type = typeApi.columnType(values);
+      obj[key].category = typeApi.category;
+      obj[key].length = property.length || "";
+      obj[key].required = !!values.required;
+      obj[key].search = obj[key].category === "integer" ? "=" : "ILIKE";
+      obj[key].key = "";
+    }
+  });
 
-    return Object.assign(defaultObj, obj);
+  return obj;
 };
 
-me.approval_history = (obj = {}) => {
-    var defaultObj = {
-        type: "json_array",
-        category: "array",
-        length: "2",
-        required: false,
-        search: "=",
-        key: "",
-    };
-
-    return Object.assign(defaultObj, obj);
-};
+me.integer = (obj = {}) => mergeField("integer", obj);
+me.datetime = (obj = {}) => mergeField("datetime", obj);
+me.lock = (obj = {}) => mergeField("lock", obj);
+me.approval_status = (obj = {}) => mergeField("approval_status", obj);
+me.approval_history = (obj = {}) => mergeField("approval_history", obj);
 
 module.exports = me;