db-model-router 1.0.0

package/src/commons/function.js

@@ -0,0 +1,165 @@
+function jsonSafeParse(obj) {
+  if (typeof obj === "string") {
+    try {
+      // If the string is a bare numeric literal that would lose precision,
+      // return it as-is (string) to preserve the original value.
+      if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(obj.trim())) {
+        if (wouldLosePrecision(obj.trim())) {
+          return obj;
+        }
+      }
+      // Pre-process: find numeric literals in the JSON that would lose precision.
+      // A number loses precision if:
+      //   - It's an integer with more than 15 significant digits
+      //   - It's a float with more than 15 significant digits total
+      //   - It exceeds Number.MAX_SAFE_INTEGER (9007199254740991)
+      //
+      // We wrap those in quotes before JSON.parse sees them.
+      const safed = obj.replace(
+        /(?<=[:,\[]\s*)-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?(?=\s*[,\}\]])/g,
+        (match) => {
+          // Check if this number would lose precision
+          if (wouldLosePrecision(match)) {
+            return '"' + match + '"';
+          }
+          return match;
+        },
+      );
+      return JSON.parse(safed);
+    } catch (err) {
+      // If the regex approach fails, fall back to standard reviver
+      try {
+        return JSON.parse(obj, (key, value) => {
+          if (
+            typeof value === "number" &&
+            !Number.isSafeInteger(value) &&
+            !isSmallFloat(value)
+          ) {
+            return value.toString();
+          }
+          return value;
+        });
+      } catch (err2) {
+        return obj;
+      }
+    }
+  } else if (typeof obj === "object" && obj !== null) {
+    for (const i in obj) {
+      obj[i] = jsonSafeParse(obj[i]);
+    }
+    return obj;
+  } else {
+    return obj;
+  }
+}
+
+/**
+ * Check if a numeric string would lose precision when parsed as a JS number.
+ */
+function wouldLosePrecision(numStr) {
+  // Remove sign
+  const abs = numStr.replace(/^-/, "");
+
+  // Handle scientific notation
+  if (/[eE]/.test(abs)) {
+    const num = Number(numStr);
+    // If re-stringifying doesn't match, precision was lost
+    return num.toString() !== numStr && String(+numStr) !== numStr;
+  }
+
+  // Split integer and decimal parts
+  const parts = abs.split(".");
+  const intPart = parts[0] || "0";
+  const decPart = parts[1] || "";
+
+  // Count significant digits (strip leading zeros from integer, trailing zeros from decimal)
+  const sigDigits =
+    (intPart === "0" ? "" : intPart).replace(/^0+/, "") + decPart;
+  const significantCount = sigDigits.replace(/^0+/, "").length;
+
+  // JS can represent ~15-17 significant digits accurately for most values.
+  // For integers specifically, anything <= MAX_SAFE_INTEGER is fine regardless of digit count.
+  if (significantCount > 16) return true;
+
+  // For integers, also check against MAX_SAFE_INTEGER
+  if (!decPart) {
+    const n = Number(numStr);
+    if (!Number.isSafeInteger(n)) return true;
+  }
+
+  // Round-trip check: parse and re-stringify
+  const n = Number(numStr);
+  if (String(n) !== numStr && n.toString() !== numStr) {
+    // Could be trailing zeros in decimal (e.g., "1.50") — that's not precision loss
+    if (decPart && Number(numStr) === parseFloat(numStr)) {
+      return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Check if a float is small enough that toString() preserves it.
+ * Floats within normal range with <= 15 significant digits are fine.
+ */
+function isSmallFloat(value) {
+  if (!Number.isFinite(value)) return false;
+  if (Number.isInteger(value)) return Number.isSafeInteger(value);
+  // For floats, check if round-trip preserves the value
+  return value === parseFloat(value.toString());
+}
+
+function jsonStringify(obj) {
+  if (typeof obj === "object") {
+    if (!Array.isArray(obj)) {
+      for (const i in obj) {
+        if (typeof obj[i] === "object") {
+          if (obj[i] != null) obj[i] = JSON.stringify(obj[i]);
+        }
+      }
+      return obj;
+    } else {
+      for (const i in obj) {
+        if (obj[i] != null) obj[i] = jsonStringify(obj[i]);
+      }
+      return obj;
+    }
+  } else {
+    return obj;
+  }
+}
+
+function getType(obj) {
+  if (Array.isArray(obj)) {
+    return "array";
+  } else if (obj === null || obj === undefined) {
+    return "null";
+  } else {
+    return typeof obj;
+  }
+}
+
+function empty(obj) {
+  return obj === null || obj === undefined || obj === "";
+}
+
+function objectSelecter(obj, picker) {
+  for (let i of picker) {
+    if (obj.hasOwnProperty(i)) {
+      obj = obj[i];
+    } else {
+      return null;
+    }
+  }
+  return obj;
+}
+
+module.exports = {
+  jsonSafeParse,
+  jsonStringify,
+  getType,
+  empty,
+  objectSelecter,
+};

package/src/commons/model.js

@@ -0,0 +1,444 @@
+const {
+  RemovePK,
+  getPayloadValidator,
+  validateInput,
+  dataToFilter,
+  RemoveUnknownData,
+} = require("./validator");
+const { getType, jsonStringify, jsonSafeParse } = require("./function");
+
+/**
+ * Extract and remove reserved params from a data/payload object.
+ * Returns { select_columns: string[]|null, output_content_type: string|null, cleaned: data }
+ */
+function extractReservedParams(data) {
+  let select_columns = null;
+  let output_content_type = null;
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    if (data.select_columns) {
+      select_columns =
+        typeof data.select_columns === "string"
+          ? data.select_columns.split(",").map((s) => s.trim())
+          : data.select_columns;
+      delete data.select_columns;
+    }
+    if (data.output_content_type) {
+      output_content_type = data.output_content_type;
+      delete data.output_content_type;
+    }
+  }
+  return { select_columns, output_content_type };
+}
+
+/**
+ * Apply column projection to a single record or array of records.
+ */
+function applySelect(data, select_columns) {
+  if (!select_columns || select_columns.length === 0) return data;
+  if (Array.isArray(data)) {
+    return data.map((row) => pickKeys(row, select_columns));
+  }
+  if (data && typeof data === "object") {
+    return pickKeys(data, select_columns);
+  }
+  return data;
+}
+
+function pickKeys(obj, keys) {
+  const result = {};
+  for (const k of keys) {
+    if (obj.hasOwnProperty(k)) result[k] = obj[k];
+  }
+  return result;
+}
+
+/**
+ * Convert data to CSV string.
+ */
+function toCSV(data) {
+  if (!Array.isArray(data) || data.length === 0) return "";
+  const headers = Object.keys(data[0]);
+  const rows = data.map((row) =>
+    headers
+      .map((h) => {
+        const val = row[h];
+        if (val === null || val === undefined) return "";
+        const str = typeof val === "object" ? JSON.stringify(val) : String(val);
+        return str.includes(",") || str.includes('"') || str.includes("\n")
+          ? '"' + str.replace(/"/g, '""') + '"'
+          : str;
+      })
+      .join(","),
+  );
+  return headers.join(",") + "\n" + rows.join("\n");
+}
+
+/**
+ * Convert data to simple XML string.
+ */
+function toXML(data, rootName = "records", itemName = "record") {
+  const items = Array.isArray(data) ? data : [data];
+  let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<' + rootName + ">\n";
+  for (const item of items) {
+    xml += "  <" + itemName + ">\n";
+    for (const [key, val] of Object.entries(item)) {
+      const escaped =
+        val === null || val === undefined
+          ? ""
+          : typeof val === "object"
+            ? escapeXml(JSON.stringify(val))
+            : escapeXml(String(val));
+      xml += "    <" + key + ">" + escaped + "</" + key + ">\n";
+    }
+    xml += "  </" + itemName + ">\n";
+  }
+  xml += "</" + rootName + ">\n";
+  return xml;
+}
+
+function escapeXml(str) {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+const CREATED_AT_VARIANTS = [
+  "created_at",
+  "createdAt",
+  "created",
+  "create_date",
+  "createDate",
+  "creation_date",
+  "creationDate",
+];
+const MODIFIED_AT_VARIANTS = [
+  "modified_at",
+  "modifiedAt",
+  "modified",
+  "updated_at",
+  "updatedAt",
+  "updated",
+  "update_date",
+  "updateDate",
+  "modification_date",
+  "modificationDate",
+];
+
+function buildTimestampKeys(option) {
+  let createdKeys = [];
+  let modifiedKeys = [];
+  if (option.created_at) {
+    createdKeys = Array.isArray(option.created_at)
+      ? option.created_at
+      : [option.created_at];
+  } else {
+    createdKeys = CREATED_AT_VARIANTS;
+  }
+  if (option.modified_at) {
+    modifiedKeys = Array.isArray(option.modified_at)
+      ? option.modified_at
+      : [option.modified_at];
+  } else {
+    modifiedKeys = MODIFIED_AT_VARIANTS;
+  }
+  return { createdKeys, modifiedKeys };
+}
+
+function stripTimestampFields(data, keys) {
+  if (Array.isArray(data)) {
+    for (const row of data) {
+      for (const k of keys) delete row[k];
+    }
+  } else if (data && typeof data === "object") {
+    for (const k of keys) delete data[k];
+  }
+  return data;
+}
+
+module.exports = function model(
+  dbOrTable,
+  tableOrStructure,
+  modelStructureOrPK,
+  primary_keyOrUnique,
+  uniqueOrOption,
+  optionOrUndefined,
+) {
+  // Detect if db was passed or if first arg is the table name (string)
+  let db, table, modelStructure, primary_key, unique, option;
+  if (typeof dbOrTable === "string") {
+    // model("table", structure, pk, unique, option) — no db, use singleton
+    const restRouter = require("../index.js");
+    db = restRouter.db;
+    table = dbOrTable;
+    modelStructure = tableOrStructure || {};
+    primary_key = modelStructureOrPK || "id";
+    unique = primary_keyOrUnique || [];
+    option = uniqueOrOption || { safeDelete: null };
+  } else {
+    // model(db, "table", structure, pk, unique, option) — classic signature
+    db = dbOrTable;
+    table = tableOrStructure;
+    modelStructure = modelStructureOrPK || {};
+    primary_key = primary_keyOrUnique || "id";
+    unique = uniqueOrOption || [];
+    option = optionOrUndefined || { safeDelete: null };
+  }
+
+  const { createdKeys, modifiedKeys } = buildTimestampKeys(option);
+  const allTimestampKeys = [...createdKeys, ...modifiedKeys];
+
+  return {
+    insert: async (data) => {
+      let isBulk = false;
+      if (data.hasOwnProperty("data")) {
+        isBulk = true;
+        RemovePK(primary_key, data.data);
+        stripTimestampFields(data.data, allTimestampKeys);
+        await validateInput(
+          data,
+          getPayloadValidator("CREATE", modelStructure, primary_key, true),
+        );
+        data = data.data;
+      } else {
+        delete data[primary_key];
+        stripTimestampFields(data, allTimestampKeys);
+        await validateInput(
+          data,
+          getPayloadValidator("CREATE", modelStructure, primary_key, false),
+        );
+      }
+      data = jsonStringify(data);
+      const insertResult = await db.insert(table, data, unique);
+      if (!isBulk && insertResult.hasOwnProperty("id")) {
+        const getResult = await db.get(table, [
+          [[primary_key, "=", insertResult.id]],
+        ]);
+        return getResult.count > 0 ? getResult["data"][0] : null;
+      }
+      //TODO: Bulk Insert -> Return inserted objects
+      return insertResult;
+    },
+    update: async (data) => {
+      let updateResult = null;
+      if (data.hasOwnProperty("data")) {
+        stripTimestampFields(data.data, allTimestampKeys);
+        await validateInput(
+          data,
+          getPayloadValidator("UPDATE", modelStructure, primary_key, true),
+        );
+        data = data.data;
+        data = RemoveUnknownData(modelStructure, data);
+        data = jsonStringify(data);
+        updateResult = await db.upsert(table, data, unique);
+        //TODO: Bulk Update -> Return updated objects
+      } else {
+        stripTimestampFields(data, allTimestampKeys);
+        await validateInput(
+          data,
+          getPayloadValidator("UPDATE", modelStructure, primary_key, false),
+        );
+        data = RemoveUnknownData(modelStructure, [data]);
+        data = jsonStringify(data);
+        updateResult = await db.upsert(table, data, unique);
+        if (updateResult.hasOwnProperty("id") && updateResult.id > 0) {
+          const getResult = await db.get(table, [
+            [[primary_key, "=", updateResult.id]],
+          ]);
+          return getResult.count > 0 ? getResult["data"][0] : null;
+        } else if (data[0].hasOwnProperty(primary_key)) {
+          const result = await db.get(
+            table,
+            [[[primary_key, "=", data[0][primary_key]]]],
+            [],
+            option.safeDelete,
+          );
+          if (result.count > 0) return result["data"][0];
+          else return null;
+        }
+      }
+      return updateResult;
+    },
+    upsert: async (data) => {
+      //* Same as Update but primary key is optional */
+      let updateResult = null;
+      if (data.hasOwnProperty("data")) {
+        stripTimestampFields(data.data, allTimestampKeys);
+        await validateInput(
+          data,
+          getPayloadValidator("CREATE", modelStructure, primary_key, true),
+        );
+        data = data.data;
+        data = RemoveUnknownData(modelStructure, data);
+        data = jsonStringify(data);
+        updateResult = await db.upsert(table, data, unique);
+        //TODO: Bulk Upsert -> Return Inserted/Updated objects
+      } else {
+        stripTimestampFields(data, allTimestampKeys);
+        await validateInput(
+          data,
+          getPayloadValidator("CREATE", modelStructure, primary_key, false),
+        );
+        data = RemoveUnknownData(modelStructure, [data]);
+        data = jsonStringify(data);
+        updateResult = await db.upsert(table, data, unique);
+        if (updateResult.hasOwnProperty("id")) {
+          const getResult = await db.get(table, [
+            [[primary_key, "=", updateResult.id]],
+          ]);
+          return getResult.count > 0 ? getResult["data"][0] : null;
+        } else if (data.hasOwnProperty(primary_key)) {
+          const result = await db.get(
+            table,
+            [[[primary_key, "=", data[primary_key]]]],
+            option.safeDelete,
+          );
+          if (result.count > 0) return result["data"][0];
+          else return null;
+        }
+      }
+      return updateResult;
+    },
+    remove: async (data) => {
+      let filter = dataToFilter(jsonSafeParse(data), primary_key);
+      return await db.remove(table, filter, option.safeDelete);
+    },
+    byId: async (id, options = {}) => {
+      let type = getType(id);
+      if (type === "string" || type === "number") {
+        const result = await db.get(
+          table,
+          [[[primary_key, "=", id]]],
+          [],
+          option.safeDelete,
+        );
+        if (result.count > 0) {
+          let record = result["data"][0];
+          if (options.select_columns)
+            record = applySelect(record, options.select_columns);
+          return record;
+        } else return null;
+      } else {
+        throw new Error("Invalid id value", { cause: { status: 422 } });
+      }
+    },
+    //TODO: Implement Sort Logic
+    find: async (data) => {
+      const { select_columns } = extractReservedParams(data);
+      let sort = [];
+      if (data.hasOwnProperty("sort")) {
+        sort = data.sort;
+        delete data.sort;
+        sort = jsonSafeParse(sort);
+      }
+      let filter = dataToFilter(jsonSafeParse(data), primary_key);
+      const result = await db.get(table, filter, sort, option.safeDelete);
+      if (select_columns)
+        result.data = applySelect(result.data, select_columns);
+      return result;
+    },
+    findOne: async (data) => {
+      const { select_columns } = extractReservedParams(data);
+      let sort = [];
+      if (data.hasOwnProperty("sort")) {
+        sort = data.sort;
+        delete data.sort;
+        sort = jsonSafeParse(sort);
+      }
+      let filter = dataToFilter(jsonSafeParse(data), primary_key);
+      let result = await db.get(table, filter, sort, option.safeDelete);
+      if (result.count > 0) {
+        let record = result["data"][0];
+        if (select_columns) record = applySelect(record, select_columns);
+        return record;
+      } else {
+        return false;
+      }
+    },
+    list: async (data) => {
+      const { select_columns } = extractReservedParams(data);
+      let page = 0;
+      let size = 30;
+      let sort = [];
+      if (data.hasOwnProperty("page")) {
+        page = parseInt(data.page, 10);
+        if (isNaN(page) || page < 0) page = 0;
+        delete data.page;
+      }
+      if (data.hasOwnProperty("size")) {
+        size = parseInt(data.size, 10);
+        if (isNaN(size) || size < 1) size = 30;
+        if (size > 200) size = 200;
+        delete data.size;
+      }
+      if (data.hasOwnProperty("sort")) {
+        sort = data.sort;
+        delete data.sort;
+      }
+      let filter = dataToFilter(jsonSafeParse(data), primary_key);
+      sort = jsonSafeParse(sort);
+      const result = await db.list(
+        table,
+        filter,
+        sort,
+        option.safeDelete,
+        page,
+        size,
+      );
+      if (select_columns)
+        result.data = applySelect(result.data, select_columns);
+      return result;
+    },
+    patch: async (data) => {
+      // Partial update — fetch existing, merge patch fields, then upsert
+      stripTimestampFields(data, allTimestampKeys);
+      if (!data.hasOwnProperty(primary_key)) {
+        throw new Error("Primary key is required for patch", {
+          cause: { status: 422 },
+        });
+      }
+      const pkValue = data[primary_key];
+      // Fetch existing record
+      const existing = await db.get(
+        table,
+        [[[primary_key, "=", pkValue]]],
+        [],
+        option.safeDelete,
+      );
+      if (existing.count === 0) return null;
+      // Merge: start with existing, overlay only known fields from patch
+      const merged = { ...existing.data[0] };
+      for (const key of Object.keys(data)) {
+        if (key === primary_key) continue;
+        if (modelStructure.hasOwnProperty(key)) {
+          merged[key] = data[key];
+        }
+      }
+      const pkOrig = merged[primary_key];
+      const mergedArray = jsonStringify([merged]);
+      // Restore the primary key value in case jsonStringify converted it
+      // (e.g., MongoDB ObjectId gets stringified to a JSON string)
+      mergedArray[0][primary_key] = pkOrig;
+      await db.upsert(table, mergedArray, unique);
+      // Re-fetch to return the updated record
+      const result = await db.get(
+        table,
+        [[[primary_key, "=", pkValue]]],
+        [],
+        option.safeDelete,
+      );
+      if (result.count > 0) return result["data"][0];
+      return null;
+    },
+    pk: primary_key,
+    modelStructure,
+    table,
+  };
+};
+
+// Export format helpers for route.js
+module.exports.toCSV = toCSV;
+module.exports.toXML = toXML;
+module.exports.applySelect = applySelect;
+module.exports.extractReservedParams = extractReservedParams;