@remit/drizzle-service 0.0.104 → 0.0.106

package/src/repos/calendar-store.ts

@@ -8,6 +8,7 @@ import type {
 import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import { and, eq, exists, sql } from "drizzle-orm";
 import type { SqliteBatchItem, WriteBatch } from "../batch.js";
+import { chunkRows } from "../bound-parameters.js";
 import type { RepositoryDb, SqliteStore } from "../db.js";
 import {
 	calendarEventIndexTable,
@@ -36,6 +37,7 @@ export class DrizzleCalendarStore implements ICalendarStore {
 
 	private readonly db: DB;
 	private readonly batch: WriteBatch;
+	private readonly maxBoundParameters: number;
 
 	constructor(
 		store: SqliteStore<Record<string, unknown>>,
@@ -43,10 +45,11 @@ export class DrizzleCalendarStore implements ICalendarStore {
 	) {
 		this.db = store.db;
 		this.batch = store.batch;
+		this.maxBoundParameters = store.maxBoundParameters;
 		this.repos = {
 			calendarCollection: new CalendarCollectionRepo(store.db),
 			calendarObject: new CalendarObjectRepo(store.db),
-			calendarEventIndex: new CalendarEventIndexRepo(store.db),
+			calendarEventIndex: new CalendarEventIndexRepo(store),
 			calendarSuggestion,
 			calendarFeedToken: new CalendarFeedTokenRepo(store.db),
 		};
@@ -138,17 +141,21 @@ export class DrizzleCalendarStore implements ICalendarStore {
 						}),
 					this.clearOccurrences(calendarId, calendarObjectId),
 				];
-				if (write.occurrences.length === 0) return items;
+				const occurrences = write.occurrences.map((occurrence) => ({
+					...occurrence,
+					calendarId,
+					calendarObjectId,
+					createdAt: now,
+					updatedAt: now,
+				}));
 				return [
 					...items,
-					this.db.insert(calendarEventIndexTable).values(
-						write.occurrences.map((occurrence) => ({
-							...occurrence,
-							calendarId,
-							calendarObjectId,
-							createdAt: now,
-							updatedAt: now,
-						})),
+					...chunkRows(
+						calendarEventIndexTable,
+						occurrences,
+						this.maxBoundParameters,
+					).map((slice) =>
+						this.db.insert(calendarEventIndexTable).values(slice),
 					),
 				];
 			}

package/src/repos/cascade-delete.test.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
 import { MailboxCursorState } from "@remit/domain-enums";
 import { eq } from "drizzle-orm";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { syncStores } from "../databases.js";
 import {
 	accountSettingTable,
@@ -300,7 +301,10 @@ describe("runDrizzleCascadeDelete", () => {
 
 	test("deletes every enumerated row across all tables", async () => {
 		await runDrizzleCascadeDelete(
-			syncStores({ app: db, mail: db, search: db } as never),
+			syncStores(
+				{ app: db, mail: db, search: db } as never,
+				BETTER_SQLITE3_LIMITS,
+			),
 			entities,
 			log,
 		);
@@ -439,7 +443,10 @@ describe("runDrizzleCascadeDelete", () => {
 		await assert.rejects(
 			() =>
 				runDrizzleCascadeDelete(
-					syncStores({ app: db, mail: db, search: db } as never),
+					syncStores(
+						{ app: db, mail: db, search: db } as never,
+						BETTER_SQLITE3_LIMITS,
+					),
 					[{ entityType: "Nonsense", key: { id: "x" } }],
 					log,
 				),

package/src/repos/cascade-delete.ts

@@ -1,4 +1,5 @@
 import type { SqliteBatchItem } from "../batch.js";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import {
 	openSqliteDatabases,
 	type SqliteDatabasePaths,
@@ -241,6 +242,6 @@ export const createSqliteCascadeDeleter = async (
 	paths: SqliteDatabasePaths,
 ): Promise<CascadeDeleter> => {
 	const databases = await openSqliteDatabases(paths);
-	const stores = syncStores(databases);
+	const stores = syncStores(databases, BETTER_SQLITE3_LIMITS);
 	return (entities, log) => runDrizzleCascadeDelete(stores, entities, log);
 };

package/src/repos/envelope.d1.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import type { BodyPartUpsertInput } from "@remit/data-ports";
+import { ReferenceType } from "@remit/domain-enums";
+import { openD1TestStore } from "../test-d1.js";
+import { DrizzleEnvelopeRepository } from "./envelope.js";
+
+const MESSAGE_ID = "00000000-0000-0000-4444-000000000d01";
+
+const bodyPart = (index: number): BodyPartUpsertInput => ({
+	partPath: `${index + 1}`,
+	parentPartPath: null,
+	mediaType: "TEXT",
+	mediaSubtype: "plain",
+	transferEncoding: "7BIT",
+	sizeOctets: 128,
+	isMultipart: false,
+	parameters: [{ parameterName: "charset", parameterValue: "utf-8" }],
+});
+
+describe("DrizzleEnvelopeRepository on D1's 100 bound parameter limit", () => {
+	let repo: DrizzleEnvelopeRepository;
+	let close: () => Promise<void>;
+
+	before(async () => {
+		const opened = await openD1TestStore("mail");
+		close = opened.close;
+		repo = new DrizzleEnvelopeRepository(opened.store);
+		await repo.upsertEnvelope({
+			envelopeId: "ignored-derived",
+			messageId: MESSAGE_ID,
+			dateValue: 1700000000000,
+			dateRaw: "Mon, 14 Nov 2023 08:00:00 +0000",
+			subject: "Thirty parts",
+		});
+	});
+
+	after(async () => {
+		await close();
+	});
+
+	test("upsertBodyParts writes thirty parts and their parameters", async () => {
+		await repo.upsertBodyParts(
+			MESSAGE_ID,
+			Array.from({ length: 30 }, (_, index) => bodyPart(index)),
+		);
+
+		const data = await repo.getMessageData(MESSAGE_ID);
+		assert.equal(data.bodyPart.length, 30);
+		assert.equal(data.bodyPartParameter.length, 30);
+	});
+
+	test("replaceMessageReferences writes thirty references", async () => {
+		await repo.replaceMessageReferences(
+			MESSAGE_ID,
+			Array.from({ length: 30 }, (_, index) => ({
+				messageIdValue: `<ref-${index}@example.com>`,
+				referenceType: ReferenceType.References,
+				referenceOrder: index,
+			})),
+		);
+
+		const data = await repo.getMessageData(MESSAGE_ID);
+		assert.equal(data.messageReference.length, 30);
+	});
+});

package/src/repos/envelope.sqlite.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import {
 	type MessageDataSchema,
 	messageDataSchema,
@@ -20,7 +21,10 @@ describe("DrizzleEnvelopeRepository (sqlite)", () => {
 
 	before(async () => {
 		({ db, close } = await createSqliteTestDb(messageDataSchema));
-		repo = createSqliteRepositories({ app: db, mail: db, search: db }).envelope;
+		repo = createSqliteRepositories(
+			{ app: db, mail: db, search: db },
+			BETTER_SQLITE3_LIMITS,
+		).envelope;
 	});
 
 	after(async () => {

package/src/repos/envelope.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import type { BodyPartUpsertInput } from "@remit/data-ports";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { envelopeId as deriveEnvelopeId } from "../id.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import type { DrizzleEnvelopeRepository } from "./envelope.js";
@@ -19,7 +20,10 @@ describe("DrizzleEnvelopeRepository", () => {
 
 	before(async () => {
 		({ db, stop } = await createTestDb());
-		repo = createSqliteRepositories({ app: db, mail: db, search: db }).envelope;
+		repo = createSqliteRepositories(
+			{ app: db, mail: db, search: db },
+			BETTER_SQLITE3_LIMITS,
+		).envelope;
 
 		await repo.upsertEnvelope({
 			envelopeId: ENVELOPE_ID,

package/src/repos/envelope.ts

@@ -9,7 +9,8 @@ import type {
 	UpdateEnvelopeInput,
 } from "@remit/data-ports";
 import { eq } from "drizzle-orm";
-import type { WriteBatch } from "../batch.js";
+import type { SqliteBatchItem, WriteBatch } from "../batch.js";
+import { chunkRows } from "../bound-parameters.js";
 import type { RepositoryDb, SqliteStore } from "../db.js";
 import {
 	CreateFailedConflictError,
@@ -57,10 +58,12 @@ function dedupeById<T>(rows: T[], getId: (row: T) => string): T[] {
 export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 	private readonly db: DB;
 	private readonly batch: WriteBatch;
+	private readonly maxBoundParameters: number;
 
 	constructor(store: SqliteStore<Record<string, unknown>>) {
 		this.db = store.db;
 		this.batch = store.batch;
+		this.maxBoundParameters = store.maxBoundParameters;
 	}
 
 	async getMessageData(messageId: string): Promise<MessageData> {
@@ -180,22 +183,30 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 			(r) => r.bodyPartParameterId,
 		);
 
-		const insertParts = this.db
-			.insert(bodyPartTable)
-			.values(dedupedBodyPartRows)
-			.onConflictDoUpdate({
-				target: bodyPartTable.bodyPartId,
-				set: { updatedAt: now },
-			});
-		if (dedupedParameterRows.length === 0) {
-			await this.batch([insertParts]);
-			return;
-		}
-		await this.batch([
-			insertParts,
+		const upsertUpdatedAt = 1;
+		const insertParts: SqliteBatchItem[] = chunkRows(
+			bodyPartTable,
+			dedupedBodyPartRows,
+			this.maxBoundParameters,
+			upsertUpdatedAt,
+		).map((slice) =>
+			this.db
+				.insert(bodyPartTable)
+				.values(slice)
+				.onConflictDoUpdate({
+					target: bodyPartTable.bodyPartId,
+					set: { updatedAt: now },
+				}),
+		);
+		const insertParameters: SqliteBatchItem[] = chunkRows(
+			bodyPartParameterTable,
+			dedupedParameterRows,
+			this.maxBoundParameters,
+			upsertUpdatedAt,
+		).map((slice) =>
 			this.db
 				.insert(bodyPartParameterTable)
-				.values(dedupedParameterRows)
+				.values(slice)
 				.onConflictDoUpdate({
 					target: bodyPartParameterTable.bodyPartParameterId,
 					set: {
@@ -203,7 +214,8 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 						updatedAt: now,
 					},
 				}),
-		]);
+		);
+		await this.batch([...insertParts, ...insertParameters]);
 	}
 
 	async replaceMessageReferences(
@@ -215,23 +227,20 @@ export class DrizzleEnvelopeRepository implements IEnvelopeRepository {
 		const clear = this.db
 			.delete(messageReferenceTable)
 			.where(eq(messageReferenceTable.messageId, messageId));
-		if (references.length === 0) {
-			await this.batch([clear]);
-			return;
-		}
+		const rows = references.map((reference) => ({
+			...reference,
+			messageReferenceId: deterministicBase36Id(
+				`msgref:${messageId}:${reference.referenceType}:${reference.referenceOrder}`,
+			),
+			messageId,
+			envelopeId,
+			createdAt: now,
+			updatedAt: now,
+		}));
 		await this.batch([
 			clear,
-			this.db.insert(messageReferenceTable).values(
-				references.map((reference) => ({
-					...reference,
-					messageReferenceId: deterministicBase36Id(
-						`msgref:${messageId}:${reference.referenceType}:${reference.referenceOrder}`,
-					),
-					messageId,
-					envelopeId,
-					createdAt: now,
-					updatedAt: now,
-				})),
+			...chunkRows(messageReferenceTable, rows, this.maxBoundParameters).map(
+				(slice) => this.db.insert(messageReferenceTable).values(slice),
 			),
 		]);
 	}

package/src/repos/i4-account.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createTestDb, randomId, type TestDb } from "../test-db.js";
 import type { AccountRepo } from "./i4-account.js";
@@ -26,11 +27,14 @@ describe("AccountRepo", () => {
 
 	before(async () => {
 		({ db, close } = await createTestDb());
-		repo = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).account;
+		repo = createSqliteRepositories(
+			{
+				app: db,
+				mail: db,
+				search: db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		).account;
 	});
 
 	after(async () => {
@@ -164,11 +168,14 @@ describe("AccountRepo", () => {
 		const accountConfigId = randomId();
 		const account = await repo.create(makeAccountInput(accountConfigId));
 
-		const mailboxRepo = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).mailbox;
+		const mailboxRepo = createSqliteRepositories(
+			{
+				app: db,
+				mail: db,
+				search: db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		).mailbox;
 		mailboxCreated(
 			await mailboxRepo.create({
 				accountId: account.accountId,

package/src/repos/i4-address-junk-move.sqlite.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { after, before, beforeEach, describe, test } from "node:test";
 import type Database from "better-sqlite3";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createTestDb, type TestDb } from "../test-db.js";
 import { AddressRepo } from "./i4-address.js";
@@ -125,11 +126,14 @@ describe("reconciling one message's addresses at the moment it moves", () => {
 	before(async () => {
 		({ db, sqlite, close } = await createTestDb());
 		repo = new AddressRepo(db as never);
-		specialUse = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).mailboxSpecialUse;
+		specialUse = createSqliteRepositories(
+			{
+				app: db,
+				mail: db,
+				search: db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		).mailboxSpecialUse;
 	});
 
 	/**

package/src/repos/i4-mailbox-special-use.sqlite.test.ts

@@ -6,6 +6,7 @@ import {
 	meetsTrashAssurance,
 } from "@remit/data-ports/folder-role";
 import { CanonicalMailboxRole } from "@remit/domain-enums";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import {
 	accountSettingTable,
 	accountTable,
@@ -57,11 +58,14 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 		});
 		close = testDb.close;
 		db = testDb.db;
-		const repos = createSqliteRepositories({
-			app: testDb.db,
-			mail: testDb.db,
-			search: testDb.db,
-		});
+		const repos = createSqliteRepositories(
+			{
+				app: testDb.db,
+				mail: testDb.db,
+				search: testDb.db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		);
 		repo = repos.mailboxSpecialUse;
 		mailboxes = repos.mailbox;
 		accountSettings = repos.accountSetting;

package/src/repos/i4-mailbox.sqlite.test.ts

@@ -4,6 +4,7 @@ import { after, before, describe, test } from "node:test";
 import { MailboxSyncStatus } from "@remit/domain-enums";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { mailboxTable } from "../schema.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
@@ -41,11 +42,14 @@ describe("MailboxRepo (sqlite)", () => {
 	before(async () => {
 		const testDb = await createSqliteTestDb({ mailbox: mailboxTable });
 		close = testDb.close;
-		repo = createSqliteRepositories({
-			app: testDb.db,
-			mail: testDb.db,
-			search: testDb.db,
-		}).mailbox;
+		repo = createSqliteRepositories(
+			{
+				app: testDb.db,
+				mail: testDb.db,
+				search: testDb.db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		).mailbox;
 	});
 
 	after(async () => {
@@ -211,11 +215,14 @@ describe("MailboxRepo (sqlite, shipped migrations)", () => {
 		const sqlite = new Database(":memory:");
 		applyMigrationSet(sqlite, "mail");
 		const db = drizzle(sqlite, { schema: { mailbox: mailboxTable } });
-		repo = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).mailbox;
+		repo = createSqliteRepositories(
+			{
+				app: db,
+				mail: db,
+				search: db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		).mailbox;
 		close = async () => {
 			sqlite.close();
 		};

package/src/repos/i4-mailbox.test.ts

@@ -3,6 +3,7 @@ import { after, before, describe, test } from "node:test";
 import { MailboxSyncStatus } from "@remit/domain-enums";
 import { eq } from "drizzle-orm";
 import { syncBatch } from "../batch.js";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import {
 	envelopeId as deriveEnvelopeId,
 	rootBodyPartId as deriveRootBodyPartId,
@@ -54,11 +55,14 @@ describe("MailboxRepo", () => {
 
 	before(async () => {
 		({ db, close } = await createTestDb());
-		repo = createSqliteRepositories({
-			app: db,
-			mail: db,
-			search: db,
-		}).mailbox;
+		repo = createSqliteRepositories(
+			{
+				app: db,
+				mail: db,
+				search: db,
+			},
+			BETTER_SQLITE3_LIMITS,
+		).mailbox;
 	});
 
 	after(async () => {
@@ -543,11 +547,14 @@ describe("MailboxRepo", () => {
 	describe("deleteMailboxWithMail — the folder's mail goes with it (D8)", () => {
 		const seedMessage = async (mailboxId: string, uid: number) => {
 			const messageId = randomId();
-			await createSqliteRepositories({
-				app: db,
-				mail: db,
-				search: db,
-			}).message.create({
+			await createSqliteRepositories(
+				{
+					app: db,
+					mail: db,
+					search: db,
+				},
+				BETTER_SQLITE3_LIMITS,
+			).message.create({
 				messageId,
 				mailboxId,
 				uid,

package/src/repos/i4-outbox-attachment.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createTestDb, randomId } from "../test-db.js";
 import type { OutboxAttachmentRepo } from "./i4-outbox-attachment.js";
@@ -28,11 +29,14 @@ const input = (
 
 before(async () => {
 	harness = await createTestDb();
-	repo = createSqliteRepositories({
-		app: harness.db,
-		mail: harness.db,
-		search: harness.db,
-	}).outboxAttachment;
+	repo = createSqliteRepositories(
+		{
+			app: harness.db,
+			mail: harness.db,
+			search: harness.db,
+		},
+		BETTER_SQLITE3_LIMITS,
+	).outboxAttachment;
 });
 
 after(async () => {

package/src/repos/message.sqlite.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import {
 	envelopeId as deriveEnvelopeId,
 	rootBodyPartId as deriveRootBodyPartId,
@@ -43,7 +44,10 @@ describe("DrizzleMessageRepository (sqlite)", () => {
 
 	before(async () => {
 		({ db, close } = await createSqliteTestDb(SCHEMA));
-		repo = createSqliteRepositories({ app: db, mail: db, search: db }).message;
+		repo = createSqliteRepositories(
+			{ app: db, mail: db, search: db },
+			BETTER_SQLITE3_LIMITS,
+		).message;
 	});
 
 	after(async () => {

package/src/repos/message.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
+import { BETTER_SQLITE3_LIMITS } from "../bound-parameters.js";
 import {
 	envelopeId as deriveEnvelopeId,
 	rootBodyPartId as deriveRootBodyPartId,
@@ -37,7 +38,10 @@ describe("DrizzleMessageRepository", () => {
 
 	before(async () => {
 		({ db, stop } = await createTestDb());
-		const repos = createSqliteRepositories({ app: db, mail: db, search: db });
+		const repos = createSqliteRepositories(
+			{ app: db, mail: db, search: db },
+			BETTER_SQLITE3_LIMITS,
+		);
 		messageRepo = repos.message;
 		envelopeRepo = repos.envelope;
 	});

package/src/repos/sync-warning.ts

@@ -6,14 +6,24 @@ import type {
 } from "@remit/data-ports";
 import { deriveSyncWarningId } from "@remit/data-ports/id";
 import { and, count, desc, eq, gte, sql } from "drizzle-orm";
-import type { RepositoryDb } from "../db.js";
+import type { WriteBatch } from "../batch.js";
+import { chunkRows } from "../bound-parameters.js";
+import type { RepositoryDb, SqliteStore } from "../db.js";
 import { syncWarningTable } from "../schema/sync-warning.js";
 import { inList } from "./in-list.js";
 
 type DB = RepositoryDb<Record<string, unknown>>;
 
 export class SyncWarningRepo implements ISyncWarningRepository {
-	constructor(private db: DB) {}
+	private readonly db: DB;
+	private readonly batch: WriteBatch;
+	private readonly maxBoundParameters: number;
+
+	constructor(store: SqliteStore<Record<string, unknown>>) {
+		this.db = store.db;
+		this.batch = store.batch;
+		this.maxBoundParameters = store.maxBoundParameters;
+	}
 
 	listByMailboxId = async (mailboxId: string): Promise<SyncWarningItem[]> =>
 		this.db
@@ -46,26 +56,29 @@ export class SyncWarningRepo implements ISyncWarningRepository {
 	recordFailures = async (keys: SyncWarningKey[]): Promise<void> => {
 		if (keys.length === 0) return;
 		const now = Date.now();
-		await this.db
-			.insert(syncWarningTable)
-			.values(
-				keys.map((key) => ({
-					syncWarningId: deriveSyncWarningId(
-						key.accountId,
-						key.mailboxId,
-						key.uidValidity,
-						key.uid,
-						key.stage,
-					),
-					...key,
-					attempts: 1,
-					createdAt: now,
-				})),
-			)
-			.onConflictDoUpdate({
-				target: syncWarningTable.syncWarningId,
-				set: { attempts: sql`${syncWarningTable.attempts} + 1` },
-			});
+		const rows = keys.map((key) => ({
+			syncWarningId: deriveSyncWarningId(
+				key.accountId,
+				key.mailboxId,
+				key.uidValidity,
+				key.uid,
+				key.stage,
+			),
+			...key,
+			attempts: 1,
+			createdAt: now,
+		}));
+		await this.batch(
+			chunkRows(syncWarningTable, rows, this.maxBoundParameters).map((slice) =>
+				this.db
+					.insert(syncWarningTable)
+					.values(slice)
+					.onConflictDoUpdate({
+						target: syncWarningTable.syncWarningId,
+						set: { attempts: sql`${syncWarningTable.attempts} + 1` },
+					}),
+			),
+		);
 	};
 
 	deleteMany = async (syncWarningIds: string[]): Promise<void> => {