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

package/dist/agent/chunks/files-D1daDgY0.mjs

@@ -0,0 +1,367 @@
+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 { sanitizeFileName, guessMime, sha256Hex, thumbIdOf, fileKind, DEFAULT_MAX_UPLOAD_MB } from "./files-CjsPJSR6.mjs";
+import { n as newId } from "./ids-CvnmrMJX.mjs";
+import { f as fileStoreOf, F as FileStoreUnavailableError } from "./index-RCmo-uld.mjs";
+import { m as mapLimit } from "./http-Bk9ICb7I.mjs";
+import { assertCan, OpsError, actorId } from "./context-CxFfqS4D.mjs";
+import { s as sameTarget, e as fileFieldIds, g as fileIdsIn, f as fileTargetPatch, h as referencedFileIds } from "./relations-B9TynBmA.mjs";
+import { timelineScope } from "./activities-Cj_SIOay.mjs";
+import { updateRecord } from "./records-DcHFelq5.mjs";
+import { fileOf, requireFile, filesOf, recordOf, activitiesOf, settingsDoc, asDoc, requireRecord, objectOf, requireObject, recordsOf } from "./store-5gqRSKXg.mjs";
+import "./index-BM8qeGOb.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./fields-B0bitgmr.mjs";
+import "./query-C5nJB_3C.mjs";
+import "../agentcrm.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 "./standardObjects-CheqfDqa.mjs";
+const ORPHAN_GRACE_MS = 864e5;
+function maxUploadBytes(ctx) {
+  const mb = settingsDoc(ctx.store)?.maxUploadMb;
+  return Math.round((typeof mb === "number" && mb > 0 ? mb : DEFAULT_MAX_UPLOAD_MB) * 1024 * 1024);
+}
+function resolveTarget(ctx, ref) {
+  const id = typeof ref === "string" ? ref : ref.id;
+  const kind = typeof ref === "string" ? void 0 : ref.kind;
+  if (kind !== "activity") {
+    const r = recordOf(ctx.store, id);
+    if (r && !r.deletedAt) return { kind: "record", object: r.object, id: r.id };
+    if (kind === "record") throw new OpsError("validation", `Record "${id}" not found.`);
+  }
+  const a = ctx.store.get("activities", id);
+  if (a && !a.deletedAt) return { kind: "activity", id: a.id };
+  throw new OpsError("validation", `Target "${id}" is neither a record nor an activity.`);
+}
+function uniqueTargets(targets) {
+  return targets.filter((t, i) => targets.findIndex((x) => sameTarget(x, t)) === i);
+}
+function activityAttachmentMutations(ctx, fileId, add, remove = []) {
+  const out = [];
+  for (const id of /* @__PURE__ */ new Set([...add, ...remove])) {
+    const a = ctx.store.get("activities", id);
+    if (!a) continue;
+    const current = a.attachments ?? [];
+    const next = add.includes(id) ? current.includes(fileId) ? current : [...current, fileId] : current.filter((x) => x !== fileId);
+    if (next.length === current.length && next.every((x, i) => x === current[i])) continue;
+    out.push({ op: "patch", collection: "activities", id, fields: { attachments: next.length ? next : void 0, updatedAt: ctx.now() } });
+  }
+  return out;
+}
+async function uploadFile(ctx, input) {
+  assertCan(ctx, "records.write");
+  if (!(input.bytes instanceof Uint8Array)) throw new OpsError("validation", "uploadFile: bytes must be a Uint8Array.");
+  const name = sanitizeFileName(input.name);
+  const limit = maxUploadBytes(ctx);
+  if (input.bytes.length > limit) {
+    throw new OpsError("validation", `${name} is too large (${Math.ceil(input.bytes.length / 1048576)} MB > ${Math.round(limit / 1048576)} MB, Settings → General → Max upload size).`);
+  }
+  if (input.bytes.length === 0) throw new OpsError("validation", `${name} is empty.`);
+  const targets = uniqueTargets((input.targets ?? []).map((t) => resolveTarget(ctx, t)));
+  const files = fileStoreOf(ctx.store);
+  const now = ctx.now();
+  const id = input.id ?? newId(now);
+  if (fileOf(ctx.store, id)) throw new OpsError("conflict", `File "${id}" already exists.`);
+  const mime = guessMime(name, input.mime);
+  const meta = {
+    id,
+    name,
+    mime,
+    size: input.bytes.length,
+    ...input.width ? { width: Math.round(input.width) } : {},
+    ...input.height ? { height: Math.round(input.height) } : {},
+    ...input.thumbnail ? { thumbId: thumbIdOf(id) } : {},
+    sha256: await sha256Hex(input.bytes),
+    createdAt: now,
+    updatedAt: now,
+    ...actorId(ctx) ? { createdBy: actorId(ctx) } : {},
+    targets
+  };
+  const blobs = [{ id, bytes: input.bytes, meta: { name, mime } }];
+  if (input.thumbnail) blobs.push({ id: thumbIdOf(id), bytes: input.thumbnail.bytes, meta: { name: `thumb-${name}`, mime: input.thumbnail.mime ?? "image/webp" } });
+  try {
+    if (files.putMany) await files.putMany(blobs);
+    else for (const b of blobs) await files.put(b.id, b.bytes, b.meta);
+  } catch (err) {
+    if (err instanceof FileStoreUnavailableError) throw new OpsError("invalid", err.message);
+    throw err;
+  }
+  const mutations = [{ op: "set", collection: "files", doc: asDoc(meta) }];
+  mutations.push(...activityAttachmentMutations(ctx, id, targets.filter((t) => t.kind === "activity").map((t) => t.id)));
+  await ctx.store.write(mutations, { message: `Upload ${name}` });
+  return requireFile(ctx.store, id);
+}
+async function attachFile(ctx, fileId, target) {
+  assertCan(ctx, "records.write");
+  const file = requireFile(ctx.store, fileId);
+  const t = resolveTarget(ctx, target);
+  const mutations = [];
+  const patch = fileTargetPatch(ctx, file, [t]);
+  if (patch) mutations.push(patch);
+  if (t.kind === "activity") mutations.push(...activityAttachmentMutations(ctx, fileId, [t.id]));
+  if (mutations.length) await ctx.store.write(mutations, { message: `Attach ${file.name}` });
+  return requireFile(ctx.store, fileId);
+}
+async function detachFile(ctx, fileId, target) {
+  assertCan(ctx, "records.write");
+  const file = requireFile(ctx.store, fileId);
+  const id = typeof target === "string" ? target : target.id;
+  const t = file.targets.find((x) => x.id === id);
+  if (!t) return file;
+  const mutations = [];
+  const patch = fileTargetPatch(ctx, file, [], [t]);
+  if (patch) mutations.push(patch);
+  if (t.kind === "activity") mutations.push(...activityAttachmentMutations(ctx, fileId, [], [t.id]));
+  if (t.kind === "record") mutations.push(...recordFieldCleanup(ctx, fileId, [t.id]));
+  await ctx.store.write(mutations, { message: `Detach ${file.name}` });
+  return requireFile(ctx.store, fileId);
+}
+function recordFieldCleanup(ctx, fileId, onlyRecords) {
+  const out = [];
+  const now = ctx.now();
+  for (const r of recordsOf(ctx.store, void 0, { includeDeleted: true })) {
+    if (onlyRecords && !onlyRecords.includes(r.id)) continue;
+    const fields = {};
+    for (const f of fileFieldIds(ctx, r.object)) {
+      const ids = fileIdsIn(r.fields[f]);
+      if (!ids.includes(fileId)) continue;
+      const rest = ids.filter((x) => x !== fileId);
+      fields[`fields.${f}`] = Array.isArray(r.fields[f]) ? rest.length ? rest : void 0 : void 0;
+    }
+    if (Object.keys(fields).length) out.push({ op: "patch", collection: "records", id: r.id, fields: { ...fields, updatedAt: now } });
+  }
+  return out;
+}
+function getFile(ctx, id, opts = {}) {
+  assertCan(ctx, "records.read");
+  return requireFile(ctx.store, id, opts);
+}
+async function getFileBytes(ctx, id, opts = {}) {
+  assertCan(ctx, "records.read");
+  const file = requireFile(ctx.store, id, { includeDeleted: true });
+  const files = fileStoreOf(ctx.store);
+  if (opts.thumb && file.thumbId) {
+    const thumb = await files.get(file.thumbId).catch(() => null);
+    if (thumb) return thumb;
+  }
+  const bytes = await files.get(file.id);
+  if (!bytes) throw new OpsError("notFound", `The bytes of ${file.name} are missing from the storage.`);
+  return bytes;
+}
+function listFiles(ctx, target, opts = {}) {
+  assertCan(ctx, "records.read");
+  const all = filesOf(ctx.store, { includeDeleted: opts.includeDeleted });
+  let items;
+  if (!target) {
+    items = all.map((f) => ({ ...f, via: f.targets[0] ? { kind: f.targets[0].kind, id: f.targets[0].id } : { kind: "record", id: "" } }));
+  } else {
+    const id = typeof target === "string" ? target : target.id;
+    const activity = ctx.store.get("activities", id);
+    const record = recordOf(ctx.store, id);
+    if (!record && !activity) throw new OpsError("notFound", `"${id}" is neither a record nor an activity.`);
+    const byId = new Map(all.map((f) => [f.id, f]));
+    const out = /* @__PURE__ */ new Map();
+    const add = (f, via) => {
+      if (f && !out.has(f.id)) out.set(f.id, { ...f, via });
+    };
+    if (activity && !record) {
+      for (const f of all) if (f.targets.some((t) => t.kind === "activity" && t.id === id)) add(f, { kind: "activity", id });
+      for (const fid of activity.attachments ?? []) add(byId.get(fid), { kind: "activity", id });
+    } else if (record) {
+      const scope = opts.includeRelated ? timelineScope(ctx, record.id, true) : /* @__PURE__ */ new Set([record.id]);
+      const fieldIdsOf = (r) => fileFieldIds(ctx, r.object).flatMap((f) => fileIdsIn(r.fields[f]));
+      for (const f of all) if (f.targets.some((t) => t.kind === "record" && t.id === record.id)) add(f, { kind: "record", id: record.id });
+      for (const fid of fieldIdsOf(record)) add(byId.get(fid), { kind: "record", id: record.id });
+      if (opts.includeActivities !== false || opts.includeRelated) {
+        for (const a of activitiesOf(ctx.store)) {
+          if (!a.targets.some((t) => scope.has(t.id))) continue;
+          for (const f of all) if (f.targets.some((t) => t.kind === "activity" && t.id === a.id)) add(f, { kind: "activity", id: a.id });
+          for (const fid of a.attachments ?? []) add(byId.get(fid), { kind: "activity", id: a.id });
+        }
+      }
+      if (opts.includeRelated) {
+        for (const rid of scope) {
+          if (rid === record.id) continue;
+          const r = recordOf(ctx.store, rid);
+          if (!r || r.deletedAt) continue;
+          for (const f of all) if (f.targets.some((t) => t.kind === "record" && t.id === rid)) add(f, { kind: "related", id: rid });
+          for (const fid of fieldIdsOf(r)) add(byId.get(fid), { kind: "related", id: rid });
+        }
+      }
+    }
+    items = [...out.values()];
+  }
+  if (opts.kind) items = items.filter((f) => fileKind(f.mime, f.name) === opts.kind);
+  const q = opts.search?.trim().toLowerCase();
+  if (q) items = items.filter((f) => f.name.toLowerCase().includes(q));
+  items.sort((a, b) => b.createdAt - a.createdAt || (a.id < b.id ? 1 : -1));
+  return opts.limit ? items.slice(0, opts.limit) : items;
+}
+function fileUsage(ctx) {
+  assertCan(ctx, "records.read");
+  const usage = { count: 0, totalBytes: 0, images: 0, deleted: 0, deletedBytes: 0 };
+  for (const f of filesOf(ctx.store, { includeDeleted: true })) {
+    if (f.deletedAt) {
+      usage.deleted++;
+      usage.deletedBytes += f.size;
+      continue;
+    }
+    usage.count++;
+    usage.totalBytes += f.size;
+    if (fileKind(f.mime, f.name) === "image") usage.images++;
+  }
+  return usage;
+}
+async function renameFile(ctx, id, name) {
+  assertCan(ctx, "records.write");
+  requireFile(ctx.store, id);
+  const clean = sanitizeFileName(name);
+  await ctx.store.write([{ op: "patch", collection: "files", id, fields: { name: clean, updatedAt: ctx.now() } }], { message: "Rename file" });
+  return requireFile(ctx.store, id);
+}
+async function deleteFile(ctx, id) {
+  assertCan(ctx, "records.write");
+  requireFile(ctx.store, id);
+  const now = ctx.now();
+  const mutations = [{ op: "patch", collection: "files", id, fields: { deletedAt: now, updatedAt: now } }];
+  const holders = activitiesOf(ctx.store, { includeDeleted: true }).filter((a) => a.attachments?.includes(id)).map((a) => a.id);
+  mutations.push(...activityAttachmentMutations(ctx, id, [], holders));
+  mutations.push(...recordFieldCleanup(ctx, id));
+  await ctx.store.write(mutations, { message: "Delete file" });
+  return { id };
+}
+async function restoreFile(ctx, id) {
+  assertCan(ctx, "records.write");
+  const f = requireFile(ctx.store, id, { includeDeleted: true });
+  if (!f.deletedAt) return f;
+  const mutations = [{ op: "patch", collection: "files", id, fields: { deletedAt: void 0, updatedAt: ctx.now() } }];
+  mutations.push(...activityAttachmentMutations(ctx, id, f.targets.filter((t) => t.kind === "activity").map((t) => t.id)));
+  await ctx.store.write(mutations, { message: "Restore file" });
+  return requireFile(ctx.store, id);
+}
+async function purgeFiles(ctx, opts = {}) {
+  assertCan(ctx, "compact");
+  const report = { purged: [], blobsDeleted: 0, orphanBlobs: 0, errors: [], dryRun: !!opts.dryRun };
+  const store = ctx.store.files;
+  const now = ctx.now();
+  const cutoff = now - (opts.olderThanDays ?? 0) * 864e5;
+  const referenced = referencedFileIds(ctx);
+  const exists = (t) => t.kind === "record" ? !!recordOf(ctx.store, t.id) : !!ctx.store.get("activities", t.id);
+  const all = filesOf(ctx.store, { includeDeleted: true });
+  const doomed = all.filter((f) => {
+    if (f.deletedAt) return f.deletedAt <= cutoff;
+    if (referenced.has(f.id)) return false;
+    const live = f.targets.filter(exists);
+    if (live.length) return false;
+    return f.targets.length > 0 || f.createdAt <= now - ORPHAN_GRACE_MS;
+  });
+  if (opts.dryRun || !store) {
+    report.purged = doomed.map((f) => f.id);
+    return report;
+  }
+  const done = [];
+  await mapLimit(doomed, 4, async (f) => {
+    try {
+      await store.delete(f.id);
+      if (f.thumbId) await store.delete(f.thumbId);
+      report.blobsDeleted += f.thumbId ? 2 : 1;
+      done.push(f.id);
+    } catch (err) {
+      report.errors.push({ id: f.id, message: err.message });
+    }
+  });
+  if (done.length) {
+    const mutations = done.map((id) => ({ op: "delete", collection: "files", id }));
+    for (const id of done) {
+      const holders = activitiesOf(ctx.store, { includeDeleted: true }).filter((a) => a.attachments?.includes(id)).map((a) => a.id);
+      mutations.push(...activityAttachmentMutations(ctx, id, [], holders));
+    }
+    await ctx.store.write(mutations, { message: `Purge ${done.length} files` });
+  }
+  report.purged = done;
+  if (store.list) {
+    try {
+      const known = /* @__PURE__ */ new Set();
+      for (const f of filesOf(ctx.store, { includeDeleted: true })) {
+        known.add(f.id);
+        if (f.thumbId) known.add(f.thumbId);
+      }
+      const orphans = (await store.list()).filter((id) => !known.has(id));
+      await mapLimit(orphans, 4, (id) => store.delete(id));
+      report.orphanBlobs = orphans.length;
+    } catch (err) {
+      report.errors.push({ id: "*", message: `Listing stored files failed: ${err.message}` });
+    }
+  }
+  return report;
+}
+function imageFieldOf(ctx, record, fieldId) {
+  const object = requireObject(ctx.store, record.object);
+  const id = fieldId ?? object.imageField;
+  if (!id) throw new OpsError("validation", `${object.labelPlural} have no image field (Settings → Data model → ${object.labelPlural} → image field).`);
+  const field = object.fields.find((f) => f.id === id);
+  if (!field) throw new OpsError("validation", `Unknown field "${id}" on ${object.labelPlural}.`);
+  if (field.type !== "image") throw new OpsError("validation", `${field.label} is not an image field.`);
+  return id;
+}
+async function setRecordImage(ctx, recordId, fieldId, file) {
+  assertCan(ctx, "records.write");
+  const record = requireRecord(ctx.store, recordId);
+  const field = imageFieldOf(ctx, record, fieldId);
+  if (!/^image\//.test(guessMime(file.name, file.mime))) throw new OpsError("validation", `${sanitizeFileName(file.name)} is not an image.`);
+  const previous = typeof record.fields[field] === "string" ? record.fields[field] : void 0;
+  const meta = await uploadFile(ctx, { ...file, targets: [{ kind: "record", object: record.object, id: record.id }] });
+  const updated = await updateRecord(ctx, recordId, { [field]: meta.id });
+  if (previous && previous !== meta.id) await retireImage(ctx, previous, record.id);
+  return { record: updated, file: meta };
+}
+async function clearRecordImage(ctx, recordId, fieldId) {
+  assertCan(ctx, "records.write");
+  const record = requireRecord(ctx.store, recordId);
+  const field = imageFieldOf(ctx, record, fieldId);
+  const previous = typeof record.fields[field] === "string" ? record.fields[field] : void 0;
+  const updated = await updateRecord(ctx, recordId, { [field]: null });
+  if (previous) await retireImage(ctx, previous, record.id);
+  return updated;
+}
+async function retireImage(ctx, fileId, recordId) {
+  const f = fileOf(ctx.store, fileId);
+  if (!f || f.deletedAt) return;
+  if (referencedFileIds(ctx).has(fileId)) return;
+  if (f.targets.some((t) => !(t.kind === "record" && t.id === recordId))) return;
+  await deleteFile(ctx, fileId);
+}
+function recordImageId(ctx, record) {
+  const object = objectOf(ctx.store, record.object);
+  const id = object?.imageField ? record.fields[object.imageField] : void 0;
+  return typeof id === "string" && id ? id : void 0;
+}
+export {
+  ORPHAN_GRACE_MS,
+  attachFile,
+  clearRecordImage,
+  deleteFile,
+  detachFile,
+  fileUsage,
+  getFile,
+  getFileBytes,
+  listFiles,
+  maxUploadBytes,
+  purgeFiles,
+  recordImageId,
+  renameFile,
+  restoreFile,
+  setRecordImage,
+  uploadFile
+};