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

package/dist/agent/chunks/relations-B9TynBmA.mjs

@@ -0,0 +1,191 @@
+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 { filesOf, objectsOf, recordsOf, activitiesOf, objectOf, recordOf, requireRecord, requireObject } from "./store-5gqRSKXg.mjs";
+import { recordLabel } from "./fields-B0bitgmr.mjs";
+import { actorId, assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+const sameTarget = (a, b) => a.kind === b.kind && a.id === b.id;
+function fileFieldIds(ctx, objectId) {
+  const o = objectsOf(ctx.store).find((x) => x.id === objectId);
+  return o ? o.fields.filter((f) => f.type === "image" || f.type === "files").map((f) => f.id) : [];
+}
+function fileIdsIn(value) {
+  if (typeof value === "string" && value) return [value];
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string" && !!v);
+  return [];
+}
+function referencedFileIds(ctx) {
+  const out = /* @__PURE__ */ new Set();
+  const byObject = /* @__PURE__ */ new Map();
+  for (const r of recordsOf(ctx.store, void 0, { includeDeleted: true })) {
+    let ids = byObject.get(r.object);
+    if (!ids) byObject.set(r.object, ids = fileFieldIds(ctx, r.object));
+    for (const f of ids) for (const id of fileIdsIn(r.fields[f])) out.add(id);
+  }
+  for (const a of activitiesOf(ctx.store, { includeDeleted: true })) for (const id of a.attachments ?? []) out.add(id);
+  return out;
+}
+function fileCleanupMutations(ctx, doomed) {
+  const records = new Set(doomed.records ?? []);
+  const activities = new Set(doomed.activities ?? []);
+  if (!records.size && !activities.size) return [];
+  const now = ctx.now();
+  const out = [];
+  for (const f of filesOf(ctx.store, { includeDeleted: true })) {
+    const gone = (t) => t.kind === "record" ? records.has(t.id) : activities.has(t.id);
+    if (!f.targets.some(gone)) continue;
+    const rest = f.targets.filter((t) => !gone(t));
+    const fields = { targets: rest, updatedAt: now };
+    if (!rest.length && !f.deletedAt) fields.deletedAt = now;
+    out.push({ op: "patch", collection: "files", id: f.id, fields });
+  }
+  return out;
+}
+function fileMergeMutations(ctx, duplicates, primary) {
+  const dup = new Set(duplicates);
+  const now = ctx.now();
+  const out = [];
+  for (const f of filesOf(ctx.store, { includeDeleted: true })) {
+    if (!f.targets.some((t) => t.kind === "record" && dup.has(t.id))) continue;
+    const targets = [];
+    for (const t of f.targets) {
+      const next = t.kind === "record" && dup.has(t.id) ? { kind: "record", object: primary.object, id: primary.id } : t;
+      if (!targets.some((x) => sameTarget(x, next))) targets.push(next);
+    }
+    out.push({ op: "patch", collection: "files", id: f.id, fields: { targets, updatedAt: now } });
+  }
+  return out;
+}
+function fileTargetPatch(ctx, file, add, remove = []) {
+  let targets = file.targets.filter((t) => !remove.some((r) => sameTarget(r, t)));
+  for (const t of add) if (!targets.some((x) => sameTarget(x, t))) targets = [...targets, t];
+  if (targets.length === file.targets.length && targets.every((t, i) => sameTarget(t, file.targets[i]))) return null;
+  return { op: "patch", collection: "files", id: file.id, fields: { targets, updatedAt: ctx.now() } };
+}
+function relationFields(object) {
+  return object.fields.filter((f) => f.type === "relation" && f.relation);
+}
+function relationIds(value) {
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return typeof value === "string" && value ? [value] : [];
+}
+function toRef(ctx, record) {
+  return { id: record.id, object: record.object, label: recordLabel(objectOf(ctx.store, record.object), record) };
+}
+function labelOf(ctx, id) {
+  const r = recordOf(ctx.store, id);
+  return r ? recordLabel(objectOf(ctx.store, r.object), r) : void 0;
+}
+function relatedRecords(ctx, record, fieldId) {
+  return relationIds(record.fields[fieldId]).map((id) => recordOf(ctx.store, id)).filter((r) => !!r && !r.deletedAt);
+}
+function inverseRelations(ctx, record) {
+  const out = [];
+  for (const object of objectsOf(ctx.store)) {
+    for (const field of relationFields(object)) {
+      if (field.relation.object !== record.object) continue;
+      const records = recordsOf(ctx.store, object.id).filter((r) => relationIds(r.fields[field.id]).includes(record.id));
+      out.push({
+        object: object.id,
+        field: field.id,
+        fieldLabel: field.label,
+        label: object.labelPlural,
+        records: records.map((r) => toRef(ctx, r))
+      });
+    }
+  }
+  return out;
+}
+function expandRelations(ctx, record) {
+  const object = objectOf(ctx.store, record.object);
+  const out = {};
+  if (!object) return out;
+  for (const field of relationFields(object)) out[field.id] = relatedRecords(ctx, record, field.id).map((r) => toRef(ctx, r));
+  return out;
+}
+function validateRelationValue(ctx, field, value) {
+  const target = field.relation?.object;
+  for (const id of relationIds(value)) {
+    const r = recordOf(ctx.store, id);
+    if (!r || r.deletedAt) return `${field.label}: record "${id}" not found.`;
+    if (r.object !== target) return `${field.label}: "${id}" is a ${r.object} record, expected ${target}.`;
+  }
+  return null;
+}
+function patchFieldMutation(ctx, record, fieldId, value) {
+  return {
+    op: "patch",
+    collection: "records",
+    id: record.id,
+    fields: { [`fields.${fieldId}`]: value, updatedAt: ctx.now(), updatedBy: actorId(ctx) }
+  };
+}
+function rewriteReferences(ctx, fromIds, toId) {
+  const from = new Set(fromIds);
+  const out = [];
+  for (const object of objectsOf(ctx.store)) {
+    const fields = relationFields(object);
+    if (!fields.length) continue;
+    for (const r of recordsOf(ctx.store, object.id, { includeDeleted: true })) {
+      if (from.has(r.id)) continue;
+      for (const field of fields) {
+        const ids = relationIds(r.fields[field.id]);
+        if (!ids.some((id) => from.has(id))) continue;
+        if (field.relation.cardinality === "many") {
+          const next = [...new Set(ids.map((id) => from.has(id) ? toId : id).filter((id) => !!id))];
+          out.push(patchFieldMutation(ctx, r, field.id, next.length ? next : void 0));
+        } else {
+          out.push(patchFieldMutation(ctx, r, field.id, toId ?? void 0));
+        }
+      }
+    }
+  }
+  return out;
+}
+async function linkRecords(ctx, recordId, fieldId, targetId) {
+  assertCan(ctx, "records.write");
+  const record = requireRecord(ctx.store, recordId);
+  const object = requireObject(ctx.store, record.object);
+  const field = object.fields.find((f) => f.id === fieldId);
+  if (!field || field.type !== "relation") throw new OpsError("invalid", `"${fieldId}" is not a relation field of ${object.labelPlural}.`);
+  const err = validateRelationValue(ctx, field, targetId);
+  if (err) throw new OpsError("validation", err);
+  const ids = relationIds(record.fields[fieldId]);
+  const value = field.relation.cardinality === "many" ? [.../* @__PURE__ */ new Set([...ids, targetId])] : targetId;
+  await ctx.store.write([patchFieldMutation(ctx, record, fieldId, value)], { message: `Link ${object.labelSingular}` });
+  return requireRecord(ctx.store, recordId);
+}
+async function unlinkRecords(ctx, recordId, fieldId, targetId) {
+  assertCan(ctx, "records.write");
+  const record = requireRecord(ctx.store, recordId);
+  const ids = relationIds(record.fields[fieldId]).filter((id) => id !== targetId);
+  const object = requireObject(ctx.store, record.object);
+  const field = object.fields.find((f) => f.id === fieldId);
+  if (!field || field.type !== "relation") throw new OpsError("invalid", `"${fieldId}" is not a relation field of ${object.labelPlural}.`);
+  const value = field.relation.cardinality === "many" ? ids.length ? ids : void 0 : ids[0];
+  await ctx.store.write([patchFieldMutation(ctx, record, fieldId, value)], { message: `Unlink ${object.labelSingular}` });
+  return requireRecord(ctx.store, recordId);
+}
+export {
+  relationIds as a,
+  fileCleanupMutations as b,
+  rewriteReferences as c,
+  fileMergeMutations as d,
+  fileFieldIds as e,
+  fileTargetPatch as f,
+  fileIdsIn as g,
+  referencedFileIds as h,
+  inverseRelations as i,
+  expandRelations as j,
+  linkRecords as k,
+  labelOf as l,
+  relatedRecords as m,
+  relationFields as r,
+  sameTarget as s,
+  toRef as t,
+  unlinkRecords as u,
+  validateRelationValue as v
+};

package/dist/agent/chunks/reports-BB59N6ke.mjs

@@ -0,0 +1,189 @@
+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 { recordLabel, dateValueToMs } from "./fields-B0bitgmr.mjs";
+import { L as LIFECYCLE_OPTIONS } from "./standardObjects-CheqfDqa.mjs";
+import { A as ACTIVITY_TYPES } from "../agentcrm.mjs";
+import { lastActivityAt } from "./activities-Cj_SIOay.mjs";
+import { OpsError, assertCan } from "./context-CxFfqS4D.mjs";
+import { forecast, pipelineOfRecord } from "./pipelines-DCdRBNBV.mjs";
+import { getSettings } from "./settings-BtvR_jdm.mjs";
+import { objectOf, recordsOf, pipelinesOf, usersOf, activitiesOf, requirePipeline } from "./store-5gqRSKXg.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+import "./ids-CvnmrMJX.mjs";
+import "./query-C5nJB_3C.mjs";
+import "./relations-B9TynBmA.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./records-DoqiT9xR.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+const DAY = 864e5;
+function defaultPipelineId(ctx, pipelineId) {
+  if (pipelineId) return requirePipeline(ctx.store, pipelineId).id;
+  const p = pipelinesOf(ctx.store, "deals")[0] ?? pipelinesOf(ctx.store)[0];
+  if (!p) throw new OpsError("notFound", "No pipeline.");
+  return p.id;
+}
+function pipelineByStage(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const pipelineId = defaultPipelineId(ctx, opts.pipelineId);
+  const pipeline = requirePipeline(ctx.store, pipelineId);
+  const f = forecast(ctx, { pipelineId, ownerId: opts.ownerId });
+  return {
+    pipelineId,
+    stages: f.byStage.map((s) => ({ stageId: s.stageId, label: s.label, color: pipeline.stages.find((x) => x.id === s.stageId)?.color ?? "gray", kind: s.kind, count: s.count, amount: s.amount, weighted: s.weighted }))
+  };
+}
+function monthKey(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+}
+function lastMonths(now, months) {
+  const d = new Date(now);
+  const out = [];
+  for (let i = months - 1; i >= 0; i--) out.push(monthKey(new Date(d.getFullYear(), d.getMonth() - i, 1).getTime()));
+  return out;
+}
+function closedAt(r) {
+  return dateValueToMs(r.fields.closeDate) ?? r.updatedAt;
+}
+function wonLost(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const pipelineId = defaultPipelineId(ctx, opts.pipelineId);
+  const pipeline = requirePipeline(ctx.store, pipelineId);
+  const months = lastMonths(ctx.now(), Math.max(1, Math.min(36, opts.months ?? 6)));
+  const rows = new Map(months.map((m) => [m, { month: m, wonCount: 0, wonAmount: 0, lostCount: 0, lostAmount: 0, winRate: null }]));
+  for (const r of recordsOf(ctx.store, pipeline.object)) {
+    if (opts.ownerId && r.ownerId !== opts.ownerId) continue;
+    if (pipelineOfRecord(ctx, r)?.id !== pipelineId) continue;
+    const stage = pipeline.stages.find((s) => s.id === r.fields[pipeline.stageField]);
+    if (!stage || stage.kind === "open") continue;
+    const row = rows.get(monthKey(closedAt(r)));
+    if (!row) continue;
+    const amount = typeof r.fields.amount === "number" ? r.fields.amount : 0;
+    if (stage.kind === "won") {
+      row.wonCount++;
+      row.wonAmount += amount;
+    } else {
+      row.lostCount++;
+      row.lostAmount += amount;
+    }
+  }
+  const list = [...rows.values()].map((r) => ({ ...r, winRate: r.wonCount + r.lostCount ? Math.round(r.wonCount / (r.wonCount + r.lostCount) * 1e3) / 10 : null }));
+  const t = list.reduce((a, r) => ({ wonCount: a.wonCount + r.wonCount, wonAmount: a.wonAmount + r.wonAmount, lostCount: a.lostCount + r.lostCount, lostAmount: a.lostAmount + r.lostAmount }), { wonCount: 0, wonAmount: 0, lostCount: 0, lostAmount: 0 });
+  return { pipelineId, months: list, totals: { ...t, winRate: t.wonCount + t.lostCount ? Math.round(t.wonCount / (t.wonCount + t.lostCount) * 1e3) / 10 : null } };
+}
+function activityByUser(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const days = opts.days ?? 30;
+  const since = ctx.now() - days * DAY;
+  const users = new Map(usersOf(ctx.store).map((u) => [u.id, u.name]));
+  const rows = /* @__PURE__ */ new Map();
+  const row = (id) => {
+    let r = rows.get(id);
+    if (!r) {
+      r = { userId: id, name: id ? users.get(id) ?? id : "Unassigned", total: 0, byType: Object.fromEntries(ACTIVITY_TYPES.map((t) => [t, 0])), tasksDone: 0, tasksOpen: 0 };
+      rows.set(id, r);
+    }
+    return r;
+  };
+  for (const a of activitiesOf(ctx.store)) {
+    const who = (a.type === "task" ? a.assigneeId ?? a.createdBy : a.createdBy) ?? null;
+    if (a.type === "task" && !a.doneAt) row(who).tasksOpen++;
+    if (a.createdAt < since && !(a.doneAt && a.doneAt >= since)) continue;
+    const r = row(who);
+    r.total++;
+    r.byType[a.type]++;
+    if (a.type === "task" && a.doneAt && a.doneAt >= since) r.tasksDone++;
+  }
+  return { days, users: [...rows.values()].sort((a, b) => b.total - a.total) };
+}
+function leadSources(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const objectId = opts.object ?? "people";
+  const object = objectOf(ctx.store, objectId);
+  const field = object?.fields.find((f) => f.id === "leadSource");
+  if (!object || !field) return { field: "leadSource", sources: [] };
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of recordsOf(ctx.store, objectId)) {
+    if (opts.since && r.createdAt < opts.since) continue;
+    const id = typeof r.fields.leadSource === "string" ? r.fields.leadSource : null;
+    const entry = counts.get(id) ?? { id, label: id ? field.options?.find((o) => o.id === id)?.label ?? id : "Unknown", count: 0, customers: 0 };
+    entry.count++;
+    if (r.fields.lifecycleStage === "customer" || r.fields.lifecycleStage === "evangelist") entry.customers++;
+    counts.set(id, entry);
+  }
+  return { field: "leadSource", sources: [...counts.values()].sort((a, b) => b.count - a.count) };
+}
+function staleDeals(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const days = opts.days ?? getSettings(ctx).staleDealDays;
+  const now = ctx.now();
+  const out = [];
+  for (const pipeline of pipelinesOf(ctx.store)) {
+    if (opts.pipelineId && pipeline.id !== opts.pipelineId) continue;
+    const object = objectOf(ctx.store, pipeline.object);
+    for (const r of recordsOf(ctx.store, pipeline.object)) {
+      if (pipelineOfRecord(ctx, r)?.id !== pipeline.id) continue;
+      const stage = pipeline.stages.find((s) => s.id === r.fields[pipeline.stageField]);
+      if (!stage || stage.kind !== "open") continue;
+      const last = Math.max(lastActivityAt(ctx, r.id) ?? 0, r.updatedAt);
+      const idle = Math.floor((now - last) / DAY);
+      if (idle < days) continue;
+      out.push({ id: r.id, label: recordLabel(object, r), stage: stage.label, amount: typeof r.fields.amount === "number" ? r.fields.amount : 0, ownerId: r.ownerId, lastActivityAt: lastActivityAt(ctx, r.id) ?? null, idleDays: idle });
+    }
+  }
+  out.sort((a, b) => b.idleDays - a.idleDays || b.amount - a.amount);
+  return { days, deals: opts.limit ? out.slice(0, opts.limit) : out };
+}
+function conversion(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const object = objectOf(ctx.store, "people");
+  const field = object?.fields.find((f) => f.id === "lifecycleStage");
+  const options = field?.options ?? LIFECYCLE_OPTIONS;
+  const counts = new Map(options.map((o) => [o.id, 0]));
+  for (const r of recordsOf(ctx.store, "people")) {
+    if (opts.since && r.createdAt < opts.since) continue;
+    const v = r.fields.lifecycleStage;
+    if (typeof v === "string" && counts.has(v)) counts.set(v, counts.get(v) + 1);
+  }
+  const stages = options.map((o, i) => ({ id: o.id, label: o.label, count: counts.get(o.id) ?? 0, reached: options.slice(i).reduce((a, x) => a + (counts.get(x.id) ?? 0), 0), conversionFromPrevious: null }));
+  for (let i = 1; i < stages.length; i++) {
+    const prev = stages[i - 1].reached;
+    stages[i].conversionFromPrevious = prev ? Math.round(stages[i].reached / prev * 1e3) / 10 : null;
+  }
+  return { stages };
+}
+const REPORTS = {
+  pipelineByStage: { description: "Open pipeline by stage: count, amount, weighted amount.", run: pipelineByStage },
+  forecast: { description: "Weighted forecast (amount × probability) by stage and close month.", run: forecast },
+  wonLost: { description: "Won vs lost deals per month with win rate (params: months).", run: wonLost },
+  activityByUser: { description: "Activities logged per user over the last N days (params: days).", run: activityByUser },
+  leadSources: { description: "People per lead source, with how many became customers.", run: leadSources },
+  staleDeals: { description: "Open deals without activity for N days (params: days).", run: staleDeals },
+  conversion: { description: "Lifecycle stage funnel with step conversion rates.", run: conversion }
+};
+function runReport(ctx, name, params = {}) {
+  const report = REPORTS[name];
+  if (!report) throw new OpsError("notFound", `Unknown report "${name}". Reports: ${Object.keys(REPORTS).join(", ")}.`);
+  return report.run(ctx, params);
+}
+export {
+  REPORTS,
+  activityByUser,
+  conversion,
+  leadSources,
+  pipelineByStage,
+  runReport,
+  staleDeals,
+  wonLost
+};