@abraca/dabra 0.1.0 → 0.1.2

package/src/MessageReceiver.ts

@@ -1,4 +1,4 @@
-import { readAuthMessage } from "@hocuspocus/common";
+import { readAuthMessage } from "@abraca/dabra-common";
 import { readVarInt, readVarString } from "lib0/decoding";
 import type { CloseEvent } from "ws";
 import * as awarenessProtocol from "y-protocols/awareness";
@@ -9,131 +9,128 @@ import { OutgoingMessage } from "./OutgoingMessage.ts";
 import { MessageType } from "./types.ts";
 
 export class MessageReceiver {
-	message: IncomingMessage;
-
-	constructor(message: IncomingMessage) {
-		this.message = message;
-	}
-
-	public apply(provider: HocuspocusProvider, emitSynced: boolean) {
-		const { message } = this;
-		const type = message.readVarUint();
-
-		const emptyMessageLength = message.length();
-
-		switch (type) {
-			case MessageType.Sync:
-				this.applySyncMessage(provider, emitSynced);
-				break;
-
-			case MessageType.Awareness:
-				this.applyAwarenessMessage(provider);
-				break;
-
-			case MessageType.Auth:
-				this.applyAuthMessage(provider);
-				break;
-
-			case MessageType.QueryAwareness:
-				this.applyQueryAwarenessMessage(provider);
-				break;
-
-			case MessageType.Stateless:
-				provider.receiveStateless(readVarString(message.decoder));
-				break;
-
-			case MessageType.SyncStatus:
-				this.applySyncStatusMessage(
-					provider,
-					readVarInt(message.decoder) === 1,
-				);
-				break;
-
-			case MessageType.CLOSE:
-				// eslint-disable-next-line no-case-declarations
-				const event: CloseEvent = {
-					code: 1000,
-					reason: readVarString(message.decoder),
-					// @ts-ignore
-					target: provider.configuration.websocketProvider.webSocket!,
-					type: "close",
-				};
-				provider.onClose();
-				provider.configuration.onClose({ event });
-				provider.forwardClose({ event });
-				break;
-
-			default:
-				throw new Error(`Can’t apply message of unknown type: ${type}`);
-		}
-
-		// Reply
-		if (message.length() > emptyMessageLength + 1) {
-			// length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
-			// @ts-ignore
-			provider.send(OutgoingMessage, { encoder: message.encoder });
-		}
-	}
-
-	private applySyncMessage(provider: HocuspocusProvider, emitSynced: boolean) {
-		const { message } = this;
-
-		message.writeVarUint(MessageType.Sync);
-
-		// Apply update
-		const syncMessageType = readSyncMessage(
-			message.decoder,
-			message.encoder,
-			provider.document,
-			provider,
-		);
-
-		// Synced once we receive Step2
-		if (emitSynced && syncMessageType === messageYjsSyncStep2) {
-			provider.synced = true;
-		}
-	}
-
-	applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean) {
-		if (applied) {
-			provider.decrementUnsyncedChanges();
-		}
-	}
-
-	private applyAwarenessMessage(provider: HocuspocusProvider) {
-		if (!provider.awareness) return;
-
-		const { message } = this;
-
-		awarenessProtocol.applyAwarenessUpdate(
-			provider.awareness,
-			message.readVarUint8Array(),
-			provider,
-		);
-	}
-
-	private applyAuthMessage(provider: HocuspocusProvider) {
-		const { message } = this;
-
-		readAuthMessage(
-			message.decoder,
-			provider.sendToken.bind(provider),
-			provider.permissionDeniedHandler.bind(provider),
-			provider.authenticatedHandler.bind(provider),
-		);
-	}
-
-	private applyQueryAwarenessMessage(provider: HocuspocusProvider) {
-		if (!provider.awareness) return;
-
-		const { message } = this;
-
-		message.writeVarUint(MessageType.Awareness);
-		message.writeVarUint8Array(
-			awarenessProtocol.encodeAwarenessUpdate(
-				provider.awareness,
-				Array.from(provider.awareness.getStates().keys()),
-			),
-		);
-	}
+  message: IncomingMessage;
+
+  constructor(message: IncomingMessage) {
+    this.message = message;
+  }
+
+  public apply(provider: HocuspocusProvider, emitSynced: boolean) {
+    const { message } = this;
+    const type = message.readVarUint();
+
+    const emptyMessageLength = message.length();
+
+    switch (type) {
+      case MessageType.Sync:
+        this.applySyncMessage(provider, emitSynced);
+        break;
+
+      case MessageType.Awareness:
+        this.applyAwarenessMessage(provider);
+        break;
+
+      case MessageType.Auth:
+        this.applyAuthMessage(provider);
+        break;
+
+      case MessageType.QueryAwareness:
+        this.applyQueryAwarenessMessage(provider);
+        break;
+
+      case MessageType.Stateless:
+        provider.receiveStateless(readVarString(message.decoder));
+        break;
+
+      case MessageType.SyncStatus:
+        this.applySyncStatusMessage(provider, readVarInt(message.decoder) === 1);
+        break;
+
+      case MessageType.CLOSE:
+        // eslint-disable-next-line no-case-declarations
+        const event: CloseEvent = {
+          code: 1000,
+          reason: readVarString(message.decoder),
+          // @ts-ignore
+          target: provider.configuration.websocketProvider.webSocket!,
+          type: "close",
+        };
+        provider.onClose();
+        provider.configuration.onClose({ event });
+        provider.forwardClose({ event });
+        break;
+
+      default:
+        throw new Error(`Can’t apply message of unknown type: ${type}`);
+    }
+
+    // Reply
+    if (message.length() > emptyMessageLength + 1) {
+      // length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
+      // @ts-ignore
+      provider.send(OutgoingMessage, { encoder: message.encoder });
+    }
+  }
+
+  private applySyncMessage(provider: HocuspocusProvider, emitSynced: boolean) {
+    const { message } = this;
+
+    message.writeVarUint(MessageType.Sync);
+
+    // Apply update
+    const syncMessageType = readSyncMessage(
+      message.decoder,
+      message.encoder,
+      provider.document,
+      provider,
+    );
+
+    // Synced once we receive Step2
+    if (emitSynced && syncMessageType === messageYjsSyncStep2) {
+      provider.synced = true;
+    }
+  }
+
+  applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean) {
+    if (applied) {
+      provider.decrementUnsyncedChanges();
+    }
+  }
+
+  private applyAwarenessMessage(provider: HocuspocusProvider) {
+    if (!provider.awareness) return;
+
+    const { message } = this;
+
+    awarenessProtocol.applyAwarenessUpdate(
+      provider.awareness,
+      message.readVarUint8Array(),
+      provider,
+    );
+  }
+
+  private applyAuthMessage(provider: HocuspocusProvider) {
+    const { message } = this;
+
+    readAuthMessage(
+      message.decoder,
+      provider.sendToken.bind(provider),
+      provider.permissionDeniedHandler.bind(provider),
+      provider.authenticatedHandler.bind(provider),
+    );
+  }
+
+  private applyQueryAwarenessMessage(provider: HocuspocusProvider) {
+    if (!provider.awareness) return;
+
+    const { message } = this;
+
+    message.writeVarUint(MessageType.Awareness);
+    message.writeVarUint8Array(
+      awarenessProtocol.encodeAwarenessUpdate(
+        provider.awareness,
+        Array.from(provider.awareness.getStates().keys()),
+      ),
+    );
+  }
 }

