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

packages/common/nbstore/src/storage/dummy/awareness.ts

@@ -0,0 +1,16 @@
+import { DummyConnection } from '../../connection';
+import { type AwarenessRecord, AwarenessStorageBase } from '../awareness';
+
+export class DummyAwarenessStorage extends AwarenessStorageBase {
+  override update(_record: AwarenessRecord, _origin?: string): Promise<void> {
+    return Promise.resolve();
+  }
+  override subscribeUpdate(
+    _id: string,
+    _onUpdate: (update: AwarenessRecord, origin?: string) => void,
+    _onCollect: () => Promise<AwarenessRecord | null>
+  ): () => void {
+    return () => {};
+  }
+  override connection = new DummyConnection();
+}

packages/common/nbstore/src/storage/dummy/blob-sync.ts

@@ -0,0 +1,14 @@
+import { type Connection, DummyConnection } from '../../connection';
+import type { BlobSyncStorage } from '../blob-sync';
+
+export class DummyBlobSyncStorage implements BlobSyncStorage {
+  storageType = 'blobSync' as const;
+  connection: Connection<any> = new DummyConnection();
+
+  setBlobUploadedAt(): Promise<void> {
+    return Promise.resolve();
+  }
+  getBlobUploadedAt(): Promise<Date | null> {
+    return Promise.resolve(new Date());
+  }
+}

packages/common/nbstore/src/storage/dummy/blob.ts

