@ecsplico/editor 1.0.0 → 2.1.0

package/dist/adapters/documents.js

@@ -0,0 +1,108 @@
+import { settingsKey } from "./shared.js";
+import { HttpError } from "../server/errors.js";
+import { authenticated, empty, json } from "../server/handlers/context.js";
+import { handleCommentsRequest } from "./comments/server.js";
+//#region src/adapters/documents.ts
+const isDocument = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "doc";
+function documentId(request) {
+	const id = request.params?.id;
+	if (!id) throw new HttpError(400, "Dokument-ID fehlt");
+	return id;
+}
+/** The user and what they may do with document `id`: 403 when the adapter's `authorize` refuses. */
+async function accessOf(ctx, request, id) {
+	const user = await authenticated(ctx, request);
+	const access = ctx.adapter.authorize ? await ctx.adapter.authorize(user, id) : { readOnly: false };
+	if (!access) throw new HttpError(403, "Kein Zugriff auf dieses Dokument");
+	return {
+		user,
+		readOnly: access.readOnly
+	};
+}
+/**
+* The document's TipTap JSON: the live content when the collaboration server has the document open (unsaved edits
+* included), else what the adapter stores; `404` when there is none.
+*/
+async function documentGet(ctx, request) {
+	const id = documentId(request);
+	await accessOf(ctx, request, id);
+	const content = ctx.collab?.liveContent(id) ?? await ctx.adapter.loadContent(id);
+	if (!content) throw new HttpError(404, "Dokument nicht gefunden");
+	return json(content);
+}
+/**
+* Stores the request's TipTap JSON (`400` for anything but a `{ type: 'doc' }` object, `403` for a read-only user).
+* Creates the document on adapters that manage documents (`putDocument`); on the others only existing documents can be saved.
+*/
+async function documentPut(ctx, request) {
+	const id = documentId(request);
+	const { readOnly } = await accessOf(ctx, request, id);
+	if (readOnly) throw new HttpError(403, "Dokument ist schreibgeschützt");
+	let body;
+	try {
+		body = await request.readJson?.();
+	} catch {
+		throw new HttpError(400, "Ungültiger JSON-Body");
+	}
+	if (!isDocument(body)) throw new HttpError(400, "Der Body muss ein TipTap-Dokument sein ({ \"type\": \"doc\", … })");
+	if (ctx.adapter.putDocument) await ctx.adapter.putDocument(id, body);
+	else if (await ctx.adapter.loadContent(id)) await ctx.adapter.storeContent(id, body);
+	else throw new HttpError(404, "Dokument nicht gefunden");
+	return empty();
+}
+/** `GET`: the document's `Discussion`. */
+async function commentsGet(ctx, request) {
+	const id = documentId(request);
+	await accessOf(ctx, request, id);
+	const { status, body } = await handleCommentsRequest(ctx.store, {
+		method: "GET",
+		documentId: id
+	});
+	return json(body, status);
+}
+const recordOf = (value) => typeof value === "object" && value !== null ? value : {};
+/** The comment authors a `CommentAction` writes (new comments) or touches (edits and deletions of existing ones). */
+async function authorsOf(store, id, body) {
+	const authorOf = (comment) => {
+		const { authorId } = recordOf(comment);
+		return typeof authorId === "string" ? [authorId] : [];
+	};
+	switch (body.action) {
+		case "create": return authorOf(recordOf(body.thread).initialComment);
+		case "reply": return authorOf(body.comment);
+		case "edit":
+		case "remove-comment": {
+			const comment = (await store.getDiscussion(id)).threads.find((candidate) => candidate.id === body.threadId)?.comments.find((candidate) => candidate.id === body.commentId);
+			return comment ? [comment.authorId] : [];
+		}
+		default: return [];
+	}
+}
+/**
+* `POST` with a `CommentAction` (see `handleCommentsRequest`). The handler trusts its caller, so this route does the
+* authorising: read-only users write nothing, and a user only writes comments under their own id and only edits or
+* deletes their own comments (`403` otherwise).
+*/
+async function commentsPost(ctx, request) {
+	const id = documentId(request);
+	const { user, readOnly } = await accessOf(ctx, request, id);
+	if (readOnly) throw new HttpError(403, "Dokument ist schreibgeschützt");
+	let body;
+	try {
+		body = await request.readJson?.();
+	} catch {
+		throw new HttpError(400, "Ungültiger JSON-Body");
+	}
+	const self = settingsKey(user);
+	if ((await authorsOf(ctx.store, id, recordOf(body))).some((author) => author !== self)) throw new HttpError(403, "Kommentare dürfen nur unter der eigenen Kennung geschrieben und geändert werden");
+	const { status, body: answer } = await handleCommentsRequest(ctx.store, {
+		method: "POST",
+		documentId: id,
+		body
+	});
+	return json(answer, status);
+}
+//#endregion
+export { commentsGet, commentsPost, documentGet, documentPut };
+
+//# sourceMappingURL=documents.js.map

