Comp AI CRM is an open source, CRM designed for AI agents. Agentic-first CRM.
TypeScript
import {
ActivityType,
type Db,
EmailDirection,
type MailboxSyncModel as MailboxSync,
type Prisma,
Prisma as PrismaNamespace,
RecordSource,
} from "@crm/db";
import { Injectable, Logger } from "@nestjs/common";
import { ActivityStampService } from "../crm/activity-stamp.service";
import { InjectDatabase } from "../database/database.constants";
import type { SyncSource } from "./mailbox.constants";
import {
MailboxMatchService,
type MatchContext,
} from "./mailbox-match.service";
import { snippetOf } from "./message-text";
import type { Participant } from "./participants";
export type IncomingMessage = {
rfcMessageId: string;
rootId: string;
subject: string | null;
from: Participant;
recipients: { email: string; name: string | null; kind: "to" | "cc" }[];
body: string;
sentAt: Date;
gmailMessageId?: string | null;
outlookMessageId?: string | null;
outlookWebLink?: string | null;
};
@Injectable()
export class ThreadWriterService {
private readonly logger = new Logger(ThreadWriterService.name);
constructor(
@InjectDatabase() private readonly db: Db,
private readonly match: MailboxMatchService,
private readonly stamp: ActivityStampService,
) {}
async context(): Promise<MatchContext> {
const [internal, suppressedDomains, suppressedEmails] = await Promise.all([
this.match.internalIdentity(),
this.match.suppressedDomains(),
this.match.suppressedEmails(),
]);
return {
ourAddresses: internal.addresses,
ourDomains: internal.domains,
suppressedDomains,
suppressedEmails,
};
}
async store(
row: MailboxSync,
options: { mailbox: string; origin: SyncSource },
parsed: IncomingMessage,
context: MatchContext,
): Promise<boolean> {
const existing = await this.db.emailMessage.findUnique({
where: { rfcMessageId: parsed.rfcMessageId },
select: {
threadId: true,
thread: {
select: {
companyId: true,
contactId: true,
activity: { select: { id: true } },
},
},
},
});
if (existing?.thread.activity) return false;
const repair = existing !== null;
const participants = [parsed.from, ...parsed.recipients];
const outbound = parsed.from.email === options.mailbox;
const thread = existing
? {
id: existing.threadId,
companyId: existing.thread.companyId,
contactId: existing.thread.contactId,
}
: await this.db.emailThread.findUnique({
where: { rootMessageId: parsed.rootId },
select: { id: true, companyId: true, contactId: true },
});
let companyId = thread?.companyId ?? null;
let contactId = thread?.contactId ?? null;
if (!thread) {
const repliedTo =
outbound ||
(await this.hasOutboundInThread(parsed.rootId, options.mailbox));
const match = await this.match.resolve(
{
participants,
allowCreate: row.autoCreate && repliedTo,
source: RecordSource.EMAIL,
ownerId: row.userId,
},
context,
);
companyId = match.companyId;
contactId = match.contactId;
if (!companyId && !contactId) {
return false;
}
}
let occurredAt: Date;
try {
occurredAt = await this.db.$transaction(async (tx) => {
const record = existing
? { id: existing.threadId }
: await tx.emailThread.upsert({
where: { rootMessageId: parsed.rootId },
create: {
rootMessageId: parsed.rootId,
subject: parsed.subject,
companyId,
contactId,
firstMessageAt: parsed.sentAt,
lastMessageAt: parsed.sentAt,
messageCount: 0,
},
update: {},
select: { id: true },
});
if (!repair) {
await tx.emailMessage.create({
data: {
threadId: record.id,
rfcMessageId: parsed.rfcMessageId,
syncedByUserId: row.userId,
gmailMessageId: parsed.gmailMessageId ?? null,
outlookMessageId: parsed.outlookMessageId ?? null,
outlookWebLink: parsed.outlookWebLink ?? null,
direction: outbound
? EmailDirection.OUTBOUND
: EmailDirection.INBOUND,
fromEmail: parsed.from.email,
fromName: parsed.from.name,
recipients: parsed.recipients,
subject: parsed.subject,
snippet: snippetOf(parsed.body),
body: parsed.body || null,
sentAt: parsed.sentAt,
},
});
}
const stats = await tx.emailMessage.aggregate({
where: { threadId: record.id },
_count: { _all: true },
_min: { sentAt: true },
_max: { sentAt: true },
});
const firstMessageAt = stats._min.sentAt ?? parsed.sentAt;
const lastMessageAt = stats._max.sentAt ?? parsed.sentAt;
const data: Prisma.EmailThreadUpdateInput = {
messageCount: stats._count._all,
firstMessageAt,
lastMessageAt,
};
if (parsed.sentAt <= firstMessageAt) data.subject = parsed.subject;
await tx.emailThread.update({ where: { id: record.id }, data });
return this.project(tx, record.id, row.userId, {
subject: parsed.subject ?? "(no subject)",
snippet: snippetOf(parsed.body),
lastMessageAt,
companyId,
contactId,
origin: options.origin,
});
});
} catch (error) {
if (await this.storedElsewhere(error, parsed.rfcMessageId)) return false;
throw error;
}
await this.touch({ companyId, contactId }, occurredAt, parsed.rfcMessageId);
return !repair;
}
private async storedElsewhere(
cause: unknown,
rfcMessageId: string,
): Promise<boolean> {
const duplicate =
cause instanceof PrismaNamespace.PrismaClientKnownRequestError &&
cause.code === "P2002";
if (!duplicate) return false;
const winner = await this.db.emailMessage.findFirst({
where: { rfcMessageId, thread: { activity: { isNot: null } } },
select: { id: true },
});
return winner !== null;
}
private async touch(
target: { companyId: string | null; contactId: string | null },
at: Date,
rfcMessageId: string,
): Promise<void> {
try {
await this.stamp.touch(target, at);
} catch (error) {
this.logger.error(
{
message: "An email was stored but its activity stamps were not moved",
rfcMessageId,
...target,
},
error instanceof Error ? error.stack : String(error),
);
}
}
private async hasOutboundInThread(
rootMessageId: string,
mailbox: string,
): Promise<boolean> {
const found = await this.db.emailMessage.findFirst({
where: {
thread: { rootMessageId },
fromEmail: mailbox,
},
select: { id: true },
});
return found !== null;
}
private async project(
tx: Prisma.TransactionClient,
emailThreadId: string,
userId: string,
summary: {
subject: string;
snippet: string | null;
lastMessageAt: Date;
companyId: string | null;
contactId: string | null;
origin: SyncSource;
},
): Promise<Date> {
const activity = await tx.activity.upsert({
where: { emailThreadId },
create: {
type: ActivityType.EMAIL,
subject: summary.subject,
body: summary.snippet,
occurredAt: summary.lastMessageAt,
companyId: summary.companyId,
contactId: summary.contactId,
createdById: userId,
emailThreadId,
meta: { synced: true, source: summary.origin },
},
update: {
body: summary.snippet,
occurredAt: summary.lastMessageAt,
},
select: { createdAt: true },
});
return activity.createdAt;
}
}