@ketvietlab/ketsuite 0.1.1

package/dist/modules/crm/operations.js

@@ -0,0 +1,744 @@
+import { randomUUID } from 'node:crypto';
+import { asc, bucketEq, compileListFilter, deleteFrom, desc, eq, from, inArray, isNull, like, or, } from '@ketvietlab/ketjs';
+import { addDays, cancelActivity, completeActivity, scheduleActivity } from '../activity/index.js';
+import { ensureThread } from '../mail/index.js';
+import { CASE_KINDS, CASE_PRIORITIES, MESSAGE_VISIBILITIES } from './types.js';
+import { caseListSearch, emptyCaseListState } from './search.js';
+export const issue = (field, code, params) => ({
+    field,
+    code,
+    ...(params ? { params } : {}),
+});
+export const invalid = (...errors) => ({ ok: false, errors });
+export const now = () => new Date().toISOString();
+export const n = (value) => Number(value ?? 0);
+export const normalized = (value) => String(value ?? '')
+    .normalize('NFKC')
+    .trim()
+    .toLowerCase();
+const jsonStrings = (value) => Array.isArray(value)
+    ? [
+        ...new Set(value
+            .map(String)
+            .map((item) => item.trim())
+            .filter(Boolean)),
+    ]
+    : [];
+export const actorRequired = (ctx) => ctx.actor || null;
+export const commandKey = (value) => {
+    const key = String(value ?? '').trim();
+    return key.length >= 8 && key.length <= 200 ? key : null;
+};
+const defaultStages = [
+    {
+        id: 'crm-stage-new',
+        code: 'new',
+        name: 'New',
+        sequence: 10,
+        allowedKinds: ['lead', 'opportunity'],
+        terminalState: 'open',
+        fold: false,
+    },
+    {
+        id: 'crm-stage-qualified',
+        code: 'qualified',
+        name: 'Qualified',
+        sequence: 20,
+        allowedKinds: ['lead', 'opportunity'],
+        terminalState: 'open',
+        fold: false,
+    },
+    {
+        id: 'crm-stage-proposition',
+        code: 'proposition',
+        name: 'Proposition',
+        sequence: 30,
+        allowedKinds: ['opportunity'],
+        terminalState: 'open',
+        fold: false,
+    },
+    {
+        id: 'crm-stage-won',
+        code: 'won',
+        name: 'Won',
+        sequence: 90,
+        allowedKinds: ['opportunity'],
+        terminalState: 'won',
+        fold: true,
+    },
+    {
+        id: 'crm-stage-lost',
+        code: 'lost',
+        name: 'Lost',
+        sequence: 100,
+        allowedKinds: ['opportunity'],
+        terminalState: 'lost',
+        fold: true,
+    },
+];
+/** Idempotent seed used by named E2E fixtures and by the first write on a fresh company. */
+export async function ensureCrmDefaults(ctx) {
+    await ctx.db.insertIfAbsent('crm.Team', {
+        id: 'crm-team-sales',
+        code: 'sales',
+        name: 'Sales',
+        active: true,
+        assignmentMode: 'round_robin',
+        assignmentCursor: 0,
+        version: 1,
+    });
+    for (const stage of defaultStages)
+        await ctx.db.insertIfAbsent('crm.Stage', { ...stage, active: true });
+    await ctx.db.insertIfAbsent('activity.Type', {
+        id: 'crm-next-action',
+        name: 'CRM next action',
+        category: 'call',
+        icon: 'phone',
+        defaultDelayDays: 0,
+        chainingPolicy: 'none',
+        sequence: 20,
+        active: true,
+    });
+}
+export const stageKinds = (stage) => jsonStrings(stage.allowedKinds);
+export async function activeStage(ctx, stageId, kind) {
+    const stage = (await ctx.db.select('crm.Stage', { id: stageId, active: true }))[0] ?? null;
+    return stage && stageKinds(stage).includes(kind) ? stage : null;
+}
+export async function firstStage(ctx, kind) {
+    const S = ctx.table('crm.Stage');
+    const stages = await ctx.db.all(from(S).where(eq(S.active, true)).orderBy(asc(S.sequence), asc(S.id)));
+    return stages.find((stage) => stageKinds(stage).includes(kind) && stage.terminalState === 'open') ?? null;
+}
+export async function addTimeline(ctx, input) {
+    const row = {
+        id: input.id ?? randomUUID(),
+        caseId: input.caseId,
+        eventType: input.eventType,
+        actorUserId: ctx.actor ?? null,
+        customerVisible: input.customerVisible ?? false,
+        body: input.body,
+        metadata: input.metadata ?? null,
+        occurredAt: input.occurredAt ?? now(),
+    };
+    await ctx.db.insert('crm.TimelineEntry', row);
+    return row;
+}
+const partnerExists = async (ctx, id) => !id || Boolean((await ctx.db.select('partner.Partner', { id, active: true }))[0]);
+const userExists = async (ctx, id) => !id || Boolean((await ctx.db.select('user.User', { id, active: true }))[0]);
+const teamExists = async (ctx, id) => !id || Boolean((await ctx.db.select('crm.Team', { id, active: true }))[0]);
+async function canReadCase(ctx, row) {
+    if (!ctx.actor)
+        return true;
+    const user = (await ctx.db.select('user.User', { id: ctx.actor, active: true }))[0];
+    if (user?.superuser === true)
+        return true;
+    if (row.assigneeUserId === ctx.actor)
+        return true;
+    if (!row.teamId)
+        return row.createdByUserId === ctx.actor;
+    return Boolean((await ctx.db.select('crm.TeamMember', {
+        teamId: row.teamId,
+        userId: ctx.actor,
+        active: true,
+    }))[0]);
+}
+export async function visibleCases(ctx, rows) {
+    if (!ctx.actor)
+        return rows;
+    const user = (await ctx.db.select('user.User', { id: ctx.actor, active: true }))[0];
+    if (user?.superuser === true)
+        return rows;
+    const memberships = await ctx.db.select('crm.TeamMember', { userId: ctx.actor, active: true });
+    const teams = new Set(memberships.map((membership) => String(membership.teamId)));
+    return rows.filter((row) => row.assigneeUserId === ctx.actor ||
+        row.createdByUserId === ctx.actor ||
+        (row.teamId && teams.has(String(row.teamId))));
+}
+export async function saveCase(ctx, input, options = {}) {
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    if (options.actorRequired !== false && !actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    if (!ctx.scope.company)
+        return invalid(issue('company', 'crm.error.companyRequired'));
+    if (!CASE_KINDS.includes(input.kind))
+        return invalid(issue('kind', 'crm.error.invalidKind'));
+    if (!String(input.name ?? '').trim())
+        return invalid(issue('name', 'crm.error.required'));
+    if (!CASE_PRIORITIES.includes(String(input.priority ?? '1')))
+        return invalid(issue('priority', 'crm.error.required'));
+    if (!(await partnerExists(ctx, input.partnerId)))
+        return invalid(issue('partnerId', 'crm.error.notFound'));
+    if (!(await userExists(ctx, input.assigneeUserId)))
+        return invalid(issue('assigneeUserId', 'crm.error.notFound'));
+    if (!(await teamExists(ctx, input.teamId)))
+        return invalid(issue('teamId', 'crm.error.notFound'));
+    const run = async (tx) => {
+        await ensureCrmDefaults(tx);
+        const existing = (await tx.db.select('crm.Case', { id: input.id }))[0];
+        if (existing && !(await canReadCase(tx, existing)))
+            return invalid(issue('id', 'crm.error.notFound'));
+        if (existing && existing.kind !== input.kind)
+            return invalid(issue('kind', 'crm.error.leadConversion'));
+        const stage = input.stageId
+            ? await activeStage(tx, input.stageId, input.kind)
+            : await firstStage(tx, input.kind);
+        if (!stage)
+            return invalid(issue('stageId', 'crm.error.invalidStage'));
+        const teamId = input.teamId ?? stage.teamId ?? 'crm-team-sales';
+        if (!(await teamExists(tx, teamId)))
+            return invalid(issue('teamId', 'crm.error.notFound'));
+        const timestamp = now();
+        const nextVersion = n(existing?.version) + 1;
+        const values = {
+            kind: input.kind,
+            name: input.name.trim(),
+            partnerId: input.partnerId || null,
+            contactName: input.contactName?.trim() || null,
+            email: normalized(input.email) || null,
+            phone: String(input.phone ?? '').trim() || null,
+            teamId,
+            assigneeUserId: input.assigneeUserId || null,
+            stageId: stage.id,
+            priority: input.priority ?? existing?.priority ?? '1',
+            description: input.description?.trim() || null,
+            utmSource: input.utmSource?.trim() || null,
+            utmMedium: input.utmMedium?.trim() || null,
+            utmCampaign: input.utmCampaign?.trim() || null,
+            terminalState: stage.terminalState,
+            active: true,
+            version: nextVersion,
+            score: existing?.score ?? '0',
+            updatedAt: timestamp,
+        };
+        if (existing) {
+            const expected = input.expectedVersion ?? n(existing.version);
+            const changed = await tx.db.compareAndSet('crm.Case', { id: input.id }, { version: expected }, values);
+            if (!('dryRun' in changed) && !changed.matched)
+                return invalid(issue('version', 'crm.error.stageConflict', { current: existing.version }));
+        }
+        else {
+            const thread = await ensureThread(tx, {
+                id: `thread:crm.Case:${input.id}`,
+                resModel: 'crm.Case',
+                resId: input.id,
+                displayName: input.name.trim(),
+                createdAt: timestamp,
+            });
+            await tx.db.insert('crm.Case', {
+                id: input.id,
+                ...values,
+                threadId: thread.id,
+                createdByUserId: tx.actor ?? null,
+                createdAt: timestamp,
+            });
+        }
+        if (existing)
+            await ensureThread(tx, {
+                id: String(existing.threadId),
+                resModel: 'crm.Case',
+                resId: input.id,
+                displayName: input.name.trim(),
+            });
+        const detail = (await tx.db.select('crm.SalesDetail', { caseId: input.id }))[0];
+        const salesValues = {
+            caseId: input.id,
+            expectedRevenue: String(input.expectedRevenue ?? detail?.expectedRevenue ?? '0'),
+            recurringRevenue: String(input.recurringRevenue ?? detail?.recurringRevenue ?? '0'),
+            probability: String(input.probability ?? detail?.probability ?? '0'),
+            expectedClosing: input.expectedClosing ?? detail?.expectedClosing ?? null,
+            forecastCategory: input.forecastCategory ?? detail?.forecastCategory ?? 'pipeline',
+            lostReason: detail?.lostReason ?? null,
+            sourceLeadId: detail?.sourceLeadId ?? null,
+        };
+        if (detail)
+            await tx.db.update('crm.SalesDetail', { id: detail.id }, salesValues);
+        else
+            await tx.db.insert('crm.SalesDetail', { id: `sales:${input.id}`, ...salesValues });
+        if (input.tagIds) {
+            const ids = [...new Set(input.tagIds)];
+            const tags = ids.length
+                ? await tx.db.all(from(tx.table('crm.Tag')).where(inArray(tx.table('crm.Tag').id, ids), eq(tx.table('crm.Tag').active, true)))
+                : [];
+            if (tags.length !== ids.length)
+                return invalid(issue('tagIds', 'crm.error.notFound'));
+            const CT = tx.table('crm.CaseTag');
+            await tx.db.del(deleteFrom(CT).where(eq(CT.caseId, input.id)));
+            for (const tagId of ids)
+                await tx.db.insert('crm.CaseTag', { id: `${input.id}:${tagId}`, caseId: input.id, tagId });
+        }
+        if (!existing)
+            await addTimeline(tx, {
+                id: `timeline:${input.id}:created`,
+                caseId: input.id,
+                eventType: 'created',
+                body: 'crm.timeline.created',
+                customerVisible: false,
+                occurredAt: timestamp,
+            });
+        return { ok: true, id: input.id, version: nextVersion };
+    };
+    return options.inTransaction ? run(ctx) : ctx.tx(run);
+}
+export async function serializeCaseList(ctx, rows) {
+    const ids = (values) => [...new Set(values.filter(Boolean).map(String))];
+    const stageIds = ids(rows.map((row) => row.stageId));
+    const teamIds = ids(rows.map((row) => row.teamId));
+    const userIds = ids(rows.map((row) => row.assigneeUserId));
+    const partnerIds = ids(rows.map((row) => row.partnerId));
+    const stages = stageIds.length
+        ? await ctx.db.all(from(ctx.table('crm.Stage')).where(inArray(ctx.table('crm.Stage').id, stageIds)))
+        : [];
+    const teams = teamIds.length
+        ? await ctx.db.all(from(ctx.table('crm.Team')).where(inArray(ctx.table('crm.Team').id, teamIds)))
+        : [];
+    const users = userIds.length
+        ? await ctx.db.all(from(ctx.table('user.User')).where(inArray(ctx.table('user.User').id, userIds)))
+        : [];
+    const partners = partnerIds.length
+        ? await ctx.db.all(from(ctx.table('partner.Partner')).where(inArray(ctx.table('partner.Partner').id, partnerIds)))
+        : [];
+    const by = (values) => new Map(values.map((row) => [String(row.id), row]));
+    const stageBy = by(stages);
+    const teamBy = by(teams);
+    const userBy = by(users);
+    const partnerBy = by(partners);
+    return rows.map((row) => ({
+        ...row,
+        stageCode: stageBy.get(String(row.stageId))?.code ?? null,
+        stageName: stageBy.get(String(row.stageId))?.name ?? row.stageId,
+        teamName: row.teamId ? (teamBy.get(String(row.teamId))?.name ?? row.teamId) : null,
+        assigneeName: row.assigneeUserId
+            ? (userBy.get(String(row.assigneeUserId))?.name ?? row.assigneeUserId)
+            : null,
+        partnerName: row.partnerId ? (partnerBy.get(String(row.partnerId))?.name ?? row.partnerId) : null,
+    }));
+}
+export async function caseDetail(ctx, id) {
+    const row = (await ctx.db.select('crm.Case', { id }))[0];
+    if (!row || !(await canReadCase(ctx, row)))
+        return null;
+    const [serialized] = await serializeCaseList(ctx, [row]);
+    const [salesDetail, tags, timeline, messages, activityLinks, calendarLinks, attachments] = await Promise.all([
+        ctx.db.select('crm.SalesDetail', { caseId: id }),
+        ctx.db.select('crm.CaseTag', { caseId: id }),
+        ctx.db.all(from(ctx.table('crm.TimelineEntry'))
+            .where(eq(ctx.table('crm.TimelineEntry').caseId, id))
+            .orderBy(desc(ctx.table('crm.TimelineEntry').occurredAt))),
+        ctx.db.all(from(ctx.table('crm.Message'))
+            .where(eq(ctx.table('crm.Message').caseId, id))
+            .orderBy(asc(ctx.table('crm.Message').createdAt))),
+        ctx.db.select('crm.ActivityLink', { caseId: id }),
+        ctx.db.select('crm.CalendarLink', { caseId: id }),
+        ctx.db.select('storage.Attachment', { resModel: 'crm.Case', resId: id }),
+    ]);
+    const tagIds = tags.map((tag) => tag.tagId);
+    const tagRows = tagIds.length
+        ? await ctx.db.all(from(ctx.table('crm.Tag')).where(inArray(ctx.table('crm.Tag').id, tagIds)))
+        : [];
+    const activityIds = activityLinks.map((link) => link.activityId);
+    const activities = activityIds.length
+        ? await ctx.db.all(from(ctx.table('activity.Activity')).where(inArray(ctx.table('activity.Activity').id, activityIds)))
+        : [];
+    const eventIds = calendarLinks.map((link) => link.eventId);
+    const meetings = eventIds.length
+        ? await ctx.db.all(from(ctx.table('calendar.Event')).where(inArray(ctx.table('calendar.Event').id, eventIds)))
+        : [];
+    return {
+        ...serialized,
+        salesDetail: salesDetail[0] ?? null,
+        tags: tagRows,
+        timeline,
+        messages,
+        attachments,
+        activities,
+        meetings,
+    };
+}
+const listStateOf = (value) => value && typeof value === 'object' ? value : null;
+const caseQuery = async (ctx, args) => {
+    const C = ctx.table('crm.Case');
+    const state = listStateOf(args.listState) ?? emptyCaseListState();
+    const timezone = String(args.timezone ?? 'UTC');
+    let query = from(C);
+    const compiled = compileListFilter(caseListSearch(C), state, { timezone });
+    if (compiled)
+        query = query.where(compiled);
+    const path = Array.isArray(args.path) ? args.path : [];
+    const spec = caseListSearch(C);
+    for (let index = 0; index < path.length; index++) {
+        const selected = state.groupBy[index];
+        const field = spec.groupable?.find((candidate) => candidate.key === selected?.key);
+        if (!field)
+            continue;
+        const value = path[index];
+        query = query.where(value == null
+            ? isNull(field.col)
+            : selected?.interval
+                ? bucketEq(field.col, selected.interval, timezone, String(value))
+                : eq(field.col, value));
+    }
+    if (args.kind)
+        query = query.where(eq(C.kind, args.kind));
+    if (args.stageId)
+        query = query.where(eq(C.stageId, args.stageId));
+    if (args.teamId)
+        query = query.where(eq(C.teamId, args.teamId));
+    if (args.assigneeUserId)
+        query = query.where(eq(C.assigneeUserId, args.assigneeUserId));
+    if (args.terminalState)
+        query = query.where(eq(C.terminalState, args.terminalState));
+    if (!state.includeArchived && args.includeArchived !== true)
+        query = query.where(eq(C.active, true));
+    if (args.search)
+        query = query.where(like(C.name, `%${String(args.search).trim()}%`));
+    if (ctx.actor) {
+        const user = (await ctx.db.select('user.User', { id: ctx.actor, active: true }))[0];
+        if (user?.superuser !== true) {
+            const memberships = await ctx.db.select('crm.TeamMember', { userId: ctx.actor, active: true });
+            const teams = [...new Set(memberships.map((membership) => String(membership.teamId)))];
+            query = query.where(or(eq(C.assigneeUserId, ctx.actor), eq(C.createdByUserId, ctx.actor), ...(teams.length ? [inArray(C.teamId, teams)] : [])));
+        }
+    }
+    const sorts = state.sort.length ? state.sort : emptyCaseListState().sort;
+    const sortable = new Map((spec.sortable ?? []).map((field) => [field.key, field.col]));
+    for (const sort of sorts) {
+        const col = sortable.get(sort.key);
+        if (col)
+            query = query.orderBy(sort.dir === 'desc' ? desc(col) : asc(col));
+    }
+    return { query, state, spec, timezone };
+};
+export async function listCases(ctx, args) {
+    const { query } = await caseQuery(ctx, args);
+    const offset = Math.max(0, Number.parseInt(String(args.cursor ?? '0'), 10) || 0);
+    const limit = Math.max(1, Math.min(200, n(args.limit ?? 50)));
+    const [total, page] = await Promise.all([
+        ctx.db.count(query),
+        ctx.db.all(query.limit(limit).offset(offset)),
+    ]);
+    return {
+        rows: await serializeCaseList(ctx, page),
+        total,
+        nextCursor: offset + limit < total ? String(offset + limit) : null,
+    };
+}
+export async function groupCases(ctx, args) {
+    const { query, state, spec, timezone } = await caseQuery(ctx, args);
+    const path = Array.isArray(args.path) ? args.path : [];
+    const selected = state.groupBy[path.length];
+    const field = spec.groupable?.find((candidate) => candidate.key === selected?.key);
+    if (!field)
+        return [];
+    let grouped = query
+        .groupBy({ col: field.col, interval: selected?.interval, timezone })
+        .orderGroupsBy({ by: 'key', dir: 'asc' });
+    if (args.limit != null)
+        grouped = grouped.limit(Number(args.limit));
+    if (args.offset != null)
+        grouped = grouped.offset(Number(args.offset));
+    return ctx.db.group(grouped);
+}
+export async function addCaseMessage(ctx, input) {
+    if (!MESSAGE_VISIBILITIES.includes(input.visibility))
+        return invalid(issue('visibility', 'crm.error.invalidVisibility'));
+    const held = (await ctx.db.select('crm.Case', { id: input.caseId }))[0];
+    if (!held)
+        return invalid(issue('caseId', 'crm.error.notFound'));
+    if (!input.body.trim())
+        return invalid(issue('body', 'crm.error.required'));
+    const existing = (await ctx.db.select('crm.Message', { id: input.id }))[0];
+    if (existing)
+        return { ok: true, id: input.id };
+    const timestamp = now();
+    await ctx.db.insert('crm.Message', {
+        id: input.id,
+        caseId: input.caseId,
+        actorUserId: ctx.actor ?? null,
+        authorPartnerId: input.authorPartnerId ?? null,
+        visibility: input.visibility,
+        body: input.body.trim(),
+        createdAt: timestamp,
+    });
+    await addTimeline(ctx, {
+        id: `timeline:message:${input.id}`,
+        caseId: input.caseId,
+        eventType: 'message',
+        body: input.body.trim(),
+        customerVisible: false,
+        occurredAt: timestamp,
+    });
+    return { ok: true, id: input.id };
+}
+export async function moveCase(ctx, input) {
+    if (!actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    return ctx.tx(async (tx) => {
+        const held = (await tx.db.select('crm.Case', { id: input.id }))[0];
+        if (!held || !(await canReadCase(tx, held)))
+            return invalid(issue('id', 'crm.error.notFound'));
+        const stage = await activeStage(tx, input.stageId, String(held.kind));
+        if (!stage)
+            return invalid(issue('stageId', 'crm.error.invalidStage'));
+        const timestamp = now();
+        const patch = {
+            stageId: stage.id,
+            terminalState: stage.terminalState,
+            active: true,
+            version: n(held.version) + 1,
+            updatedAt: timestamp,
+            closedAt: held.closedAt,
+        };
+        const changed = await tx.db.compareAndSet('crm.Case', { id: input.id }, { version: input.expectedVersion }, patch);
+        if (!('dryRun' in changed) && !changed.matched)
+            return invalid(issue('version', 'crm.error.stageConflict', { current: held.version }));
+        await addTimeline(tx, {
+            id: `timeline:${input.id}:move:${input.idempotencyKey}`,
+            caseId: input.id,
+            eventType: 'stage',
+            body: 'crm.timeline.stage',
+            metadata: { from: held.stageId, to: stage.id },
+        });
+        return { ok: true, id: input.id, version: patch.version, terminalState: stage.terminalState };
+    });
+}
+async function routedAssignee(ctx, team) {
+    const M = ctx.table('crm.TeamMember');
+    const members = await ctx.db.all(from(M).where(eq(M.teamId, team.id), eq(M.active, true)).orderBy(asc(M.sequence), asc(M.id)));
+    if (!members.length)
+        return null;
+    if (team.assignmentMode === 'capacity')
+        return [...members].sort((a, b) => n(a.assignedCount) / Math.max(1, n(a.capacity)) - n(b.assignedCount) / Math.max(1, n(b.capacity)) ||
+            String(a.lastAssignedAt ?? '').localeCompare(String(b.lastAssignedAt ?? '')) ||
+            String(a.id).localeCompare(String(b.id)))[0];
+    return members[n(team.assignmentCursor) % members.length];
+}
+export async function assignCase(ctx, input) {
+    if (!actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    return ctx.tx(async (tx) => {
+        const held = (await tx.db.select('crm.Case', { id: input.id }))[0];
+        if (!held || !(await canReadCase(tx, held)))
+            return invalid(issue('id', 'crm.error.notFound'));
+        if (held.assigneeUserId && !input.force && !input.assigneeUserId)
+            return { ok: true, id: input.id, assigneeUserId: held.assigneeUserId, version: held.version };
+        let teamId = input.teamId ?? (held.teamId ? String(held.teamId) : null);
+        let assigneeUserId = input.assigneeUserId ?? null;
+        if (!teamId || !assigneeUserId) {
+            const rules = (await tx.db.select('crm.AssignmentRule', { active: true })).sort((a, b) => n(a.priority) - n(b.priority) || String(a.id).localeCompare(String(b.id)));
+            const matched = rules.find((rule) => jsonStrings(rule.allowedKinds).includes(String(held.kind)) &&
+                (!rule.utmSource || normalized(rule.utmSource) === normalized(held.utmSource)) &&
+                (rule.minimumScore == null || n(held.score) >= n(rule.minimumScore)));
+            teamId ??= matched?.teamId ? String(matched.teamId) : null;
+            assigneeUserId ??= matched?.assigneeUserId ? String(matched.assigneeUserId) : null;
+        }
+        if (!teamId)
+            return invalid(issue('teamId', 'crm.error.notFound'));
+        const team = (await tx.db.select('crm.Team', { id: teamId, active: true }))[0];
+        if (!team)
+            return invalid(issue('teamId', 'crm.error.notFound'));
+        let member = null;
+        if (!assigneeUserId) {
+            member = await routedAssignee(tx, team);
+            assigneeUserId = member?.userId
+                ? String(member.userId)
+                : team.leaderUserId
+                    ? String(team.leaderUserId)
+                    : null;
+        }
+        if (!assigneeUserId || !(await userExists(tx, assigneeUserId)))
+            return invalid(issue('assigneeUserId', 'crm.error.notFound'));
+        if (!(await tx.db.select('crm.TeamMember', { teamId, userId: assigneeUserId, active: true }))[0] &&
+            team.leaderUserId !== assigneeUserId)
+            return invalid(issue('assigneeUserId', 'crm.error.notFound'));
+        const expected = input.expectedVersion ?? n(held.version);
+        const timestamp = now();
+        const changed = await tx.db.compareAndSet('crm.Case', { id: input.id }, { version: expected }, {
+            teamId,
+            assigneeUserId,
+            version: n(held.version) + 1,
+            updatedAt: timestamp,
+        });
+        if (!('dryRun' in changed) && !changed.matched)
+            return invalid(issue('version', 'crm.error.stageConflict', { current: held.version }));
+        if (member) {
+            await tx.db.update('crm.TeamMember', { id: member.id }, {
+                assignedCount: n(member.assignedCount) + 1,
+                lastAssignedAt: timestamp,
+            });
+            await tx.db.update('crm.Team', { id: team.id }, {
+                assignmentCursor: n(team.assignmentCursor) + 1,
+                version: n(team.version) + 1,
+            });
+        }
+        await addTimeline(tx, {
+            id: `timeline:${input.id}:assign:${input.idempotencyKey}`,
+            caseId: input.id,
+            eventType: 'assigned',
+            body: 'crm.timeline.assigned',
+            metadata: { teamId, assigneeUserId },
+        });
+        return { ok: true, id: input.id, teamId, assigneeUserId, version: n(held.version) + 1 };
+    });
+}
+export async function scheduleCaseActivity(ctx, input) {
+    if (!actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    return ctx.tx(async (tx) => {
+        const held = (await tx.db.select('crm.Case', { id: input.caseId }))[0];
+        if (!held || !(await canReadCase(tx, held)))
+            return invalid(issue('caseId', 'crm.error.notFound'));
+        const activity = await scheduleActivity(tx, {
+            id: input.id,
+            threadId: String(held.threadId),
+            typeId: input.typeId ?? 'crm-next-action',
+            assigneeUserId: input.assigneeUserId ?? String(held.assigneeUserId ?? tx.actor),
+            summary: input.summary,
+            note: input.note,
+            dueDate: input.dueDate,
+        });
+        await tx.db.insertIfAbsent('crm.ActivityLink', {
+            id: `crm-activity:${activity.id}`,
+            caseId: input.caseId,
+            activityId: activity.id,
+        });
+        await addTimeline(tx, {
+            id: `timeline:${input.caseId}:activity:${activity.id}`,
+            caseId: input.caseId,
+            eventType: 'activity_scheduled',
+            body: input.summary,
+            metadata: { activityId: activity.id, dueDate: input.dueDate },
+        });
+        return { ok: true, id: String(activity.id), activity };
+    });
+}
+export async function completeCaseActivity(ctx, input) {
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    if (!actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    return ctx.tx(async (tx) => {
+        const link = (await tx.db.select('crm.ActivityLink', { activityId: input.id }))[0];
+        if (!link)
+            return invalid(issue('id', 'crm.error.notFound'));
+        const result = await completeActivity(tx, input.id, input.feedback ?? '', input.completedDate);
+        await addTimeline(tx, {
+            id: `timeline:${String(link.caseId)}:activity-done:${input.id}`,
+            caseId: String(link.caseId),
+            eventType: 'activity_completed',
+            body: input.feedback?.trim() || String(result.activity.summary),
+            metadata: { activityId: input.id },
+        });
+        return { ok: true, id: input.id, activity: result.activity, nextActivity: result.nextActivity };
+    });
+}
+export async function cancelCaseActivity(ctx, input) {
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    if (!actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    return ctx.tx(async (tx) => {
+        const link = (await tx.db.select('crm.ActivityLink', { activityId: input.id }))[0];
+        if (!link)
+            return invalid(issue('id', 'crm.error.notFound'));
+        const activity = await cancelActivity(tx, input.id, input.feedback);
+        await addTimeline(tx, {
+            id: `timeline:${String(link.caseId)}:activity-cancel:${input.id}`,
+            caseId: String(link.caseId),
+            eventType: 'activity_cancelled',
+            body: input.feedback?.trim() || String(activity.summary),
+            metadata: { activityId: input.id },
+        });
+        return { ok: true, id: input.id, activity };
+    });
+}
+export async function applyCasePlan(ctx, input) {
+    if (!commandKey(input.idempotencyKey))
+        return invalid(issue('idempotencyKey', 'crm.error.idempotencyRequired'));
+    if (!actorRequired(ctx))
+        return invalid(issue('actor', 'crm.error.actorRequired'));
+    return ctx.tx(async (tx) => {
+        const held = (await tx.db.select('crm.Case', { id: input.caseId }))[0];
+        if (!held || !(await canReadCase(tx, held)))
+            return invalid(issue('caseId', 'crm.error.notFound'));
+        const plan = (await tx.db.select('activity.Plan', { id: input.planId, active: true }))[0];
+        if (!plan)
+            return invalid(issue('planId', 'crm.error.notFound'));
+        const steps = (await tx.db.select('activity.PlanStep', { planId: input.planId })).sort((a, b) => n(a.sequence) - n(b.sequence) || String(a.id).localeCompare(String(b.id)));
+        const activities = [];
+        for (const step of steps) {
+            const id = `crm-plan:${input.caseId}:${input.planId}:${String(step.id)}`;
+            const activity = await scheduleActivity(tx, {
+                id,
+                threadId: String(held.threadId),
+                typeId: String(step.typeId),
+                assigneeUserId: step.assigneeStrategy === 'specific'
+                    ? String(step.assigneeUserId)
+                    : step.assigneeStrategy === 'actor'
+                        ? String(tx.actor)
+                        : String(held.assigneeUserId ?? tx.actor),
+                summary: String(step.summary ?? plan.name),
+                note: step.note ? String(step.note) : undefined,
+                dueDate: addDays(input.anchorDate, n(step.offsetDays)),
+            });
+            await tx.db.insertIfAbsent('crm.ActivityLink', {
+                id: `crm-activity:${id}`,
+                caseId: input.caseId,
+                activityId: id,
+            });
+            activities.push(activity);
+        }
+        await addTimeline(tx, {
+            id: `timeline:${input.caseId}:plan:${input.idempotencyKey}`,
+            caseId: input.caseId,
+            eventType: 'plan_applied',
+            body: String(plan.name),
+            metadata: { planId: input.planId, activityIds: activities.map((row) => row.id) },
+        });
+        return { ok: true, id: input.caseId, activities };
+    });
+}
+export async function refreshCaseScore(ctx, caseId, sourceKey) {
+    return ctx.tx(async (tx) => {
+        const held = (await tx.db.select('crm.Case', { id: caseId }))[0];
+        if (!held)
+            return invalid(issue('caseId', 'crm.error.notFound'));
+        const rules = (await tx.db.select('crm.ScoreRule', { active: true })).sort((a, b) => n(a.sequence) - n(b.sequence) || String(a.id).localeCompare(String(b.id)));
+        let score = 0;
+        const reasons = [];
+        for (const rule of rules) {
+            const actual = held[String(rule.field)];
+            const wanted = String(rule.value);
+            const matches = (rule.operator === 'eq' && normalized(actual) === normalized(wanted)) ||
+                (rule.operator === 'contains' && normalized(actual).includes(normalized(wanted))) ||
+                (rule.operator === 'present' && Boolean(String(actual ?? '').trim())) ||
+                (rule.operator === 'gte' && n(actual) >= n(wanted));
+            if (!matches)
+                continue;
+            score += n(rule.points);
+            reasons.push({ ruleId: String(rule.id), points: n(rule.points) });
+        }
+        const timestamp = now();
+        await tx.db.update('crm.Case', { id: caseId }, {
+            score: String(score),
+            version: n(held.version) + 1,
+            updatedAt: timestamp,
+        });
+        await tx.db.insertIfAbsent('crm.ScoreHistory', {
+            id: `score:${caseId}:${sourceKey}`,
+            caseId,
+            score: String(score),
+            reasons,
+            calculatedAt: timestamp,
+        });
+        return { ok: true, id: caseId, score, reasons };
+    });
+}
+//# sourceMappingURL=operations.js.map