@remit/drizzle-service 0.0.1

package/src/repos/i4-outbox-message.ts

@@ -0,0 +1,299 @@
+import type {
+	CreateOutboxMessageInput,
+	IOutboxMessageRepository,
+	OutboxMessageItem,
+	ResultList,
+	UpdateOutboxMessageInput,
+} from "@remit/data-ports";
+import { and, desc, eq, inArray, lt, or } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { ForbiddenError, NotFoundError } from "../error.js";
+import { decodeToken, resultList } from "../pagination.js";
+import { outboxMessageTable } from "../schema/i4-outbox-message.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+function rowToOutboxMessage(
+	row: typeof outboxMessageTable.$inferSelect,
+): OutboxMessageItem {
+	return {
+		outboxMessageId: row.outboxMessageId,
+		accountId: row.accountId,
+		accountConfigId: row.accountConfigId,
+		fromAddress: row.fromAddress,
+		fromName: row.fromName ?? undefined,
+		toAddresses: (row.toAddresses as string[]) ?? [],
+		ccAddresses: (row.ccAddresses as string[]) ?? [],
+		bccAddresses: (row.bccAddresses as string[]) ?? [],
+		replyToAddress: row.replyToAddress ?? undefined,
+		subject: row.subject ?? undefined,
+		messageIdValue: row.messageIdValue,
+		inReplyTo: row.inReplyTo ?? undefined,
+		references: (row.references as string[]) ?? [],
+		textBody: row.textBody ?? undefined,
+		htmlBody: row.htmlBody ?? undefined,
+		status: row.status as OutboxMessageItem["status"],
+		lastError: row.lastError ?? undefined,
+		lastSmtpCode: row.lastSmtpCode ?? undefined,
+		sentAt: row.sentAt ?? undefined,
+		smtpMessageId: row.smtpMessageId ?? undefined,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class OutboxMessageRepo implements IOutboxMessageRepository {
+	constructor(private db: DB) {}
+
+	async create(input: CreateOutboxMessageInput): Promise<OutboxMessageItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.insert(outboxMessageTable)
+			.values({
+				accountId: input.accountId,
+				accountConfigId: input.accountConfigId,
+				fromAddress: input.fromAddress,
+				fromName: input.fromName,
+				toAddresses: input.toAddresses ?? [],
+				ccAddresses: input.ccAddresses ?? [],
+				bccAddresses: input.bccAddresses ?? [],
+				replyToAddress: input.replyToAddress,
+				subject: input.subject,
+				messageIdValue: input.messageIdValue,
+				inReplyTo: input.inReplyTo,
+				references: input.references ?? [],
+				textBody: input.textBody,
+				htmlBody: input.htmlBody,
+				status: input.status,
+				lastError: input.lastError,
+				lastSmtpCode: input.lastSmtpCode,
+				sentAt: input.sentAt,
+				smtpMessageId: input.smtpMessageId,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		return rowToOutboxMessage(row);
+	}
+
+	async get(
+		accountConfigId: string,
+		outboxMessageId: string,
+		mode?: "read" | "act",
+	): Promise<OutboxMessageItem>;
+	async get(
+		accountConfigId: string,
+		outboxMessageIds: string[],
+	): Promise<OutboxMessageItem[]>;
+	async get(
+		accountConfigId: string,
+		outboxMessageId: string | string[],
+		mode: "read" | "act" = "read",
+	): Promise<OutboxMessageItem | OutboxMessageItem[]> {
+		if (Array.isArray(outboxMessageId)) {
+			if (outboxMessageId.length === 0) return [];
+			const rows = await this.db
+				.select()
+				.from(outboxMessageTable)
+				.where(
+					and(
+						eq(outboxMessageTable.accountConfigId, accountConfigId),
+						inArray(outboxMessageTable.outboxMessageId, outboxMessageId),
+					),
+				);
+			return rows.map(rowToOutboxMessage);
+		}
+		// Fetch unscoped by id so a foreign row can be distinguished from an
+		// absent one — mode="act" reports the former as 403, not 404.
+		const [row] = await this.db
+			.select()
+			.from(outboxMessageTable)
+			.where(eq(outboxMessageTable.outboxMessageId, outboxMessageId));
+		if (!row) {
+			throw new NotFoundError(`OutboxMessage not found: ${outboxMessageId}`);
+		}
+		if (row.accountConfigId !== accountConfigId) {
+			if (mode === "act") {
+				throw new ForbiddenError(
+					`OutboxMessage ${outboxMessageId} not in account config`,
+				);
+			}
+			throw new NotFoundError(`OutboxMessage not found: ${outboxMessageId}`);
+		}
+		return rowToOutboxMessage(row);
+	}
+
+	async update(
+		accountConfigId: string,
+		outboxMessageId: string,
+		input: UpdateOutboxMessageInput,
+	): Promise<OutboxMessageItem> {
+		const now = Date.now();
+		const updates: Partial<typeof outboxMessageTable.$inferInsert> = {
+			updatedAt: now,
+		};
+		if (input.status !== undefined) updates.status = input.status;
+		if (input.lastError !== undefined) updates.lastError = input.lastError;
+		if (input.lastSmtpCode !== undefined)
+			updates.lastSmtpCode = input.lastSmtpCode;
+		if (input.sentAt !== undefined) updates.sentAt = input.sentAt;
+		if (input.smtpMessageId !== undefined)
+			updates.smtpMessageId = input.smtpMessageId;
+		if (input.toAddresses !== undefined)
+			updates.toAddresses = input.toAddresses;
+		if (input.ccAddresses !== undefined)
+			updates.ccAddresses = input.ccAddresses;
+		if (input.bccAddresses !== undefined)
+			updates.bccAddresses = input.bccAddresses;
+		if (input.subject !== undefined) updates.subject = input.subject;
+		if (input.textBody !== undefined) updates.textBody = input.textBody;
+		if (input.htmlBody !== undefined) updates.htmlBody = input.htmlBody;
+		if (input.inReplyTo !== undefined) updates.inReplyTo = input.inReplyTo;
+		if (input.references !== undefined) updates.references = input.references;
+
+		const [row] = await this.db
+			.update(outboxMessageTable)
+			.set(updates)
+			.where(
+				and(
+					eq(outboxMessageTable.accountConfigId, accountConfigId),
+					eq(outboxMessageTable.outboxMessageId, outboxMessageId),
+				),
+			)
+			.returning();
+		if (!row)
+			throw new NotFoundError(`OutboxMessage not found: ${outboxMessageId}`);
+		return rowToOutboxMessage(row);
+	}
+
+	async updateStatus(
+		accountConfigId: string,
+		outboxMessageId: string,
+		status: OutboxMessageItem["status"],
+	): Promise<OutboxMessageItem> {
+		return this.update(accountConfigId, outboxMessageId, { status });
+	}
+
+	async markSent(
+		accountConfigId: string,
+		outboxMessageId: string,
+		fields: { sentAt: number; smtpMessageId?: string },
+	): Promise<OutboxMessageItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.update(outboxMessageTable)
+			.set({
+				status: "sent",
+				sentAt: fields.sentAt,
+				smtpMessageId: fields.smtpMessageId,
+				lastError: null,
+				lastSmtpCode: null,
+				updatedAt: now,
+			})
+			.where(
+				and(
+					eq(outboxMessageTable.accountConfigId, accountConfigId),
+					eq(outboxMessageTable.outboxMessageId, outboxMessageId),
+				),
+			)
+			.returning();
+		if (!row)
+			throw new NotFoundError(`OutboxMessage not found: ${outboxMessageId}`);
+		return rowToOutboxMessage(row);
+	}
+
+	async delete(
+		accountConfigId: string,
+		outboxMessageId: string,
+	): Promise<void> {
+		await this.db
+			.delete(outboxMessageTable)
+			.where(
+				and(
+					eq(outboxMessageTable.accountConfigId, accountConfigId),
+					eq(outboxMessageTable.outboxMessageId, outboxMessageId),
+				),
+			);
+	}
+
+	async deleteMany(
+		accountConfigId: string,
+		outboxMessageIds: string[],
+	): Promise<void> {
+		if (outboxMessageIds.length === 0) return;
+		await this.db
+			.delete(outboxMessageTable)
+			.where(
+				and(
+					eq(outboxMessageTable.accountConfigId, accountConfigId),
+					inArray(outboxMessageTable.outboxMessageId, outboxMessageIds),
+				),
+			);
+	}
+
+	async listByAccount(
+		accountId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<OutboxMessageItem>> {
+		const limit = options?.limit ?? 100;
+		const cursor = options?.continuationToken
+			? decodeToken(options.continuationToken)
+			: undefined;
+		const after = cursor
+			? {
+					createdAt: cursor.createdAt as number,
+					outboxMessageId: cursor.outboxMessageId as string,
+				}
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(outboxMessageTable)
+			.where(
+				and(
+					eq(outboxMessageTable.accountId, accountId),
+					after
+						? or(
+								lt(outboxMessageTable.createdAt, after.createdAt),
+								and(
+									eq(outboxMessageTable.createdAt, after.createdAt),
+									lt(outboxMessageTable.outboxMessageId, after.outboxMessageId),
+								),
+							)
+						: undefined,
+				),
+			)
+			.orderBy(
+				desc(outboxMessageTable.createdAt),
+				desc(outboxMessageTable.outboxMessageId),
+			)
+			.limit(limit + 1);
+
+		const hasMore = rows.length > limit;
+		const items = rows.slice(0, limit).map(rowToOutboxMessage);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			hasMore && lastItem
+				? {
+						createdAt: lastItem.createdAt,
+						outboxMessageId: lastItem.outboxMessageId,
+					}
+				: undefined,
+		);
+	}
+
+	async listQueued(accountId: string): Promise<OutboxMessageItem[]> {
+		const rows = await this.db
+			.select()
+			.from(outboxMessageTable)
+			.where(
+				and(
+					eq(outboxMessageTable.accountId, accountId),
+					eq(outboxMessageTable.status, "queued"),
+				),
+			);
+		return rows.map(rowToOutboxMessage);
+	}
+}

package/src/repos/label.conformance.sqlite.test.ts

@@ -0,0 +1,23 @@
+import { labelRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { labelTable } from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { LabelRepo } from "./label.js";
+
+let close: (() => Promise<void>) | undefined;
+
+labelRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createSqliteTestDb({
+			labels: labelTable,
+		});
+		close = closeDb;
+		return new LabelRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/label.conformance.test.ts

@@ -0,0 +1,19 @@
+import { labelRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { createTestDb, randomId } from "../test-db.js";
+import { LabelRepo } from "./label.js";
+
+let close: (() => Promise<void>) | undefined;
+
+labelRepositoryConformance({
+	async createRepository() {
+		const { db, close: closeDb } = await createTestDb();
+		close = closeDb;
+		return new LabelRepo(db as never);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/label.ts

@@ -0,0 +1,125 @@
+import type {
+	CreateLabelInput,
+	ILabelRepository,
+	LabelItem,
+	UpdateLabelInput,
+} from "@remit/data-ports";
+import { and, eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { labelTable } from "../schema.js";
+
+type DB = NodePgDatabase<Record<string, unknown>>;
+
+const normalize = (name: string): string => name.trim().toLowerCase();
+
+function rowToLabel(row: typeof labelTable.$inferSelect): LabelItem {
+	return {
+		labelId: row.labelId,
+		accountConfigId: row.accountConfigId,
+		name: row.name,
+		normalizedName: row.normalizedName,
+		color: row.color,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class LabelRepo implements ILabelRepository {
+	constructor(private db: DB) {}
+
+	async create(input: CreateLabelInput): Promise<LabelItem> {
+		const now = Date.now();
+		const [row] = await this.db
+			.insert(labelTable)
+			.values({
+				labelId: randomId(),
+				accountConfigId: input.accountConfigId,
+				name: input.name,
+				normalizedName: normalize(input.name),
+				color: input.color ?? "Default",
+				createdAt: now,
+				updatedAt: now,
+			})
+			.returning();
+		return rowToLabel(row);
+	}
+
+	async get(accountConfigId: string, labelId: string): Promise<LabelItem> {
+		const [row] = await this.db
+			.select()
+			.from(labelTable)
+			.where(
+				and(
+					eq(labelTable.accountConfigId, accountConfigId),
+					eq(labelTable.labelId, labelId),
+				),
+			);
+		if (!row) {
+			throw new NotFoundError(`Label not found: ${labelId}`);
+		}
+		return rowToLabel(row);
+	}
+
+	async update(
+		accountConfigId: string,
+		labelId: string,
+		input: UpdateLabelInput,
+	): Promise<LabelItem> {
+		const patch =
+			input.name !== undefined
+				? { ...input, normalizedName: normalize(input.name) }
+				: input;
+		const [row] = await this.db
+			.update(labelTable)
+			.set({ ...patch, updatedAt: Date.now() })
+			.where(
+				and(
+					eq(labelTable.accountConfigId, accountConfigId),
+					eq(labelTable.labelId, labelId),
+				),
+			)
+			.returning();
+		if (!row) {
+			throw new NotFoundError(`Label not found: ${labelId}`);
+		}
+		return rowToLabel(row);
+	}
+
+	async delete(accountConfigId: string, labelId: string): Promise<void> {
+		await this.db
+			.delete(labelTable)
+			.where(
+				and(
+					eq(labelTable.accountConfigId, accountConfigId),
+					eq(labelTable.labelId, labelId),
+				),
+			);
+	}
+
+	async listByAccountConfig(accountConfigId: string): Promise<LabelItem[]> {
+		const rows = await this.db
+			.select()
+			.from(labelTable)
+			.where(eq(labelTable.accountConfigId, accountConfigId))
+			.orderBy(labelTable.createdAt);
+		return rows.map(rowToLabel);
+	}
+
+	async findByNormalizedName(
+		accountConfigId: string,
+		normalizedName: string,
+	): Promise<LabelItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(labelTable)
+			.where(
+				and(
+					eq(labelTable.accountConfigId, accountConfigId),
+					eq(labelTable.normalizedName, normalize(normalizedName)),
+				),
+			);
+		return row ? rowToLabel(row) : null;
+	}
+}

package/src/repos/mappers.ts

@@ -0,0 +1,171 @@
+import type {
+	BodyPartContentItem,
+	BodyPartItem,
+	BodyPartParameterItem,
+	BodyPartStorageItem,
+	EnvelopeAddressItem,
+	EnvelopeItem,
+	MessageReferenceItem,
+	RawMessageStorageItem,
+} from "@remit/data-ports";
+import type {
+	bodyPartContentTable,
+	bodyPartParameterTable,
+	bodyPartStorageTable,
+	bodyPartTable,
+	envelopeAddressTable,
+	envelopeTable,
+	messageReferenceTable,
+	rawMessageStorageTable,
+} from "../schema/message-data.js";
+
+export function toEnvelopeItem(
+	row: typeof envelopeTable.$inferSelect,
+): EnvelopeItem {
+	return {
+		envelopeId: row.envelopeId,
+		messageId: row.messageId,
+		dateValue: row.dateValue,
+		dateRaw: row.dateRaw,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		...(row.subject !== null ? { subject: row.subject } : {}),
+		...(row.messageIdValue !== null
+			? { messageIdValue: row.messageIdValue }
+			: {}),
+	};
+}
+
+export function toMessageReferenceItem(
+	row: typeof messageReferenceTable.$inferSelect,
+): MessageReferenceItem {
+	return {
+		messageReferenceId: row.messageReferenceId,
+		messageId: row.messageId,
+		envelopeId: row.envelopeId,
+		messageIdValue: row.messageIdValue,
+		referenceType: row.referenceType,
+		referenceOrder: row.referenceOrder,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export function toEnvelopeAddressItem(
+	row: typeof envelopeAddressTable.$inferSelect,
+): EnvelopeAddressItem {
+	return {
+		envelopeAddressId: row.envelopeAddressId,
+		messageId: row.messageId,
+		addressId: row.addressId,
+		normalizedEmail: row.normalizedEmail,
+		addressRole: row.addressRole,
+		addressOrder: row.addressOrder,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		...(row.displayName !== null ? { displayName: row.displayName } : {}),
+	};
+}
+
+export function toBodyPartItem(
+	row: typeof bodyPartTable.$inferSelect,
+): BodyPartItem {
+	return {
+		bodyPartId: row.bodyPartId,
+		messageId: row.messageId,
+		partPath: row.partPath,
+		mediaType: row.mediaType,
+		mediaSubtype: row.mediaSubtype,
+		transferEncoding: row.transferEncoding,
+		sizeOctets: row.sizeOctets,
+		isMultipart: row.isMultipart,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		...(row.parentBodyPartId !== null
+			? { parentBodyPartId: row.parentBodyPartId }
+			: {}),
+		...(row.contentId !== null ? { contentId: row.contentId } : {}),
+		...(row.contentDescription !== null
+			? { contentDescription: row.contentDescription }
+			: {}),
+		...(row.lineCount !== null ? { lineCount: row.lineCount } : {}),
+		...(row.md5Hash !== null ? { md5Hash: row.md5Hash } : {}),
+		...(row.disposition !== null ? { disposition: row.disposition } : {}),
+		...(row.dispositionFilename !== null
+			? { dispositionFilename: row.dispositionFilename }
+			: {}),
+		...(row.language !== null ? { language: row.language } : {}),
+		...(row.location !== null ? { location: row.location } : {}),
+		...(row.multipartSubtype !== null
+			? { multipartSubtype: row.multipartSubtype }
+			: {}),
+	};
+}
+
+export function toBodyPartParameterItem(
+	row: typeof bodyPartParameterTable.$inferSelect,
+): BodyPartParameterItem {
+	return {
+		bodyPartParameterId: row.bodyPartParameterId,
+		messageId: row.messageId,
+		bodyPartId: row.bodyPartId,
+		parameterName: row.parameterName,
+		parameterValue: row.parameterValue,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export function toRawMessageStorageItem(
+	row: typeof rawMessageStorageTable.$inferSelect,
+): RawMessageStorageItem {
+	return {
+		rawStorageId: row.rawStorageId,
+		messageId: row.messageId,
+		storageType: row.storageType,
+		storageLocation: row.storageLocation,
+		storageKey: row.storageKey,
+		sizeBytes: row.sizeBytes,
+		checksumSha256: row.checksumSha256,
+		contentEncoding: row.contentEncoding,
+		storedAt: row.storedAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		...(row.expiresAt !== null ? { expiresAt: row.expiresAt } : {}),
+	};
+}
+
+export function toBodyPartStorageItem(
+	row: typeof bodyPartStorageTable.$inferSelect,
+): BodyPartStorageItem {
+	return {
+		bodyPartStorageId: row.bodyPartStorageId,
+		messageId: row.messageId,
+		bodyPartId: row.bodyPartId,
+		storageType: row.storageType,
+		storageLocation: row.storageLocation,
+		storageKey: row.storageKey,
+		decodedSizeBytes: row.decodedSizeBytes,
+		checksumSha256: row.checksumSha256,
+		contentEncoding: row.contentEncoding,
+		isDeduped: row.isDeduped,
+		storedAt: row.storedAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+		...(row.dedupHash !== null ? { dedupHash: row.dedupHash } : {}),
+	};
+}
+
+export function toBodyPartContentItem(
+	row: typeof bodyPartContentTable.$inferSelect,
+): BodyPartContentItem {
+	return {
+		bodyPartContentId: row.bodyPartContentId,
+		messageId: row.messageId,
+		bodyPartId: row.bodyPartId,
+		content: row.content,
+		contentLength: row.contentLength,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}