package/dist/adapters/documents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.js","names":[],"sources":["../../src/adapters/documents.ts"],"sourcesContent":["import type { JSONContent } from '@tiptap/core'\nimport { HttpError } from '../server'\nimport { authenticated, empty, type HandlerContext, type HandlerRequest, type HandlerResponse, json } from '../server/handlers'\nimport { settingsKey, type DocumentAdmin } from './shared'\nimport { handleCommentsRequest } from './comments/server'\nimport type { CommentStore, Discussion } from './comments/types'\n\n// Framework-free handlers of the two routes this package adds to the editor's own (`/api/editor/*`): a document's\n// content (what `useEditorDocument` loads and saves) and its comments endpoint. They follow the editor's handler shape\n// (`(ctx, request) => HandlerResponse`, `HttpError` for refusals), so any HTTP server can mount them; `./server/nitro`\n// does so for Nitro. Authentication is the adapter's `authenticate`, per-document access its optional `authorize`.\n\n/** What the document handlers need: the editor's handler context, whose adapter may also manage documents (`json`, `drizzle`). */\nexport interface DocumentsContext extends HandlerContext {\n  adapter: HandlerContext['adapter'] & Partial<DocumentAdmin>\n}\n\nconst isDocument = (value: unknown): value is JSONContent => typeof value === 'object' && value !== null && 'type' in value && value.type === 'doc'\n\nfunction documentId(request: HandlerRequest): string {\n  const id = request.params?.id\n  if (!id) throw new HttpError(400, 'Dokument-ID fehlt')\n  return id\n}\n\n/** The user and what they may do with document `id`: 403 when the adapter's `authorize` refuses. */\nasync function accessOf(ctx: DocumentsContext, request: HandlerRequest, id: string): Promise<{ user: object, readOnly: boolean }> {\n  const user = await authenticated(ctx, request)\n  const access = ctx.adapter.authorize ? await ctx.adapter.authorize(user, id) : { readOnly: false }\n  if (!access) throw new HttpError(403, 'Kein Zugriff auf dieses Dokument')\n  return { user, readOnly: access.readOnly }\n}\n\n/**\n * The document's TipTap JSON: the live content when the collaboration server has the document open (unsaved edits\n * included), else what the adapter stores; `404` when there is none.\n */\nexport async function documentGet(ctx: DocumentsContext, request: HandlerRequest): Promise<HandlerResponse> {\n  const id = documentId(request)\n  await accessOf(ctx, request, id)\n  const content = ctx.collab?.liveContent(id) ?? await ctx.adapter.loadContent(id)\n  if (!content) throw new HttpError(404, 'Dokument nicht gefunden')\n  return json(content)\n}\n\n/**\n * Stores the request's TipTap JSON (`400` for anything but a `{ type: 'doc' }` object, `403` for a read-only user).\n * Creates the document on adapters that manage documents (`putDocument`); on the others only existing documents can be saved.\n */\nexport async function documentPut(ctx: DocumentsContext, request: HandlerRequest): Promise<HandlerResponse> {\n  const id = documentId(request)\n  const { readOnly } = await accessOf(ctx, request, id)\n  if (readOnly) throw new HttpError(403, 'Dokument ist schreibgeschützt')\n  let body: unknown\n  try {\n    body = await request.readJson?.()\n  }\n  catch {\n    throw new HttpError(400, 'Ungültiger JSON-Body')\n  }\n  if (!isDocument(body)) throw new HttpError(400, 'Der Body muss ein TipTap-Dokument sein ({ \"type\": \"doc\", … })')\n  if (ctx.adapter.putDocument) await ctx.adapter.putDocument(id, body)\n  else if (await ctx.adapter.loadContent(id)) await ctx.adapter.storeContent(id, body)\n  else throw new HttpError(404, 'Dokument nicht gefunden')\n  return empty()\n}\n\nexport interface CommentsRouteContext extends DocumentsContext {\n  store: CommentStore\n}\n\n/** `GET`: the document's `Discussion`. */\nexport async function commentsGet(ctx: CommentsRouteContext, request: HandlerRequest): Promise<HandlerResponse> {\n  const id = documentId(request)\n  await accessOf(ctx, request, id)\n  const { status, body } = await handleCommentsRequest(ctx.store, { method: 'GET', documentId: id })\n  return json(body, status)\n}\n\nconst recordOf = (value: unknown): Record<string, unknown> => typeof value === 'object' && value !== null ? value as Record<string, unknown> : {}\n\n/** The comment authors a `CommentAction` writes (new comments) or touches (edits and deletions of existing ones). */\nasync function authorsOf(store: CommentStore, id: string, body: Record<string, unknown>): Promise<string[]> {\n  // A malformed comment has no author to compare; the handler answers it with 400.\n  const authorOf = (comment: unknown) => {\n    const { authorId } = recordOf(comment)\n    return typeof authorId === 'string' ? [authorId] : []\n  }\n  switch (body.action) {\n    case 'create':\n      return authorOf(recordOf(body.thread).initialComment)\n    case 'reply':\n      return authorOf(body.comment)\n    case 'edit':\n    case 'remove-comment': {\n      const discussion: Discussion = await store.getDiscussion(id)\n      const thread = discussion.threads.find(candidate => candidate.id === body.threadId)\n      const comment = thread?.comments.find(candidate => candidate.id === body.commentId)\n      // An unknown id is the handler's 404, not an authorisation question.\n      return comment ? [comment.authorId] : []\n    }\n    default:\n      return []\n  }\n}\n\n/**\n * `POST` with a `CommentAction` (see `handleCommentsRequest`). The handler trusts its caller, so this route does the\n * authorising: read-only users write nothing, and a user only writes comments under their own id and only edits or\n * deletes their own comments (`403` otherwise).\n */\nexport async function commentsPost(ctx: CommentsRouteContext, request: HandlerRequest): Promise<HandlerResponse> {\n  const id = documentId(request)\n  const { user, readOnly } = await accessOf(ctx, request, id)\n  if (readOnly) throw new HttpError(403, 'Dokument ist schreibgeschützt')\n  let body: unknown\n  try {\n    body = await request.readJson?.()\n  }\n  catch {\n    throw new HttpError(400, 'Ungültiger JSON-Body')\n  }\n  const self = settingsKey(user)\n  if ((await authorsOf(ctx.store, id, recordOf(body))).some(author => author !== self)) throw new HttpError(403, 'Kommentare dürfen nur unter der eigenen Kennung geschrieben und geändert werden')\n  const { status, body: answer } = await handleCommentsRequest(ctx.store, { method: 'POST', documentId: id, body })\n  return json(answer, status)\n}\n"],"mappings":"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"}

