snapshot of https://github.com/toeverything/AFFiNE.git (canary, 2026-09-16; blobs > 131072B omitted)

blocksuite/playground/apps/_common/sync/blob/mock-server.ts

@@ -0,0 +1,129 @@
+import type { BlobSource, BlobState } from '@blocksuite/sync';
+import { BehaviorSubject, ReplaySubject, share, throttleTime } from 'rxjs';
+
+/**
+ * @internal just for test
+ *
+ * API: /api/collection/:id/blob/:key
+ * GET: get blob
+ * PUT: set blob
+ * DELETE: delete blob
+ */
+export class MockServerBlobSource implements BlobSource {
+  private readonly _cache = new Map<string, Blob>();
+  private readonly _states = new Map<string, BehaviorSubject<BlobState>>();
+
+  readonly = false;
+
+  constructor(readonly name: string) {}
+
+  async delete(key: string) {
+    this._cache.delete(key);
+    this._states.delete(key);
+
+    await fetch(`/api/collection/${this.name}/blob/${key}`, {
+      method: 'DELETE',
+    });
+  }
+
+  async get(key: string) {
+    if (this._cache.has(key)) return this._cache.get(key)!;
+
+    let state$ = this._states.get(key);
+    if (!state$) {
+      state$ = new BehaviorSubject<BlobState>(defaultState());
+
+      this._states.set(key, state$);
+    }
+
+    let blob: Blob | null = null;
+
+    nextState(state$, { downloading: true });
+
+    try {
+      const resp = await fetch(`/api/collection/${this.name}/blob/${key}`);
+
+      if (!resp.ok) throw new Error(`Failed to fetch blob ${key}`);
+
+      blob = await resp.blob();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      nextState(state$, { errorMessage });
+    } finally {
+      nextState(state$, { downloading: false });
+
+      if (blob) {
+        this._cache.set(key, blob);
+      }
+    }
+
+    return blob;
+  }
+
+  async list() {
+    return Array.from(this._cache.keys());
+  }
+
+  async set(key: string, value: Blob) {
+    let state$ = this._states.get(key);
+    if (!state$) {
+      state$ = new BehaviorSubject<BlobState>(defaultState());
+
+      this._states.set(key, state$);
+    }
+
+    this._cache.set(key, value);
+
+    nextState(state$, { uploading: true });
+
+    try {
+      await fetch(`/api/collection/${this.name}/blob/${key}`, {
+        method: 'PUT',
+        body: value,
+      });
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      nextState(state$, { errorMessage });
+    } finally {
+      nextState(state$, { uploading: false });
+    }
+
+    return key;
+  }
+
+  blobState$(key: string) {
+    let state$ = this._states.get(key);
+
+    if (!state$) {
+      state$ = new BehaviorSubject<BlobState>(defaultState());
+
+      this._states.set(key, state$);
+
+      nextState(state$, { errorMessage: 'Blob not found' });
+    }
+
+    return state$.pipe(
+      throttleTime(1000, undefined, { leading: true, trailing: true }),
+      share({
+        connector: () => new ReplaySubject(1),
+      })
+    );
+  }
+}
+
+function defaultState(): BlobState {
+  return {
+    uploading: false,
+    downloading: false,
+    overSize: false,
+    needDownload: false,
+    needUpload: false,
+  };
+}
+
+function nextState(
+  state$: BehaviorSubject<BlobState>,
+  state?: Partial<BlobState>
+) {
+  state$.next({ ...state$.value, ...state });
+}

blocksuite/playground/apps/_common/sync/websocket/awareness.ts

@@ -0,0 +1,93 @@
+import type { AwarenessSource } from '@blocksuite/sync';
+import type { Awareness } from 'y-protocols/awareness';
+import {
+  applyAwarenessUpdate,
+  encodeAwarenessUpdate,
+} from 'y-protocols/awareness';
+
+import type { WebSocketMessage } from './types';
+
+type AwarenessChanges = Record<'added' | 'updated' | 'removed', number[]>;
+
+export class WebSocketAwarenessSource implements AwarenessSource {
+  private readonly _onAwareness = (
+    changes: AwarenessChanges,
+    origin: unknown
+  ) => {
+    if (origin === 'remote') return;
+
+    const changedClients = Object.values(changes).reduce((res, cur) =>
+      res.concat(cur)
+    );
+
+    if (!this.awareness) {
+      throw new Error('awareness is not found');
+    }
+    const update = encodeAwarenessUpdate(this.awareness, changedClients);
+    this.ws.send(
+      JSON.stringify({
+        channel: 'awareness',
+        payload: {
+          type: 'update',
+          update: Array.from(update),
+        },
+      } satisfies WebSocketMessage)
+    );
+  };
+
+  private readonly _onWebSocket = (event: MessageEvent<string>) => {
+    const data = JSON.parse(event.data) as WebSocketMessage;
+
+    if (data.channel !== 'awareness') return;
+    const { type } = data.payload;
+
+    if (type === 'update') {
+      const update = data.payload.update;
+      if (!this.awareness) {
+        throw new Error('awareness is not found');
+      }
+      applyAwarenessUpdate(this.awareness, new Uint8Array(update), 'remote');
+    }
+
+    if (type === 'connect') {
+      if (!this.awareness) {
+        throw new Error('awareness is not found');
+      }
+      this.ws.send(
+        JSON.stringify({
+          channel: 'awareness',
+          payload: {
+            type: 'update',
+            update: Array.from(
+              encodeAwarenessUpdate(this.awareness, [this.awareness.clientID])
+            ),
+          },
+        } satisfies WebSocketMessage)
+      );
+    }
+  };
+
+  awareness: Awareness | null = null;
+
+  constructor(readonly ws: WebSocket) {}
+
+  connect(awareness: Awareness): void {
+    this.awareness = awareness;
+    awareness.on('update', this._onAwareness);
+
+    this.ws.addEventListener('message', this._onWebSocket);
+    this.ws.send(
+      JSON.stringify({
+        channel: 'awareness',
+        payload: {
+          type: 'connect',
+        },
+      } satisfies WebSocketMessage)
+    );
+  }
+
+  disconnect(): void {
+    this.awareness?.off('update', this._onAwareness);
+    this.ws.close();
+  }
+}

