@firedrill-tools/unified 0.1.1

package/firedrill/tools/unified/ops/crm.mjs

@@ -0,0 +1,126 @@
+// CRM contacts and companies: body specs, defaults, derived `name`, list filters.
+import { badRequest } from "../lib/errors.mjs";
+import { idFilter, textFilter } from "../lib/query.mjs";
+import { bool, idArray, num, shape, str, strArray } from "../lib/validate.mjs";
+import { makeResource } from "./resource.mjs";
+
+const TEXT = 1000;
+
+const CONTACT_SPECS = {
+  name: str(TEXT),
+  first_name: str(TEXT),
+  last_name: str(TEXT),
+  title: str(TEXT),
+  company: str(TEXT),
+  department: str(TEXT),
+  image_url: str(2048),
+  user_id: str(256),
+  emails: shape("emails"),
+  telephones: shape("telephones"),
+  address: shape("address"),
+  company_ids: idArray(100),
+  deal_ids: idArray(100),
+  link_urls: strArray(32, 2048),
+  metadata: shape("metadata"),
+  raw: shape("raw"),
+};
+
+const COMPANY_SPECS = {
+  name: str(TEXT, { nullable: false, min: 1 }),
+  description: str(20000),
+  industry: str(TEXT),
+  timezone: str(128),
+  employees: num({ min: 0, integer: true }),
+  is_active: bool(),
+  tags: strArray(100, 256),
+  websites: strArray(32, 253),
+  domains: strArray(32, 253),
+  emails: shape("emails"),
+  telephones: shape("telephones"),
+  address: shape("address"),
+  link_urls: strArray(32, 2048),
+  contact_ids: idArray(100),
+  deal_ids: idArray(100),
+  user_id: str(256),
+  metadata: shape("metadata"),
+  raw: shape("raw"),
+};
+
+const contactDefaults = () => ({
+  name: null, first_name: null, last_name: null, title: null, company: null, department: null, image_url: null, user_id: null,
+  emails: [], telephones: [], address: null, company_ids: [], deal_ids: [], link_urls: [], metadata: [], raw: {},
+});
+
+const companyDefaults = () => ({
+  name: "", description: null, industry: null, timezone: null, employees: null, is_active: true, tags: [], websites: [], domains: [],
+  emails: [], telephones: [], address: null, link_urls: [], contact_ids: [], deal_ids: [], user_id: null, metadata: [], raw: {},
+});
+
+/** `name` derives from first/last name when the body does not set it. */
+function deriveName(fields) {
+  if (fields.name !== null && fields.name !== undefined) return fields.name;
+  const parts = [fields.first_name, fields.last_name].filter((part) => typeof part === "string" && part.length > 0);
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+
+/** Reference filters by association array membership plus the exact `user_id`. */
+function crmFilter(names) {
+  return (input, context) => {
+    const wanted = [];
+    for (const [param, field] of Object.entries(names)) {
+      const value = idFilter(input, context, param);
+      if (value !== null) wanted.push([field, value]);
+    }
+    const userId = textFilter(input, context, "user_id");
+    return (row) => {
+      if (userId !== null && row.user_id !== userId) return false;
+      for (const [field, value] of wanted) if (!Array.isArray(row[field]) || !row[field].includes(value)) return false;
+      return true;
+    };
+  };
+}
+
+export const contacts = makeResource({
+  namespace: "contacts",
+  label: "Contact",
+  category: "crm",
+  permission: "crm_contact",
+  objectType: "crm_contact",
+  searchFields: ["name", "first_name", "last_name", "emails"],
+  bodySpecs: CONTACT_SPECS,
+  defaults: contactDefaults,
+  filter: crmFilter({ company_id: "company_ids", deal_id: "deal_ids" }),
+  prepareCreate(context, connection, fields) {
+    const row = { ...contactDefaults(), ...fields };
+    row.name = deriveName(row);
+    if (row.name === null && row.emails.length === 0) badRequest(context, "At least one of name, first_name, last_name or emails is required");
+    return row;
+  },
+  prepareUpdate(context, connection, existing, fields) {
+    const merged = { ...existing, ...fields };
+    if (!Object.hasOwn(fields, "name") && (Object.hasOwn(fields, "first_name") || Object.hasOwn(fields, "last_name"))) {
+      merged.name = deriveName({ ...merged, name: null }) ?? merged.name;
+    }
+    if (merged.name === null && merged.emails.length === 0) badRequest(context, "At least one of name, first_name, last_name or emails is required");
+    return merged;
+  },
+});
+
+export const companies = makeResource({
+  namespace: "companies",
+  label: "Company",
+  category: "crm",
+  permission: "crm_company",
+  objectType: "crm_company",
+  searchFields: ["name", "emails", "domains", "websites"],
+  bodySpecs: COMPANY_SPECS,
+  defaults: companyDefaults,
+  filter: crmFilter({ contact_id: "contact_ids", deal_id: "deal_ids" }),
+  prepareCreate(context, connection, fields) {
+    if (typeof fields.name !== "string" || fields.name.length === 0) badRequest(context, "name is required");
+    return { ...companyDefaults(), ...fields };
+  },
+  prepareUpdate(context, connection, existing, fields) {
+    return { ...existing, ...fields };
+  },
+});

package/firedrill/tools/unified/ops/deals.mjs

@@ -0,0 +1,123 @@
+// CRM deals: pipeline/stage validation against the connection's pipelines, probability defaulting and closed_at
+// derivation when a deal enters or leaves a closed stage.
+import { badRequest } from "../lib/errors.mjs";
+import { idFilter, textFilter } from "../lib/query.mjs";
+import { getRow, scanBound, scanConnection } from "../lib/store.mjs";
+import { nowIso } from "../lib/time.mjs";
+import { idArray, iso, num, shape, str, strArray } from "../lib/validate.mjs";
+import { clip } from "../lib/util.mjs";
+import { makeResource } from "./resource.mjs";
+
+const DEAL_SPECS = {
+  name: str(1000, { nullable: false, min: 1 }),
+  description: str(20000),
+  source: str(256),
+  currency: str(3, { pattern: /^[A-Z]{3}$/ }),
+  amount: num({ min: 0 }),
+  probability: num({ min: 0, max: 100 }),
+  closed_at: iso(),
+  closing_at: iso(),
+  lost_reason: str(1000),
+  won_reason: str(1000),
+  tags: strArray(100, 256),
+  pipelines: shape("pipelineRefs"),
+  stages: shape("pipelineRefs"),
+  contact_ids: idArray(100),
+  company_ids: idArray(100),
+  user_id: str(256),
+  metadata: shape("metadata"),
+  raw: shape("raw"),
+};
+
+const defaults = () => ({
+  name: "", description: null, source: null, currency: null, amount: null, probability: null, closed_at: null, closing_at: null,
+  lost_reason: null, won_reason: null, tags: [], pipelines: [], stages: [], contact_ids: [], company_ids: [], user_id: null, metadata: [], raw: {},
+});
+
+const activeStages = (pipeline) => [...pipeline.stages].sort((a, b) => a.display_order - b.display_order);
+
+/** Finds the pipeline owning a stage id across the connection (bounded scan of the small pipelines namespace). */
+function pipelineOfStage(context, workspace, connectionId, stageId) {
+  for (const pipeline of scanConnection(context, "pipelines", connectionId, scanBound(workspace))) {
+    if (pipeline.stages.some((stage) => stage.id === stageId)) return pipeline;
+  }
+  return null;
+}
+
+/**
+ * Resolves `pipelines`/`stages` references: a stage without a pipeline implies its owner; a pipeline without a stage
+ * takes its first active stage; both must agree. Returns { pipelines, stages, stage } with names filled in.
+ */
+function resolveStage(context, workspace, connectionId, pipelines, stages) {
+  if (pipelines.length === 0 && stages.length === 0) return { pipelines: [], stages: [], stage: null };
+  let pipeline = null;
+  if (pipelines.length > 0) {
+    pipeline = getRow(context, "pipelines", connectionId, pipelines[0].id);
+    if (pipeline === null) badRequest(context, `Unknown pipeline id ${clip(pipelines[0].id, 40)}`);
+  } else {
+    pipeline = pipelineOfStage(context, workspace, connectionId, stages[0].id);
+    if (pipeline === null) badRequest(context, `Unknown stage id ${clip(stages[0].id, 40)}`);
+  }
+  let stage = null;
+  if (stages.length > 0) {
+    stage = pipeline.stages.find((entry) => entry.id === stages[0].id) ?? null;
+    if (stage === null) badRequest(context, `Stage ${clip(stages[0].id, 40)} does not belong to pipeline ${pipeline.id}`);
+  } else {
+    stage = activeStages(pipeline).find((entry) => entry.active) ?? activeStages(pipeline)[0] ?? null;
+  }
+  return {
+    pipelines: [{ id: pipeline.id, name: pipeline.name, type: null }],
+    stages: stage === null ? [] : [{ id: stage.id, name: stage.name, type: null }],
+    stage,
+  };
+}
+
+function applyStage(context, row, resolved, previousStageId, bodyHasProbability) {
+  row.pipelines = resolved.pipelines;
+  row.stages = resolved.stages;
+  const stage = resolved.stage;
+  if (!bodyHasProbability && stage !== null) row.probability = stage.deal_probability;
+  const stageId = stage === null ? null : stage.id;
+  if (stageId !== previousStageId) {
+    if (stage !== null && stage.is_closed) row.closed_at = row.closed_at ?? nowIso(context);
+    else if (previousStageId !== null) row.closed_at = null;
+  }
+}
+
+export const deals = makeResource({
+  namespace: "deals",
+  label: "Deal",
+  category: "crm",
+  permission: "crm_deal",
+  objectType: "crm_deal",
+  searchFields: ["name"],
+  bodySpecs: DEAL_SPECS,
+  defaults,
+  filter(input, context) {
+    const companyId = idFilter(input, context, "company_id");
+    const contactId = idFilter(input, context, "contact_id");
+    const pipelineId = idFilter(input, context, "pipeline_id");
+    const userId = textFilter(input, context, "user_id");
+    return (row) =>
+      (companyId === null || row.company_ids.includes(companyId)) &&
+      (contactId === null || row.contact_ids.includes(contactId)) &&
+      (pipelineId === null || row.pipelines.some((entry) => entry.id === pipelineId)) &&
+      (userId === null || row.user_id === userId);
+  },
+  prepareCreate(context, connection, fields, workspace) {
+    if (typeof fields.name !== "string" || fields.name.length === 0) badRequest(context, "name is required");
+    const row = { ...defaults(), ...fields };
+    const resolved = resolveStage(context, workspace, connection.id, row.pipelines, row.stages);
+    applyStage(context, row, resolved, null, Object.hasOwn(fields, "probability") && fields.probability !== null);
+    return row;
+  },
+  prepareUpdate(context, connection, existing, fields, workspace) {
+    const merged = { ...existing, ...fields };
+    if (Object.hasOwn(fields, "pipelines") || Object.hasOwn(fields, "stages")) {
+      const previousStageId = existing.stages[0]?.id ?? null;
+      const resolved = resolveStage(context, workspace, connection.id, merged.pipelines, merged.stages);
+      applyStage(context, merged, resolved, previousStageId, Object.hasOwn(fields, "probability") && fields.probability !== null);
+    }
+    return merged;
+  },
+});

package/firedrill/tools/unified/ops/messages.mjs

@@ -0,0 +1,133 @@
+// Messaging messages: list filters (channel aliases, threads, unread, date window, author, mentions), create (post or
+// threaded reply with the author taken from the connection's authorised identity), update of text fields and
+// is_unread, remove with the parent's has_children recomputed.
+import { badRequest } from "../lib/errors.mjs";
+import { enumFilter, idFilter, textFilter } from "../lib/query.mjs";
+import { getRow, putRow, scanBound, scanConnection } from "../lib/store.mjs";
+import { parseIsoUs } from "../lib/time.mjs";
+import { bool, shape, str } from "../lib/validate.mjs";
+import { clip, isHex24 } from "../lib/util.mjs";
+import { makeResource, rowsOf } from "./resource.mjs";
+
+const ALIASES = new Set(["INBOX", "SENT", "DRAFT"]);
+const TEXT_FIELDS = ["message", "message_html", "message_markdown"];
+
+const MESSAGE_SPECS = {
+  channels: shape("channelRefs"),
+  parent_id: str(24, { pattern: /^[0-9a-f]{24}$/ }),
+  message_thread_identifier: str(256),
+  author_member: shape("member"),
+  destination_members: shape("members"),
+  hidden_members: shape("members"),
+  mentioned_members: shape("members"),
+  reactions: shape("reactions"),
+  subject: str(1000),
+  message: str(20000),
+  message_html: str(20000),
+  message_markdown: str(20000),
+  attachments: shape("attachments"),
+  web_url: str(2048),
+  reference: str(256),
+  has_children: bool(),
+  is_unread: bool(),
+  buttons: shape("buttons"),
+  raw: shape("raw"),
+};
+
+const defaults = () => ({
+  channels: [], parent_id: null, message_thread_identifier: null, author_member: { user_id: null, email: null, name: null, image_url: null },
+  destination_members: [], hidden_members: [], mentioned_members: [], reactions: [], subject: null, message: null, message_html: null,
+  message_markdown: null, attachments: [], web_url: null, reference: null, has_children: false, is_unread: false, buttons: [], raw: {},
+});
+
+const hasText = (row) => TEXT_FIELDS.some((field) => typeof row[field] === "string" && row[field].trim().length > 0);
+
+function dateBound(input, context, name) {
+  const value = input[name];
+  if (value === undefined || value === null) return null;
+  const us = typeof value === "string" ? parseIsoUs(value) : null;
+  if (us === null) badRequest(context, `${name} must be an ISO-8601 date or date-time`);
+  return us;
+}
+
+/** Resolves INBOX/SENT/DRAFT to the connection's channel carrying that alias; a connection without one matches nothing. */
+function resolveChannel(context, workspace, connectionId, value) {
+  if (!ALIASES.has(value)) return value;
+  const channel = scanConnection(context, "channels", connectionId, scanBound(workspace)).find((row) => row.alias === value);
+  return channel === undefined ? "" : channel.id;
+}
+
+export const messages = makeResource({
+  namespace: "messages",
+  label: "Message",
+  category: "messaging",
+  permission: "messaging_message",
+  objectType: "messaging_message",
+  searchFields: ["subject", "message", "author_member"],
+  nameField: "subject",
+  bodySpecs: MESSAGE_SPECS,
+  defaults,
+  filter(input, context, connection, workspace) {
+    const channelParam = idFilter(input, context, "channel_id", ALIASES);
+    const channelId = channelParam === null ? null : resolveChannel(context, workspace, connection.id, channelParam);
+    const parentId = idFilter(input, context, "parent_id");
+    const type = enumFilter(input, context, "type", ["READ", "UNREAD"]);
+    const startUs = dateBound(input, context, "start_gte");
+    const endUs = dateBound(input, context, "end_lt");
+    const userId = textFilter(input, context, "user_id");
+    const mentioned = textFilter(input, context, "user_mentioned_id");
+    if (input.expand !== undefined && input.expand !== null && typeof input.expand !== "string") badRequest(context, "expand must be a string");
+    return (row) => {
+      if (channelId !== null && !row.channels.some((channel) => channel.id === channelId)) return false;
+      if (parentId !== null && row.parent_id !== parentId) return false;
+      if (type !== null && row.is_unread !== (type === "UNREAD")) return false;
+      const createdUs = parseIsoUs(row.created_at) ?? 0;
+      if (startUs !== null && createdUs < startUs) return false;
+      if (endUs !== null && createdUs >= endUs) return false;
+      if (userId !== null && row.author_member?.user_id !== userId) return false;
+      if (mentioned !== null && !row.mentioned_members.some((member) => member.user_id === mentioned)) return false;
+      return true;
+    };
+  },
+  prepareCreate(context, connection, fields) {
+    const row = { ...defaults(), ...fields };
+    if (!hasText(row)) badRequest(context, "One of message, message_html or message_markdown is required");
+    if (row.parent_id !== null) {
+      const parent = getRow(context, "messages", connection.id, row.parent_id);
+      if (parent === null) badRequest(context, `Unknown parent_id ${clip(row.parent_id, 40)}`);
+      if (row.channels.length === 0) row.channels = parent.channels.map((channel) => ({ ...channel }));
+    }
+    if (row.channels.length === 0) badRequest(context, "channels[0].id or parent_id is required");
+    row.channels = row.channels.map((ref) => {
+      const channel = getRow(context, "channels", connection.id, ref.id);
+      if (channel === null) badRequest(context, `Unknown channel id ${clip(ref.id, 40)}`);
+      return { id: channel.id, name: channel.name };
+    });
+    const auth = connection.auth ?? {};
+    row.author_member = { user_id: auth.user_id ?? null, email: Array.isArray(auth.emails) && auth.emails.length > 0 ? auth.emails[0] : null, name: auth.name ?? null, image_url: null };
+    row.has_children = false;
+    row.reactions = [];
+    return row;
+  },
+  afterCreate(context, connection, row) {
+    if (row.parent_id === null) return;
+    const parent = getRow(context, "messages", connection.id, row.parent_id);
+    if (parent !== null && parent.has_children !== true) putRow(context, "messages", { ...parent, has_children: true });
+  },
+  prepareUpdate(context, connection, existing, fields) {
+    const merged = { ...existing };
+    for (const field of [...TEXT_FIELDS, "subject", "is_unread"]) {
+      if (Object.hasOwn(fields, field) && fields[field] !== null) merged[field] = fields[field];
+      else if (Object.hasOwn(fields, field) && field !== "is_unread") merged[field] = null;
+    }
+    if (!hasText(merged)) badRequest(context, "One of message, message_html or message_markdown must remain set");
+    return merged;
+  },
+  beforeRemove(context, connection, existing, workspace) {
+    if (existing.parent_id === null || !isHex24(existing.parent_id)) return;
+    const parent = getRow(context, "messages", connection.id, existing.parent_id);
+    if (parent === null) return;
+    const siblings = rowsOf(context, workspace, { namespace: "messages" }, connection.id).filter((row) => row.parent_id === parent.id && row.id !== existing.id);
+    if (parent.has_children !== siblings.length > 0) putRow(context, "messages", { ...parent, has_children: siblings.length > 0 });
+  },
+});

package/firedrill/tools/unified/ops/pipelines.mjs

@@ -0,0 +1,20 @@
+// CRM pipelines: read-only reference data (list and get); stages are returned ordered by display_order.
+import { makeResource } from "./resource.mjs";
+
+const orderStages = (item) =>
+  Array.isArray(item.stages) ? { ...item, stages: [...item.stages].sort((a, b) => a.display_order - b.display_order || (a.id < b.id ? -1 : 1)) } : item;
+
+export const pipelines = makeResource({
+  namespace: "pipelines",
+  label: "Pipeline",
+  category: "crm",
+  permission: "crm_pipeline",
+  objectType: "crm_pipeline",
+  searchFields: ["name"],
+  bodySpecs: {},
+  defaults: () => ({}),
+  filter: () => () => true,
+  present: orderStages,
+  prepareCreate: () => ({}),
+  prepareUpdate: (context, connection, existing) => existing,
+});

package/firedrill/tools/unified/ops/resource.mjs

@@ -0,0 +1,114 @@
+// Generic list/get/create/update/remove engine shared by every connection-scoped resource. A resource spec supplies
+// the namespace, category, permission slug, object type, searchable fields, list filters, body specs and hooks;
+// everything else (identity rules, paging, projection, events, bounds) is computed here from `context.state`.
+import { CRM, checkReferences, detachAll, syncAssociations } from "../lib/assoc.mjs";
+import { badRequest, notFound, scanBoundExceeded } from "../lib/errors.mjs";
+import { emitCreated, emitDeleted, emitUpdated } from "../lib/events.mjs";
+import { requireConnection, resolveWorkspace } from "../lib/identity.mjs";
+import { finishPage, matchesQuery, parseFields, parseListParams, project, sortRows, updatedSince } from "../lib/query.mjs";
+import { deleteRow, getRow, nextId, putRow, scanBound, scanConnection } from "../lib/store.mjs";
+import { nowIso } from "../lib/time.mjs";
+import { bodyOf, validateBody } from "../lib/validate.mjs";
+import { isHex24, jsonEqual } from "../lib/util.mjs";
+
+const ADDRESSING = ["connection_id", "id", "__request_error"];
+
+export function open(input, context, spec, mode) {
+  const workspace = resolveWorkspace(input, context);
+  const connection = requireConnection(context, workspace, input.connection_id, spec.category, `${spec.permission}_${mode}`);
+  return { workspace, connection };
+}
+
+export function requireId(context, spec, connectionId, id) {
+  if (!isHex24(id)) badRequest(context, `Invalid ${spec.label.toLowerCase()} id`);
+  const row = getRow(context, spec.namespace, connectionId, id);
+  if (row === null) notFound(context, `${spec.label} not found`);
+  return row;
+}
+
+/** Rows of one connection, in creation order, after the bounded scan. */
+export function rowsOf(context, workspace, spec, connectionId) {
+  return scanConnection(context, spec.namespace, connectionId, scanBound(workspace));
+}
+
+/** Top-level fields whose stored value differs between two rows. */
+export function changedFields(before, after) {
+  const out = [];
+  for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+    if (key === "updated_at") continue;
+    if (!jsonEqual(before[key], after[key])) out.push(key);
+  }
+  return out;
+}
+
+export function makeResource(spec) {
+  const hidden = spec.hidden ?? [];
+  const isCrm = Object.hasOwn(CRM, spec.namespace);
+
+  const list = (input, context) => {
+    const { workspace, connection } = open(input, context, spec, "read");
+    const params = parseListParams(input, context);
+    const fields = parseFields(input, context);
+    const filter = spec.filter(input, context, connection, workspace);
+    const rows = rowsOf(context, workspace, spec, connection.id).filter(
+      (row) => updatedSince(row, params.updatedGteUs) && matchesQuery(row, params.query, spec.searchFields) && filter(row),
+    );
+    sortRows(rows, params.sort, params.order, spec.nameField ?? "name");
+    const page = finishPage(context, rows, params, fields, hidden);
+    return spec.present ? page.map((item) => spec.present(item, context, workspace)) : page;
+  };
+
+  const get = (input, context) => {
+    const { workspace, connection } = open(input, context, spec, "read");
+    const fields = parseFields(input, context);
+    const row = requireId(context, spec, connection.id, input.id);
+    const item = project(row, fields, hidden);
+    return spec.present ? spec.present(item, context, workspace) : item;
+  };
+
+  const create = (input, context) => {
+    const { workspace, connection } = open(input, context, spec, "write");
+    const fields = validateBody(context, bodyOf(input, ADDRESSING), spec.bodySpecs);
+    const prepared = spec.prepareCreate(context, connection, fields, workspace);
+    if (isCrm) checkReferences(context, connection.id, spec.namespace, prepared);
+    // The namespace must stay within the per-connection bound after this write.
+    const bound = scanBound(workspace);
+    const existing = rowsOf(context, workspace, spec, connection.id);
+    if (existing.length >= bound) scanBoundExceeded(context, spec.namespace, bound);
+    const now = nowIso(context);
+    const id = nextId(context);
+    const row = { ...spec.defaults(), ...prepared, connection_id: connection.id, id, created_at: now, updated_at: now };
+    putRow(context, spec.namespace, row);
+    if (isCrm) syncAssociations(context, connection, spec.namespace, row, null);
+    if (spec.afterCreate) spec.afterCreate(context, connection, row);
+    emitCreated(context, connection, spec.objectType, id);
+    return project(row, null, hidden);
+  };
+
+  const update = (input, context) => {
+    const { workspace, connection } = open(input, context, spec, "write");
+    const existing = requireId(context, spec, connection.id, input.id);
+    const fields = validateBody(context, bodyOf(input, ADDRESSING), spec.updateSpecs ?? spec.bodySpecs);
+    const merged = spec.prepareUpdate(context, connection, existing, fields, workspace);
+    if (isCrm) checkReferences(context, connection.id, spec.namespace, merged);
+    const changed = changedFields(existing, merged);
+    if (changed.length === 0) return project(existing, null, hidden);
+    const row = { ...merged, connection_id: connection.id, id: existing.id, created_at: existing.created_at, updated_at: nowIso(context) };
+    putRow(context, spec.namespace, row);
+    if (isCrm) syncAssociations(context, connection, spec.namespace, row, existing);
+    emitUpdated(context, connection, spec.objectType, row.id, changed);
+    return project(row, null, hidden);
+  };
+
+  const remove = (input, context) => {
+    const { workspace, connection } = open(input, context, spec, "write");
+    const existing = requireId(context, spec, connection.id, input.id);
+    if (spec.beforeRemove) spec.beforeRemove(context, connection, existing, workspace);
+    if (isCrm) detachAll(context, connection, spec.namespace, existing);
+    deleteRow(context, spec.namespace, connection.id, existing.id);
+    emitDeleted(context, connection, spec.objectType, existing.id);
+    return {};
+  };
+
+  return { list, get, create, update, remove };
+}