package/dist/adapters/drizzle.d.ts

@@ -0,0 +1,293 @@
+import { AssetRecord } from "../features/media/assets.js";
+import "../features/media/schema.js";
+import { AdapterHooks, StoredEditorAdapter } from "./shared.js";
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+import { JSONContent } from "@tiptap/core";
+//#region src/adapters/drizzle.d.ts
+declare const EDITOR_TABLES: {
+  documents: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_documents";
+    schema: undefined;
+    columns: {
+      id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "id";
+        tableName: "editor_documents";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "content";
+        tableName: "editor_documents";
+        dataType: "json";
+        columnType: "SQLiteTextJson";
+        data: JSONContent;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        $type: JSONContent;
+      }>;
+      version: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "version";
+        tableName: "editor_documents";
+        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;
+      }>;
+      updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "updated_at";
+        tableName: "editor_documents";
+        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;
+      }>;
+    };
+    dialect: "sqlite";
+  }>;
+  states: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_states";
+    schema: undefined;
+    columns: {
+      id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "id";
+        tableName: "editor_states";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      state: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "state";
+        tableName: "editor_states";
+        dataType: "buffer";
+        columnType: "SQLiteBlobBuffer";
+        data: Buffer<ArrayBufferLike>;
+        driverParam: Buffer<ArrayBufferLike>;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "sqlite";
+  }>;
+  settings: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_settings";
+    schema: undefined;
+    columns: {
+      userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "user_id";
+        tableName: "editor_settings";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      json: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "json";
+        tableName: "editor_settings";
+        dataType: "json";
+        columnType: "SQLiteTextJson";
+        data: unknown;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        $type: unknown;
+      }>;
+    };
+    dialect: "sqlite";
+  }>;
+  assets: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "editor_assets";
+    schema: undefined;
+    columns: {
+      id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "id";
+        tableName: "editor_assets";
+        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;
+      }>;
+      name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "name";
+        tableName: "editor_assets";
+        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;
+      }>;
+      record: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "record";
+        tableName: "editor_assets";
+        dataType: "json";
+        columnType: "SQLiteTextJson";
+        data: AssetRecord;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        $type: AssetRecord;
+      }>;
+      data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "data";
+        tableName: "editor_assets";
+        dataType: "buffer";
+        columnType: "SQLiteBlobBuffer";
+        data: Buffer<ArrayBufferLike>;
+        driverParam: Buffer<ArrayBufferLike>;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "sqlite";
+  }>;
+};
+export type EditorTables = typeof EDITOR_TABLES;
+/**
+ * The tables of the editor's storage in a SQLite database (`bun:sqlite`, better-sqlite3, libsql, D1):
+ *
+ *     editor_documents(id PK, content json, version text, updated_at text)   TipTap JSON + opaque content version
+ *     editor_states(id PK, state blob)                                        the collab server's state bytes
+ *     editor_settings(user_id PK, json json)                                  per-user editor settings
+ *     editor_assets(id, name, record json, data blob; PK (id, name))          uploaded files
+ *
+ * Call it from the host's drizzle schema (so `drizzle-kit` migrates the tables) or use `bootstrapEditorTables` in a
+ * host that creates its tables with `CREATE TABLE IF NOT EXISTS`.
+ */
+export declare const editorTables: () => EditorTables;
+/** Any drizzle SQLite database, sync (`bun:sqlite`, better-sqlite3) or async (libsql, D1). */
+export type EditorDb = BaseSQLiteDatabase<'sync' | 'async', unknown, Record<string, unknown>>;
+/** `CREATE TABLE IF NOT EXISTS` for the tables of `editorTables()`, for hosts without migrations. */
+export declare function bootstrapEditorTables(db: EditorDb): Promise<void>;
+export interface DrizzleAdapterOptions extends AdapterHooks {
+  db: EditorDb;
+  tables: EditorTables;
+}
+/**
+ * The editor's adapter on drizzle tables. Every write to a document's content (`storeContent`, `putDocument`) stores a
+ * fresh random `version`, which `contentVersion` returns: a document changed by any other writer keeps its row's
+ * version only if that writer left it alone, so hosts that edit `editor_documents` themselves must go through
+ * `putDocument` (or set `version` to anything new). `storeContent` only updates existing rows: create documents with
+ * `putDocument`. Single-statement operations only (no transaction), so the adapter runs on sync and async drivers;
+ * `deleteDocument` removes content first, so a concurrent `storeContent` finds nothing to update. No theme library.
+ */
+export declare function createDrizzleAdapter({ db, tables, ...hooks }: DrizzleAdapterOptions): StoredEditorAdapter;
+//#endregion
+export {};
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/adapters/drizzle.js

