@dxos/echo-pipeline 0.4.10-main.d4e372f → 0.4.10-main.d51f2c2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-pipeline",
-  "version": "0.4.10-main.d4e372f",
+  "version": "0.4.10-main.d51f2c2",
   "description": "ECHO database.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -35,36 +35,39 @@
     "src"
   ],
   "dependencies": {
+    "abstract-level": "^1.0.2",
     "crc-32": "^1.2.2",
-    "@dxos/automerge": "0.4.10-main.d4e372f",
-    "@dxos/async": "0.4.10-main.d4e372f",
-    "@dxos/context": "0.4.10-main.d4e372f",
-    "@dxos/codec-protobuf": "0.4.10-main.d4e372f",
-    "@dxos/crypto": "0.4.10-main.d4e372f",
-    "@dxos/credentials": "0.4.10-main.d4e372f",
-    "@dxos/debug": "0.4.10-main.d4e372f",
-    "@dxos/echo-db": "0.4.10-main.d4e372f",
-    "@dxos/feed-store": "0.4.10-main.d4e372f",
-    "@dxos/hypercore": "0.4.10-main.d4e372f",
-    "@dxos/invariant": "0.4.10-main.d4e372f",
-    "@dxos/keyring": "0.4.10-main.d4e372f",
-    "@dxos/keys": "0.4.10-main.d4e372f",
-    "@dxos/messaging": "0.4.10-main.d4e372f",
-    "@dxos/log": "0.4.10-main.d4e372f",
-    "@dxos/network-manager": "0.4.10-main.d4e372f",
-    "@dxos/node-std": "0.4.10-main.d4e372f",
-    "@dxos/protocols": "0.4.10-main.d4e372f",
-    "@dxos/random-access-storage": "0.4.10-main.d4e372f",
-    "@dxos/teleport": "0.4.10-main.d4e372f",
-    "@dxos/rpc": "0.4.10-main.d4e372f",
-    "@dxos/teleport-extension-automerge-replicator": "0.4.10-main.d4e372f",
-    "@dxos/teleport-extension-gossip": "0.4.10-main.d4e372f",
-    "@dxos/teleport-extension-object-sync": "0.4.10-main.d4e372f",
-    "@dxos/teleport-extension-replicator": "0.4.10-main.d4e372f",
-    "@dxos/tracing": "0.4.10-main.d4e372f",
-    "@dxos/typings": "0.4.10-main.d4e372f",
-    "@dxos/timeframe": "0.4.10-main.d4e372f",
-    "@dxos/util": "0.4.10-main.d4e372f"
+    "level": "^8.0.1",
+    "level-transcoder": "^1.0.1",
+    "@dxos/async": "0.4.10-main.d51f2c2",
+    "@dxos/codec-protobuf": "0.4.10-main.d51f2c2",
+    "@dxos/context": "0.4.10-main.d51f2c2",
+    "@dxos/credentials": "0.4.10-main.d51f2c2",
+    "@dxos/automerge": "0.4.10-main.d51f2c2",
+    "@dxos/crypto": "0.4.10-main.d51f2c2",
+    "@dxos/debug": "0.4.10-main.d51f2c2",
+    "@dxos/feed-store": "0.4.10-main.d51f2c2",
+    "@dxos/echo-db": "0.4.10-main.d51f2c2",
+    "@dxos/hypercore": "0.4.10-main.d51f2c2",
+    "@dxos/keyring": "0.4.10-main.d51f2c2",
+    "@dxos/keys": "0.4.10-main.d51f2c2",
+    "@dxos/invariant": "0.4.10-main.d51f2c2",
+    "@dxos/log": "0.4.10-main.d51f2c2",
+    "@dxos/messaging": "0.4.10-main.d51f2c2",
+    "@dxos/node-std": "0.4.10-main.d51f2c2",
+    "@dxos/protocols": "0.4.10-main.d51f2c2",
+    "@dxos/random-access-storage": "0.4.10-main.d51f2c2",
+    "@dxos/network-manager": "0.4.10-main.d51f2c2",
+    "@dxos/rpc": "0.4.10-main.d51f2c2",
+    "@dxos/teleport": "0.4.10-main.d51f2c2",
+    "@dxos/teleport-extension-automerge-replicator": "0.4.10-main.d51f2c2",
+    "@dxos/teleport-extension-gossip": "0.4.10-main.d51f2c2",
+    "@dxos/teleport-extension-object-sync": "0.4.10-main.d51f2c2",
+    "@dxos/timeframe": "0.4.10-main.d51f2c2",
+    "@dxos/typings": "0.4.10-main.d51f2c2",
+    "@dxos/teleport-extension-replicator": "0.4.10-main.d51f2c2",
+    "@dxos/tracing": "0.4.10-main.d51f2c2",
+    "@dxos/util": "0.4.10-main.d51f2c2"
   },
   "devDependencies": {
     "fast-check": "^3.15.1",

package/src/automerge/automerge-doc-loader.ts

@@ -17,6 +17,8 @@ type SpaceDocumentLinks = SpaceDoc['links'];
 export interface AutomergeDocumentLoader {
   onObjectDocumentLoaded: Event<ObjectDocumentLoaded>;
 
+  getAllHandles(): DocHandle<SpaceDoc>[];
+
   loadSpaceRootDocHandle(ctx: Context, spaceState: SpaceState): Promise<void>;
   loadObjectDocument(objectId: string): void;
   getSpaceRootDocHandle(): DocHandle<SpaceDoc>;
@@ -52,6 +54,10 @@ export class AutomergeDocumentLoaderImpl implements AutomergeDocumentLoader {
     private readonly _repo: Repo,
   ) {}
 
+  getAllHandles(): DocHandle<SpaceDoc>[] {
+    return [...new Set(this._objectDocumentHandles.values())];
+  }
+
   public async loadSpaceRootDocHandle(ctx: Context, spaceState: SpaceState): Promise<void> {
     if (this._spaceRootDocHandle != null) {
       return;

package/src/automerge/automerge-host.test.ts

@@ -25,10 +25,18 @@ import { arrayToBuffer, bufferToArray } from '@dxos/util';
 import { AutomergeHost } from './automerge-host';
 import { AutomergeStorageAdapter } from './automerge-storage-adapter';
 import { MeshNetworkAdapter } from './mesh-network-adapter';
+import { createTestLevel } from '../testing';
 
 describe('AutomergeHost', () => {
-  test('can create documents', () => {
-    const host = new AutomergeHost({ directory: createStorage({ type: StorageType.RAM }).createDirectory() });
+  test('can create documents', async () => {
+    const level = createTestLevel();
+    await level.open();
+    afterTest(() => level.close());
+    const host = new AutomergeHost({
+      db: level.sublevel('automerge'),
+    });
+    await host.open();
+    afterTest(() => host.close());
 
     const handle = host.repo.create();
     handle.change((doc: any) => {
@@ -38,9 +46,13 @@ describe('AutomergeHost', () => {
   });
 
   test('changes are preserved in storage', async () => {
-    const storageDirectory = createStorage({ type: StorageType.RAM }).createDirectory();
+    const level = createTestLevel();
+    await level.open();
+    afterTest(() => level.close());
 
-    const host = new AutomergeHost({ directory: storageDirectory });
+    const host = new AutomergeHost({ db: level.sublevel('automerge') });
+    await host.open();
+    afterTest(() => host.close());
     const handle = host.repo.create();
     handle.change((doc: any) => {
       doc.text = 'Hello world';
@@ -50,7 +62,9 @@ describe('AutomergeHost', () => {
     // TODO(dmaretskyi): Is there a way to know when automerge has finished saving?
     await sleep(100);
 
-    const host2 = new AutomergeHost({ directory: storageDirectory });
+    const host2 = new AutomergeHost({ db: level.sublevel('automerge') });
+    await host2.open();
+    afterTest(() => host2.close());
     const handle2 = host2.repo.find(url);
     await handle2.whenReady();
     expect(handle2.docSync().text).toEqual('Hello world');

package/src/automerge/automerge-host.ts

@@ -10,23 +10,29 @@ import {
   type StorageKey,
   type DocHandle,
   type DocHandleChangePayload,
+  type StorageAdapterInterface,
 } from '@dxos/automerge/automerge-repo';
-import { IndexedDBStorageAdapter } from '@dxos/automerge/automerge-repo-storage-indexeddb';
 import { type Stream } from '@dxos/codec-protobuf';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { idCodec } from '@dxos/protocols';
-import { type HostInfo, type SyncRepoRequest, type SyncRepoResponse } from '@dxos/protocols/proto/dxos/echo/service';
-import { StorageType, type Directory } from '@dxos/random-access-storage';
+import {
+  type FlushRequest,
+  type HostInfo,
+  type SyncRepoRequest,
+  type SyncRepoResponse,
+} from '@dxos/protocols/proto/dxos/echo/service';
+import { type Directory } from '@dxos/random-access-storage';
 import { type AutomergeReplicator } from '@dxos/teleport-extension-automerge-replicator';
 import { trace } from '@dxos/tracing';
-import { ComplexMap, ComplexSet, defaultMap, mapValues } from '@dxos/util';
+import { ComplexMap, ComplexSet, type MaybePromise, defaultMap, mapValues } from '@dxos/util';
 
-import { AutomergeStorageAdapter } from './automerge-storage-adapter';
-import { AutomergeStorageWrapper } from './automerge-storage–wrapper';
+import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
 import { LocalHostNetworkAdapter } from './local-host-network-adapter';
 import { MeshNetworkAdapter } from './mesh-network-adapter';
+import { levelMigration } from './migrations';
+import { type MySublevel } from './types';
 
 export type { DocumentId };
 
@@ -35,20 +41,28 @@ export interface MetadataMethods {
 }
 
 export type AutomergeHostParams = {
-  directory: Directory;
+  db: MaybePromise<MySublevel>;
+  /**
+   * For migration purposes.
+   */
+  directory?: Directory;
   metadata?: MetadataMethods;
 };
 
 @trace.resource()
 export class AutomergeHost {
   private readonly _ctx = new Context();
-  private readonly _repo: Repo;
-  private readonly _meshNetwork: MeshNetworkAdapter;
-  private readonly _clientNetwork: LocalHostNetworkAdapter;
-  private readonly _storage: AutomergeStorageWrapper;
+  private readonly _directory?: Directory;
+  private readonly _db: MaybePromise<MySublevel>;
+  private readonly _metadata?: MetadataMethods;
+
+  private _repo!: Repo;
+  private _meshNetwork!: MeshNetworkAdapter;
+  private _clientNetwork!: LocalHostNetworkAdapter;
+  private _storage!: StorageAdapterInterface & { close?: () => void };
 
   @trace.info()
-  private readonly _peerId: string;
+  private _peerId!: string;
 
   /**
    * spaceKey -> deviceKey[]
@@ -56,24 +70,25 @@ export class AutomergeHost {
   private readonly _authorizedDevices = new ComplexMap<PublicKey, ComplexSet<PublicKey>>(PublicKey.hash);
 
   private readonly _updatingMetadata = new Map<string, Promise<void>>();
-  private readonly _metadata?: MetadataMethods;
 
   public _requestedDocs = new Set<string>();
 
-  constructor({ directory, metadata }: AutomergeHostParams) {
+  constructor({ directory, db, metadata }: AutomergeHostParams) {
+    this._directory = directory;
+    this._db = db;
     this._metadata = metadata;
-    this._meshNetwork = new MeshNetworkAdapter();
-    this._clientNetwork = new LocalHostNetworkAdapter();
+  }
 
-    this._storage = new AutomergeStorageWrapper({
-      storage:
-        // TODO(mykola): Delete specific handling of IDB storage.
-        directory.type === StorageType.IDB
-          ? new IndexedDBStorageAdapter(directory.path, 'data')
-          : new AutomergeStorageAdapter(directory),
+  async open() {
+    this._directory && (await levelMigration({ db: await this._db, directory: this._directory }));
+    this._storage = new LevelDBStorageAdapter({
+      db: await this._db,
       callbacks: { beforeSave: (params) => this._beforeSave(params) },
     });
     this._peerId = `host-${PublicKey.random().toHex()}` as PeerId;
+
+    this._meshNetwork = new MeshNetworkAdapter();
+    this._clientNetwork = new LocalHostNetworkAdapter();
     this._repo = new Repo({
       peerId: this._peerId as PeerId,
       network: [this._clientNetwork, this._meshNetwork],
@@ -138,10 +153,17 @@ export class AutomergeHost {
       this._repo.on('document', listener);
       this._ctx.onDispose(() => {
         this._repo.off('document', listener);
+        Object.values(this._repo.handles).forEach((handle) => handle.off('change'));
       });
     }
   }
 
+  async close() {
+    this._storage.close?.();
+    await this._clientNetwork.close();
+    await this._ctx.dispose();
+  }
+
   get repo(): Repo {
     return this._repo;
   }
@@ -156,9 +178,6 @@ export class AutomergeHost {
   private _onDocument(handle: DocHandle<any>) {
     const listener = (event: DocHandleChangePayload<any>) => this._onUpdate(event);
     handle.on('change', listener);
-    this._ctx.onDispose(() => {
-      handle.off('change', listener);
-    });
   }
 
   private _onUpdate(event: DocHandleChangePayload<any>) {
@@ -197,8 +216,8 @@ export class AutomergeHost {
       hasDoc: !!handle.docSync(),
       heads: handle.docSync() ? automerge.getHeads(handle.docSync()) : null,
       data:
-        handle.docSync()?.doc &&
-        mapValues(handle.docSync()?.doc, (value, key) => {
+        handle.docSync() &&
+        mapValues(handle.docSync(), (value, key) => {
           try {
             switch (key) {
               case 'access':
@@ -221,16 +240,16 @@ export class AutomergeHost {
     return this._repo.peers;
   }
 
-  async close() {
-    await this._storage.close();
-    await this._clientNetwork.close();
-    await this._ctx.dispose();
-  }
-
   //
   // Methods for client-services.
   //
 
+  async flush({ documentIds }: FlushRequest): Promise<void> {
+    // Note: Wait for all requested documents to be loaded/synced from thin-client.
+    await Promise.all(documentIds?.map((id) => this._repo.find(id as DocumentId).whenReady()) ?? []);
+    await this._repo.flush(documentIds as DocumentId[]);
+  }
+
   syncRepo(request: SyncRepoRequest): Stream<SyncRepoResponse> {
     return this._clientNetwork.syncRepo(request);
   }

package/src/automerge/index.ts

@@ -8,3 +8,4 @@ export * from './automerge-doc-loader';
 export * from './local-host-network-adapter';
 export * from './mesh-network-adapter';
 export * from './types';
+export * from './reference';

package/src/automerge/level.test.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+import { Level } from 'level';
+
+import { PublicKey } from '@dxos/keys';
+import { describe, test } from '@dxos/test';
+
+import { createTestLevel } from '../testing';
+
+describe('Level', () => {
+  test('missing keys', async () => {
+    const level = createTestLevel();
+    await level.open();
+
+    expect(() => level.get('missing')).to.throw;
+  });
+
+  test('data persistance after reload', async () => {
+    const path = `/tmp/dxos-${PublicKey.random().toHex()}`;
+    const level = new Level<string, string>(path);
+    await level.open();
+
+    const key = 'name';
+    const value = 'Rich';
+    {
+      await level.put(key, value);
+      expect(await level.get(key)).to.equal(value);
+    }
+
+    await level.close();
+
+    {
+      const level = new Level<string, string>(path);
+      await level.open();
+      expect(await level.get(key)).to.equal(value);
+      await level.clear();
+      expect(() => level.get(key)).to.throw;
+    }
+  });
+});

package/src/automerge/leveldb-storage-adapter.ts

@@ -0,0 +1,105 @@
+//
+// Copyright 2024 DXOS.org
+// s
+
+import { type MixedEncoding } from 'level-transcoder';
+
+import { type StorageAdapterInterface, type Chunk, type StorageKey } from '@dxos/automerge/automerge-repo';
+import { type MaybePromise } from '@dxos/util';
+
+import { type MySublevel } from './types';
+
+export type LevelDBStorageAdapterParams = {
+  db: MySublevel;
+  callbacks?: StorageCallbacks;
+};
+
+export type StorageCallbacks = {
+  beforeSave?: (path: StorageKey) => MaybePromise<void>;
+  afterSave?: (path: StorageKey) => MaybePromise<void>;
+};
+
+export class LevelDBStorageAdapter implements StorageAdapterInterface {
+  private _state: 'opened' | 'closed' = 'opened';
+  constructor(private readonly _params: LevelDBStorageAdapterParams) {}
+
+  async load(keyArray: StorageKey): Promise<Uint8Array | undefined> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
+    return this._params.db
+      .get<StorageKey, Uint8Array>(keyArray, { ...encodingOptions })
+      .catch((err) => (err.code === 'LEVEL_NOT_FOUND' ? undefined : Promise.reject(err)));
+  }
+
+  async save(keyArray: StorageKey, binary: Uint8Array): Promise<void> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
+    await this._params.callbacks?.beforeSave?.(keyArray);
+    await this._params.db.put<StorageKey, Uint8Array>(keyArray, Buffer.from(binary), {
+      ...encodingOptions,
+    });
+    await this._params.callbacks?.afterSave?.(keyArray);
+  }
+
+  async remove(keyArray: StorageKey): Promise<void> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
+    await this._params.db.del<StorageKey>(keyArray, { ...encodingOptions });
+  }
+
+  async loadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
+    if (this._state !== 'opened') {
+      return [];
+    }
+    const result: Chunk[] = [];
+    for await (const [key, value] of this._params.db.iterator<StorageKey, Uint8Array>({
+      gte: keyPrefix,
+      lte: [...keyPrefix, '\uffff'],
+      ...encodingOptions,
+    })) {
+      result.push({
+        key,
+        data: value,
+      });
+    }
+    return result;
+  }
+
+  async removeRange(keyPrefix: StorageKey): Promise<void> {
+    if (this._state !== 'opened') {
+      return undefined;
+    }
+    const batch = this._params.db.batch();
+
+    for await (const [key] of this._params.db.iterator<StorageKey, Uint8Array>({
+      gte: keyPrefix,
+      lte: [...keyPrefix, '\uffff'],
+      ...encodingOptions,
+    })) {
+      batch.del<StorageKey>(key, { ...encodingOptions });
+    }
+    await batch.write();
+  }
+
+  close() {
+    this._state = 'closed';
+  }
+}
+
+const keyEncoder: MixedEncoding<StorageKey, Uint8Array, StorageKey> = {
+  encode: (key: StorageKey): Uint8Array =>
+    Buffer.from(key.map((k) => k.replaceAll('%', '%25').replaceAll('-', '%2D')).join('-')),
+  decode: (key: Uint8Array): StorageKey =>
+    Buffer.from(key)
+      .toString()
+      .split('-')
+      .map((k) => k.replaceAll('%2D', '-').replaceAll('%25', '%')),
+};
+
+export const encodingOptions = {
+  keyEncoding: keyEncoder,
+  valueEncoding: 'buffer',
+};

package/src/automerge/migrations.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type StorageKey } from '@dxos/automerge/automerge-repo';
+import { IndexedDBStorageAdapter } from '@dxos/automerge/automerge-repo-storage-indexeddb';
+import { log } from '@dxos/log';
+import { StorageType, type Directory } from '@dxos/random-access-storage';
+
+import { AutomergeStorageAdapter } from './automerge-storage-adapter';
+import { encodingOptions } from './leveldb-storage-adapter';
+import { type MySublevel } from './types';
+
+export const levelMigration = async ({ db, directory }: { db: MySublevel; directory: Directory }) => {
+  // Note: Make automigration from previous storage to leveldb here.
+  const isNewLevel = !(await db
+    .iterator<StorageKey, Uint8Array>({
+      ...encodingOptions,
+    })
+    .next());
+
+  if (!isNewLevel) {
+    return;
+  }
+
+  const oldStorageAdapter =
+    directory.type === StorageType.IDB
+      ? new IndexedDBStorageAdapter(directory.path, 'data')
+      : new AutomergeStorageAdapter(directory);
+
+  const chunks = await oldStorageAdapter.loadRange([]);
+  if (chunks.length === 0) {
+    return;
+  }
+  const batch = db.batch();
+  log.info('found chunks on old storage adapter', { chunks: chunks.length });
+  for (const { key, data } of await oldStorageAdapter.loadRange([])) {
+    data && batch.put<StorageKey, Uint8Array>(key, data, { ...encodingOptions });
+  }
+  await batch.write();
+};

package/src/automerge/reference.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Reference } from '@dxos/echo-db';
+
+export const REFERENCE_TYPE_TAG = 'dxos.echo.model.document.Reference';
+
+/**
+ * Reference as it is stored in Automerge document.
+ */
+export type EncodedReferenceObject = {
+  '@type': typeof REFERENCE_TYPE_TAG;
+  itemId: string | null;
+  protocol: string | null;
+  host: string | null;
+};
+
+export const encodeReference = (reference: Reference): EncodedReferenceObject => ({
+  '@type': REFERENCE_TYPE_TAG,
+  // NOTE: Automerge do not support undefined values, so we need to use null instead.
+  itemId: reference.itemId ?? null,
+  protocol: reference.protocol ?? null,
+  host: reference.host ?? null,
+});
+
+export const decodeReference = (value: any) =>
+  new Reference(value.itemId, value.protocol ?? undefined, value.host ?? undefined);
+
+export const isEncodedReferenceObject = (value: any): value is EncodedReferenceObject =>
+  typeof value === 'object' && value !== null && value['@type'] === REFERENCE_TYPE_TAG;

package/src/automerge/storage-adapter.test.ts

@@ -0,0 +1,90 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { type StorageAdapterInterface } from '@dxos/automerge/automerge-repo';
+import { PublicKey } from '@dxos/keys';
+import { StorageType, createStorage } from '@dxos/random-access-storage';
+import { afterTest, describe, test } from '@dxos/test';
+import { type MaybePromise } from '@dxos/util';
+
+import { AutomergeStorageAdapter } from './automerge-storage-adapter';
+import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
+import { createTestLevel } from '../testing';
+
+const runTests = (
+  testNamespace: string,
+  /** Run per test. Expects automatic clean-up with `afterTest`. */ createAdapter: () => MaybePromise<StorageAdapterInterface>,
+) => {
+  describe(testNamespace, () => {
+    const chunks = [
+      { key: ['a', 'b', 'c', '1'], data: PublicKey.random().asUint8Array() },
+      { key: ['a', 'b', 'c', '2'], data: PublicKey.random().asUint8Array() },
+      { key: ['a', 'b', 'd', '3'], data: PublicKey.random().asUint8Array() },
+      { key: ['a', 'b', 'd', '4'], data: PublicKey.random().asUint8Array() },
+    ];
+
+    test('should store and retrieve data', async () => {
+      const adapter = await createAdapter();
+
+      await adapter.save(chunks[0].key, chunks[0].data);
+      expect(await adapter.load(chunks[0].key)).to.deep.equal(chunks[0].data);
+    });
+
+    test('loadRange return inputs with correct prefixes', async () => {
+      const adapter = await createAdapter();
+
+      for (const chunk of chunks) {
+        await adapter.save(chunk.key, chunk.data);
+      }
+
+      expect((await adapter.loadRange(['a', 'b'])).length).to.equal(4);
+      expect((await adapter.loadRange(['a', 'b', 'c']))[0]).to.deep.equal(chunks[0]);
+      expect((await adapter.loadRange(['a', 'b', 'c'])).length).to.equal(2);
+    });
+
+    test('deletion works', async () => {
+      const adapter = await createAdapter();
+
+      for (const chunk of chunks) {
+        await adapter.save(chunk.key, chunk.data);
+      }
+
+      await adapter.remove(['a', 'b', 'c', '1']);
+
+      expect((await adapter.loadRange(['a', 'b'])).length).to.equal(3);
+      expect((await adapter.loadRange(['a', 'b', 'c'])).length).to.equal(1);
+
+      await adapter.removeRange(['a', 'b', 'd']);
+
+      expect((await adapter.loadRange(['a', 'b'])).length).to.equal(1);
+      expect((await adapter.loadRange(['a', 'b']))[0]).to.deep.equal(chunks[1]);
+      expect(await adapter.load(['a', 'b', 'c', '2'])).to.deep.equal(chunks[1].data);
+      expect(await adapter.load(['a', 'b', 'd', '3'])).to.be.undefined;
+    });
+  });
+};
+
+/**
+ * Run tests for AutomergeStorageAdapter.
+ */
+runTests('AutomergeStorageAdapter', () => {
+  const storage = createStorage({ type: StorageType.RAM });
+  afterTest(() => storage.close());
+  const dir = storage.createDirectory('automerge');
+  const adapter = new AutomergeStorageAdapter(dir);
+  afterTest(() => adapter.close());
+  return adapter;
+});
+
+/**
+ * Run tests for LevelDBStorageAdapter.
+ */
+runTests('LevelDBStorageAdapter', async () => {
+  const level = createTestLevel();
+  await level.open();
+  afterTest(() => level.close());
+  return new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
+});

package/src/automerge/types.ts

@@ -2,11 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-//
-// Copyright 2023 DXOS.org
-//
+import { type AbstractSublevel } from 'abstract-level';
+import { type Level } from 'level';
 
-import { type Reference } from '@dxos/echo-db';
+import { type EncodedReferenceObject } from './reference';
 
 export type SpaceState = {
   // Url of the root automerge document.
@@ -79,5 +78,8 @@ export type ObjectSystem = {
   /**
    * Object reference ('protobuf' protocol) type.
    */
-  type?: Reference;
+  type?: EncodedReferenceObject;
 };
+
+export type MyLevel = Level<string, string>;
+export type MySublevel = AbstractSublevel<any, string | Buffer | Uint8Array, string, string>;

package/src/db-host/data-service.ts

@@ -33,7 +33,7 @@ export class DataServiceImpl implements DataService {
   }
 
   async flush(request: FlushRequest): Promise<void> {
-    // TODO(dmaretskyi): Implement with automerge.
+    await this._automergeHost.flush(request);
   }
 
   // Automerge specific.