@dxos/echo-pipeline 0.8.3 → 0.8.4-main.1068cf700f

package/src/db-host/local-queue-service.ts

@@ -0,0 +1,147 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+
+import { ATTR_META, type ObjectJSON } from '@dxos/echo/internal';
+import type { ForeignKey } from '@dxos/echo-protocol';
+import { RuntimeProvider } from '@dxos/effect';
+import { type FeedStore } from '@dxos/feed';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { type SpaceId } from '@dxos/keys';
+import { FeedProtocol } from '@dxos/protocols';
+import {
+  type DeleteFromQueueRequest,
+  type InsertIntoQueueRequest,
+  type QueryQueueRequest,
+  type QueueQueryResult,
+  type QueueService,
+} from '@dxos/protocols/proto/dxos/client/services';
+import type { SqlTransaction } from '@dxos/sql-sqlite';
+
+/**
+ * Writes queue data to a local FeedStore.
+ */
+export class LocalQueueServiceImpl implements QueueService {
+  #runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>;
+  #feedStore: FeedStore;
+
+  constructor(
+    runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>,
+    feedStore: FeedStore,
+  ) {
+    this.#runtime = runtime;
+    this.#feedStore = feedStore;
+  }
+
+  queryQueue(request: QueryQueueRequest): Promise<QueueQueryResult> {
+    const { query } = request;
+    invariant(query, 'query is required');
+    const { spaceId, queueIds } = query;
+    return RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(this, function* () {
+        const cursor = query.after ? parseInt(query.after) : -1;
+        const result = yield* this.#feedStore.query({
+          requestId: crypto.randomUUID(),
+          feedNamespace: request.query.queuesNamespace || FeedProtocol.WellKnownNamespaces.data,
+          spaceId: spaceId! as SpaceId,
+          query: { feedIds: queueIds ?? [] },
+          position: cursor,
+          limit: query.limit,
+        });
+
+        const objects = result.blocks.map((block: FeedProtocol.Block) => {
+          const data = JSON.parse(new TextDecoder().decode(block.data));
+          if (block.position !== null) {
+            setQueuePosition(data, block.position);
+          }
+          return data;
+        });
+
+        const lastBlock = result.blocks[result.blocks.length - 1];
+        const nextCursor = lastBlock && lastBlock.position != null ? String(lastBlock.position) : null;
+
+        return Function.identity<QueueQueryResult>({
+          objects,
+
+          // TODO(dmaretskyi): This is wrong, fix later - cursors should come directly from the feed.
+          nextCursor: nextCursor?.toString() ?? '',
+          prevCursor: '',
+        });
+      }),
+    );
+  }
+
+  insertIntoQueue(request: InsertIntoQueueRequest): Promise<void> {
+    const { subspaceTag, spaceId, queueId, objects } = request;
+    const feedNamespace = subspaceTag ?? FeedProtocol.WellKnownNamespaces.data;
+    assertArgument(
+      FeedProtocol.isWellKnownNamespace(feedNamespace),
+      'request.subspaceTag',
+      'expected a well-known queue namespace',
+    );
+    return RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(this, function* () {
+        const messages = objects!.map((obj) => {
+          const data = structuredClone(obj);
+          if (data[ATTR_META]?.keys?.find((key: ForeignKey) => key.source === FeedProtocol.KEY_QUEUE_POSITION)) {
+            data[ATTR_META].keys = data[ATTR_META].keys.filter(
+              (key: ForeignKey) => key.source !== FeedProtocol.KEY_QUEUE_POSITION,
+            );
+          }
+
+          return {
+            spaceId: spaceId,
+            feedId: queueId!,
+            feedNamespace,
+            data: new TextEncoder().encode(JSON.stringify(obj)),
+          };
+        });
+
+        yield* this.#feedStore.appendLocal(messages);
+      }),
+    );
+  }
+
+  deleteFromQueue(request: DeleteFromQueueRequest): Promise<void> {
+    const { subspaceTag, spaceId, queueId, objectIds } = request;
+    const feedNamespace = subspaceTag ?? FeedProtocol.WellKnownNamespaces.data;
+    assertArgument(
+      FeedProtocol.isWellKnownNamespace(feedNamespace),
+      'request.subspaceTag',
+      'expected a well-known queue namespace',
+    );
+    return RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(this, function* () {
+        const messages = objectIds!.map((id) => ({
+          spaceId: spaceId,
+          feedId: queueId!,
+          feedNamespace,
+          data: new TextEncoder().encode(JSON.stringify({ id, '@deleted': true })),
+        }));
+
+        yield* this.#feedStore.appendLocal(messages);
+      }),
+    );
+  }
+}
+
+// TODO(dmaretskyi): Duplicated code.
+const setQueuePosition = (obj: ObjectJSON, position: number) => {
+  obj[ATTR_META] ??= { keys: [] };
+  obj[ATTR_META].keys ??= [];
+  for (let i = 0; i < obj[ATTR_META].keys.length; i++) {
+    const key = obj[ATTR_META].keys[i];
+    if (key.source === FeedProtocol.KEY_QUEUE_POSITION) {
+      obj[ATTR_META].keys.splice(i, 1);
+      i--;
+    }
+  }
+  obj[ATTR_META].keys.push({
+    source: FeedProtocol.KEY_QUEUE_POSITION,
+    id: position.toString(),
+  });
+};

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