package/src/OutgoingMessages/AuthenticationMessage.ts

@@ -1,25 +1,23 @@
 import { writeVarString, writeVarUint } from "lib0/encoding";
-import { writeAuthentication } from "@hocuspocus/common";
+import { writeAuthentication } from "@abraca/dabra-common";
 import type { OutgoingMessageArguments } from "../types.ts";
 import { MessageType } from "../types.ts";
 import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class AuthenticationMessage extends OutgoingMessage {
-	type = MessageType.Auth;
+  type = MessageType.Auth;
 
-	description = "Authentication";
+  description = "Authentication";
 
-	get(args: Partial<OutgoingMessageArguments>) {
-		if (typeof args.token === "undefined") {
-			throw new Error(
-				"The authentication message requires `token` as an argument.",
-			);
-		}
+  get(args: Partial<OutgoingMessageArguments>) {
+    if (typeof args.token === "undefined") {
+      throw new Error("The authentication message requires `token` as an argument.");
+    }
 
-		writeVarString(this.encoder, args.documentName!);
-		writeVarUint(this.encoder, this.type);
-		writeAuthentication(this.encoder, args.token);
+    writeVarString(this.encoder, args.documentName!);
+    writeVarUint(this.encoder, this.type);
+    writeAuthentication(this.encoder, args.token);
 
-		return this.encoder;
-	}
+    return this.encoder;
+  }
 }