@@ -0,0 +1,157 @@
+import { bytesOf, identityPart, settingsKey } from "./shared.js";
+import { randomUUID } from "node:crypto";
+import { and, eq, sql } from "drizzle-orm";
+import { blob, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+//#region src/adapters/drizzle.ts
+const EDITOR_TABLES = {
+	documents: sqliteTable("editor_documents", {
+		id: text("id").primaryKey(),
+		content: text("content", { mode: "json" }).$type().notNull(),
+		version: text("version").notNull(),
+		updatedAt: text("updated_at").notNull()
+	}),
+	states: sqliteTable("editor_states", {
+		id: text("id").primaryKey(),
+		state: blob("state", { mode: "buffer" }).notNull()
+	}),
+	settings: sqliteTable("editor_settings", {
+		userId: text("user_id").primaryKey(),
+		json: text("json", { mode: "json" }).$type().notNull()
+	}),
+	assets: sqliteTable("editor_assets", {
+		id: text("id").notNull(),
+		name: text("name").notNull(),
+		record: text("record", { mode: "json" }).$type().notNull(),
+		data: blob("data", { mode: "buffer" }).notNull()
+	}, (table) => [primaryKey({ columns: [table.id, table.name] })])
+};
+/**
+* The tables of the editor's storage in a SQLite database (`bun:sqlite`, better-sqlite3, libsql, D1):
+*
+*     editor_documents(id PK, content json, version text, updated_at text)   TipTap JSON + opaque content version
+*     editor_states(id PK, state blob)                                        the collab server's state bytes
+*     editor_settings(user_id PK, json json)                                  per-user editor settings
+*     editor_assets(id, name, record json, data blob; PK (id, name))          uploaded files
+*
+* Call it from the host's drizzle schema (so `drizzle-kit` migrates the tables) or use `bootstrapEditorTables` in a
+* host that creates its tables with `CREATE TABLE IF NOT EXISTS`.
+*/
+const editorTables = () => EDITOR_TABLES;
+/** `CREATE TABLE IF NOT EXISTS` for the tables of `editorTables()`, for hosts without migrations. */
+async function bootstrapEditorTables(db) {
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_documents (id text PRIMARY KEY NOT NULL, content text NOT NULL, version text NOT NULL, updated_at text NOT NULL)`);
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_states (id text PRIMARY KEY NOT NULL, state blob NOT NULL)`);
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_settings (user_id text PRIMARY KEY NOT NULL, json text NOT NULL)`);
+	await db.run(sql`CREATE TABLE IF NOT EXISTS editor_assets (id text NOT NULL, name text NOT NULL, record text NOT NULL, data blob NOT NULL, PRIMARY KEY (id, name))`);
+}
+/**
+* The editor's adapter on drizzle tables. Every write to a document's content (`storeContent`, `putDocument`) stores a
+* fresh random `version`, which `contentVersion` returns: a document changed by any other writer keeps its row's
+* version only if that writer left it alone, so hosts that edit `editor_documents` themselves must go through
+* `putDocument` (or set `version` to anything new). `storeContent` only updates existing rows: create documents with
+* `putDocument`. Single-statement operations only (no transaction), so the adapter runs on sync and async drivers;
+* `deleteDocument` removes content first, so a concurrent `storeContent` finds nothing to update. No theme library.
+*/
+function createDrizzleAdapter({ db, tables, ...hooks }) {
+	const { documents, states, settings, assets } = tables;
+	const documentContent = async (id) => (await db.select({ content: documents.content }).from(documents).where(eq(documents.id, id)).get())?.content ?? null;
+	return {
+		...identityPart(hooks),
+		loadContent: documentContent,
+		async storeContent(id, content) {
+			await db.update(documents).set({
+				content,
+				version: randomUUID(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).where(eq(documents.id, id)).run();
+		},
+		async contentVersion(id) {
+			return (await db.select({ version: documents.version }).from(documents).where(eq(documents.id, id)).get())?.version ?? null;
+		},
+		async listContents() {
+			return db.select({
+				id: documents.id,
+				content: documents.content
+			}).from(documents).orderBy(documents.id).all();
+		},
+		async loadState(id) {
+			const row = await db.select({ state: states.state }).from(states).where(eq(states.id, id)).get();
+			return row ? bytesOf(row.state) : null;
+		},
+		async storeState(id, state) {
+			const data = Buffer.from(state);
+			await db.insert(states).values({
+				id,
+				state: data
+			}).onConflictDoUpdate({
+				target: states.id,
+				set: { state: data }
+			}).run();
+		},
+		async removeState(id) {
+			await db.delete(states).where(eq(states.id, id)).run();
+		},
+		async storeAsset(id, { data, ...record }) {
+			await db.insert(assets).values({
+				id,
+				name: record.name,
+				record,
+				data
+			}).onConflictDoUpdate({
+				target: [assets.id, assets.name],
+				set: {
+					record,
+					data
+				}
+			}).run();
+		},
+		async loadAsset(id, name) {
+			const row = await db.select({
+				record: assets.record,
+				data: assets.data
+			}).from(assets).where(and(eq(assets.id, id), eq(assets.name, name))).get();
+			return row ? {
+				record: row.record,
+				data: Buffer.from(row.data)
+			} : null;
+		},
+		async loadSettings(user) {
+			return (await db.select({ json: settings.json }).from(settings).where(eq(settings.userId, settingsKey(user))).get())?.json ?? null;
+		},
+		async storeSettings(user, value) {
+			await db.insert(settings).values({
+				userId: settingsKey(user),
+				json: value
+			}).onConflictDoUpdate({
+				target: settings.userId,
+				set: { json: value }
+			}).run();
+		},
+		async putDocument(id, content) {
+			const row = {
+				content,
+				version: randomUUID(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await db.insert(documents).values({
+				id,
+				...row
+			}).onConflictDoUpdate({
+				target: documents.id,
+				set: row
+			}).run();
+		},
+		async deleteDocument(id) {
+			await db.delete(documents).where(eq(documents.id, id)).run();
+			await db.delete(states).where(eq(states.id, id)).run();
+			await db.delete(assets).where(eq(assets.id, id)).run();
+		},
+		async listDocumentIds() {
+			return (await db.select({ id: documents.id }).from(documents).orderBy(documents.id).all()).map((row) => row.id);
+		}
+	};
+}
+//#endregion
+export { bootstrapEditorTables, createDrizzleAdapter, editorTables };
+
+//# sourceMappingURL=drizzle.js.map

package/dist/adapters/drizzle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.js","names":[],"sources":["../../src/adapters/drizzle.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport type { JSONContent } from '@tiptap/core'\nimport type { AssetRecord } from '../features/media/schema'\nimport { and, eq, sql } from 'drizzle-orm'\nimport { type BaseSQLiteDatabase, blob, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'\nimport { type AdapterHooks, bytesOf, identityPart, settingsKey, type StoredEditorAdapter } from './shared'\n\nconst EDITOR_TABLES = {\n  documents: sqliteTable('editor_documents', {\n    id: text('id').primaryKey(),\n    content: text('content', { mode: 'json' }).$type<JSONContent>().notNull(),\n    version: text('version').notNull(),\n    updatedAt: text('updated_at').notNull(),\n  }),\n  states: sqliteTable('editor_states', {\n    id: text('id').primaryKey(),\n    state: blob('state', { mode: 'buffer' }).notNull(),\n  }),\n  settings: sqliteTable('editor_settings', {\n    userId: text('user_id').primaryKey(),\n    json: text('json', { mode: 'json' }).$type<unknown>().notNull(),\n  }),\n  assets: sqliteTable('editor_assets', {\n    id: text('id').notNull(),\n    name: text('name').notNull(),\n    record: text('record', { mode: 'json' }).$type<AssetRecord>().notNull(),\n    data: blob('data', { mode: 'buffer' }).notNull(),\n  }, table => [primaryKey({ columns: [table.id, table.name] })]),\n}\n\nexport type EditorTables = typeof EDITOR_TABLES\n\n/**\n * The tables of the editor's storage in a SQLite database (`bun:sqlite`, better-sqlite3, libsql, D1):\n *\n *     editor_documents(id PK, content json, version text, updated_at text)   TipTap JSON + opaque content version\n *     editor_states(id PK, state blob)                                        the collab server's state bytes\n *     editor_settings(user_id PK, json json)                                  per-user editor settings\n *     editor_assets(id, name, record json, data blob; PK (id, name))          uploaded files\n *\n * Call it from the host's drizzle schema (so `drizzle-kit` migrates the tables) or use `bootstrapEditorTables` in a\n * host that creates its tables with `CREATE TABLE IF NOT EXISTS`.\n */\nexport const editorTables = (): EditorTables => EDITOR_TABLES\n\n/** Any drizzle SQLite database, sync (`bun:sqlite`, better-sqlite3) or async (libsql, D1). */\nexport type EditorDb = BaseSQLiteDatabase<'sync' | 'async', unknown, Record<string, unknown>>\n\n/** `CREATE TABLE IF NOT EXISTS` for the tables of `editorTables()`, for hosts without migrations. */\nexport async function bootstrapEditorTables(db: EditorDb): Promise<void> {\n  await db.run(sql`CREATE TABLE IF NOT EXISTS editor_documents (id text PRIMARY KEY NOT NULL, content text NOT NULL, version text NOT NULL, updated_at text NOT NULL)`)\n  await db.run(sql`CREATE TABLE IF NOT EXISTS editor_states (id text PRIMARY KEY NOT NULL, state blob NOT NULL)`)\n  await db.run(sql`CREATE TABLE IF NOT EXISTS editor_settings (user_id text PRIMARY KEY NOT NULL, json text NOT NULL)`)\n  await db.run(sql`CREATE TABLE IF NOT EXISTS editor_assets (id text NOT NULL, name text NOT NULL, record text NOT NULL, data blob NOT NULL, PRIMARY KEY (id, name))`)\n}\n\nexport interface DrizzleAdapterOptions extends AdapterHooks {\n  db: EditorDb\n  tables: EditorTables\n}\n\n/**\n * The editor's adapter on drizzle tables. Every write to a document's content (`storeContent`, `putDocument`) stores a\n * fresh random `version`, which `contentVersion` returns: a document changed by any other writer keeps its row's\n * version only if that writer left it alone, so hosts that edit `editor_documents` themselves must go through\n * `putDocument` (or set `version` to anything new). `storeContent` only updates existing rows: create documents with\n * `putDocument`. Single-statement operations only (no transaction), so the adapter runs on sync and async drivers;\n * `deleteDocument` removes content first, so a concurrent `storeContent` finds nothing to update. No theme library.\n */\nexport function createDrizzleAdapter({ db, tables, ...hooks }: DrizzleAdapterOptions): StoredEditorAdapter {\n  const { documents, states, settings, assets } = tables\n\n  const documentContent = async (id: string) => (await db.select({ content: documents.content }).from(documents).where(eq(documents.id, id)).get())?.content ?? null\n\n  return {\n    ...identityPart(hooks),\n\n    loadContent: documentContent,\n    async storeContent(id, content) {\n      await db.update(documents).set({ content, version: randomUUID(), updatedAt: new Date().toISOString() }).where(eq(documents.id, id)).run()\n    },\n    async contentVersion(id) {\n      return (await db.select({ version: documents.version }).from(documents).where(eq(documents.id, id)).get())?.version ?? null\n    },\n    async listContents() {\n      return db.select({ id: documents.id, content: documents.content }).from(documents).orderBy(documents.id).all()\n    },\n\n    async loadState(id) {\n      const row = await db.select({ state: states.state }).from(states).where(eq(states.id, id)).get()\n      return row ? bytesOf(row.state) : null\n    },\n    async storeState(id, state) {\n      const data = Buffer.from(state)\n      await db.insert(states).values({ id, state: data }).onConflictDoUpdate({ target: states.id, set: { state: data } }).run()\n    },\n    async removeState(id) {\n      await db.delete(states).where(eq(states.id, id)).run()\n    },\n\n    async storeAsset(id, { data, ...record }) {\n      await db.insert(assets).values({ id, name: record.name, record, data })\n        .onConflictDoUpdate({ target: [assets.id, assets.name], set: { record, data } }).run()\n    },\n    async loadAsset(id, name) {\n      const row = await db.select({ record: assets.record, data: assets.data }).from(assets).where(and(eq(assets.id, id), eq(assets.name, name))).get()\n      return row ? { record: row.record, data: Buffer.from(row.data) } : null\n    },\n\n    async loadSettings(user) {\n      return (await db.select({ json: settings.json }).from(settings).where(eq(settings.userId, settingsKey(user))).get())?.json ?? null\n    },\n    async storeSettings(user, value) {\n      await db.insert(settings).values({ userId: settingsKey(user), json: value })\n        .onConflictDoUpdate({ target: settings.userId, set: { json: value } }).run()\n    },\n\n    async putDocument(id, content) {\n      const row = { content, version: randomUUID(), updatedAt: new Date().toISOString() }\n      await db.insert(documents).values({ id, ...row }).onConflictDoUpdate({ target: documents.id, set: row }).run()\n    },\n    async deleteDocument(id) {\n      await db.delete(documents).where(eq(documents.id, id)).run()\n      await db.delete(states).where(eq(states.id, id)).run()\n      await db.delete(assets).where(eq(assets.id, id)).run()\n    },\n    async listDocumentIds() {\n      return (await db.select({ id: documents.id }).from(documents).orderBy(documents.id).all()).map(row => row.id)\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/adapters/files.js

@@ -0,0 +1,30 @@
+import { randomUUID } from "node:crypto";
+import { promises } from "node:fs";
+import path from "node:path";
+//#region src/adapters/files.ts
+const isMissing = (error) => error.code === "ENOENT";
+/** Writes through a temp file in the same directory and renames it into place: a reader sees the old or the new file, never a torn one. */
+async function writeAtomic(file, data) {
+	await promises.mkdir(path.dirname(file), { recursive: true });
+	const temp = path.join(path.dirname(file), `.${path.basename(file)}.${randomUUID()}.tmp`);
+	try {
+		await promises.writeFile(temp, data);
+		await promises.rename(temp, file);
+	} catch (error) {
+		await promises.rm(temp, { force: true });
+		throw error;
+	}
+}
+/** The bytes of `file`, `null` when it does not exist. */
+async function readOrNull(file) {
+	try {
+		return await promises.readFile(file);
+	} catch (error) {
+		if (isMissing(error)) return null;
+		throw error;
+	}
+}
+//#endregion
+export { isMissing, readOrNull, writeAtomic };
+
+//# sourceMappingURL=files.js.map

package/dist/adapters/files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.js","names":["fs"],"sources":["../../src/adapters/files.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport { promises as fs } from 'node:fs'\nimport path from 'node:path'\n\nexport const isMissing = (error: unknown) => (error as NodeJS.ErrnoException).code === 'ENOENT'\n\n/** Writes through a temp file in the same directory and renames it into place: a reader sees the old or the new file, never a torn one. */\nexport async function writeAtomic(file: string, data: string | Uint8Array): Promise<void> {\n  await fs.mkdir(path.dirname(file), { recursive: true })\n  const temp = path.join(path.dirname(file), `.${path.basename(file)}.${randomUUID()}.tmp`)\n  try {\n    await fs.writeFile(temp, data)\n    await fs.rename(temp, file)\n  }\n  catch (error) {\n    await fs.rm(temp, { force: true })\n    throw error\n  }\n}\n\n/** The bytes of `file`, `null` when it does not exist. */\nexport async function readOrNull(file: string): Promise<Buffer | null> {\n  try {\n    return await fs.readFile(file)\n  }\n  catch (error) {\n    if (isMissing(error)) return null\n    throw error\n  }\n}\n"],"mappings":";;;;AAIA,MAAa,aAAa,UAAoB,MAAgC,SAAS;;AAGvF,eAAsB,YAAY,MAAc,MAA0C;CACxF,MAAMA,SAAG,MAAM,KAAK,QAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;CACtD,MAAM,OAAO,KAAK,KAAK,KAAK,QAAQ,IAAI,GAAG,IAAI,KAAK,SAAS,IAAI,EAAE,GAAG,WAAW,EAAE,KAAK;CACxF,IAAI;EACF,MAAMA,SAAG,UAAU,MAAM,IAAI;EAC7B,MAAMA,SAAG,OAAO,MAAM,IAAI;CAC5B,SACO,OAAO;EACZ,MAAMA,SAAG,GAAG,MAAM,EAAE,OAAO,KAAK,CAAC;EACjC,MAAM;CACR;AACF;;AAGA,eAAsB,WAAW,MAAsC;CACrE,IAAI;EACF,OAAO,MAAMA,SAAG,SAAS,IAAI;CAC/B,SACO,OAAO;EACZ,IAAI,UAAU,KAAK,GAAG,OAAO;EAC7B,MAAM;CACR;AACF"}