@abraca/dabra 0.1.6 → 0.2.0

package/dist/index.d.ts

@@ -311,6 +311,7 @@ declare class AbracadabraProvider extends HocuspocusProvider {
   private _client;
   private offlineStore;
   private childProviders;
+  private pendingLoads;
   private subdocLoading;
   private abracadabraConfig;
   private readonly boundHandleYSubdocsChange;
@@ -353,6 +354,7 @@ declare class AbracadabraProvider extends HocuspocusProvider {
    * the server is document-scoped (one WebSocket ↔ one document).
    */
   loadChild(childId: string): Promise<AbracadabraProvider>;
+  private _doLoadChild;
   private unloadChild;
   /** Return all currently-loaded child providers. */
   get children(): Map<string, AbracadabraProvider>;
@@ -766,6 +768,7 @@ interface CompleteHocuspocusProviderConfiguration {
   forceSyncInterval: false | number;
   onAuthenticated: (data: onAuthenticatedParameters) => void;
   onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
+  onRateLimited: () => void;
   onOpen: (data: onOpenParameters) => void;
   onConnect: () => void;
   onStatus: (data: onStatusParameters) => void;
@@ -807,6 +810,7 @@ declare class HocuspocusProvider extends EventEmitter {
   forwardClose: (e: onCloseParameters) => this;
   forwardDisconnect: (e: onDisconnectParameters) => this;
   forwardDestroy: () => this;
+  forwardRateLimited: () => this;
   setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
   get document(): Y.Doc;
   get isAttached(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/dabra",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "abracadabra provider",
   "keywords": [
     "abracadabra",

package/src/AbracadabraProvider.ts

@@ -61,6 +61,11 @@ export interface AbracadabraProviderConfiguration
 	websocketProvider?: HocuspocusProviderWebsocket;
 }
 
+/** Validate that a string is a UUID acceptable by the server's DocId parser. */
+function isValidDocId(id: string): boolean {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+
 /**
  * AbracadabraProvider extends HocuspocusProvider with:
  *
@@ -82,6 +87,7 @@ export class AbracadabraProvider extends HocuspocusProvider {
 	private _client: AbracadabraClient | null;
 	private offlineStore: OfflineStore | null;
 	private childProviders = new Map<string, AbracadabraProvider>();
+	private pendingLoads = new Map<string, Promise<AbracadabraProvider>>();
 	private subdocLoading: "lazy" | "eager";
 
 	private abracadabraConfig: AbracadabraProviderConfiguration;
@@ -281,6 +287,7 @@ export class AbracadabraProvider extends HocuspocusProvider {
 		loaded: Set<Y.Doc>;
 	}) {
 		for (const subdoc of added) {
+			if (!isValidDocId(subdoc.guid)) continue;
 			this.registerSubdoc(subdoc);
 		}
 		for (const subdoc of removed) {
@@ -315,11 +322,33 @@ export class AbracadabraProvider extends HocuspocusProvider {
 	 * child document id.  Each child opens its own WebSocket connection because
 	 * the server is document-scoped (one WebSocket ↔ one document).
 	 */
-	async loadChild(childId: string): Promise<AbracadabraProvider> {
+	loadChild(childId: string): Promise<AbracadabraProvider> {
+		if (!isValidDocId(childId)) {
+			return Promise.reject(
+				new Error(
+					`loadChild: "${childId}" is not a valid document ID (must be a UUID). ` +
+					`If this node was created with an older version of the app, delete it and recreate it.`,
+				),
+			);
+		}
+
 		if (this.childProviders.has(childId)) {
-			return this.childProviders.get(childId)!;
+			return Promise.resolve(this.childProviders.get(childId)!);
 		}
 
+		// Deduplicate concurrent calls: return the same Promise so both callers
+		// get the exact same AbracadabraProvider instance.
+		if (this.pendingLoads.has(childId)) {
+			return this.pendingLoads.get(childId)!;
+		}
+
+		const load = this._doLoadChild(childId);
+		this.pendingLoads.set(childId, load);
+		load.finally(() => this.pendingLoads.delete(childId));
+		return load;
+	}
+
+	private async _doLoadChild(childId: string): Promise<AbracadabraProvider> {
 		const childDoc = new Y.Doc({ guid: childId });
 
 		// Notify the server that this child belongs to the parent document and
@@ -346,7 +375,7 @@ export class AbracadabraProvider extends HocuspocusProvider {
 		const childProvider = new AbracadabraProvider({
 			name: childId,
 			document: childDoc,
-			url: this.abracadabraConfig.url,
+			url: this.abracadabraConfig.url ?? this.configuration.websocketProvider?.url,
 			token: this.configuration.token,
 			subdocLoading: this.subdocLoading,
 			disableOfflineStore: this.abracadabraConfig.disableOfflineStore,

package/src/HocuspocusProvider.ts

@@ -78,6 +78,7 @@ export interface CompleteHocuspocusProviderConfiguration {
 
   onAuthenticated: (data: onAuthenticatedParameters) => void;
   onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
+  onRateLimited: () => void;
   onOpen: (data: onOpenParameters) => void;
   onConnect: () => void;
   onStatus: (data: onStatusParameters) => void;
@@ -108,6 +109,7 @@ export class HocuspocusProvider extends EventEmitter {
     forceSyncInterval: false,
     onAuthenticated: () => null,
     onAuthenticationFailed: () => null,
+    onRateLimited: () => null,
     onOpen: () => null,
     onConnect: () => null,
     onMessage: () => null,
@@ -162,6 +164,7 @@ export class HocuspocusProvider extends EventEmitter {
 
     this.on("authenticated", this.configuration.onAuthenticated);
     this.on("authenticationFailed", this.configuration.onAuthenticationFailed);
+    this.on("rateLimited", this.configuration.onRateLimited);
 
     this.awareness?.on("update", () => {
       this.emit("awarenessUpdate", {
@@ -215,6 +218,8 @@ export class HocuspocusProvider extends EventEmitter {
 
   forwardDestroy = () => this.emit("destroy");
 
+  forwardRateLimited = () => this.emit("rateLimited");
+
   public setConfiguration(configuration: Partial<HocuspocusProviderConfiguration> = {}): void {
     if (!configuration.websocketProvider) {
       this.manageSocket = true;
@@ -492,6 +497,8 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.off("destroy", this.configuration.onDestroy);
     this.configuration.websocketProvider.off("destroy", this.forwardDestroy);
 
+    this.configuration.websocketProvider.off("rateLimited", this.forwardRateLimited);
+
     this.configuration.websocketProvider.detach(this);
 
     this._isAttached = false;
@@ -518,6 +525,8 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.on("destroy", this.configuration.onDestroy);
     this.configuration.websocketProvider.on("destroy", this.forwardDestroy);
 
+    this.configuration.websocketProvider.on("rateLimited", this.forwardRateLimited);
+
     this.configuration.websocketProvider.attach(this);
 
     this._isAttached = true;

package/src/HocuspocusProviderWebsocket.ts

@@ -500,13 +500,21 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     // Let’s update the connection status.
     this.status = WebSocketStatus.Disconnected;
     this.emit("status", { status: WebSocketStatus.Disconnected });
+
+    // Detect server-side rate-limit close (code 4429).
+    const isRateLimited = (event as any)?.code === 4429;
     this.emit("disconnect", { event });
+    if (isRateLimited) {
+      this.emit("rateLimited");
+    }
 
     // trigger connect if no retry is running and we want to have a connection
     if (!this.cancelWebsocketRetry && this.shouldConnect) {
+      // Apply a much longer delay for rate-limited closes to let the server window reset.
+      const delay = isRateLimited ? 60_000 : this.configuration.delay;
       setTimeout(() => {
         this.connect();
-      }, this.configuration.delay);
+      }, delay);
     }
   }