@ecsplico/editor 2.0.0 → 2.1.0

package/dist/adapters/comments/drizzle.d.ts

@@ -0,0 +1,430 @@
+import { PortableAnchor } from "../anchors.js";
+import { EditorDb } from "../drizzle.js";
+import { CommentStore } from "./types.js";
+import { SQLiteColumn } from "drizzle-orm/sqlite-core";
+//#region src/adapters/comments/drizzle.d.ts
+declare const COMMENT_TABLES: {
+  annotations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_comment_annotations";
+    schema: undefined;
+    columns: {
+      documentId: SQLiteColumn<{
+        name: "document_id";
+        tableName: "editor_comment_annotations";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      id: SQLiteColumn<{
+        name: "id";
+        tableName: "editor_comment_annotations";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      threadId: SQLiteColumn<{
+        name: "thread_id";
+        tableName: "editor_comment_annotations";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      seq: SQLiteColumn<{
+        name: "seq";
+        tableName: "editor_comment_annotations";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+      anchor: SQLiteColumn<{
+        name: "anchor";
+        tableName: "editor_comment_annotations";
+        dataType: "json";
+        columnType: "SQLiteTextJson";
+        data: PortableAnchor;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        $type: PortableAnchor;
+      }>;
+    };
+    dialect: "sqlite";
+  }>;
+  threads: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_comment_threads";
+    schema: undefined;
+    columns: {
+      documentId: SQLiteColumn<{
+        name: "document_id";
+        tableName: "editor_comment_threads";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      id: SQLiteColumn<{
+        name: "id";
+        tableName: "editor_comment_threads";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      annotationId: SQLiteColumn<{
+        name: "annotation_id";
+        tableName: "editor_comment_threads";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      status: SQLiteColumn<{
+        name: "status";
+        tableName: "editor_comment_threads";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: "open" | "resolved";
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: ["open", "resolved"];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      seq: SQLiteColumn<{
+        name: "seq";
+        tableName: "editor_comment_threads";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "sqlite";
+  }>;
+  comments: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_comments";
+    schema: undefined;
+    columns: {
+      documentId: SQLiteColumn<{
+        name: "document_id";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      threadId: SQLiteColumn<{
+        name: "thread_id";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      id: SQLiteColumn<{
+        name: "id";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      seq: SQLiteColumn<{
+        name: "seq";
+        tableName: "editor_comments";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+      body: SQLiteColumn<{
+        name: "body";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      authorId: SQLiteColumn<{
+        name: "author_id";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      authorName: SQLiteColumn<{
+        name: "author_name";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      authorColor: SQLiteColumn<{
+        name: "author_color";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      createdAt: SQLiteColumn<{
+        name: "created_at";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      editedAt: SQLiteColumn<{
+        name: "edited_at";
+        tableName: "editor_comments";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+    };
+    dialect: "sqlite";
+  }>;
+};
+export type CommentTables = typeof COMMENT_TABLES;
+/**
+ * The tables of the comment store in a SQLite database:
+ *
+ *     editor_comment_annotations(document_id, id, thread_id, seq, anchor json; PK (document_id, id))
+ *     editor_comment_threads(document_id, id, annotation_id, status, seq; PK (document_id, id))
+ *     editor_comments(document_id, thread_id, id, seq, body, author_id, author_name?, author_color?, created_at, edited_at?; PK (document_id, thread_id, id))
+ *
+ * `seq` orders rows within their document (annotations, threads) or thread (comments). Call it from the host's drizzle
+ * schema (so `drizzle-kit` migrates the tables) or use `bootstrapCommentTables` in a host without migrations.
+ */
+export declare const commentTables: () => CommentTables;
+/** `CREATE TABLE IF NOT EXISTS` for the tables of `commentTables()`. */
+export declare function bootstrapCommentTables(db: EditorDb): Promise<void>;
+export interface DrizzleCommentStoreOptions {
+  db: EditorDb;
+  tables: CommentTables;
+}
+/**
+ * The comment store on drizzle tables. Operations are several single statements (no transaction, so it runs on sync and
+ * async drivers) applied one after another per database; a failed `createThread` removes what it had written. A
+ * unique key still protects against a second process writing the same ids. Unlike the JSON store it keeps only the
+ * fields of `Comment`, `Annotation` and `CommentThread`.
+ */
+export declare function createDrizzleCommentStore({ db, tables }: DrizzleCommentStoreOptions): CommentStore;
+//#endregion
+export {};
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/adapters/comments/drizzle.js

@@ -0,0 +1,236 @@
+import { conflict, invalid, notFound } from "./errors.js";
+import { assertNewThread } from "./record.js";
+import { and, eq, sql } from "drizzle-orm";
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+//#region src/adapters/comments/drizzle.ts
+const COMMENT_TABLES = {
+	annotations: sqliteTable("editor_comment_annotations", {
+		documentId: text("document_id").notNull(),
+		id: text("id").notNull(),
+		threadId: text("thread_id").notNull(),
+		seq: integer("seq").notNull(),
+		anchor: text("anchor", { mode: "json" }).$type().notNull()
+	}, (table) => [primaryKey({ columns: [table.documentId, table.id] })]),
+	threads: sqliteTable("editor_comment_threads", {
+		documentId: text("document_id").notNull(),
+		id: text("id").notNull(),
+		annotationId: text("annotation_id").notNull(),
+		status: text("status", { enum: ["open", "resolved"] }).notNull(),
+		seq: integer("seq").notNull()
+	}, (table) => [primaryKey({ columns: [table.documentId, table.id] })]),
+	comments: sqliteTable("editor_comments", {
+		documentId: text("document_id").notNull(),
+		threadId: text("thread_id").notNull(),
+		id: text("id").notNull(),
+		seq: integer("seq").notNull(),
+		body: text("body").notNull(),
+		authorId: text("author_id").notNull(),
+		authorName: text("author_name"),
+		authorColor: text("author_color"),
+		createdAt: text("created_at").notNull(),
+		editedAt: text("edited_at")
+	}, (table) => [primaryKey({ columns: [
+		table.documentId,
+		table.threadId,
+		table.id
+	] })])
+};
+/**
+* The tables of the comment store in a SQLite database:
+*
+*     editor_comment_annotations(document_id, id, thread_id, seq, anchor json; PK (document_id, id))
+*     editor_comment_threads(document_id, id, annotation_id, status, seq; PK (document_id, id))
+*     editor_comments(document_id, thread_id, id, seq, body, author_id, author_name?, author_color?, created_at, edited_at?; PK (document_id, thread_id, id))
+*
+* `seq` orders rows within their document (annotations, threads) or thread (comments). Call it from the host's drizzle
+* schema (so `drizzle-kit` migrates the tables) or use `bootstrapCommentTables` in a host without migrations.
+*/
+const commentTables = () => COMMENT_TABLES;
+/** `CREATE TABLE IF NOT EXISTS` for the tables of `commentTables()`. */
+async function bootstrapCommentTables(db) {
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_comment_annotations (document_id text NOT NULL, id text NOT NULL, thread_id text NOT NULL, seq integer NOT NULL, anchor text NOT NULL, PRIMARY KEY (document_id, id))`);
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_comment_threads (document_id text NOT NULL, id text NOT NULL, annotation_id text NOT NULL, status text NOT NULL, seq integer NOT NULL, PRIMARY KEY (document_id, id))`);
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_comments (document_id text NOT NULL, thread_id text NOT NULL, id text NOT NULL, seq integer NOT NULL, body text NOT NULL, author_id text NOT NULL, author_name text, author_color text, created_at text NOT NULL, edited_at text, PRIMARY KEY (document_id, thread_id, id))`);
+}
+/** Writers on one database of one process run one after another: SQLite has one writer, and each operation is several statements. */
+const queues = /* @__PURE__ */ new WeakMap();
+function serialized(db, action) {
+	const run = (queues.get(db) ?? Promise.resolve()).then(action);
+	const tail = run.catch(() => {});
+	queues.set(db, tail);
+	tail.then(() => {
+		if (queues.get(db) === tail) queues.delete(db);
+	});
+	return run;
+}
+/**
+* The comment store on drizzle tables. Operations are several single statements (no transaction, so it runs on sync and
+* async drivers) applied one after another per database; a failed `createThread` removes what it had written. A
+* unique key still protects against a second process writing the same ids. Unlike the JSON store it keeps only the
+* fields of `Comment`, `Annotation` and `CommentThread`.
+*/
+function createDrizzleCommentStore({ db, tables }) {
+	const { annotations, threads, comments } = tables;
+	const commentOf = (row) => ({
+		id: row.id,
+		body: row.body,
+		authorId: row.authorId,
+		createdAt: row.createdAt,
+		...row.authorName !== null && { authorName: row.authorName },
+		...row.authorColor !== null && { authorColor: row.authorColor },
+		...row.editedAt !== null && { editedAt: row.editedAt }
+	});
+	async function threadRow(documentId, id) {
+		return db.select().from(threads).where(and(eq(threads.documentId, documentId), eq(threads.id, id))).get();
+	}
+	async function threadOf(documentId, id) {
+		const row = await threadRow(documentId, id);
+		if (!row) return void 0;
+		const rows = await db.select().from(comments).where(and(eq(comments.documentId, documentId), eq(comments.threadId, id))).orderBy(comments.seq).all();
+		return {
+			id: row.id,
+			annotationId: row.annotationId,
+			status: row.status,
+			comments: rows.map(commentOf)
+		};
+	}
+	async function requireThread(documentId, id) {
+		const thread = await threadOf(documentId, id);
+		if (!thread) throw notFound("comment thread", id);
+		return thread;
+	}
+	async function discussion(documentId) {
+		const [annotationRows, threadRows, commentRows] = await Promise.all([
+			db.select().from(annotations).where(eq(annotations.documentId, documentId)).orderBy(annotations.seq).all(),
+			db.select().from(threads).where(eq(threads.documentId, documentId)).orderBy(threads.seq).all(),
+			db.select().from(comments).where(eq(comments.documentId, documentId)).orderBy(comments.seq).all()
+		]);
+		return {
+			annotations: annotationRows.map((row) => ({
+				id: row.id,
+				threadId: row.threadId,
+				anchor: row.anchor
+			})),
+			threads: threadRows.map((row) => ({
+				id: row.id,
+				annotationId: row.annotationId,
+				status: row.status,
+				comments: commentRows.filter((comment) => comment.threadId === row.id).map(commentOf)
+			}))
+		};
+	}
+	const nextSeq = async (column, table, where) => {
+		return ((await db.select({ value: sql`coalesce(max(${column}), 0)` }).from(table).where(where).get())?.value ?? 0) + 1;
+	};
+	const insertComment = async (documentId, threadId, comment) => {
+		await db.insert(comments).values({
+			documentId,
+			threadId,
+			id: comment.id,
+			seq: await nextSeq(comments.seq, comments, and(eq(comments.documentId, documentId), eq(comments.threadId, threadId))),
+			body: comment.body,
+			authorId: comment.authorId,
+			authorName: comment.authorName ?? null,
+			authorColor: comment.authorColor ?? null,
+			createdAt: comment.createdAt,
+			editedAt: comment.editedAt ?? null
+		}).run();
+	};
+	const write = (action) => serialized(db, action);
+	return {
+		getDiscussion: discussion,
+		getThread: (documentId, threadId) => threadOf(documentId, threadId),
+		async listThreads(documentId) {
+			return (await discussion(documentId)).threads;
+		},
+		createThread: (documentId, input) => write(async () => {
+			assertNewThread(input);
+			const { annotation, thread } = input;
+			if (await db.select({ id: annotations.id }).from(annotations).where(and(eq(annotations.documentId, documentId), eq(annotations.id, annotation.id))).get()) throw conflict(`Annotation "${annotation.id}" already exists.`);
+			if (await threadRow(documentId, thread.id)) throw conflict(`Comment thread "${thread.id}" already exists.`);
+			try {
+				await db.insert(annotations).values({
+					documentId,
+					id: annotation.id,
+					threadId: annotation.threadId,
+					seq: await nextSeq(annotations.seq, annotations, eq(annotations.documentId, documentId)),
+					anchor: annotation.anchor
+				}).run();
+				await db.insert(threads).values({
+					documentId,
+					id: thread.id,
+					annotationId: thread.annotationId,
+					status: "open",
+					seq: await nextSeq(threads.seq, threads, eq(threads.documentId, documentId))
+				}).run();
+				await insertComment(documentId, thread.id, thread.initialComment);
+			} catch (error) {
+				await db.delete(comments).where(and(eq(comments.documentId, documentId), eq(comments.threadId, thread.id))).run();
+				await db.delete(threads).where(and(eq(threads.documentId, documentId), eq(threads.id, thread.id))).run();
+				await db.delete(annotations).where(and(eq(annotations.documentId, documentId), eq(annotations.id, annotation.id))).run();
+				throw error;
+			}
+			return {
+				annotation: structuredClone(annotation),
+				thread: await requireThread(documentId, thread.id)
+			};
+		}),
+		addComment: (documentId, threadId, comment) => write(async () => {
+			await requireThread(documentId, threadId);
+			if (await db.select({ id: comments.id }).from(comments).where(and(eq(comments.documentId, documentId), eq(comments.threadId, threadId), eq(comments.id, comment.id))).get()) throw conflict(`Comment "${comment.id}" already exists in thread "${threadId}".`);
+			await insertComment(documentId, threadId, comment);
+			return requireThread(documentId, threadId);
+		}),
+		editComment: (documentId, threadId, commentId, body, editedAt) => write(async () => {
+			if (!(await requireThread(documentId, threadId)).comments.some((comment) => comment.id === commentId)) throw notFound("comment", commentId);
+			await db.update(comments).set({
+				body,
+				editedAt
+			}).where(and(eq(comments.documentId, documentId), eq(comments.threadId, threadId), eq(comments.id, commentId))).run();
+			return requireThread(documentId, threadId);
+		}),
+		removeComment: (documentId, threadId, commentId) => write(async () => {
+			const index = (await requireThread(documentId, threadId)).comments.findIndex((comment) => comment.id === commentId);
+			if (index < 0) throw notFound("comment", commentId);
+			if (index === 0) throw invalid("The first comment of a thread cannot be removed on its own; remove the thread.");
+			await db.delete(comments).where(and(eq(comments.documentId, documentId), eq(comments.threadId, threadId), eq(comments.id, commentId))).run();
+			return requireThread(documentId, threadId);
+		}),
+		setThreadStatus: (documentId, threadId, status) => write(async () => {
+			await requireThread(documentId, threadId);
+			await db.update(threads).set({ status }).where(and(eq(threads.documentId, documentId), eq(threads.id, threadId))).run();
+			return requireThread(documentId, threadId);
+		}),
+		updateAnchor: (documentId, annotation) => write(async () => {
+			const row = await db.select().from(annotations).where(and(eq(annotations.documentId, documentId), eq(annotations.id, annotation.id))).get();
+			if (!row) throw notFound("annotation", annotation.id);
+			if (row.threadId !== annotation.threadId) throw invalid("An annotation cannot move to another thread.");
+			await db.update(annotations).set({ anchor: annotation.anchor }).where(and(eq(annotations.documentId, documentId), eq(annotations.id, annotation.id))).run();
+			return structuredClone(annotation);
+		}),
+		removeThread: (documentId, threadId) => write(async () => {
+			await db.delete(comments).where(and(eq(comments.documentId, documentId), eq(comments.threadId, threadId))).run();
+			await db.delete(threads).where(and(eq(threads.documentId, documentId), eq(threads.id, threadId))).run();
+			await db.delete(annotations).where(and(eq(annotations.documentId, documentId), eq(annotations.threadId, threadId))).run();
+		}),
+		removeDocuments: (prefix) => write(async () => {
+			const under = (column) => sql`substr(${sql.identifier(column.name)}, 1, ${prefix.length}) = ${prefix}`;
+			const documents = /* @__PURE__ */ new Set();
+			for (const [table, column] of [
+				[annotations, annotations.documentId],
+				[threads, threads.documentId],
+				[comments, comments.documentId]
+			]) for (const row of await db.selectDistinct({ documentId: column }).from(table).where(under(column)).all()) documents.add(row.documentId);
+			for (const [table, column] of [
+				[comments, comments.documentId],
+				[threads, threads.documentId],
+				[annotations, annotations.documentId]
+			]) await db.delete(table).where(under(column)).run();
+			return documents.size;
+		})
+	};
+}
+//#endregion
+export { bootstrapCommentTables, commentTables, createDrizzleCommentStore };
+
+//# sourceMappingURL=drizzle.js.map