@@ -2,19 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { getHeads } from '@automerge/automerge';
-import { type DocHandle, type DocumentId } from '@automerge/automerge-repo';
-import { Schema } from 'effect';
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Schema from 'effect/Schema';
 
 import { DeferredTask, scheduleMicroTask, synchronized } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf/stream';
-import { Context, Resource } from '@dxos/context';
+import { type Context, Resource } from '@dxos/context';
 import { raise } from '@dxos/debug';
-import { DatabaseDirectory, QueryAST } from '@dxos/echo-protocol';
-import { type IdToHeads, type Indexer, type ObjectSnapshot } from '@dxos/indexing';
+import { QueryAST } from '@dxos/echo-protocol';
+import { type RuntimeProvider } from '@dxos/effect';
+import { type IndexEngine } from '@dxos/index-core';
 import { log } from '@dxos/log';
-import { objectPointerCodec } from '@dxos/protocols';
-import { type IndexConfig } from '@dxos/protocols/proto/dxos/echo/indexing';
 import {
   type QueryRequest,
   type QueryResponse,
@@ -23,12 +21,14 @@ import {
 } from '@dxos/protocols/proto/dxos/echo/query';
 import { trace } from '@dxos/tracing';
 
-import type { SpaceStateManager } from './space-state-manager';
 import { type AutomergeHost } from '../automerge';
 import { QueryExecutor } from '../query';
 
-export type QueryServiceParams = {
-  indexer: Indexer;
+import type { SpaceStateManager } from './space-state-manager';
+
+export type QueryServiceProps = {
+  indexEngine: IndexEngine;
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
   automergeHost: AutomergeHost;
   spaceStateManager: SpaceStateManager;
 };
@@ -55,12 +55,13 @@ type ActiveQuery = {
 
 @trace.resource()
 export class QueryServiceImpl extends Resource implements QueryService {
+  // TODO(dmaretskyi): We need to implement query deduping. Idle composer has 80 queries with only 10 being unique.
   private readonly _queries = new Set<ActiveQuery>();
 
   private _updateQueries!: DeferredTask;
 
   // TODO(burdon): OK for options, but not params. Pass separately and type readonly here.
-  constructor(private readonly _params: QueryServiceParams) {
+  constructor(private readonly _params: QueryServiceProps) {
     super();
 
     trace.diagnostic({
@@ -79,8 +80,6 @@ export class QueryServiceImpl extends Resource implements QueryService {
   }
 
   override async _open(): Promise<void> {
-    this._params.indexer.updated.on(this._ctx, () => this.invalidateQueries());
-
     this._updateQueries = new DeferredTask(this._ctx, this._executeQueries.bind(this));
   }
 
@@ -90,8 +89,19 @@ export class QueryServiceImpl extends Resource implements QueryService {
     await Promise.all(Array.from(this._queries).map((query) => query.close()));
   }
 
-  async setConfig(config: IndexConfig): Promise<void> {
-    await this._params.indexer.setConfig(config);
+  /**
+   * @deprecated No longer needed with SQL-based indexing.
+   */
+  async setConfig(): Promise<void> {
+    // No-op: SQL indexer doesn't need explicit configuration.
+  }
+
+  /**
+   * @deprecated No longer needed with SQL-based indexing.
+   */
+  async reindex(): Promise<void> {
+    // No-op: SQL indexer handles re-indexing automatically.
+    log.warn('reindex() is deprecated and no longer has any effect');
   }
 
   execQuery(request: QueryRequest): Stream<QueryResponse> {
@@ -106,26 +116,6 @@ export class QueryServiceImpl extends Resource implements QueryService {
     });
   }
 
-  /**
-   * Re-index all loaded documents.
-   */
-  async reindex(): Promise<void> {
-    log('Reindexing all documents...');
-    const iterator = createDocumentsIterator(this._params.automergeHost);
-    const ids: IdToHeads = new Map();
-    for await (const documents of iterator()) {
-      for (const { id, heads } of documents) {
-        ids.set(id, heads);
-      }
-      if (ids.size % 100 === 0) {
-        log('Collected documents...', { count: ids.size });
-      }
-    }
-
-    log('Marking all documents as dirty...', { count: ids.size });
-    await this._params.indexer.reindex(ids);
-  }
-
   /**
    * Schedule re-execution of all queries.
    */
@@ -146,7 +136,8 @@ export class QueryServiceImpl extends Resource implements QueryService {
     const parsedQuery = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
     const queryEntry: ActiveQuery = {
       executor: new QueryExecutor({
-        indexer: this._params.indexer,
+        indexEngine: this._params.indexEngine,
+        runtime: this._params.runtime,
         automergeHost: this._params.automergeHost,
         queryId: request.queryId ?? raise(new Error('query id required')),
         query: parsedQuery,
@@ -200,61 +191,3 @@ export class QueryServiceImpl extends Resource implements QueryService {
     log.verbose('executed queries', { count, duration: performance.now() - begin });
   }
 }
-
-/**
- * Factory for `getAllDocuments` iterator.
- */
-// TODO(dmaretskyi): Get roots from echo-host.
-const createDocumentsIterator = (automergeHost: AutomergeHost) =>
-  /**
-   * Recursively get all object data blobs from loaded documents from Automerge Repo.
-   */
-  // TODO(mykola): Unload automerge handles after usage.
-  async function* getAllDocuments(): AsyncGenerator<ObjectSnapshot[], void, void> {
-    /** visited automerge handles */
-    const visited = new Set<string>();
-
-    async function* getObjectsFromHandle(handle: DocHandle<DatabaseDirectory>): AsyncGenerator<ObjectSnapshot[]> {
-      if (visited.has(handle.documentId) || !handle.isReady()) {
-        return;
-      }
-
-      const doc = handle.doc()!;
-      const spaceKey = DatabaseDirectory.getSpaceKey(doc) ?? undefined;
-      if (doc.objects) {
-        yield Object.entries(doc.objects as { [key: string]: any }).map(([objectId, object]) => {
-          return {
-            id: objectPointerCodec.encode({ documentId: handle.documentId, objectId, spaceKey }),
-            object,
-            heads: getHeads(doc),
-          };
-        });
-      }
-
-      if (doc.links) {
-        for (const id of Object.values(doc.links as { [echoId: string]: string })) {
-          const urlString = id.toString();
-          if (visited.has(urlString)) {
-            continue;
-          }
-          const linkHandle = await automergeHost.loadDoc<DatabaseDirectory>(Context.default(), urlString as DocumentId);
-          for await (const result of getObjectsFromHandle(linkHandle)) {
-            yield result;
-          }
-        }
-      }
-
-      visited.add(handle.documentId);
-    }
-
-    // TODO(mykola): Use list of roots instead of iterating over all handles.
-    for (const handle of Object.values(automergeHost.repo.handles)) {
-      if (visited.has(handle.documentId)) {
-        continue;
-      }
-      for await (const result of getObjectsFromHandle(handle)) {
-        yield result;
-      }
-      visited.add(handle.documentId);
-    }
-  };

package/src/db-host/queue-data-source.ts

@@ -0,0 +1,132 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+
+import { RuntimeProvider } from '@dxos/effect';
+import { type FeedStore } from '@dxos/feed';
+import { type DataSourceCursor, type IndexDataSource, type IndexerObject } from '@dxos/index-core';
+import { failedInvariant } from '@dxos/invariant';
+import type { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { FeedProtocol } from '@dxos/protocols';
+
+export type QueueDataSourceOptions = {
+  feedStore: FeedStore;
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
+  /**
+   * Callback to get the list of space IDs that should be indexed.
+   */
+  getSpaceIds: () => SpaceId[];
+};
+
+export class QueueDataSource implements IndexDataSource {
+  readonly sourceName = 'queue';
+
+  private readonly _feedStore: FeedStore;
+  private readonly _runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
+  private readonly _getSpaceIds: () => SpaceId[];
+
+  constructor(options: QueueDataSourceOptions) {
+    this._feedStore = options.feedStore;
+    this._runtime = options.runtime;
+    this._getSpaceIds = options.getSpaceIds;
+  }
+
+  getChangedObjects(
+    cursors: DataSourceCursor[],
+    opts?: { limit?: number },
+  ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }> {
+    // For queue, the cursor is assumed to have:
+    // spaceId = set
+    // resourceId = null
+    // cursor = feed cursor
+
+    // We also add new cursors from all previously unindexed spaces.
+
+    return Effect.gen(this, function* () {
+      const objects: IndexerObject[] = [];
+      const updatedCursors: DataSourceCursor[] = [];
+
+      // Augment cursors with new spaces that haven't been indexed yet.
+      const existingSpaceIds = new Set(cursors.map((c) => c.spaceId).filter(Boolean));
+      const allSpaceIds = this._getSpaceIds();
+      const augmentedCursors = [...cursors];
+      for (const spaceId of allSpaceIds) {
+        if (!existingSpaceIds.has(spaceId)) {
+          // Add a new cursor for this space starting from the beginning.
+          // Empty string cursor means "start from beginning".
+          augmentedCursors.push({
+            spaceId,
+            resourceId: null,
+            cursor: '',
+          });
+        }
+      }
+
+      // Limit per call, but we might have multiple spaces.
+      // We should distribute limit or just fill up to limit.
+      let remainingLimit = opts?.limit ?? Infinity;
+
+      for (const cursor of augmentedCursors) {
+        if (remainingLimit <= 0) {
+          // Remaining cursors are not processed in this call.
+          updatedCursors.push(cursor);
+          continue;
+        }
+        if (!cursor.spaceId) {
+          // Ignore cursors without spaceId.
+          updatedCursors.push(cursor);
+          continue;
+        }
+
+        // Empty string cursor means "start from beginning".
+        const currentCursor =
+          typeof cursor.cursor === 'string' && cursor.cursor !== ''
+            ? FeedProtocol.FeedCursor.make(cursor.cursor)
+            : undefined;
+
+        try {
+          const result = yield* this._feedStore.query({
+            spaceId: cursor.spaceId,
+            feedNamespace: FeedProtocol.WellKnownNamespaces.data,
+            cursor: currentCursor,
+            limit: remainingLimit,
+          });
+
+          // Process blocks
+          for (const block of result.blocks) {
+            try {
+              const dataString = new TextDecoder().decode(block.data);
+              // TODO: Handle non-JSON data?
+              const data = JSON.parse(dataString);
+
+              objects.push({
+                spaceId: cursor.spaceId,
+                queueId: block.feedId ?? failedInvariant(),
+                documentId: null,
+                recordId: null,
+                data,
+              });
+            } catch (err) {
+              log.warn('Failed to parse block data for indexing', { spaceId: cursor.spaceId, err });
+            }
+          }
+
+          remainingLimit -= result.blocks.length;
+          updatedCursors.push({
+            spaceId: cursor.spaceId,
+            resourceId: null,
+            cursor: result.nextCursor,
+          });
+        } catch (error) {
+          log.error('Error querying queue for indexing', { spaceId: cursor.spaceId, error });
+        }
+      }
+
+      return { objects, cursors: updatedCursors };
+    }).pipe(RuntimeProvider.provide(this._runtime), Effect.withSpan('QueueDataSource.getChangedObjects'), Effect.orDie);
+  }
+}

package/src/db-host/queue-service.test.ts

@@ -0,0 +1,145 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { RuntimeProvider } from '@dxos/effect';
+import { FeedStore } from '@dxos/feed';
+import { ObjectId, SpaceId } from '@dxos/keys';
+import { FeedProtocol } from '@dxos/protocols';
+import { SqlTransaction } from '@dxos/sql-sqlite';
+
+import { LocalQueueServiceImpl } from './local-queue-service';
+
+const TestLayer = SqlTransaction.layer.pipe(
+  Layer.provideMerge(
+    SqliteClient.layer({
+      filename: ':memory:',
+    }),
+  ),
+);
+
+describe('LocalQueueServiceImpl', () => {
+  it.effect('should insert and query items', () =>
+    Effect.gen(function* () {
+      const feedStore = new FeedStore({ localActorId: 'actor-id', assignPositions: true });
+      const runtime = yield* RuntimeProvider.currentRuntime<SqlClient.SqlClient | SqlTransaction.SqlTransaction>();
+      const service = new LocalQueueServiceImpl(runtime, feedStore);
+      yield* feedStore.migrate();
+
+      const spaceId = SpaceId.random();
+      const queueId = ObjectId.random();
+      const object1 = { id: 'obj1', data: 'test1' };
+      const object2 = { id: 'obj2', data: 'test2' };
+
+      yield* Effect.promise(() =>
+        service.insertIntoQueue({
+          subspaceTag: FeedProtocol.WellKnownNamespaces.data,
+          spaceId,
+          queueId,
+          objects: [object1, object2],
+        }),
+      );
+
+      const result = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: { spaceId, queueIds: [queueId] },
+        }),
+      );
+      expect(result.objects?.[0]).toMatchObject(object1);
+      expect(result.objects?.[1]).toMatchObject(object2);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should delete items', () =>
+    Effect.gen(function* () {
+      const runtime = Effect.succeed(yield* Effect.runtime<any>());
+      const feedStore = new FeedStore({ localActorId: 'actor-id', assignPositions: true });
+      const service = new LocalQueueServiceImpl(runtime, feedStore);
+      yield* feedStore.migrate();
+
+      const spaceId = SpaceId.random();
+      const queueId = ObjectId.random();
+      const object1Id = ObjectId.random();
+      const object1 = { id: object1Id, data: 'test1' };
+
+      yield* Effect.promise(() =>
+        service.insertIntoQueue({
+          subspaceTag: FeedProtocol.WellKnownNamespaces.data,
+          spaceId,
+          queueId,
+          objects: [object1],
+        }),
+      );
+      yield* Effect.promise(() =>
+        service.deleteFromQueue({
+          subspaceTag: FeedProtocol.WellKnownNamespaces.data,
+          spaceId,
+          queueId,
+          objectIds: [object1Id],
+        }),
+      );
+
+      const result = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: { spaceId, queueIds: [queueId] },
+        }),
+      );
+      expect(result.objects).toHaveLength(2);
+      expect(result.objects?.[1]).toMatchObject({ id: object1Id, '@deleted': true });
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should support pagination', () =>
+    Effect.gen(function* () {
+      const runtime = Effect.succeed(yield* Effect.runtime<any>());
+      const feedStore = new FeedStore({ localActorId: 'actor-id', assignPositions: true });
+      yield* feedStore.migrate();
+      const service = new LocalQueueServiceImpl(runtime, feedStore);
+      const spaceId = 'space-1' as SpaceId;
+      const queueId = ObjectId.random();
+
+      // Insert 10 items
+      const items = Array.from({ length: 10 }, (_, i) => ({ id: `obj${i}`, data: `test${i}` }));
+      yield* Effect.promise(() =>
+        service.insertIntoQueue({
+          subspaceTag: FeedProtocol.WellKnownNamespaces.data,
+          spaceId,
+          queueId,
+          objects: items,
+        }),
+      );
+
+      // Query first 5
+      const page1 = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: { spaceId, queueIds: [queueId], limit: 5 },
+        }),
+      );
+      expect(page1.objects).toHaveLength(5);
+      expect(page1.objects?.[0]).toMatchObject(items[0]);
+      expect(page1.objects?.[4]).toMatchObject(items[4]);
+      expect(page1.nextCursor).toBeDefined();
+
+      // Query next 5
+      const page2 = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: {
+            spaceId,
+            queueIds: [queueId],
+            limit: 5,
+            after: page1.nextCursor!,
+          },
+        }),
+      );
+      expect(page2.objects).toHaveLength(5);
+      expect(page2.objects?.[0]).toMatchObject(items[5]);
+      expect(page2.objects?.[4]).toMatchObject(items[9]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+});

package/src/db-host/space-state-manager.ts

@@ -2,11 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { interpretAsDocumentId, type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import { type DocHandle, type DocumentId, interpretAsDocumentId } from '@automerge/automerge-repo';
 import isEqual from 'lodash.isequal';
 
 import { Event, UpdateScheduler } from '@dxos/async';
-import { Resource, Context, LifecycleState } from '@dxos/context';
+import { Context, LifecycleState, Resource } from '@dxos/context';
 import { type DatabaseDirectory } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import { type SpaceId } from '@dxos/keys';
@@ -32,6 +32,10 @@ export class SpaceStateManager extends Resource {
     return this._roots;
   }
 
+  get spaceIds(): SpaceId[] {
+    return Array.from(this._rootBySpace.keys());
+  }
+
   getRootByDocumentId(documentId: DocumentId): DatabaseRoot | undefined {
     return this._roots.get(documentId);
   }

package/src/db-host/stub.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type {
+  DeleteFromQueueRequest,
+  InsertIntoQueueRequest,
+  QueryQueueRequest,
+  QueueQueryResult,
+  QueueService,
+} from '@dxos/protocols/proto/dxos/client/services';
+
+/**
+ * Stub implementation for when Edge is not available.
+ */
+export class QueueServiceStub implements QueueService {
+  queryQueue(request: QueryQueueRequest): Promise<QueueQueryResult> {
+    throw new Error('Not available.');
+  }
+
+  insertIntoQueue(request: InsertIntoQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+
+  deleteFromQueue(request: DeleteFromQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+}