blocksuite/playground/apps/_common/sync/websocket/doc.ts

@@ -0,0 +1,104 @@
+import type { DocSource } from '@blocksuite/sync';
+import { diffUpdate, encodeStateVectorFromUpdate, mergeUpdates } from 'yjs';
+
+import type { WebSocketMessage } from './types';
+
+export class WebSocketDocSource implements DocSource {
+  private readonly _onMessage = (event: MessageEvent<string>) => {
+    const data = JSON.parse(event.data) as WebSocketMessage;
+
+    if (data.channel !== 'doc') return;
+
+    if (data.payload.type === 'init') {
+      for (const [docId, data] of this.docMap) {
+        this.ws.send(
+          JSON.stringify({
+            channel: 'doc',
+            payload: {
+              type: 'update',
+              docId,
+              updates: Array.from(data),
+            },
+          } satisfies WebSocketMessage)
+        );
+      }
+      return;
+    }
+
+    const { docId, updates } = data.payload;
+    const update = this.docMap.get(docId);
+    if (update) {
+      this.docMap.set(docId, mergeUpdates([update, new Uint8Array(updates)]));
+    } else {
+      this.docMap.set(docId, new Uint8Array(updates));
+    }
+  };
+
+  docMap = new Map<string, Uint8Array>();
+
+  name = 'websocket';
+
+  constructor(readonly ws: WebSocket) {
+    this.ws.addEventListener('message', this._onMessage);
+
+    this.ws.send(
+      JSON.stringify({
+        channel: 'doc',
+        payload: {
+          type: 'init',
+        },
+      } satisfies WebSocketMessage)
+    );
+  }
+
+  pull(docId: string, state: Uint8Array) {
+    const update = this.docMap.get(docId);
+    if (!update) return null;
+
+    const diff = state.length ? diffUpdate(update, state) : update;
+    return { data: diff, state: encodeStateVectorFromUpdate(update) };
+  }
+
+  push(docId: string, data: Uint8Array) {
+    const update = this.docMap.get(docId);
+    if (update) {
+      this.docMap.set(docId, mergeUpdates([update, data]));
+    } else {
+      this.docMap.set(docId, data);
+    }
+
+    const latest = this.docMap.get(docId);
+    if (!latest) {
+      throw new Error('latest is not found');
+    }
+    this.ws.send(
+      JSON.stringify({
+        channel: 'doc',
+        payload: {
+          type: 'update',
+          docId,
+          updates: Array.from(latest),
+        },
+      } satisfies WebSocketMessage)
+    );
+  }
+
+  subscribe(cb: (docId: string, data: Uint8Array) => void) {
+    const abortController = new AbortController();
+    this.ws.addEventListener(
+      'message',
+      (event: MessageEvent<string>) => {
+        const data = JSON.parse(event.data) as WebSocketMessage;
+
+        if (data.channel !== 'doc' || data.payload.type !== 'update') return;
+
+        const { docId, updates } = data.payload;
+        cb(docId, new Uint8Array(updates));
+      },
+      { signal: abortController.signal }
+    );
+    return () => {
+      abortController.abort();
+    };
+  }
+}

blocksuite/playground/apps/_common/sync/websocket/types.ts

@@ -0,0 +1,19 @@
+export type AwarenessMessage = {
+  channel: 'awareness';
+  payload: { type: 'connect' } | { type: 'update'; update: number[] };
+};
+
+export type DocMessage = {
+  channel: 'doc';
+  payload:
+    | {
+        type: 'init';
+      }
+    | {
+        type: 'update';
+        docId: string;
+        updates: number[];
+      };
+};
+
+export type WebSocketMessage = AwarenessMessage | DocMessage;

blocksuite/playground/apps/_common/sync/websocket/utils.ts

@@ -0,0 +1,8 @@
+const BASE_URL = new URL(import.meta.env.PLAYGROUND_SERVER);
+export async function generateRoomId(): Promise<string> {
+  return fetch(new URL('/room/', BASE_URL), {
+    method: 'post',
+  })
+    .then(res => res.json())
+    .then(({ id }) => id);
+}