package/src/index.ts

@@ -2,6 +2,7 @@ export * from "./HocuspocusProvider.ts";
 export * from "./HocuspocusProviderWebsocket.ts";
 export * from "./types.ts";
 export * from "./AbracadabraProvider.ts";
+export * from "./AbracadabraClient.ts";
 export * from "./OfflineStore.ts";
 export { SubdocMessage } from "./OutgoingMessages/SubdocMessage.ts";
 export { CryptoIdentityKeystore } from "./CryptoIdentityKeystore.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 "@hocuspocus/common";
+import type { CloseEvent } from "@abraca/dabra-common";
 import type { IncomingMessage } from "./IncomingMessage.ts";
 import type { OutgoingMessage } from "./OutgoingMessage.ts";
 import type { AuthenticationMessage } from "./OutgoingMessages/AuthenticationMessage.ts";
@@ -13,104 +13,104 @@ import type { SyncStepTwoMessage } from "./OutgoingMessages/SyncStepTwoMessage.t
 import type { UpdateMessage } from "./OutgoingMessages/UpdateMessage.ts";
 
 export enum MessageType {
-	Sync = 0,
-	Awareness = 1,
-	Auth = 2,
-	QueryAwareness = 3,
-	Subdoc = 4,
-	Stateless = 5,
-	CLOSE = 7,
-	SyncStatus = 8,
+  Sync = 0,
+  Awareness = 1,
+  Auth = 2,
+  QueryAwareness = 3,
+  Subdoc = 4,
+  Stateless = 5,
+  CLOSE = 7,
+  SyncStatus = 8,
 }
 
 export enum WebSocketStatus {
-	Connecting = "connecting",
-	Connected = "connected",
-	Disconnected = "disconnected",
+  Connecting = "connecting",
+  Connected = "connected",
+  Disconnected = "disconnected",
 }
 
 export type AuthorizedScope = "read-write" | "readonly";
 
 export interface OutgoingMessageInterface {
-	encoder: Encoder;
-	type?: MessageType;
+  encoder: Encoder;
+  type?: MessageType;
 }
 
 export interface OutgoingMessageArguments {
-	documentName: string;
-	token: string;
-	document: Y.Doc;
-	awareness: Awareness;
-	clients: number[];
-	states: Map<number, { [key: string]: any }>;
-	update: any;
-	payload: string;
-	encoder: Encoder;
+  documentName: string;
+  token: string;
+  document: Y.Doc;
+  awareness: Awareness;
+  clients: number[];
+  states: Map<number, { [key: string]: any }>;
+  update: any;
+  payload: string;
+  encoder: Encoder;
 }
 
 export interface Constructable<T> {
-	new (...args: any): T;
+  new (...args: any): T;
 }
 
 export type ConstructableOutgoingMessage =
