db-model-router 1.0.0

package/src/commons/route.js

@@ -0,0 +1,214 @@
+const express = (() => {
+  try {
+    return require("ultimate-express");
+  } catch (_) {
+    return require("express");
+  }
+})();
+const { errorResponse } = require("./validator");
+const { toCSV, toXML, extractReservedParams, applySelect } = require("./model");
+const _ = require("lodash");
+
+/**
+ * Send response in the requested format (json, csv, xml).
+ */
+function sendFormatted(res, data, contentType) {
+  if (contentType === "csv") {
+    const rows = Array.isArray(data) ? data : data.data || [data];
+    res.setHeader("Content-Type", "text/csv");
+    return res.send(toCSV(rows));
+  }
+  if (contentType === "xml") {
+    const rows = Array.isArray(data) ? data : data.data || [data];
+    res.setHeader("Content-Type", "application/xml");
+    return res.send(toXML(rows));
+  }
+  return res.status(200).send(data);
+}
+
+module.exports = function route(model, override = {}) {
+  return express
+    .Router({ mergeParams: true })
+    .get("/:" + model.pk, (req, res) => {
+      let payload = payloadOverride(
+        { ...req.query, ...req.params },
+        req,
+        override,
+      );
+      const { select_columns, output_content_type } =
+        extractReservedParams(payload);
+      payload[model.pk] = req.params[model.pk];
+      model
+        .find(payload)
+        .then((response) => {
+          if (response.count > 0) {
+            let record = response.data[0];
+            if (select_columns) record = applySelect(record, select_columns);
+            sendFormatted(res, record, output_content_type);
+          } else res.status(404).send({ message: "Not Found", type: "danger" });
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .post("/:id", (req, res) => {
+      let payload = payloadOverride(req.body, req, override);
+      delete payload[model.pk];
+      model
+        .insert(payload)
+        .then((response) => {
+          res.status(200).send(response);
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .put("/:id", (req, res) => {
+      let payload = payloadOverride(req.body, req, override);
+      payload[model.pk] = req.params.id;
+      let validateAccessPayload = payloadOverride({}, req, override);
+      validateAccessPayload[model.pk] = req.params.id;
+      model
+        .findOne(validateAccessPayload)
+        .then((found) => {
+          if (found) {
+            model
+              .update(payload)
+              .then((response) => {
+                res.status(200).send(response);
+              })
+              .catch((err) => {
+                errorResponse(res, err);
+              });
+          } else {
+            res.status(404).send({ message: "Not Found", type: "danger" });
+          }
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .patch("/:id", (req, res) => {
+      let payload = payloadOverride(req.body, req, override);
+      payload[model.pk] = req.params.id;
+      let validateAccessPayload = payloadOverride({}, req, override);
+      validateAccessPayload[model.pk] = req.params.id;
+      model
+        .findOne(validateAccessPayload)
+        .then((found) => {
+          if (found) {
+            model
+              .patch(payload)
+              .then((response) => {
+                res.status(200).send(response);
+              })
+              .catch((err) => {
+                errorResponse(res, err);
+              });
+          } else {
+            res.status(404).send({ message: "Not Found", type: "danger" });
+          }
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .delete("/:id", (req, res) => {
+      let payload = payloadOverride(req.body, req, override);
+      payload[model.pk] = req.params.id;
+      let validateAccessPayload = payloadOverride({}, req, override);
+      validateAccessPayload[model.pk] = req.params.id;
+      model
+        .findOne(validateAccessPayload)
+        .then((found) => {
+          if (found) {
+            model
+              .remove(payload)
+              .then((response) => {
+                res.status(200).send(response);
+              })
+              .catch((err) => {
+                errorResponse(res, err);
+              });
+          } else {
+            res.status(404).send({ message: "Not Found", type: "danger" });
+          }
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .get("/", (req, res) => {
+      let payload = payloadOverride(
+        { ...req.query, ...req.params },
+        req,
+        override,
+      );
+      const { output_content_type } = extractReservedParams(payload);
+      // select_columns stays in payload — model.list handles it
+      model
+        .list(payload)
+        .then((response) => {
+          sendFormatted(res, response, output_content_type);
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .post("/", (req, res) => {
+      let payload = payloadOverride(req.body.data, req, override);
+      model
+        .insert({ data: payload })
+        .then((response) => {
+          res.status(200).send(response);
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .put("/", (req, res) => {
+      let payload = payloadOverride(req.body.data, req, override);
+      model
+        .update({ data: payload })
+        .then((response) => {
+          res.status(200).send(response);
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    })
+    .delete("/", (req, res) => {
+      let payload = payloadOverride(req.body.data, req, override);
+      model
+        .remove(payload)
+        .then((response) => {
+          res.status(200).send(response);
+        })
+        .catch((err) => {
+          errorResponse(res, err);
+        });
+    });
+};
+
+function payloadOverride(payload, req, override) {
+  if (Array.isArray(payload)) {
+    for (const i in payload) {
+      payload[i] = dataOverride(payload[i], req, override);
+    }
+  } else {
+    payload = dataOverride(payload, req, override);
+  }
+  return payload;
+}
+
+function dataOverride(payload, req, override) {
+  for (const key in override) {
+    payload[key] = _.get(req, override[key], "");
+  }
+  for (const key in payload) {
+    if (payload[key] === "null") {
+      delete payload[key];
+    }
+  }
+  return payload;
+}

package/src/commons/validator.js

@@ -0,0 +1,172 @@
+const { Validator } = require("node-input-validator");
+const { getType } = require("./function");
+function RemovePK(modelPK, data) {
+  for (const item of data) {
+    if (item.hasOwnProperty(modelPK)) {
+      delete item[modelPK];
+    }
+  }
+}
+function RemoveUnknownData(ModelStructure, data) {
+  const modelStructure = Object.keys(ModelStructure);
+  for (const item of data) {
+    for (const i in item) {
+      if (!modelStructure.includes(i)) {
+        delete item[i];
+      }
+    }
+  }
+  return data;
+}
+function getPayloadValidator(type, structure, pk, bulk = false) {
+  if (bulk) {
+    const body = {};
+    switch (type) {
+      case "CREATE":
+        body["data"] = "required|array";
+        for (const i in structure) {
+          if (i !== pk) body[`data.*.${i}`] = structure[i];
+        }
+        break;
+      case "UPDATE":
+        body["data"] = "required|array";
+        for (const i in structure) {
+          body[`data.*.${i}`] = structure[i];
+        }
+        break;
+      case "DELETE":
+        body["filter"] = "required|array";
+        break;
+      default:
+        break;
+    }
+    return body;
+  } else {
+    const validator = { body: {} };
+    switch (type) {
+      case "CREATE":
+        for (const i in structure) {
+          if (i !== pk) validator.body[i] = structure[i];
+        }
+        break;
+      case "UPDATE":
+        for (const i in structure) {
+          validator.body[i] = structure[i];
+        }
+        break;
+      case "DELETE":
+      case "GET":
+        validator.body[pk] = structure[pk];
+        break;
+      default:
+        break;
+    }
+    return validator.body;
+  }
+}
+function errorResponse(res, err) {
+  let status = 500;
+  if (err.hasOwnProperty("cause") && err.cause.hasOwnProperty("status")) {
+    status = err.cause.status;
+  }
+  // For client errors (4xx), return the validation message.
+  // For server/database errors (5xx), return a generic message to avoid leaking internals.
+  let message;
+  if (status >= 400 && status < 500) {
+    message = err.message || "Bad request";
+  } else {
+    if (
+      process.env.NODE_ENV === "development" ||
+      process.env.NODE_ENV === "test" ||
+      process.env.NODE_ENV === "TEST"
+    ) {
+      message = err.sqlMessage || err.message || "Internal server error";
+    } else {
+      message = "Internal server error";
+    }
+  }
+  res.status(status).send({ type: "danger", message });
+}
+async function validateInput(req, required) {
+  let validator = new Validator(req, required);
+  const matched = await validator.check();
+  if (!matched) {
+    throw new Error(getErrorMessage(validator.errors), {
+      cause: { status: 422 },
+    });
+  }
+  return true;
+}
+function getErrorMessage(errors) {
+  let message = "";
+  for (const i in errors) {
+    if (errors.hasOwnProperty(i)) {
+      message = message + (message !== "" ? " " : "");
+      message = message + errors[i].message;
+    }
+  }
+  return message;
+}
+function objectToFilter(obj) {
+  let filterArray = [];
+  for (let key in obj) {
+    filterArray.push([key, "=", obj[key]]);
+  }
+  return [filterArray];
+}
+function dataToFilter(data, primary_key) {
+  let filter = [];
+  let type = getType(data);
+  if (data.hasOwnProperty("filter") && getType(data.filter) === "array") {
+    filter = JSON.parse(JSON.stringify(data.filter));
+    if (Object.keys(data).length > 1) {
+      delete data.filter;
+      let filter2 = objectToFilter(data);
+      if (filter.toString().length > 0) {
+        for (let item1 of filter) {
+          for (let item2 of filter2[0]) {
+            item1.push(item2);
+          }
+        }
+      } else {
+        filter = filter2;
+      }
+    }
+  } else if (type === "object" && Object.keys(data).length > 0) {
+    filter = objectToFilter(data);
+  } else if (type === "number" || type === "string") {
+    filter = [[[primary_key, "=", data]]];
+  } else if (type === "object" && Object.keys(data).length === 0) {
+    filter = [[[]]];
+  } else {
+    throw new Error("Invalid filter Inputs", { cause: { status: 422 } });
+  }
+  return filter;
+}
+module.exports = {
+  RemovePK,
+  RemoveUnknownData,
+  getPayloadValidator,
+  errorResponse,
+  validateInput,
+  getErrorMessage,
+  objectToFilter,
+  dataToFilter,
+};
+/*async function validateInput(req, required) {
+  console.log(req, required);
+  for (const key in required) {
+    if (req.hasOwnProperty(key)) {
+      if (Array.isArray(req[key])) {
+        throw Error({ message: "This service supports does not support array", status: 422 });
+      }
+      let validator = new Validator(req[key], required[key]);
+      const matched = await validator.check();
+      if (!matched) {
+        console.log(getErrorMessage(key, validator.errors));
+        //throw Error({ message: getErrorMessage(key, validator.errors), status: 422 });
+      }
+    }
+  }
+  return true;
+}*/