@remit/drizzle-service 0.0.67 → 0.0.69

package/package.json

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

package/src/index.ts

@@ -2,6 +2,7 @@ export { CreateFailedConflictError, NotFoundError } from "./error.js";
 export { CalendarCollectionRepo } from "./repos/calendar-collection.js";
 export { CalendarEventIndexRepo } from "./repos/calendar-event-index.js";
 export { CalendarObjectRepo } from "./repos/calendar-object.js";
+export { CalendarSuggestionRepo } from "./repos/calendar-suggestion.js";
 export { DrizzleCalendarUnitOfWork } from "./repos/calendar-unit-of-work.js";
 export {
 	type CascadeDeleteLogger,

package/src/repos/calendar-collection.ts

@@ -72,6 +72,37 @@ export class CalendarCollectionRepo implements ICalendarCollectionRepository {
 		return rowToCalendar(row);
 	}
 
+	/**
+	 * One statement, so the loser of a race is told the segment is taken rather
+	 * than handed the winner's calendar. A read followed by an insert would let
+	 * both callers see the segment free and one of them silently write into the
+	 * other's collection.
+	 */
+	async createExclusive(
+		input: CreateCalendarCollectionInput,
+	): Promise<CalendarCollectionItem | null> {
+		const now = Date.now();
+		const urlSegment = normalizeCalendarUrlSegment(input.urlSegment);
+		const [row] = await this.db
+			.insert(calendarTable)
+			.values({
+				calendarId: deriveCalendarId(input.accountConfigId, urlSegment),
+				accountConfigId: input.accountConfigId,
+				urlSegment,
+				displayName: input.displayName,
+				color: input.color ?? "Cal1",
+				componentSet: input.componentSet ?? "VeventOnly",
+				source: input.source ?? "UserCreated",
+				timezone: input.timezone ?? "",
+				syncSequence: 0,
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoNothing({ target: calendarTable.calendarId })
+			.returning();
+		return row ? rowToCalendar(row) : null;
+	}
+
 	async get(
 		accountConfigId: string,
 		calendarId: string,

package/src/repos/calendar-default.sqlite.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { provisionDefaultCalendar } from "@remit/calendar-service";
+import type { ICalendarUnitOfWork } from "@remit/data-ports";
+import type { Db } from "../db.js";
+import {
+	calendarEventIndexTable,
+	calendarObjectTable,
+	calendarTable,
+} from "../schema.js";
+import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+import { DrizzleCalendarUnitOfWork } from "./calendar-unit-of-work.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-default";
+
+describe("provisioning the default calendar", () => {
+	let db: Db<Record<string, unknown>>;
+	let close: () => Promise<void>;
+	let unitOfWork: ICalendarUnitOfWork;
+
+	before(async () => {
+		const created = await createSqliteTestDb({
+			calendars: calendarTable,
+			calendarObjects: calendarObjectTable,
+			calendarEventIndexes: calendarEventIndexTable,
+		});
+		db = created.db as unknown as Db<Record<string, unknown>>;
+		close = created.close;
+		unitOfWork = new DrizzleCalendarUnitOfWork(db);
+	});
+
+	after(() => close());
+
+	test("leaves one calendar behind when several first reads arrive together", async () => {
+		const provisioned = await Promise.all(
+			Array.from({ length: 8 }, () =>
+				provisionDefaultCalendar(unitOfWork, ACCOUNT_CONFIG_ID),
+			),
+		);
+
+		const ids = new Set(provisioned.map((collection) => collection.calendarId));
+		assert.equal(ids.size, 1, "every caller was handed the same calendar");
+
+		const rows = await new CalendarCollectionRepo(db).listByAccountConfig(
+			ACCOUNT_CONFIG_ID,
+		);
+		assert.equal(rows.length, 1);
+		assert.equal(rows[0]?.urlSegment, "default");
+		assert.equal(
+			rows[0]?.syncSequence,
+			0,
+			"a losing provision did not reset a collection the winner may already have written to",
+		);
+	});
+
+	test("a later provision returns the stored collection rather than resetting it", async () => {
+		const repo = new CalendarCollectionRepo(db);
+		const [before] = await repo.listByAccountConfig(ACCOUNT_CONFIG_ID);
+		assert.ok(before);
+		await repo.bumpSyncSequence(ACCOUNT_CONFIG_ID, before.calendarId);
+
+		const again = await provisionDefaultCalendar(
+			unitOfWork,
+			ACCOUNT_CONFIG_ID,
+			"A different name",
+		);
+
+		assert.equal(again.calendarId, before.calendarId);
+		assert.equal(again.displayName, before.displayName);
+		assert.equal(again.syncSequence, 1);
+	});
+});

package/src/repos/calendar-event-index.ts

@@ -19,6 +19,9 @@ function rowToOccurrence(
 		startAt: row.startAt,
 		endAt: row.endAt,
 		allDay: row.allDay,
+		summary: row.summary,
+		status: row.status,
+		transparency: row.transparency,
 		createdAt: row.createdAt,
 		updatedAt: row.updatedAt,
 	};
@@ -44,6 +47,9 @@ export class CalendarEventIndexRepo implements ICalendarEventIndexRepository {
 				startAt: occurrence.startAt,
 				endAt: occurrence.endAt,
 				allDay: occurrence.allDay,
+				summary: occurrence.summary,
+				status: occurrence.status,
+				transparency: occurrence.transparency,
 				createdAt: now,
 				updatedAt: now,
 			})),

package/src/repos/calendar-object.ts

@@ -4,7 +4,7 @@ import type {
 	PutCalendarObjectInput,
 } from "@remit/data-ports";
 import { deriveCalendarObjectId } from "@remit/data-ports/id";
-import { and, asc, eq, gt } from "drizzle-orm";
+import { and, asc, eq, gt, lt, ne } from "drizzle-orm";
 import type { Db } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { calendarObjectTable } from "../schema.js";
@@ -82,6 +82,22 @@ export class CalendarObjectRepo implements ICalendarObjectRepository {
 		return rowToCalendarObject(row);
 	}
 
+	async find(
+		calendarId: string,
+		calendarObjectId: string,
+	): Promise<CalendarObjectItem | null> {
+		const [row] = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(
+				and(
+					eq(calendarObjectTable.calendarId, calendarId),
+					eq(calendarObjectTable.calendarObjectId, calendarObjectId),
+				),
+			);
+		return row ? rowToCalendarObject(row) : null;
+	}
+
 	async delete(calendarId: string, calendarObjectId: string): Promise<void> {
 		await this.db
 			.delete(calendarObjectTable)
@@ -139,6 +155,24 @@ export class CalendarObjectRepo implements ICalendarObjectRepository {
 		return rows.map(rowToCalendarObject);
 	}
 
+	async listIncompleteExpansions(
+		calendarId: string,
+		instant: string,
+	): Promise<CalendarObjectItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarObjectTable)
+			.where(
+				and(
+					eq(calendarObjectTable.calendarId, calendarId),
+					ne(calendarObjectTable.expandedThrough, ""),
+					lt(calendarObjectTable.expandedThrough, instant),
+				),
+			)
+			.orderBy(asc(calendarObjectTable.calendarObjectId));
+		return rows.map(rowToCalendarObject);
+	}
+
 	async listChangedSince(
 		calendarId: string,
 		syncSequence: number,

package/src/repos/calendar-suggestion.conformance.sqlite.test.ts

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

package/src/repos/calendar-suggestion.ts

@@ -0,0 +1,223 @@
+import type {
+	CalendarSuggestionItem,
+	ICalendarSuggestionRepository,
+	PutCalendarSuggestionInput,
+	ResultList,
+	SettleCalendarSuggestionInput,
+} from "@remit/data-ports";
+import { deriveCalendarSuggestionId } from "@remit/data-ports/id";
+import { CalendarSuggestionState } from "@remit/domain-enums";
+import { and, asc, desc, eq, lt, or } from "drizzle-orm";
+import type { Db } from "../db.js";
+import { NotFoundError } from "../error.js";
+import { decodeToken, resultList } from "../pagination.js";
+import { calendarSuggestionTable } from "../schema.js";
+
+type DB = Db<Record<string, unknown>>;
+
+function rowToCalendarSuggestion(
+	row: typeof calendarSuggestionTable.$inferSelect,
+): CalendarSuggestionItem {
+	return {
+		suggestionId: row.suggestionId,
+		accountConfigId: row.accountConfigId,
+		messageId: row.messageId,
+		bodyPartId: row.bodyPartId,
+		icalUid: row.icalUid,
+		sequence: row.sequence,
+		method: row.method,
+		source: row.source,
+		state: row.state,
+		summary: row.summary,
+		dtStart: row.dtStart,
+		dtEnd: row.dtEnd,
+		allDay: row.allDay,
+		location: row.location,
+		organizer: row.organizer,
+		zoneCertainty: row.zoneCertainty,
+		icalData: row.icalData,
+		acceptedCalendarObjectId: row.acceptedCalendarObjectId,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	};
+}
+
+export class CalendarSuggestionRepo implements ICalendarSuggestionRepository {
+	constructor(private db: DB) {}
+
+	async put(
+		input: PutCalendarSuggestionInput,
+	): Promise<CalendarSuggestionItem> {
+		const now = Date.now();
+		const suggestionId = deriveCalendarSuggestionId(
+			input.messageId,
+			input.bodyPartId,
+			input.icalUid,
+		);
+		const [row] = await this.db
+			.insert(calendarSuggestionTable)
+			.values({
+				...input,
+				suggestionId,
+				state: CalendarSuggestionState.Pending,
+				acceptedCalendarObjectId: "",
+				createdAt: now,
+				updatedAt: now,
+			})
+			.onConflictDoUpdate({
+				target: [
+					calendarSuggestionTable.accountConfigId,
+					calendarSuggestionTable.suggestionId,
+				],
+				// `state` and `acceptedCalendarObjectId` are deliberately absent from
+				// the update set: they carry what a person decided, and a producer
+				// re-reading the message must not walk that back to Pending.
+				set: { ...input, updatedAt: now },
+			})
+			.returning();
+		return rowToCalendarSuggestion(row);
+	}
+
+	async get(
+		accountConfigId: string,
+		suggestionId: string,
+	): Promise<CalendarSuggestionItem> {
+		const [row] = await this.db
+			.select()
+			.from(calendarSuggestionTable)
+			.where(
+				and(
+					eq(calendarSuggestionTable.accountConfigId, accountConfigId),
+					eq(calendarSuggestionTable.suggestionId, suggestionId),
+				),
+			);
+		if (!row) {
+			throw new NotFoundError(`Calendar suggestion not found: ${suggestionId}`);
+		}
+		return rowToCalendarSuggestion(row);
+	}
+
+	async listByMessage(
+		accountConfigId: string,
+		messageId: string,
+	): Promise<CalendarSuggestionItem[]> {
+		const rows = await this.db
+			.select()
+			.from(calendarSuggestionTable)
+			.where(
+				and(
+					eq(calendarSuggestionTable.accountConfigId, accountConfigId),
+					eq(calendarSuggestionTable.messageId, messageId),
+				),
+			)
+			.orderBy(
+				asc(calendarSuggestionTable.createdAt),
+				asc(calendarSuggestionTable.suggestionId),
+			);
+		return rows.map(rowToCalendarSuggestion);
+	}
+
+	/**
+	 * Newest first, paged on a keyset over `(createdAt, suggestionId)` — the
+	 * exact trailing members of the `byState` index's sort key, read backwards.
+	 * The order is the index's own, never a sort applied on top of it.
+	 */
+	async listByState(
+		accountConfigId: string,
+		state: CalendarSuggestionItem["state"],
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<CalendarSuggestionItem>> {
+		const limit = options?.limit ?? 100;
+		const cursor = options?.continuationToken
+			? decodeToken(options.continuationToken)
+			: undefined;
+		const after = cursor
+			? {
+					createdAt: cursor.createdAt as number,
+					suggestionId: cursor.suggestionId as string,
+				}
+			: undefined;
+
+		const rows = await this.db
+			.select()
+			.from(calendarSuggestionTable)
+			.where(
+				and(
+					eq(calendarSuggestionTable.accountConfigId, accountConfigId),
+					eq(calendarSuggestionTable.state, state),
+					after
+						? or(
+								lt(calendarSuggestionTable.createdAt, after.createdAt),
+								and(
+									eq(calendarSuggestionTable.createdAt, after.createdAt),
+									lt(calendarSuggestionTable.suggestionId, after.suggestionId),
+								),
+							)
+						: undefined,
+				),
+			)
+			.orderBy(
+				desc(calendarSuggestionTable.createdAt),
+				desc(calendarSuggestionTable.suggestionId),
+			)
+			.limit(limit);
+
+		const items = rows.map(rowToCalendarSuggestion);
+		const lastItem = items[items.length - 1];
+		return resultList(
+			items,
+			limit,
+			lastItem
+				? {
+						createdAt: lastItem.createdAt,
+						suggestionId: lastItem.suggestionId,
+					}
+				: undefined,
+		);
+	}
+
+	async settle(
+		accountConfigId: string,
+		suggestionId: string,
+		input: SettleCalendarSuggestionInput,
+	): Promise<CalendarSuggestionItem> {
+		const [row] = await this.db
+			.update(calendarSuggestionTable)
+			.set({ ...input, updatedAt: Date.now() })
+			.where(
+				and(
+					eq(calendarSuggestionTable.accountConfigId, accountConfigId),
+					eq(calendarSuggestionTable.suggestionId, suggestionId),
+				),
+			)
+			.returning();
+		if (!row) {
+			throw new NotFoundError(`Calendar suggestion not found: ${suggestionId}`);
+		}
+		return rowToCalendarSuggestion(row);
+	}
+
+	async supersedeIfPending(
+		accountConfigId: string,
+		suggestionId: string,
+	): Promise<CalendarSuggestionItem | null> {
+		const [row] = await this.db
+			.update(calendarSuggestionTable)
+			.set({
+				state: CalendarSuggestionState.Superseded,
+				acceptedCalendarObjectId: "",
+				updatedAt: Date.now(),
+			})
+			.where(
+				and(
+					eq(calendarSuggestionTable.accountConfigId, accountConfigId),
+					eq(calendarSuggestionTable.suggestionId, suggestionId),
+					// The condition is the point: a card the user answered between
+					// the producer's read and this write must keep their answer.
+					eq(calendarSuggestionTable.state, CalendarSuggestionState.Pending),
+				),
+			)
+			.returning();
+		return row ? rowToCalendarSuggestion(row) : null;
+	}
+}

package/src/repos/calendar-unit-of-work.ts

@@ -7,6 +7,7 @@ import { runInTransaction } from "../tx.js";
 import { CalendarCollectionRepo } from "./calendar-collection.js";
 import { CalendarEventIndexRepo } from "./calendar-event-index.js";
 import { CalendarObjectRepo } from "./calendar-object.js";
+import { CalendarSuggestionRepo } from "./calendar-suggestion.js";
 
 type DB = Db<Record<string, unknown>>;
 
@@ -21,6 +22,7 @@ export class DrizzleCalendarUnitOfWork implements ICalendarUnitOfWork {
 				calendarCollection: new CalendarCollectionRepo(tx as never),
 				calendarObject: new CalendarObjectRepo(tx as never),
 				calendarEventIndex: new CalendarEventIndexRepo(tx as never),
+				calendarSuggestion: new CalendarSuggestionRepo(tx as never),
 			}),
 		);
 	}

package/src/schema.ts

@@ -11,6 +11,7 @@ import * as entities from "@remit/drizzle-sqlite-schema";
 export const calendarTable = entities.calendarCollections;
 export const calendarObjectTable = entities.calendarObjects;
 export const calendarEventIndexTable = entities.calendarEventIndexes;
+export const calendarSuggestionTable = entities.calendarSuggestions;
 export const filterAnchorTable = entities.filterAnchors;
 export const filterTable = entities.filters;
 export const labelTable = entities.labels;