-	| Constructable<AuthenticationMessage>
-	| Constructable<AwarenessMessage>
-	| Constructable<QueryAwarenessMessage>
-	| Constructable<SyncStepOneMessage>
-	| Constructable<SyncStepTwoMessage>
-	| Constructable<UpdateMessage>;
+  | Constructable<AuthenticationMessage>
+  | Constructable<AwarenessMessage>
+  | Constructable<QueryAwarenessMessage>
+  | Constructable<SyncStepOneMessage>
+  | Constructable<SyncStepTwoMessage>
+  | Constructable<UpdateMessage>;
 
 export type onAuthenticationFailedParameters = {
-	reason: string;
+  reason: string;
 };
 
 export type onAuthenticatedParameters = {
-	scope: AuthorizedScope;
+  scope: AuthorizedScope;
 };
 
 export type onOpenParameters = {
-	event: Event;
+  event: Event;
 };
 
 export type onMessageParameters = {
-	event: MessageEvent;
-	message: IncomingMessage;
+  event: MessageEvent;
+  message: IncomingMessage;
 };
 
 export type onOutgoingMessageParameters = {
-	message: OutgoingMessage;
+  message: OutgoingMessage;
 };
 
 export type onStatusParameters = {
-	status: WebSocketStatus;
+  status: WebSocketStatus;
 };
 
 export type onSyncedParameters = {
-	state: boolean;
+  state: boolean;
 };
 
 export type onUnsyncedChangesParameters = {
-	number: number;
+  number: number;
 };
 
 export type onDisconnectParameters = {
-	event: CloseEvent;
+  event: CloseEvent;
 };
 
 export type onCloseParameters = {
-	event: CloseEvent;
+  event: CloseEvent;
 };
 
 export type onAwarenessUpdateParameters = {
-	states: StatesArray;
+  states: StatesArray;
 };
 
 export type onAwarenessChangeParameters = {
-	states: StatesArray;
+  states: StatesArray;
 };
 
 export type onStatelessParameters = {
-	payload: string;
+  payload: string;
 };
 
 export type StatesArray = { clientId: number; [key: string | number]: any }[];
@@ -119,26 +119,70 @@ export type StatesArray = { clientId: number; [key: string | number]: any }[];
 
 export type EffectiveRole = "owner" | "editor" | "viewer" | null;
 
-/** Ed25519 identity for passwordless crypto auth (Model B multi-key). */
+/**
+ * Ed25519 identity for passwordless crypto auth.
+ *
+ * The public key is the sole identifier sent to the server during the
+ * challenge-response handshake. Username is decoupled from auth and is
+ * managed separately as a mutable display name (see PATCH /users/me).
+ */
 export interface CryptoIdentity {
-	username: string;
-	/** base64url-encoded Ed25519 public key (32 bytes) */
-	publicKey: string;
+  /** base64url-encoded Ed25519 public key (32 bytes). Primary auth identifier. */
+  publicKey: string;
 }
 
 export interface SubdocRegisteredEvent {
-	childId: string;
-	parentId: string;
+  childId: string;
+  parentId: string;
 }
 
 export type onSubdocRegisteredParameters = SubdocRegisteredEvent;
 
 export type onSubdocLoadedParameters = {
-	childId: string;
-	provider: import("./AbracadabraProvider.ts").AbracadabraProvider;
+  childId: string;
+  provider: import("./AbracadabraProvider.ts").AbracadabraProvider;
 };
 
-export interface AbracadabraOutgoingMessageArguments
-	extends OutgoingMessageArguments {
-	childDocumentName: string;
+export interface AbracadabraOutgoingMessageArguments extends OutgoingMessageArguments {
+  childDocumentName: string;
+}
+
+// ── REST API response types ──────────────────────────────────────────────────
+
+export interface UserProfile {
+  id: string;
+  username: string;
+  email: string | null;
+  displayName: string | null;
+}
+
+export interface DocumentMeta {
+  id: string;
+  parent_id: string | null;
+}
+
+export interface UploadMeta {
+  id: string;
+  doc_id: string;
+  filename: string;
+}
+
+export interface UploadInfo {
+  id: string;
+  filename: string;
+  mime_type: string;
+  size: number;
+}
+
+export interface PublicKeyInfo {
+  id: string;
+  publicKey: string;
+  deviceName: string | null;
+  revoked: boolean;
+}
+
+export interface HealthStatus {
+  status: string;
+  version: string;
+  active_documents: number;
 }