@remit/drizzle-service 0.0.102 → 0.0.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.102",
+  "version": "0.0.104",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",
@@ -25,14 +25,15 @@
     "@remit/calendar-service": "*",
     "@remit/config-transfer": "*",
     "drizzle-kit": "^0.31.1",
+    "miniflare": "^4.20260730.0",
     "tsx": "*"
   },
   "dependencies": {
     "@remit/data-ports": "*",
     "@remit/domain-enums": "*",
     "drizzle-orm": "^0.45.2",
-    "short-uuid": "*",
-    "uuid": "*",
+    "short-uuid": "^6.0.3",
+    "uuid": "^13.0.2",
     "@remit/drizzle-sqlite-schema": "*",
     "better-sqlite3": "^12.11.1",
     "@types/better-sqlite3": "^7.6.13"

package/src/batch.sqlite.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { after, before, describe, test } from "node:test";
 import { eq } from "drizzle-orm";
-import { runBatch } from "./batch.js";
+import { syncBatch } from "./batch.js";
 import { calendarTable } from "./schema.js";
 import { createSqliteTestDb, type SqliteTestDb } from "./test-db-sqlite.js";
 
@@ -36,7 +36,7 @@ describe("a batch on better-sqlite3", () => {
 	const stored = () => db.select().from(calendarTable);
 
 	test("answers each statement in order, reads seeing the writes before them", async () => {
-		const [inserted, read] = await runBatch(db, [
+		const [inserted, read] = await syncBatch(db)([
 			db.insert(calendarTable).values(collection("first")).returning(),
 			db
 				.select()
@@ -58,7 +58,7 @@ describe("a batch on better-sqlite3", () => {
 		const before = await stored();
 
 		await assert.rejects(
-			runBatch(db, [
+			syncBatch(db)([
 				db.insert(calendarTable).values(collection("second")),
 				db
 					.update(calendarTable)
@@ -73,6 +73,6 @@ describe("a batch on better-sqlite3", () => {
 	});
 
 	test("an empty batch writes nothing and answers nothing", async () => {
-		assert.deepEqual(await runBatch(db, []), []);
+		assert.deepEqual(await syncBatch(db)([]), []);
 	});
 });

package/src/batch.ts

@@ -3,6 +3,26 @@ import type { Db } from "./db.js";
 
 export type SqliteBatchItem = BatchItem<"sqlite">;
 
+/**
+ * The one write port a repository is handed for a write set, bound to one
+ * database. It has the shape of D1's `batch()`: every statement commits
+ * together or not at all, and none of them reads another's result mid-flight.
+ * A write that needs a value reads it before the batch and is written so a
+ * stale read loses safely (a conditional `WHERE`, an upsert, a deterministic
+ * id).
+ */
+export type WriteBatch = <T extends readonly SqliteBatchItem[]>(
+	items: T,
+) => Promise<BatchResponse<T>>;
+
+type NonEmptyBatch = readonly [SqliteBatchItem, ...SqliteBatchItem[]];
+
+export interface BatchingDatabase {
+	batch<U extends SqliteBatchItem, T extends Readonly<[U, ...U[]]>>(
+		batch: T,
+	): Promise<BatchResponse<T>>;
+}
+
 interface SyncPreparable {
 	_prepare(): { execute(): { sync(): unknown } };
 }
@@ -12,6 +32,10 @@ const isSyncPreparable = (value: unknown): value is SyncPreparable =>
 	value !== null &&
 	typeof Reflect.get(value, "_prepare") === "function";
 
+const isNonEmpty = <T extends readonly SqliteBatchItem[]>(
+	items: T,
+): items is T & NonEmptyBatch => items.length > 0;
+
 const runSync = (item: SqliteBatchItem): unknown => {
 	if (!isSyncPreparable(item)) {
 		throw new TypeError("batch item is not a drizzle sqlite query");
@@ -19,28 +43,30 @@ const runSync = (item: SqliteBatchItem): unknown => {
 	return item._prepare().execute().sync();
 };
 
+const emptyResponse = <
+	T extends readonly SqliteBatchItem[],
+>(): BatchResponse<T> => [] as unknown as BatchResponse<T>;
+
 /**
- * The shape of D1's `batch()`: every statement commits together or not at all,
- * and none of them reads another's result mid-flight. A write that needs a
- * value reads it before the batch and is written so a stale read loses safely
- * (a conditional `WHERE`, an upsert, a deterministic id).
- *
- * On better-sqlite3 the batch is one synchronous IMMEDIATE transaction: it
- * never yields the event loop, so no other write on the shared connection lands
- * inside it, and IMMEDIATE takes the file's write lock before the first
+ * A batch as one synchronous transaction. On better-sqlite3 it is IMMEDIATE:
+ * it never yields the event loop, so no other write on the shared connection
+ * lands inside it, and it takes the file's write lock before the first
  * statement so a writer in another process waits out the busy timeout. On a
  * Durable Object's `durable-sqlite` handle it is one `transactionSync`.
  */
-export const runBatch = async <
-	TSchema extends Record<string, unknown>,
-	T extends readonly SqliteBatchItem[],
->(
-	db: Db<TSchema>,
-	items: T,
-): Promise<BatchResponse<T>> => {
-	if (items.length === 0) return [] as unknown as BatchResponse<T>;
-	const results = db.transaction(() => items.map(runSync), {
-		behavior: "immediate",
-	});
-	return results as unknown as BatchResponse<T>;
-};
+export const syncBatch =
+	<TSchema extends Record<string, unknown>>(db: Db<TSchema>): WriteBatch =>
+	async (items) => {
+		if (items.length === 0) return emptyResponse();
+		const results = db.transaction(() => items.map(runSync), {
+			behavior: "immediate",
+		});
+		return results as unknown as BatchResponse<typeof items>;
+	};
+
+export const asyncBatch =
+	(db: BatchingDatabase): WriteBatch =>
+	async (items) => {
+		if (!isNonEmpty(items)) return emptyResponse();
+		return db.batch(items);
+	};

package/src/databases.ts

@@ -1,8 +1,6 @@
-import type { Db } from "./db.js";
-import {
-	type MessageDataSchema,
-	messageDataSchema,
-} from "./schema/message-data.js";
+import { syncBatch } from "./batch.js";
+import type { Db, SqliteStore } from "./db.js";
+import { messageDataSchema } from "./schema/message-data.js";
 import { createSqliteDatabase } from "./sqlite-client.js";
 
 // The three databases a self-host instance runs on (#1420). The app database
@@ -12,10 +10,30 @@ import { createSqliteDatabase } from "./sqlite-client.js";
 // rebuilt from the mail database, so it never commits together with it.
 export interface SqliteDatabases {
 	app: Db<Record<string, unknown>>;
-	mail: Db<MessageDataSchema>;
+	mail: Db<Record<string, unknown>>;
 	search: Db<Record<string, unknown>>;
 }
 
+export interface SqliteStores {
+	app: SqliteStore<Record<string, unknown>>;
+	mail: SqliteStore<Record<string, unknown>>;
+	search: SqliteStore<Record<string, unknown>>;
+}
+
+export const syncStore = <TSchema extends Record<string, unknown>>(
+	db: Db<TSchema>,
+): SqliteStore<TSchema> => ({ db, batch: syncBatch(db) });
+
+export const syncStores = ({
+	app,
+	mail,
+	search,
+}: SqliteDatabases): SqliteStores => ({
+	app: syncStore(app),
+	mail: syncStore(mail),
+	search: syncStore(search),
+});
+
 export interface SqliteDatabasePaths {
 	app: string;
 	mail: string;

package/src/db.ts

@@ -1,14 +1,29 @@
 import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+import type { WriteBatch } from "./batch.js";
 
 /**
- * The drizzle handle a repository runs on: any synchronous SQLite driver.
- *
- * better-sqlite3 is the one this package opens; a Cloudflare Durable Object's
- * `durable-sqlite` handle satisfies it too, so its adapter constructs the same
- * repositories over its own storage.
+ * A synchronous SQLite handle: better-sqlite3, or a Cloudflare Durable
+ * Object's `durable-sqlite`. Only `syncBatch` and the better-sqlite3
+ * composition name it; a repository never does.
  */
 export type Db<TSchema extends Record<string, unknown>> = BaseSQLiteDatabase<
 	"sync",
 	unknown,
 	TSchema
 >;
+
+/**
+ * The handle a repository runs on: any SQLite driver, synchronous or not
+ * (better-sqlite3, Durable Object storage, D1, libsql). It has no
+ * `transaction` and no `batch`, so a repository writes a set through the
+ * injected `WriteBatch` and cannot open an interactive transaction (C5).
+ */
+export type RepositoryDb<TSchema extends Record<string, unknown>> = Omit<
+	BaseSQLiteDatabase<"sync" | "async", unknown, TSchema>,
+	"transaction" | "batch"
+>;
+
+export interface SqliteStore<TSchema extends Record<string, unknown>> {
+	db: RepositoryDb<TSchema>;
+	batch: WriteBatch;
+}

package/src/index.ts

@@ -1,11 +1,22 @@
+export {
+	asyncBatch,
+	type BatchingDatabase,
+	type SqliteBatchItem,
+	syncBatch,
+	type WriteBatch,
+} from "./batch.js";
 export {
 	hasSqliteDatabaseEnv,
 	openSqliteDatabases,
 	SQLITE_DATABASE_ENV,
 	type SqliteDatabasePaths,
 	type SqliteDatabases,
+	type SqliteStores,
 	sqliteDatabasePathsFromEnv,
+	syncStore,
+	syncStores,
 } from "./databases.js";
+export type { RepositoryDb, SqliteStore } from "./db.js";
 export { CreateFailedConflictError, NotFoundError } from "./error.js";
 export { CalendarCollectionRepo } from "./repos/calendar-collection.js";
 export { CalendarEventIndexRepo } from "./repos/calendar-event-index.js";
@@ -79,6 +90,7 @@ export {
 	type SqliteClientOptions,
 } from "./sqlite-client.js";
 export {
+	composeSqliteRepositories,
 	createSqliteRepositories,
 	type SqliteRepositories,
 } from "./sqlite-repositories.js";

package/src/repair/junk-only-address.sqlite.test.ts

@@ -5,7 +5,8 @@ import { CanonicalMailboxRole } from "@remit/domain-enums";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { AccountSettingRepo } from "../repos/i4-account-setting.js";
-import { MailboxSpecialUseRepo } from "../repos/i4-mailbox-special-use.js";
+import type { MailboxSpecialUseRepo } from "../repos/i4-mailbox-special-use.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { applyMigrationSet } from "../test-shipped-sqlite-schema.js";
 import {
 	type JunkOnlyRepairClient,
@@ -181,7 +182,11 @@ describe("addresses standing only on mail in Junk", () => {
 	before(() => {
 		sqlite = new Database(":memory:");
 		const db = drizzle(sqlite);
-		specialUse = new MailboxSpecialUseRepo(db as never, db as never);
+		specialUse = createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).mailboxSpecialUse;
 		accountSetting = new AccountSettingRepo(db as never);
 		applyMigrationSet(sqlite, "app");
 		applyMigrationSet(sqlite, "mail");

package/src/repos/account.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { accountRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { composeSqliteRepositories } from "../sqlite-repositories.js";
+import { openD1TestStores } from "../test-d1.js";
+
+let close: (() => Promise<void>) | undefined;
+
+accountRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return composeSqliteRepositories(opened.stores).account;
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

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

@@ -2,8 +2,8 @@ import { accountRepositoryConformance } from "@remit/data-ports/conformance";
 import { NotFoundError } from "../error.js";
 import { randomId } from "../id.js";
 import { accountTable } from "../schema.js";
+import { createSqliteRepositories } from "../sqlite-repositories.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
-import { AccountRepo } from "./i4-account.js";
 
 let close: (() => Promise<void>) | undefined;
 
@@ -13,7 +13,11 @@ accountRepositoryConformance({
 			accounts: accountTable,
 		});
 		close = closeDb;
-		return new AccountRepo(db as never, db as never);
+		return createSqliteRepositories({
+			app: db,
+			mail: db,
+			search: db,
+		}).account;
 	},
 	teardown: async () => {
 		await close?.();

package/src/repos/calendar-collection.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { calendarCollectionRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarCollectionRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarCollectionRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-collection.ts

@@ -9,11 +9,11 @@ import {
 	normalizeCalendarUrlSegment,
 } from "@remit/data-ports/id";
 import { and, asc, eq, sql } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { calendarTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToCalendar(
 	row: typeof calendarTable.$inferSelect,

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

@@ -0,0 +1,4 @@
+import { openD1TestStores } from "../test-d1.js";
+import { calendarDefaultSuite } from "./calendar-default.suite.js";
+
+calendarDefaultSuite(openD1TestStores);

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

@@ -1,73 +1,4 @@
-import assert from "node:assert/strict";
-import { after, before, describe, test } from "node:test";
-import { provisionDefaultCalendar } from "@remit/calendar-service";
-import type { ICalendarStore } 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 { DrizzleCalendarStore } from "./calendar-store.js";
+import { openCalendarSqliteTestStores } from "../test-stores.js";
+import { calendarDefaultSuite } from "./calendar-default.suite.js";
 
-const ACCOUNT_CONFIG_ID = "account-config-default";
-
-describe("provisioning the default calendar", () => {
-	let db: Db<Record<string, unknown>>;
-	let close: () => Promise<void>;
-	let store: ICalendarStore;
-
-	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;
-		store = new DrizzleCalendarStore(db, 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(store, 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(
-			store,
-			ACCOUNT_CONFIG_ID,
-			"A different name",
-		);
-
-		assert.equal(again.calendarId, before.calendarId);
-		assert.equal(again.displayName, before.displayName);
-		assert.equal(again.syncSequence, 1);
-	});
-});
+calendarDefaultSuite(openCalendarSqliteTestStores);

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

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { provisionDefaultCalendar } from "@remit/calendar-service";
+import type { ICalendarStore } from "@remit/data-ports";
+import type { RepositoryDb } from "../db.js";
+import { composeSqliteRepositories } from "../sqlite-repositories.js";
+import type { OpenTestStores } from "../test-stores.js";
+import { CalendarCollectionRepo } from "./calendar-collection.js";
+
+const ACCOUNT_CONFIG_ID = "account-config-default";
+
+export const calendarDefaultSuite = (open: OpenTestStores): void => {
+	describe("provisioning the default calendar", () => {
+		let db: RepositoryDb<Record<string, unknown>>;
+		let close: () => Promise<void>;
+		let store: ICalendarStore;
+
+		before(async () => {
+			const opened = await open();
+			db = opened.stores.app.db;
+			close = opened.close;
+			store = composeSqliteRepositories(opened.stores).calendarStore;
+		});
+
+		after(() => close());
+
+		test("leaves one calendar behind when several first reads arrive together", async () => {
+			const provisioned = await Promise.all(
+				Array.from({ length: 8 }, () =>
+					provisionDefaultCalendar(store, 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(
+				store,
+				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.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { calendarEventIndexRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarEventIndexRepo } from "./calendar-event-index.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarEventIndexRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarEventIndexRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

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

@@ -4,10 +4,10 @@ import type {
 	ICalendarEventIndexRepository,
 } from "@remit/data-ports";
 import { and, asc, eq, gte, lt } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { calendarEventIndexTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToOccurrence(
 	row: typeof calendarEventIndexTable.$inferSelect,

package/src/repos/calendar-feed-token.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { calendarFeedTokenRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarFeedTokenRepo } from "./calendar-feed-token.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarFeedTokenRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarFeedTokenRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-feed-token.ts

@@ -5,10 +5,10 @@ import type {
 } from "@remit/data-ports";
 import { deriveCalendarFeedTokenId } from "@remit/data-ports/id";
 import { and, eq } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { calendarFeedTokenTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToFeedToken(
 	row: typeof calendarFeedTokenTable.$inferSelect,

package/src/repos/calendar-object.conformance.d1.test.ts

@@ -0,0 +1,20 @@
+import { calendarObjectRepositoryConformance } from "@remit/data-ports/conformance";
+import { NotFoundError } from "../error.js";
+import { randomId } from "../id.js";
+import { openD1TestStores } from "../test-d1.js";
+import { CalendarObjectRepo } from "./calendar-object.js";
+
+let close: (() => Promise<void>) | undefined;
+
+calendarObjectRepositoryConformance({
+	async createRepository() {
+		const opened = await openD1TestStores();
+		close = opened.close;
+		return new CalendarObjectRepo(opened.stores.app.db);
+	},
+	teardown: async () => {
+		await close?.();
+	},
+	makeId: () => randomId(),
+	isNotFoundError: (error) => error instanceof NotFoundError,
+});

package/src/repos/calendar-object.ts

@@ -5,11 +5,11 @@ import type {
 } from "@remit/data-ports";
 import { deriveCalendarObjectId } from "@remit/data-ports/id";
 import { and, asc, eq, gt, gte, lt, ne } from "drizzle-orm";
-import type { Db } from "../db.js";
+import type { RepositoryDb } from "../db.js";
 import { NotFoundError } from "../error.js";
 import { calendarObjectTable } from "../schema.js";
 
-type DB = Db<Record<string, unknown>>;
+type DB = RepositoryDb<Record<string, unknown>>;
 
 function rowToCalendarObject(
 	row: typeof calendarObjectTable.$inferSelect,

package/src/repos/calendar-put.d1.test.ts

@@ -0,0 +1,4 @@
+import { openD1TestStores } from "../test-d1.js";
+import { calendarPutSuite } from "./calendar-put.suite.js";
+
+calendarPutSuite(openD1TestStores);