@abraca/dabra 0.6.0 → 0.8.0

package/src/SearchIndex.ts

@@ -0,0 +1,247 @@
+/**
+ * IndexedDB-backed trigram full-text search index.
+ *
+ * Generic: caller passes (docId, texts[]) — works for Y.Doc text content,
+ * file names, document titles, or any other text. No Y.js coupling.
+ *
+ * Algorithm: trigram inverted index.
+ *   - Each document is decomposed into overlapping 3-character windows.
+ *   - The "postings" store maps trigram → [docId, ...].
+ *   - The "doc_trigrams" store maps docId → [trigram, ...] for efficient removal.
+ *   - search() scores by number of query trigrams that match.
+ *
+ * IDB transactions that touch multiple stores use the callback-only pattern
+ * (not async/await inside a transaction) to avoid the transaction auto-commit
+ * issue across microtask boundaries.
+ */
+
+import type { SearchResult } from "./types.ts";
+
+const DB_VERSION = 1;
+
+function idbAvailable(): boolean {
+	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
+}
+
+function openDb(origin: string): Promise<IDBDatabase> {
+	return new Promise((resolve, reject) => {
+		const req = globalThis.indexedDB.open(`abracadabra:search:${origin}`, DB_VERSION);
+
+		req.onupgradeneeded = (event) => {
+			const db = (event.target as IDBOpenDBRequest).result;
+			if (!db.objectStoreNames.contains("postings")) {
+				db.createObjectStore("postings");
+			}
+			if (!db.objectStoreNames.contains("doc_trigrams")) {
+				db.createObjectStore("doc_trigrams");
+			}
+		};
+
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+
+/** Extract the set of trigrams for a piece of text. */
+function extractTrigrams(text: string): Set<string> {
+	const trigrams = new Set<string>();
+	const padded = ` ${text.toLowerCase()} `;
+	for (let i = 0; i <= padded.length - 3; i++) {
+		trigrams.add(padded.slice(i, i + 3));
+	}
+	return trigrams;
+}
+
+/** Merge trigrams from multiple texts into a single set. */
+function extractAllTrigrams(texts: string[]): Set<string> {
+	const result = new Set<string>();
+	for (const t of texts) {
+		for (const trigram of extractTrigrams(t)) {
+			result.add(trigram);
+		}
+	}
+	return result;
+}
+
+export class SearchIndex {
+	private readonly origin: string;
+	private dbPromise: Promise<IDBDatabase | null> | null = null;
+	private db: IDBDatabase | null = null;
+
+	constructor(serverOrigin: string) {
+		this.origin = serverOrigin;
+	}
+
+	private getDb(): Promise<IDBDatabase | null> {
+		if (!idbAvailable()) return Promise.resolve(null);
+		if (!this.dbPromise) {
+			this.dbPromise = openDb(this.origin)
+				.catch(() => null)
+				.then((db) => {
+					this.db = db;
+					return db;
+				});
+		}
+		return this.dbPromise;
+	}
+
+	/**
+	 * Replace the index for docId with the given texts.
+	 * Old trigram associations are removed before new ones are added.
+	 */
+	async index(docId: string, texts: string[]): Promise<void> {
+		const db = await this.getDb();
+		if (!db) return;
+
+		const newTrigrams = extractAllTrigrams(texts);
+
+		return new Promise<void>((resolve, reject) => {
+			const tx = db.transaction(["postings", "doc_trigrams"], "readwrite");
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error);
+
+			const postings = tx.objectStore("postings");
+			const docTrigramsStore = tx.objectStore("doc_trigrams");
+
+			// Step 1: read old trigrams for this doc
+			const oldReq = docTrigramsStore.get(docId);
+			oldReq.onsuccess = () => {
+				const oldTrigrams: string[] = oldReq.result ?? [];
+				let pending = oldTrigrams.length + newTrigrams.size + 1; // +1 for doc_trigrams write
+
+				function done() {
+					pending--;
+					// tx.oncomplete fires naturally once all requests settle
+				}
+
+				// Step 2: remove docId from each old trigram's posting list
+				for (const trigram of oldTrigrams) {
+					const req = postings.get(trigram);
+					req.onsuccess = () => {
+						const list: string[] = req.result ?? [];
+						const updated = list.filter((id) => id !== docId);
+						if (updated.length === 0) {
+							postings.delete(trigram);
+						} else {
+							postings.put(updated, trigram);
+						}
+						done();
+					};
+					req.onerror = done;
+				}
+
+				// Step 3: add docId to each new trigram's posting list
+				for (const trigram of newTrigrams) {
+					const req = postings.get(trigram);
+					req.onsuccess = () => {
+						const list: string[] = req.result ?? [];
+						if (!list.includes(docId)) {
+							list.push(docId);
+						}
+						postings.put(list, trigram);
+						done();
+					};
+					req.onerror = done;
+				}
+
+				// Step 4: save new trigram set for this doc
+				const writeReq = docTrigramsStore.put([...newTrigrams], docId);
+				writeReq.onsuccess = done;
+				writeReq.onerror = done;
+			};
+			oldReq.onerror = () => reject(oldReq.error);
+		});
+	}
+
+	/** Remove all indexed content for a document. */
+	async remove(docId: string): Promise<void> {
+		const db = await this.getDb();
+		if (!db) return;
+
+		return new Promise<void>((resolve, reject) => {
+			const tx = db.transaction(["postings", "doc_trigrams"], "readwrite");
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error);
+
+			const postings = tx.objectStore("postings");
+			const docTrigramsStore = tx.objectStore("doc_trigrams");
+
+			const oldReq = docTrigramsStore.get(docId);
+			oldReq.onsuccess = () => {
+				const oldTrigrams: string[] = oldReq.result ?? [];
+
+				for (const trigram of oldTrigrams) {
+					const req = postings.get(trigram);
+					req.onsuccess = () => {
+						const list: string[] = req.result ?? [];
+						const updated = list.filter((id) => id !== docId);
+						if (updated.length === 0) {
+							postings.delete(trigram);
+						} else {
+							postings.put(updated, trigram);
+						}
+					};
+				}
+
+				docTrigramsStore.delete(docId);
+			};
+			oldReq.onerror = () => reject(oldReq.error);
+		});
+	}
+
+	/**
+	 * Search for documents matching the query.
+	 * Returns results sorted by score (matching trigram count) descending.
+	 */
+	async search(query: string, limit = 20): Promise<SearchResult[]> {
+		const db = await this.getDb();
+		if (!db) return [];
+
+		const queryTrigrams = [...extractTrigrams(query)];
+		if (queryTrigrams.length === 0) return [];
+
+		return new Promise<SearchResult[]>((resolve, reject) => {
+			const tx = db.transaction("postings", "readonly");
+			const postings = tx.objectStore("postings");
+			const scores = new Map<string, number>();
+			let remaining = queryTrigrams.length;
+
+			for (const trigram of queryTrigrams) {
+				const req = postings.get(trigram);
+				req.onsuccess = () => {
+					const docIds: string[] = req.result ?? [];
+					for (const docId of docIds) {
+						scores.set(docId, (scores.get(docId) ?? 0) + 1);
+					}
+					remaining--;
+					if (remaining === 0) {
+						const results: SearchResult[] = [...scores.entries()]
+							.map(([docId, score]) => ({ docId, score }))
+							.sort((a, b) => b.score - a.score)
+							.slice(0, limit);
+						resolve(results);
+					}
+				};
+				req.onerror = () => {
+					remaining--;
+					if (remaining === 0) {
+						const results: SearchResult[] = [...scores.entries()]
+							.map(([docId, score]) => ({ docId, score }))
+							.sort((a, b) => b.score - a.score)
+							.slice(0, limit);
+						resolve(results);
+					}
+				};
+			}
+
+			tx.onerror = () => reject(tx.error);
+		});
+	}
+
+	// ── Lifecycle ─────────────────────────────────────────────────────────────
+
+	destroy(): void {
+		this.db?.close();
+		this.db = null;
+	}
+}

package/src/auth.ts

@@ -0,0 +1,62 @@
+import * as encoding from "lib0/encoding";
+import * as decoding from "lib0/decoding";
+import type { AuthorizedScope } from "./types.ts";
+
+export enum AuthMessageType {
+	Token = 0,
+	PermissionDenied = 1,
+	Authenticated = 2,
+}
+
+export const writeAuthentication = (
+	encoder: encoding.Encoder,
+	auth: string,
+) => {
+	encoding.writeVarUint(encoder, AuthMessageType.Token);
+	encoding.writeVarString(encoder, auth);
+};
+
+export const writePermissionDenied = (
+	encoder: encoding.Encoder,
+	reason: string,
+) => {
+	encoding.writeVarUint(encoder, AuthMessageType.PermissionDenied);
+	encoding.writeVarString(encoder, reason);
+};
+
+export const writeAuthenticated = (
+	encoder: encoding.Encoder,
+	scope: AuthorizedScope,
+) => {
+	encoding.writeVarUint(encoder, AuthMessageType.Authenticated);
+	encoding.writeVarString(encoder, scope);
+};
+
+export const writeTokenSyncRequest = (
+	encoder: encoding.Encoder,
+) => {
+	encoding.writeVarUint(encoder, AuthMessageType.Token);
+};
+
+export const readAuthMessage = (
+	decoder: decoding.Decoder,
+	sendToken: () => void,
+	permissionDeniedHandler: (reason: string) => void,
+	authenticatedHandler: (scope: string) => void,
+) => {
+	switch (decoding.readVarUint(decoder)) {
+		case AuthMessageType.Token: {
+			sendToken();
+			break;
+		}
+		case AuthMessageType.PermissionDenied: {
+			permissionDeniedHandler(decoding.readVarString(decoder));
+			break;
+		}
+		case AuthMessageType.Authenticated: {
+			authenticatedHandler(decoding.readVarString(decoder));
+			break;
+		}
+		default:
+	}
+};

package/src/awarenessStatesToArray.ts

@@ -0,0 +1,10 @@
+export const awarenessStatesToArray = (
+	states: Map<number, Record<string, any>>,
+) => {
+	return Array.from(states.entries()).map(([key, value]) => {
+		return {
+			clientId: key,
+			...value,
+		};
+	});
+};

package/src/index.ts

@@ -1,8 +1,15 @@
-export * from "./HocuspocusProvider.ts";
-export * from "./HocuspocusProviderWebsocket.ts";
+export * from "./AbracadabraBaseProvider.ts";
+export * from "./AbracadabraWS.ts";
 export * from "./types.ts";
 export * from "./AbracadabraProvider.ts";
 export * from "./AbracadabraClient.ts";
 export * from "./OfflineStore.ts";
+export * from "./auth.ts";
+export * from "./CloseEvents.ts";
+export * from "./awarenessStatesToArray.ts";
 export { SubdocMessage } from "./OutgoingMessages/SubdocMessage.ts";
 export { CryptoIdentityKeystore } from "./CryptoIdentityKeystore.ts";
+export { DocumentCache } from "./DocumentCache.ts";
+export type { DocumentCacheOptions } from "./DocumentCache.ts";
+export { SearchIndex } from "./SearchIndex.ts";
+export { FileBlobStore } from "./FileBlobStore.ts";

package/src/types.ts

@@ -2,7 +2,7 @@ import type { Encoder } from "lib0/encoding";
 import type { Event, MessageEvent } from "ws";
 import type { Awareness } from "y-protocols/awareness";
 import type * as Y from "yjs";
-import type { CloseEvent } from "@abraca/dabra-common";
+import type { CloseEvent } from "./CloseEvents.ts";
 import type { IncomingMessage } from "./IncomingMessage.ts";
 import type { OutgoingMessage } from "./OutgoingMessage.ts";
 import type { AuthenticationMessage } from "./OutgoingMessages/AuthenticationMessage.ts";
@@ -12,6 +12,17 @@ import type { SyncStepOneMessage } from "./OutgoingMessages/SyncStepOneMessage.t
 import type { SyncStepTwoMessage } from "./OutgoingMessages/SyncStepTwoMessage.ts";
 import type { UpdateMessage } from "./OutgoingMessages/UpdateMessage.ts";
 
+/**
+ * State of the WebSocket connection.
+ * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+ */
+export enum WsReadyStates {
+  Connecting = 0,
+  Open = 1,
+  Closing = 2,
+  Closed = 3,
+}
+
 export enum MessageType {
   Sync = 0,
   Awareness = 1,
@@ -193,3 +204,50 @@ export interface HealthStatus {
   version: string;
   active_documents: number;
 }
+
+export interface ServerInfo {
+  /** Human-readable server name set by the operator. */
+  name?: string;
+  /** Server version string. */
+  version?: string;
+  /** Entry-point document ID advertised by the server, if configured. */
+  index_doc_id?: string;
+}
+
+// ── Search ───────────────────────────────────────────────────────────────────
+
+export interface SearchResult {
+  docId: string;
+  /** Number of matching trigrams — higher is better. */
+  score: number;
+}
+
+// ── Invites ──────────────────────────────────────────────────────────────────
+
+export interface InviteRow {
+  code: string;
+  createdBy: string | null;
+  role: string;
+  maxUses: number;
+  useCount: number;
+  expiresAt: number | null;
+  revoked: boolean;
+  createdAt: number;
+}
+
+// ── Upload queue ─────────────────────────────────────────────────────────────
+
+export type UploadQueueStatus = "pending" | "uploading" | "done" | "error";
+
+export interface UploadQueueEntry {
+  /** Client-generated UUID. */
+  id: string;
+  docId: string;
+  /** File or Blob to upload. File extends Blob and survives IDB as Blob. */
+  file: Blob;
+  /** Eagerly captured filename (from File.name or explicit arg). */
+  filename: string;
+  status: UploadQueueStatus;
+  createdAt: number;
+  error?: string;
+}