@@ -0,0 +1,33 @@
+import { DummyConnection } from '../../connection';
+import {
+  type BlobRecord,
+  BlobStorageBase,
+  type ListedBlobRecord,
+} from '../blob';
+
+export class DummyBlobStorage extends BlobStorageBase {
+  override readonly isReadonly = true;
+  override get(
+    _key: string,
+    _signal?: AbortSignal
+  ): Promise<BlobRecord | null> {
+    return Promise.resolve(null);
+  }
+  override set(_blob: BlobRecord, _signal?: AbortSignal): Promise<void> {
+    return Promise.resolve();
+  }
+  override delete(
+    _key: string,
+    _permanently: boolean,
+    _signal?: AbortSignal
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+  override release(_signal?: AbortSignal): Promise<void> {
+    return Promise.resolve();
+  }
+  override list(_signal?: AbortSignal): Promise<ListedBlobRecord[]> {
+    return Promise.resolve([]);
+  }
+  override connection = new DummyConnection();
+}

packages/common/nbstore/src/storage/dummy/doc-sync.ts

@@ -0,0 +1,49 @@
+import { DummyConnection } from '../../connection';
+import type { DocClock, DocClocks } from '../doc';
+import { DocSyncStorageBase } from '../doc-sync';
+
+export class DummyDocSyncStorage extends DocSyncStorageBase {
+  override getPeerRemoteClock(
+    _peer: string,
+    _docId: string
+  ): Promise<DocClock | null> {
+    return Promise.resolve(null);
+  }
+  override getPeerRemoteClocks(_peer: string): Promise<DocClocks> {
+    return Promise.resolve({});
+  }
+  override setPeerRemoteClock(_peer: string, _clock: DocClock): Promise<void> {
+    return Promise.resolve();
+  }
+  override getPeerPulledRemoteClock(
+    _peer: string,
+    _docId: string
+  ): Promise<DocClock | null> {
+    return Promise.resolve(null);
+  }
+  override getPeerPulledRemoteClocks(_peer: string): Promise<DocClocks> {
+    return Promise.resolve({});
+  }
+  override setPeerPulledRemoteClock(
+    _peer: string,
+    _clock: DocClock
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+  override getPeerPushedClock(
+    _peer: string,
+    _docId: string
+  ): Promise<DocClock | null> {
+    return Promise.resolve(null);
+  }
+  override getPeerPushedClocks(_peer: string): Promise<DocClocks> {
+    return Promise.resolve({});
+  }
+  override setPeerPushedClock(_peer: string, _clock: DocClock): Promise<void> {
+    return Promise.resolve();
+  }
+  override clearClocks(): Promise<void> {
+    return Promise.resolve();
+  }
+  override connection = new DummyConnection();
+}

packages/common/nbstore/src/storage/dummy/doc.ts

@@ -0,0 +1,42 @@
+import { DummyConnection } from '../../connection';
+import {
+  type DocClock,
+  type DocClocks,
+  type DocDiff,
+  type DocRecord,
+  type DocStorage,
+  type DocUpdate,
+} from '../doc';
+
+export class DummyDocStorage implements DocStorage {
+  spaceId = '';
+  readonly storageType = 'doc';
+  readonly isReadonly = true;
+  getDoc(_docId: string): Promise<DocRecord | null> {
+    return Promise.resolve(null);
+  }
+  getDocDiff(_docId: string, _state?: Uint8Array): Promise<DocDiff | null> {
+    return Promise.resolve(null);
+  }
+  pushDocUpdate(update: DocUpdate, _origin?: string): Promise<DocClock> {
+    return Promise.resolve({
+      docId: update.docId,
+      timestamp: new Date(),
+    });
+  }
+  getDocTimestamp(_docId: string): Promise<DocClock | null> {
+    return Promise.resolve(null);
+  }
+  getDocTimestamps(_after?: Date): Promise<DocClocks> {
+    return Promise.resolve({});
+  }
+  deleteDoc(_docId: string): Promise<void> {
+    return Promise.resolve();
+  }
+  subscribeDocUpdate(
+    _callback: (update: DocRecord, origin?: string) => void
+  ): () => void {
+    return () => {};
+  }
+  connection = new DummyConnection();
+}

packages/common/nbstore/src/storage/dummy/indexer-sync.ts

@@ -0,0 +1,15 @@
+import { DummyConnection } from '../../connection';
+import { type DocIndexedClock, IndexerSyncStorageBase } from '../indexer-sync';
+
+export class DummyIndexerSyncStorage extends IndexerSyncStorageBase {
+  override connection = new DummyConnection();
+  override getDocIndexedClock(_docId: string): Promise<DocIndexedClock | null> {
+    return Promise.resolve(null);
+  }
+  override setDocIndexedClock(_docClock: DocIndexedClock): Promise<void> {
+    return Promise.resolve();
+  }
+  override clearDocIndexedClock(_docId: string): Promise<void> {
+    return Promise.resolve();
+  }
+}

packages/common/nbstore/src/storage/dummy/indexer.ts

@@ -0,0 +1,94 @@
+import { NEVER, type Observable } from 'rxjs';
+
+import { DummyConnection } from '../../connection';
+import {
+  type AggregateOptions,
+  type AggregateResult,
+  type IndexerDocument,
+  type IndexerSchema,
+  IndexerStorageBase,
+  type Query,
+  type SearchOptions,
+  type SearchResult,
+} from '../indexer';
+
+export class DummyIndexerStorage extends IndexerStorageBase {
+  readonly isReadonly = true;
+  readonly connection = new DummyConnection();
+
+  override search<
+    T extends keyof IndexerSchema,
+    const O extends SearchOptions<T>,
+  >(_table: T, _query: Query<T>, _options?: O): Promise<SearchResult<T, O>> {
+    return Promise.resolve({
+      pagination: { count: 0, limit: 0, skip: 0, hasMore: false },
+      nodes: [],
+    });
+  }
+  override aggregate<
+    T extends keyof IndexerSchema,
+    const O extends AggregateOptions<T>,
+  >(
+    _table: T,
+    _query: Query<T>,
+    _field: keyof IndexerSchema[T],
+    _options?: O
+  ): Promise<AggregateResult<T, O>> {
+    return Promise.resolve({
+      pagination: { count: 0, limit: 0, skip: 0, hasMore: false },
+      buckets: [],
+    });
+  }
+  override search$<
+    T extends keyof IndexerSchema,
+    const O extends SearchOptions<T>,
+  >(_table: T, _query: Query<T>, _options?: O): Observable<SearchResult<T, O>> {
+    return NEVER;
+  }
+  override aggregate$<
+    T extends keyof IndexerSchema,
+    const O extends AggregateOptions<T>,
+  >(
+    _table: T,
+    _query: Query<T>,
+    _field: keyof IndexerSchema[T],
+    _options?: O
+  ): Observable<AggregateResult<T, O>> {
+    return NEVER;
+  }
+
+  override deleteByQuery<T extends keyof IndexerSchema>(
+    _table: T,
+    _query: Query<T>
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+
+  override insert<T extends keyof IndexerSchema>(
+    _table: T,
+    _document: IndexerDocument<T>
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+  override delete<T extends keyof IndexerSchema>(
+    _table: T,
+    _id: string
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+  override update<T extends keyof IndexerSchema>(
+    _table: T,
+    _document: IndexerDocument<T>
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+  override refresh<T extends keyof IndexerSchema>(_table: T): Promise<void> {
+    return Promise.resolve();
+  }
+  override async refreshIfNeed(): Promise<void> {
+    return;
+  }
+  override async indexVersion(): Promise<number> {
+    return 0;
+  }
+}