@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.0

package/dist/agent/chunks/query-C5nJB_3C.mjs

@@ -0,0 +1,192 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { comparableValue, dateValueToMs, parseNumber, isEmptyFieldValue, findOption, parseDateValue, formatFieldValue } from "./fields-B0bitgmr.mjs";
+const DAY = 864e5;
+const SYSTEM_FIELDS = {
+  id: { id: "id", label: "ID", type: "text", system: true },
+  ownerId: { id: "ownerId", label: "Owner", type: "user", system: true },
+  createdBy: { id: "createdBy", label: "Created by", type: "user", system: true },
+  updatedBy: { id: "updatedBy", label: "Updated by", type: "user", system: true },
+  createdAt: { id: "createdAt", label: "Created", type: "datetime", system: true },
+  updatedAt: { id: "updatedAt", label: "Updated", type: "datetime", system: true }
+};
+function resolveField(object, fieldId) {
+  return object.fields.find((f) => f.id === fieldId) ?? SYSTEM_FIELDS[fieldId];
+}
+function getRecordValue(record, fieldId) {
+  if (fieldId in SYSTEM_FIELDS) return record[fieldId];
+  return record.fields[fieldId];
+}
+function asArray(v) {
+  return Array.isArray(v) ? v : v === void 0 || v === null ? [] : [v];
+}
+function resolveDateArg(value, now) {
+  if (value === "now") return now;
+  if (value === "today") {
+    const d = new Date(now);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+  }
+  if (typeof value === "string") {
+    const rel = /^([+-]?\d+)d$/.exec(value.trim());
+    if (rel) return now + Number(rel[1]) * DAY;
+    const iso = parseDateValue(value);
+    if (iso && /^\d{4}-\d{2}-\d{2}$/.test(value.trim())) return dateValueToMs(iso);
+  }
+  return dateValueToMs(value);
+}
+function sameDay(a, b) {
+  const da = new Date(a);
+  const db = new Date(b);
+  return da.getFullYear() === db.getFullYear() && da.getMonth() === db.getMonth() && da.getDate() === db.getDate();
+}
+function textOf(field, value, ctx) {
+  return formatFieldValue(field, value, ctx).toLowerCase();
+}
+function normalizeOperand(field, operand) {
+  if ((field.type === "select" || field.type === "multiSelect") && operand !== void 0 && operand !== null) {
+    return findOption(field, operand)?.id ?? String(operand);
+  }
+  return operand;
+}
+function equals(field, stored, operand, ctx) {
+  const op = normalizeOperand(field, operand);
+  switch (field.type) {
+    case "number":
+    case "currency":
+    case "percent":
+    case "rating": {
+      const a = typeof stored === "number" ? stored : parseNumber(stored);
+      const b = parseNumber(op);
+      return a !== null && b !== null && a === b;
+    }
+    case "boolean":
+      return Boolean(stored) === (op === true || op === "true" || op === 1 || op === "1" || op === "yes");
+    case "date":
+    case "datetime": {
+      const a = dateValueToMs(stored);
+      const b = resolveDateArg(op, ctx.now ?? Date.now());
+      return a !== null && b !== null && sameDay(a, b);
+    }
+    case "multiSelect":
+    case "tags":
+      return asArray(stored).some((v) => String(v).toLowerCase() === String(op).toLowerCase());
+    case "relation":
+      return asArray(stored).some((v) => String(v) === String(op));
+    case "select":
+    case "user":
+      return stored !== void 0 && stored !== null && String(stored) === String(op);
+    default:
+      return typeof stored === "string" && typeof op !== "object" && stored.trim().toLowerCase() === String(op ?? "").trim().toLowerCase();
+  }
+}
+function contains(field, stored, operand, ctx) {
+  const needle = String(operand ?? "").trim().toLowerCase();
+  if (!needle) return true;
+  if (field.type === "relation") {
+    const target = field.relation?.object ?? "";
+    return asArray(stored).some((id) => {
+      const label = ctx.recordLabel?.(target, String(id)) ?? String(id);
+      return label.toLowerCase().includes(needle);
+    });
+  }
+  return textOf(field, stored, ctx).includes(needle);
+}
+function compareNum(field, stored, operand, ctx) {
+  const isDate = field.type === "date" || field.type === "datetime";
+  const a = isDate ? dateValueToMs(stored) : typeof stored === "number" ? stored : parseNumber(stored);
+  const b = isDate ? resolveDateArg(operand, ctx.now ?? Date.now()) : parseNumber(operand);
+  return a === null || b === null ? null : [a, b];
+}
+function matchesFilter(record, filter, ctx) {
+  const field = resolveField(ctx.object, filter.field);
+  if (!field) return true;
+  const stored = getRecordValue(record, filter.field);
+  const value = filter.value;
+  switch (filter.op) {
+    case "eq":
+      return equals(field, stored, value, ctx);
+    case "neq":
+      return !equals(field, stored, value, ctx);
+    case "contains":
+      return contains(field, stored, value, ctx);
+    case "notContains":
+      return !contains(field, stored, value, ctx);
+    case "empty":
+      return isEmptyFieldValue(field, stored);
+    case "notEmpty":
+      return !isEmptyFieldValue(field, stored);
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "before":
+    case "after": {
+      const pair = compareNum(field, stored, value, ctx);
+      if (!pair) return false;
+      const [a, b] = pair;
+      if (filter.op === "gt" || filter.op === "after") return a > b;
+      if (filter.op === "gte") return a >= b;
+      if (filter.op === "lt" || filter.op === "before") return a < b;
+      return a <= b;
+    }
+    case "in":
+    case "notIn": {
+      const set = asArray(value).map((v) => String(normalizeOperand(field, v)));
+      const hit = asArray(stored).some((v) => set.includes(String(v)));
+      return filter.op === "in" ? hit : !hit;
+    }
+    case "withinDays": {
+      const ms = dateValueToMs(stored);
+      const days = parseNumber(value);
+      if (ms === null || days === null) return false;
+      const now = ctx.now ?? Date.now();
+      return days >= 0 ? ms >= now - DAY && ms <= now + days * DAY : ms >= now + days * DAY && ms <= now;
+    }
+    default:
+      return true;
+  }
+}
+function applyFilters(records, filters, ctx) {
+  if (!filters?.length) return records;
+  return records.filter((r) => filters.every((f) => matchesFilter(r, f, ctx)));
+}
+function applySorts(records, sorts, ctx) {
+  if (!sorts?.length) return records;
+  const keyed = records.map((r) => ({
+    r,
+    keys: sorts.map((s) => comparableValue(resolveField(ctx.object, s.field), getRecordValue(r, s.field), ctx))
+  }));
+  keyed.sort((a, b) => {
+    for (let i = 0; i < sorts.length; i++) {
+      const x = a.keys[i];
+      const y = b.keys[i];
+      if (x === null && y === null) continue;
+      if (x === null) return 1;
+      if (y === null) return -1;
+      let c;
+      if (typeof x === "number" && typeof y === "number") c = x - y;
+      else c = String(x).localeCompare(String(y), void 0, { numeric: true, sensitivity: "base" });
+      if (c !== 0) return sorts[i].dir === "desc" ? -c : c;
+    }
+    return a.r.id < b.r.id ? -1 : a.r.id > b.r.id ? 1 : 0;
+  });
+  return keyed.map((k) => k.r);
+}
+function paginate(items, req = {}) {
+  const offset = Math.max(0, Math.floor(req.offset ?? 0));
+  const limit = req.limit === void 0 ? items.length : Math.max(0, Math.floor(req.limit));
+  const slice = items.slice(offset, offset + limit);
+  return { items: slice, total: items.length, offset, limit, hasMore: offset + slice.length < items.length };
+}
+export {
+  applySorts as a,
+  applyFilters as b,
+  getRecordValue as g,
+  matchesFilter as m,
+  paginate as p,
+  resolveField as r
+};