@remit/drizzle-service 0.0.110 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.110",
+  "version": "1.0.0",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

package/src/index.ts

@@ -33,6 +33,7 @@ export { CalendarFeedTokenRepo } from "./repos/calendar-feed-token.js";
 export { CalendarObjectRepo } from "./repos/calendar-object.js";
 export { DrizzleCalendarStore } from "./repos/calendar-store.js";
 export { CalendarSuggestionRepo } from "./repos/calendar-suggestion.js";
+export { CalendarTaskRepo } from "./repos/calendar-task.js";
 export {
 	type CascadeDeleteLogger,
 	type CascadeDeleter,
@@ -78,6 +79,7 @@ export {
 	type MessageObjectStore,
 	messageObjectsInMemory,
 } from "./repos/message-objects.js";
+export { OutboxSchedulingPartRepo } from "./repos/outbox-scheduling-part.js";
 export { QuarantineRepo } from "./repos/quarantine.js";
 export { SyncWarningRepo } from "./repos/sync-warning.js";
 export { DrizzleThreadMessageRepository } from "./repos/thread-message.js";

package/src/repos/calendar-put.suite.ts

@@ -6,6 +6,7 @@ import {
 	putCalendarObject,
 } from "@remit/calendar-service";
 import type {
+	CalendarCommitReport,
 	CalendarRepositories,
 	CalendarWrite,
 	ICalendarStore,
@@ -49,7 +50,9 @@ class FailingLastWriteStore implements ICalendarStore {
 		return this.inner.repos;
 	}
 
-	async commit(writes: readonly CalendarWrite[]): Promise<void> {
+	async commit(
+		writes: readonly CalendarWrite[],
+	): Promise<CalendarCommitReport> {
 		const orphan = await prepareCalendarObject(
 			{ timezone: "" },
 			{
@@ -60,7 +63,7 @@ class FailingLastWriteStore implements ICalendarStore {
 			},
 		);
 		assert.ok(orphan.ok);
-		await this.inner.commit([...writes, orphan.value]);
+		return this.inner.commit([...writes, orphan.value]);
 	}
 }
 

package/src/repos/calendar-store.ts

@@ -1,4 +1,5 @@
 import type {
+	CalendarCommitReport,
 	CalendarRepositories,
 	CalendarWrite,
 	ICalendarStore,
@@ -15,6 +16,7 @@ import {
 	calendarFeedTokenTable,
 	calendarObjectTable,
 	calendarTable,
+	calendarTaskTable,
 } from "../schema.js";
 import { CalendarCollectionRepo } from "./calendar-collection.js";
 import { CalendarEventIndexRepo } from "./calendar-event-index.js";
@@ -55,10 +57,30 @@ export class DrizzleCalendarStore implements ICalendarStore {
 		};
 	}
 
-	async commit(writes: readonly CalendarWrite[]): Promise<void> {
-		await this.batch(
-			writes.filter(isBatchWrite).flatMap((write) => this.statements(write)),
-		);
+	async commit(
+		writes: readonly CalendarWrite[],
+	): Promise<CalendarCommitReport> {
+		const items: SqliteBatchItem[] = [];
+		const reprojections: { at: number; calendarObjectId: string }[] = [];
+		for (const write of writes.filter(isBatchWrite)) {
+			items.push(...this.statements(write));
+			if (write.kind === "ReprojectObject") {
+				reprojections.push({
+					at: items.length - 1,
+					calendarObjectId: deriveCalendarObjectId(
+						write.object.calendarId,
+						write.object.resourceName,
+					),
+				});
+			}
+		}
+		const results: readonly unknown[] = await this.batch(items);
+		const staleReprojections = reprojections
+			.filter(({ at }) => {
+				const written = results[at];
+				return Array.isArray(written) && written.length === 0;
+			})
+			.map(({ calendarObjectId }) => calendarObjectId);
 		for (const write of writes.filter(isSettlement)) {
 			await this.repos.calendarSuggestion.settle(
 				write.accountConfigId,
@@ -66,6 +88,7 @@ export class DrizzleCalendarStore implements ICalendarStore {
 				write.settle,
 			);
 		}
+		return { staleReprojections };
 	}
 
 	private collection(accountConfigId: string, calendarId: string) {
@@ -167,6 +190,9 @@ export class DrizzleCalendarStore implements ICalendarStore {
 				);
 				// Every statement reads the object it rewrites at the version the
 				// caller read, so a resource edited or deleted since writes nothing.
+				// The object's own update runs last, so the occurrence statements still
+				// see that version, and it returns the row it wrote, so the commit can
+				// tell a stale read from a written one.
 				const asRead = and(
 					eq(calendarObjectTable.calendarObjectId, calendarObjectId),
 					eq(calendarObjectTable.etag, write.readEtag),
@@ -180,17 +206,6 @@ export class DrizzleCalendarStore implements ICalendarStore {
 				const value = <T>(field: T, name: string) => sql<T>`${field}`.as(name);
 				return [
 					this.bump(write.accountConfigId, calendarId),
-					this.db
-						.update(calendarObjectTable)
-						.set({
-							...write.object,
-							syncSequence: this.bumpedSequence(
-								write.accountConfigId,
-								calendarId,
-							),
-							updatedAt: now,
-						})
-						.where(asRead),
 					this.db
 						.delete(calendarEventIndexTable)
 						.where(
@@ -223,6 +238,18 @@ export class DrizzleCalendarStore implements ICalendarStore {
 								.where(asRead),
 						),
 					),
+					this.db
+						.update(calendarObjectTable)
+						.set({
+							...write.object,
+							syncSequence: this.bumpedSequence(
+								write.accountConfigId,
+								calendarId,
+							),
+							updatedAt: now,
+						})
+						.where(asRead)
+						.returning({ id: calendarObjectTable.calendarObjectId }),
 				];
 			}
 			case "DeleteObject":
@@ -250,6 +277,9 @@ export class DrizzleCalendarStore implements ICalendarStore {
 				];
 			case "DeleteCollection":
 				return [
+					this.db
+						.delete(calendarTaskTable)
+						.where(eq(calendarTaskTable.calendarId, write.calendarId)),
 					this.db
 						.delete(calendarEventIndexTable)
 						.where(eq(calendarEventIndexTable.calendarId, write.calendarId)),

package/src/repos/calendar-task.ts

@@ -0,0 +1,103 @@
+import type {
+	CalendarTaskItem,
+	ICalendarTaskRepository,
+	PutCalendarTaskInput,
+} from "@remit/data-ports";
+import { deriveCalendarTaskId } from "@remit/data-ports/id";
+import { and, asc, eq, gte, lt } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
+import { calendarTaskTable } from "../schema.js";
+
+type DB = RepositoryDb<Record<string, unknown>>;
+
+const rowToTask = (
+	row: typeof calendarTaskTable.$inferSelect,
+): CalendarTaskItem => ({
+	calendarTaskId: row.calendarTaskId,
+	calendarId: row.calendarId,
+	resourceName: row.resourceName,
+	icalUid: row.icalUid,
+	icalData: row.icalData,
+	etag: row.etag,
+	summary: row.summary,
+	description: row.description,
+	due: row.due,
+	dueAt: row.dueAt,
+	allDay: row.allDay,
+	completed: row.completed,
+	createdAt: row.createdAt,
+	updatedAt: row.updatedAt,
+});
+
+export class CalendarTaskRepo implements ICalendarTaskRepository {
+	constructor(private db: DB) {}
+
+	async put(input: PutCalendarTaskInput): Promise<CalendarTaskItem> {
+		const now = Date.now();
+		const calendarTaskId = deriveCalendarTaskId(
+			input.calendarId,
+			input.resourceName,
+		);
+		const [row] = await this.db
+			.insert(calendarTaskTable)
+			.values({ ...input, calendarTaskId, createdAt: now, updatedAt: now })
+			.onConflictDoUpdate({
+				target: calendarTaskTable.calendarTaskId,
+				set: { ...input, updatedAt: now },
+			})
+			.returning();
+		return rowToTask(row);
+	}
+
+	async find(
+		calendarId: string,
+		calendarTaskId: string,
+	): Promise<CalendarTaskItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(calendarTaskTable)
+			.where(
+				and(
+					eq(calendarTaskTable.calendarId, calendarId),
+					eq(calendarTaskTable.calendarTaskId, calendarTaskId),
+				),
+			);
+		return row ? rowToTask(row) : null;
+	}
+
+	async delete(calendarId: string, calendarTaskId: string): Promise<void> {
+		await this.db
+			.delete(calendarTaskTable)
+			.where(
+				and(
+					eq(calendarTaskTable.calendarId, calendarId),
+					eq(calendarTaskTable.calendarTaskId, calendarTaskId),
+				),
+			);
+	}
+
+	async listByDueRange(
+		calendarId: string,
+		fromAt: string,
+		toAt: string,
+	): Promise<CalendarTaskItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarTaskTable)
+			.where(
+				and(
+					eq(calendarTaskTable.calendarId, calendarId),
+					gte(calendarTaskTable.dueAt, fromAt),
+					lt(calendarTaskTable.dueAt, toAt),
+				),
+			)
+			.orderBy(asc(calendarTaskTable.dueAt));
+		return rows.map(rowToTask);
+	}
+
+	async deleteByCalendar(calendarId: string): Promise<void> {
+		await this.db
+			.delete(calendarTaskTable)
+			.where(eq(calendarTaskTable.calendarId, calendarId));
+	}
+}

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

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import { after, before, describe, test } from "node:test";
+import { syncBatch } from "../batch.js";
 import { ForbiddenError, NotFoundError } from "../error.js";
 import { createTestDb, randomId, type TestDb } from "../test-db.js";
 import { OutboxMessageRepo } from "./i4-outbox-message.js";
@@ -22,7 +23,7 @@ describe("OutboxMessageRepo", () => {
 
 	before(async () => {
 		({ db, close } = await createTestDb());
-		repo = new OutboxMessageRepo(db as never);
+		repo = new OutboxMessageRepo(db as never, syncBatch(db));
 	});
 
 	after(async () => {

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

@@ -1,15 +1,19 @@
 import type {
 	CreateOutboxMessageInput,
+	CreateOutboxSchedulingPartInput,
 	IOutboxMessageRepository,
 	OutboxMessageItem,
 	ResultList,
 	UpdateOutboxMessageInput,
 } from "@remit/data-ports";
+import { base36uuid } from "@remit/data-ports/id";
 import { and, desc, eq, lt, or } from "drizzle-orm";
+import type { WriteBatch } from "../batch.js";
 import type { RepositoryDb } from "../db.js";
 import { ForbiddenError, NotFoundError } from "../error.js";
 import { decodeToken, resultList } from "../pagination.js";
 import { outboxMessageTable } from "../schema/i4-outbox-message.js";
+import { outboxSchedulingPartTable } from "../schema.js";
 import { inList } from "./in-list.js";
 
 type DB = RepositoryDb<Record<string, unknown>>;
@@ -45,13 +49,21 @@ function rowToOutboxMessage(
 }
 
 export class OutboxMessageRepo implements IOutboxMessageRepository {
-	constructor(private db: DB) {}
+	constructor(
+		private db: DB,
+		private batch: WriteBatch,
+	) {}
 
-	async create(input: CreateOutboxMessageInput): Promise<OutboxMessageItem> {
+	async create(
+		input: CreateOutboxMessageInput,
+		schedulingPart?: CreateOutboxSchedulingPartInput,
+	): Promise<OutboxMessageItem> {
 		const now = Date.now();
-		const [row] = await this.db
+		const outboxMessageId = base36uuid();
+		const insert = this.db
 			.insert(outboxMessageTable)
 			.values({
+				outboxMessageId,
 				accountId: input.accountId,
 				accountConfigId: input.accountConfigId,
 				fromAddress: input.fromAddress,
@@ -75,6 +87,21 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 				updatedAt: now,
 			})
 			.returning();
+		if (!schedulingPart) {
+			const [row] = await insert;
+			return rowToOutboxMessage(row);
+		}
+		const [rows] = await this.batch([
+			insert,
+			this.db.insert(outboxSchedulingPartTable).values({
+				...schedulingPart,
+				outboxMessageId,
+				accountConfigId: input.accountConfigId,
+				createdAt: now,
+				updatedAt: now,
+			}),
+		]);
+		const [row] = rows as (typeof outboxMessageTable.$inferSelect)[];
 		return rowToOutboxMessage(row);
 	}
 
@@ -241,18 +268,12 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 		return rowToOutboxMessage(row);
 	}
 
+	/** The row and its scheduling part go together, or neither does. */
 	async delete(
 		accountConfigId: string,
 		outboxMessageId: string,
 	): Promise<void> {
-		await this.db
-			.delete(outboxMessageTable)
-			.where(
-				and(
-					eq(outboxMessageTable.accountConfigId, accountConfigId),
-					eq(outboxMessageTable.outboxMessageId, outboxMessageId),
-				),
-			);
+		await this.deleteMany(accountConfigId, [outboxMessageId]);
 	}
 
 	async deleteMany(
@@ -260,14 +281,24 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 		outboxMessageIds: string[],
 	): Promise<void> {
 		if (outboxMessageIds.length === 0) return;
-		await this.db
-			.delete(outboxMessageTable)
-			.where(
-				and(
-					eq(outboxMessageTable.accountConfigId, accountConfigId),
-					inList(outboxMessageTable.outboxMessageId, outboxMessageIds),
+		await this.batch([
+			this.db
+				.delete(outboxMessageTable)
+				.where(
+					and(
+						eq(outboxMessageTable.accountConfigId, accountConfigId),
+						inList(outboxMessageTable.outboxMessageId, outboxMessageIds),
+					),
 				),
-			);
+			this.db
+				.delete(outboxSchedulingPartTable)
+				.where(
+					and(
+						eq(outboxSchedulingPartTable.accountConfigId, accountConfigId),
+						inList(outboxSchedulingPartTable.outboxMessageId, outboxMessageIds),
+					),
+				),
+		]);
 	}
 
 	async listByAccount(

package/src/repos/outbox-scheduling-part.ts

@@ -0,0 +1,68 @@
+import type {
+	IOutboxSchedulingPartRepository,
+	OutboxSchedulingPartItem,
+} from "@remit/data-ports";
+import { and, asc, eq } from "drizzle-orm";
+import type { RepositoryDb } from "../db.js";
+import { outboxMessageTable } from "../schema/i4-outbox-message.js";
+import { outboxSchedulingPartTable } from "../schema.js";
+
+type DB = RepositoryDb<Record<string, unknown>>;
+
+const rowToPart = (
+	row: typeof outboxSchedulingPartTable.$inferSelect,
+): OutboxSchedulingPartItem => ({
+	outboxMessageId: row.outboxMessageId,
+	accountConfigId: row.accountConfigId,
+	calendarObjectId: row.calendarObjectId,
+	recipient: row.recipient,
+	method: row.method,
+	sequence: row.sequence,
+	icalData: row.icalData,
+	createdAt: row.createdAt,
+	updatedAt: row.updatedAt,
+});
+
+export class OutboxSchedulingPartRepo
+	implements IOutboxSchedulingPartRepository
+{
+	constructor(private db: DB) {}
+
+	async find(
+		outboxMessageId: string,
+	): Promise<OutboxSchedulingPartItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(outboxSchedulingPartTable)
+			.where(eq(outboxSchedulingPartTable.outboxMessageId, outboxMessageId));
+		return row ? rowToPart(row) : null;
+	}
+
+	/**
+	 * Joined to the outbox so a part whose message left the outbox by a path
+	 * that did not take the part with it is never reported as still in flight.
+	 */
+	async listByCalendarObject(
+		accountConfigId: string,
+		calendarObjectId: string,
+	): Promise<OutboxSchedulingPartItem[]> {
+		const rows = await this.db
+			.select({ part: outboxSchedulingPartTable })
+			.from(outboxSchedulingPartTable)
+			.innerJoin(
+				outboxMessageTable,
+				eq(
+					outboxMessageTable.outboxMessageId,
+					outboxSchedulingPartTable.outboxMessageId,
+				),
+			)
+			.where(
+				and(
+					eq(outboxSchedulingPartTable.accountConfigId, accountConfigId),
+					eq(outboxSchedulingPartTable.calendarObjectId, calendarObjectId),
+				),
+			)
+			.orderBy(asc(outboxSchedulingPartTable.createdAt));
+		return rows.map(({ part }) => rowToPart(part));
+	}
+}

package/src/schema-sets/app.ts

@@ -11,6 +11,7 @@ export {
 	calendarEventIndexes,
 	calendarFeedTokens,
 	calendarObjects,
+	calendarTasks,
 	configImports,
 	filters,
 	labels,

package/src/schema-sets/mail.ts

@@ -24,6 +24,7 @@ export {
 	organizeJobRequests,
 	outboxAttachments,
 	outboxMessages,
+	outboxSchedulingParts,
 	quarantines,
 	rawMessageStorages,
 	senderSignerStandings,

package/src/schema.ts

@@ -11,6 +11,8 @@ export const calendarTable = entities.calendarCollections;
 export const calendarObjectTable = entities.calendarObjects;
 export const calendarEventIndexTable = entities.calendarEventIndexes;
 export const calendarFeedTokenTable = entities.calendarFeedTokens;
+export const calendarTaskTable = entities.calendarTasks;
+export const outboxSchedulingPartTable = entities.outboxSchedulingParts;
 export const calendarSuggestionTable = entities.calendarSuggestions;
 export const filterTable = entities.filters;
 export const labelTable = entities.labels;

package/src/sqlite-repositories.ts

@@ -10,6 +10,7 @@ import { CalendarFeedTokenRepo } from "./repos/calendar-feed-token.js";
 import { CalendarObjectRepo } from "./repos/calendar-object.js";
 import { DrizzleCalendarStore } from "./repos/calendar-store.js";
 import { CalendarSuggestionRepo } from "./repos/calendar-suggestion.js";
+import { CalendarTaskRepo } from "./repos/calendar-task.js";
 import { DrizzleEnvelopeRepository } from "./repos/envelope.js";
 import { FilterRepo } from "./repos/filter.js";
 import { AccountRepo } from "./repos/i4-account.js";
@@ -35,6 +36,7 @@ import {
 	type MessageObjectStore,
 	MessageObjects,
 } from "./repos/message-objects.js";
+import { OutboxSchedulingPartRepo } from "./repos/outbox-scheduling-part.js";
 import { QuarantineRepo } from "./repos/quarantine.js";
 import { SyncWarningRepo } from "./repos/sync-warning.js";
 import { DrizzleThreadMessageRepository } from "./repos/thread-message.js";
@@ -70,7 +72,8 @@ export const composeSqliteRepositories = (
 		mailboxLock: new MailboxLockRepo(mail.db),
 		message,
 		messageFlag: new DrizzleMessageFlagRepository(mail.db),
-		outboxMessage: new OutboxMessageRepo(mail.db),
+		outboxMessage: new OutboxMessageRepo(mail.db, mail.batch),
+		outboxSchedulingPart: new OutboxSchedulingPartRepo(mail.db),
 		outboxAttachment: new OutboxAttachmentRepo(mail),
 		threadMessage: new DrizzleThreadMessageRepository(mail, searchIndex),
 		envelope: new DrizzleEnvelopeRepository(mail),
@@ -89,6 +92,7 @@ export const composeSqliteRepositories = (
 		calendarObject: new CalendarObjectRepo(app.db),
 		calendarEventIndex: new CalendarEventIndexRepo(app),
 		calendarFeedToken: new CalendarFeedTokenRepo(app.db),
+		calendarTask: new CalendarTaskRepo(app.db),
 		calendarSuggestion,
 		calendarStore: new DrizzleCalendarStore(app, calendarSuggestion),
 	};