@syncular/server 0.0.5-44 → 0.0.6-101

package/src/handlers/collection.ts

@@ -0,0 +1,121 @@
+import type { SyncCoreDb } from '../schema';
+import type { ServerTableHandler, SyncServerAuth } from './types';
+
+export interface ServerHandlerCollection<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+> {
+  handlers: ServerTableHandler<DB, Auth>[];
+  byTable: ReadonlyMap<string, ServerTableHandler<DB, Auth>>;
+}
+
+export function createServerHandlerCollection<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+>(handlers: ServerTableHandler<DB, Auth>[]): ServerHandlerCollection<DB, Auth> {
+  const byTable = new Map<string, ServerTableHandler<DB, Auth>>();
+
+  for (const handler of handlers) {
+    if (byTable.has(handler.table)) {
+      throw new Error(`Table "${handler.table}" is already registered`);
+    }
+    byTable.set(handler.table, handler);
+  }
+
+  for (const handler of handlers) {
+    for (const dep of handler.dependsOn ?? []) {
+      if (!byTable.has(dep)) {
+        throw new Error(
+          `Table "${handler.table}" depends on unknown table "${dep}"`
+        );
+      }
+    }
+  }
+
+  return { handlers, byTable };
+}
+
+export function getServerHandler<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+>(
+  collection: ServerHandlerCollection<DB, Auth>,
+  table: string
+): ServerTableHandler<DB, Auth> | undefined {
+  return collection.byTable.get(table);
+}
+
+export function getServerHandlerOrThrow<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+>(
+  collection: ServerHandlerCollection<DB, Auth>,
+  table: string
+): ServerTableHandler<DB, Auth> {
+  const handler = collection.byTable.get(table);
+  if (!handler) throw new Error(`Unknown table: ${table}`);
+  return handler;
+}
+
+function topoSortTables<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+>(
+  collection: ServerHandlerCollection<DB, Auth>,
+  targetTable?: string
+): ServerTableHandler<DB, Auth>[] {
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const sorted: ServerTableHandler<DB, Auth>[] = [];
+
+  const visit = (table: string) => {
+    if (visited.has(table)) return;
+    if (visiting.has(table)) {
+      throw new Error(
+        `Circular dependency detected involving table "${table}"`
+      );
+    }
+
+    const handler = collection.byTable.get(table);
+    if (!handler) {
+      throw new Error(`Unknown table: ${table}`);
+    }
+
+    visiting.add(table);
+    for (const dep of handler.dependsOn ?? []) {
+      visit(dep);
+    }
+    visiting.delete(table);
+    visited.add(table);
+    sorted.push(handler);
+  };
+
+  if (targetTable) {
+    visit(targetTable);
+    return sorted;
+  }
+
+  for (const table of collection.byTable.keys()) {
+    visit(table);
+  }
+  return sorted;
+}
+
+export function getServerBootstrapOrder<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+>(
+  collection: ServerHandlerCollection<DB, Auth>
+): ServerTableHandler<DB, Auth>[] {
+  return topoSortTables(collection);
+}
+
+export function getServerBootstrapOrderFor<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+>(
+  collection: ServerHandlerCollection<DB, Auth>,
+  table: string
+): ServerTableHandler<DB, Auth>[] {
+  return topoSortTables(collection, table);
+}

package/src/handlers/create-handler.ts

@@ -31,6 +31,7 @@ import type {
   UpdateQueryBuilder,
   UpdateResult,
 } from 'kysely';
+import { sql } from 'kysely';
 import type { SyncCoreDb } from '../schema';
 import type {
   ApplyOperationResult,
@@ -39,6 +40,7 @@ import type {
   ServerContext,
   ServerSnapshotContext,
   ServerTableHandler,
+  SyncServerAuth,
 } from './types';
 
 /**
@@ -66,6 +68,14 @@ function isConstraintViolationError(message: string): boolean {
   );
 }
 
+function isMissingColumnReferenceError(message: string): boolean {
+  const normalized = message.toLowerCase();
+  return (
+    normalized.includes('no such column') ||
+    (normalized.includes('column') && normalized.includes('does not exist'))
+  );
+}
+
 /**
  * Scope definition for a column - maps scope variable to column name.
  */
@@ -78,6 +88,7 @@ export interface CreateServerHandlerOptions<
   ServerDB extends SyncCoreDb,
   ClientDB,
   TableName extends keyof ServerDB & keyof ClientDB & string,
+  Auth extends SyncServerAuth = SyncServerAuth,
   ScopeDefs extends
     readonly SimpleScopeDefinition[] = readonly SimpleScopeDefinition[],
 > {
@@ -124,7 +135,7 @@ export interface CreateServerHandlerOptions<
    * })
    */
   resolveScopes: (
-    ctx: ServerContext<ServerDB>
+    ctx: ServerContext<ServerDB, Auth>
   ) => Promise<ScopeValuesFromPatterns<ScopeDefs>>;
 
   /**
@@ -132,7 +143,7 @@ export interface CreateServerHandlerOptions<
    * Use ctx.schemaVersion to handle older client versions.
    */
   transformInbound?: (
-    row: ClientDB[TableName],
+    row: Selectable<ClientDB[TableName]>,
     ctx: { schemaVersion?: number }
   ) => Updateable<ServerDB[TableName]>;
 
@@ -141,7 +152,7 @@ export interface CreateServerHandlerOptions<
    */
   transformOutbound?: (
     row: Selectable<ServerDB[TableName]>
-  ) => ClientDB[TableName];
+  ) => Selectable<ClientDB[TableName]>;
 
   /**
    * Optional column codec resolver.
@@ -149,7 +160,7 @@ export interface CreateServerHandlerOptions<
    * Only used by default snapshot/apply paths when the corresponding
    * transform hook is not provided.
    */
-  columnCodecs?: ColumnCodecSource;
+  codecs?: ColumnCodecSource;
 
   /**
    * Dialect used for codec dialect overrides.
@@ -162,19 +173,19 @@ export interface CreateServerHandlerOptions<
    * Return true to allow, or an error object to reject.
    */
   authorize?: (
-    ctx: ServerApplyOperationContext<ServerDB>,
+    ctx: ServerApplyOperationContext<ServerDB, Auth>,
     op: SyncOperation
   ) => Promise<AuthorizeResult>;
 
   /**
    * Override: Build snapshot query.
    */
-  snapshot?: ServerTableHandler<ServerDB>['snapshot'];
+  snapshot?: ServerTableHandler<ServerDB, Auth>['snapshot'];
 
   /**
    * Override: Apply operation.
    */
-  applyOperation?: ServerTableHandler<ServerDB>['applyOperation'];
+  applyOperation?: ServerTableHandler<ServerDB, Auth>['applyOperation'];
 
   /**
    * Custom scope extraction from row (for complex scope logic).
@@ -213,11 +224,18 @@ export function createServerHandler<
   ServerDB extends SyncCoreDb,
   ClientDB,
   TableName extends keyof ServerDB & keyof ClientDB & string,
+  Auth extends SyncServerAuth = SyncServerAuth,
   ScopeDefs extends
     readonly SimpleScopeDefinition[] = readonly SimpleScopeDefinition[],
 >(
-  options: CreateServerHandlerOptions<ServerDB, ClientDB, TableName, ScopeDefs>
-): ServerTableHandler<ServerDB> {
+  options: CreateServerHandlerOptions<
+    ServerDB,
+    ClientDB,
+    TableName,
+    Auth,
+    ScopeDefs
+  >
+): ServerTableHandler<ServerDB, Auth> {
   type OverloadParameters<T> = T extends (...args: infer A) => unknown
     ? A
     : never;
@@ -239,20 +257,20 @@ export function createServerHandler<
     resolveScopes,
     transformInbound,
     transformOutbound,
-    columnCodecs,
+    codecs,
     codecDialect = 'sqlite',
     authorize,
     extractScopes: customExtractScopes,
   } = options;
   const codecCache = new Map<string, ReturnType<typeof toTableColumnCodecs>>();
   const resolveTableCodecs = (row: Record<string, unknown>) => {
-    if (!columnCodecs) return {};
+    if (!codecs) return {};
     const columns = Object.keys(row);
     if (columns.length === 0) return {};
     const cacheKey = columns.slice().sort().join('\u0000');
     const cached = codecCache.get(cacheKey);
     if (cached) return cached;
-    const resolved = toTableColumnCodecs(table, columnCodecs, columns, {
+    const resolved = toTableColumnCodecs(table, codecs, columns, {
       dialect: codecDialect,
     });
     codecCache.set(cacheKey, resolved);
@@ -298,7 +316,7 @@ export function createServerHandler<
   const extractScopesImpl = customExtractScopes ?? defaultExtractScopes;
 
   const resolveScopesImpl = async (
-    ctx: ServerContext<ServerDB>
+    ctx: ServerContext<ServerDB, Auth>
   ): Promise<ScopeValues> => {
     const resolved = await resolveScopes(ctx);
     const normalized: ScopeValues = {};
@@ -312,7 +330,7 @@ export function createServerHandler<
 
   const applyOutboundTransform = (
     row: Selectable<ServerDB[TableName]>
-  ): ClientDB[TableName] => {
+  ): Selectable<ClientDB[TableName]> => {
     if (transformOutbound) {
       return transformOutbound(row);
     }
@@ -323,7 +341,7 @@ export function createServerHandler<
       resolveTableCodecs(recordRow),
       codecDialect
     );
-    return transformed as ClientDB[TableName];
+    return transformed as Selectable<ClientDB[TableName]>;
   };
 
   const applyInboundTransform = (
@@ -331,7 +349,7 @@ export function createServerHandler<
     schemaVersion: number | undefined
   ): Updateable<ServerDB[TableName]> => {
     if (transformInbound) {
-      return transformInbound(row as ClientDB[TableName], {
+      return transformInbound(row as Selectable<ClientDB[TableName]>, {
         schemaVersion,
       });
     }
@@ -346,7 +364,7 @@ export function createServerHandler<
 
   // Default snapshot implementation
   const defaultSnapshot = async (
-    ctx: ServerSnapshotContext<ServerDB>,
+    ctx: ServerSnapshotContext<ServerDB, string, Auth>,
     _params: Record<string, unknown> | undefined
   ): Promise<{ rows: unknown[]; nextCursor: string | null }> => {
     const trx = ctx.db;
@@ -415,7 +433,7 @@ export function createServerHandler<
 
   // Default applyOperation implementation
   const defaultApplyOperation = async (
-    ctx: ServerApplyOperationContext<ServerDB>,
+    ctx: ServerApplyOperationContext<ServerDB, Auth>,
     op: SyncOperation,
     opIndex: number
   ): Promise<ApplyOperationResult> => {
@@ -496,96 +514,19 @@ export function createServerHandler<
         : {};
     const payload = applyInboundTransform(payloadRecord, ctx.schemaVersion);
 
-    // Check whether the row exists and fetch only version metadata for hot path.
-    const existingRow = await (
-      trx.selectFrom(table) as SelectQueryBuilder<
-        ServerDB,
-        keyof ServerDB & string,
-        Record<string, unknown>
-      >
-    )
-      .select(ref<string>(versionColumn))
-      .where(ref<string>(primaryKey), '=', op.row_id)
-      .executeTakeFirst();
-
-    const hasExistingRow = existingRow !== undefined;
-    const existingVersion =
-      (existingRow?.[versionColumn] as number | undefined) ?? 0;
-
-    // Check version conflict
-    if (
-      hasExistingRow &&
-      op.base_version != null &&
-      existingVersion !== op.base_version
-    ) {
-      const conflictRow = await (
-        trx.selectFrom(table).selectAll() as SelectQueryBuilder<
-          ServerDB,
-          keyof ServerDB & string,
-          Record<string, unknown>
-        >
-      )
-        .where(ref<string>(primaryKey), '=', op.row_id)
-        .executeTakeFirst();
-
-      if (!conflictRow) {
-        return {
-          result: {
-            opIndex,
-            status: 'error',
-            error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
-            code: 'ROW_MISSING',
-            retriable: false,
-          },
-          emittedChanges: [],
-        };
-      }
-
-      return {
-        result: {
-          opIndex,
-          status: 'conflict',
-          message: `Version conflict: server=${existingVersion}, base=${op.base_version}`,
-          server_version: existingVersion,
-          server_row: applyOutboundTransform(
-            conflictRow as Selectable<ServerDB[TableName]>
-          ),
-        },
-        emittedChanges: [],
-      };
-    }
-
-    // If the client provided a base version, they expected this row to exist.
-    // A missing row usually indicates stale local state after a server reset.
-    if (!hasExistingRow && op.base_version != null) {
-      return {
-        result: {
-          opIndex,
-          status: 'error',
-          error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
-          code: 'ROW_MISSING',
-          retriable: false,
-        },
-        emittedChanges: [],
-      };
-    }
-
-    const nextVersion = existingVersion + 1;
-
     let updated: Record<string, unknown> | undefined;
     let constraintError: { message: string; code: string } | null = null;
 
     try {
-      if (hasExistingRow) {
-        // Update - merge payload with existing
-        const updateSet: Record<string, unknown> = {
+      if (op.base_version != null) {
+        const expectedVersion = op.base_version;
+        const conditionalUpdateSet: Record<string, unknown> = {
           ...payload,
-          [versionColumn]: nextVersion,
+          [versionColumn]: expectedVersion + 1,
         };
-        // Don't update primary key or scope columns
-        delete updateSet[primaryKey];
+        delete conditionalUpdateSet[primaryKey];
         for (const col of Object.values(scopeColumns)) {
-          delete updateSet[col];
+          delete conditionalUpdateSet[col];
         }
 
         updated = (await (
@@ -596,31 +537,144 @@ export function createServerHandler<
             UpdateResult
           >
         )
-          .set(updateSet as UpdateSetObject)
+          .set(conditionalUpdateSet as UpdateSetObject)
           .where(ref<string>(primaryKey), '=', op.row_id)
+          .where(ref<string>(versionColumn), '=', expectedVersion)
           .returningAll()
           .executeTakeFirst()) as Record<string, unknown> | undefined;
+
+        if (!updated) {
+          const conflictRow = await (
+            trx.selectFrom(table).selectAll() as SelectQueryBuilder<
+              ServerDB,
+              keyof ServerDB & string,
+              Record<string, unknown>
+            >
+          )
+            .where(ref<string>(primaryKey), '=', op.row_id)
+            .executeTakeFirst();
+
+          if (!conflictRow) {
+            return {
+              result: {
+                opIndex,
+                status: 'error',
+                error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
+                code: 'ROW_MISSING',
+                retriable: false,
+              },
+              emittedChanges: [],
+            };
+          }
+
+          const existingVersion =
+            (conflictRow[versionColumn] as number | undefined) ?? 0;
+          return {
+            result: {
+              opIndex,
+              status: 'conflict',
+              message: `Version conflict: server=${existingVersion}, base=${expectedVersion}`,
+              server_version: existingVersion,
+              server_row: applyOutboundTransform(
+                conflictRow as Selectable<ServerDB[TableName]>
+              ),
+            },
+            emittedChanges: [],
+          };
+        }
       } else {
-        // Insert
-        const insertValues: Record<string, unknown> = {
+        const updateSet: Record<string, unknown> = {
           ...payload,
-          [primaryKey]: op.row_id,
-          [versionColumn]: 1,
+          [versionColumn]: sql`${sql.ref(versionColumn)} + 1`,
         };
+        delete updateSet[primaryKey];
+        for (const col of Object.values(scopeColumns)) {
+          delete updateSet[col];
+        }
 
         updated = (await (
-          trx.insertInto(table) as InsertQueryBuilder<
+          trx.updateTable(table) as UpdateQueryBuilder<
             ServerDB,
             TableName,
-            InsertResult
+            TableName,
+            UpdateResult
           >
         )
-          .values(insertValues as Insertable<ServerDB[TableName]>)
+          .set(updateSet as UpdateSetObject)
+          .where(ref<string>(primaryKey), '=', op.row_id)
           .returningAll()
           .executeTakeFirst()) as Record<string, unknown> | undefined;
+
+        if (!updated) {
+          const insertValues: Record<string, unknown> = {
+            ...payload,
+            [primaryKey]: op.row_id,
+            [versionColumn]: 1,
+          };
+
+          try {
+            updated = (await (
+              trx.insertInto(table) as InsertQueryBuilder<
+                ServerDB,
+                TableName,
+                InsertResult
+              >
+            )
+              .values(insertValues as Insertable<ServerDB[TableName]>)
+              .returningAll()
+              .executeTakeFirst()) as Record<string, unknown> | undefined;
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!isConstraintViolationError(message)) {
+              throw err;
+            }
+            updated = (await (
+              trx.updateTable(table) as UpdateQueryBuilder<
+                ServerDB,
+                TableName,
+                TableName,
+                UpdateResult
+              >
+            )
+              .set(updateSet as UpdateSetObject)
+              .where(ref<string>(primaryKey), '=', op.row_id)
+              .returningAll()
+              .executeTakeFirst()) as Record<string, unknown> | undefined;
+            if (!updated) {
+              constraintError = {
+                message,
+                code: classifyConstraintViolationCode(message),
+              };
+            }
+          }
+        }
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      if (op.base_version != null && isMissingColumnReferenceError(message)) {
+        const row = await (
+          trx.selectFrom(table).selectAll() as SelectQueryBuilder<
+            ServerDB,
+            keyof ServerDB & string,
+            Record<string, unknown>
+          >
+        )
+          .where(ref<string>(primaryKey), '=', op.row_id)
+          .executeTakeFirst();
+        if (!row) {
+          return {
+            result: {
+              opIndex,
+              status: 'error',
+              error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
+              code: 'ROW_MISSING',
+              retriable: false,
+            },
+            emittedChanges: [],
+          };
+        }
+      }
+
       if (!isConstraintViolationError(message)) {
         throw err;
       }

package/src/handlers/index.ts

@@ -1,3 +1,3 @@
+export * from './collection';
 export * from './create-handler';
-export * from './registry';
 export * from './types';

package/src/handlers/types.ts

@@ -11,6 +11,11 @@ import type { ZodSchema, z } from 'zod';
 import type { DbExecutor } from '../dialect/types';
 import type { SyncCoreDb } from '../schema';
 
+export interface SyncServerAuth {
+  actorId: string;
+  partitionId?: string;
+}
+
 /**
  * Emitted change to be stored in the oplog.
  * Uses JSONB scopes instead of scope_keys array.
@@ -41,11 +46,16 @@ export interface ApplyOperationResult {
 /**
  * Context for server operations.
  */
-export interface ServerContext<DB extends SyncCoreDb = SyncCoreDb> {
+export interface ServerContext<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+> {
   /** Database connection (transaction in applyOperation) */
   db: DbExecutor<DB>;
   /** Actor ID (user ID from auth) */
   actorId: string;
+  /** Full auth payload returned by authenticate */
+  auth: Auth;
 }
 
 /**
@@ -54,7 +64,8 @@ export interface ServerContext<DB extends SyncCoreDb = SyncCoreDb> {
 export interface ServerSnapshotContext<
   DB extends SyncCoreDb = SyncCoreDb,
   ScopeKeys extends string = string,
-> extends ServerContext<DB> {
+  Auth extends SyncServerAuth = SyncServerAuth,
+> extends ServerContext<DB, Auth> {
   /** Database executor for the snapshot */
   db: DbExecutor<DB>;
   /** Effective scope values for this subscription */
@@ -68,8 +79,10 @@ export interface ServerSnapshotContext<
 /**
  * Context passed to applyOperation method.
  */
-export interface ServerApplyOperationContext<DB extends SyncCoreDb = SyncCoreDb>
-  extends ServerContext<DB> {
+export interface ServerApplyOperationContext<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+> extends ServerContext<DB, Auth> {
   /** Database executor for the operation */
   trx: DbExecutor<DB>;
   /** Client/device identifier */
@@ -127,6 +140,7 @@ interface ServerScopeConfig {
  */
 export interface ServerHandlerOptions<
   DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
   Scopes extends Record<ScopePattern, Record<string, string>> = Record<
     ScopePattern,
     Record<string, string>
@@ -159,7 +173,7 @@ export interface ServerHandlerOptions<
    *   project_id: ctx.user.projectIds,
    * })
    */
-  resolveScopes: (ctx: ServerContext<DB>) => Promise<ScopeValues>;
+  resolveScopes: (ctx: ServerContext<DB, Auth>) => Promise<ScopeValues>;
 
   /**
    * Optional Zod schema for subscription parameters.
@@ -191,7 +205,7 @@ export interface ServerHandlerOptions<
    */
   transformInbound?: (
     payload: Record<string, unknown>,
-    ctx: ServerApplyOperationContext<DB>
+    ctx: ServerApplyOperationContext<DB, Auth>
   ) => Partial<DB[TableName & keyof DB]>;
 
   /**
@@ -206,7 +220,7 @@ export interface ServerHandlerOptions<
    * Default uses keyset pagination ordered by primary key.
    */
   snapshot?: (
-    ctx: ServerSnapshotContext<DB>,
+    ctx: ServerSnapshotContext<DB, string, Auth>,
     params: Params extends ZodSchema ? z.infer<Params> : undefined
   ) => Promise<{ rows: unknown[]; nextCursor: string | null }>;
 
@@ -214,7 +228,7 @@ export interface ServerHandlerOptions<
    * Custom apply operation implementation.
    */
   applyOperation?: (
-    ctx: ServerApplyOperationContext<DB>,
+    ctx: ServerApplyOperationContext<DB, Auth>,
     op: SyncOperation,
     opIndex: number
   ) => Promise<ApplyOperationResult>;
@@ -224,7 +238,10 @@ export interface ServerHandlerOptions<
  * Server-side table handler for snapshots and mutations.
  * This is the internal handler interface used by the sync engine.
  */
-export interface ServerTableHandler<DB extends SyncCoreDb = SyncCoreDb> {
+export interface ServerTableHandler<
+  DB extends SyncCoreDb = SyncCoreDb,
+  Auth extends SyncServerAuth = SyncServerAuth,
+> {
   /** Table name */
   table: string;
 
@@ -244,7 +261,7 @@ export interface ServerTableHandler<DB extends SyncCoreDb = SyncCoreDb> {
   /**
    * Resolve allowed scope values for the current actor.
    */
-  resolveScopes: (ctx: ServerContext<DB>) => Promise<ScopeValues>;
+  resolveScopes: (ctx: ServerContext<DB, Auth>) => Promise<ScopeValues>;
 
   /**
    * Extract stored scopes from a row.
@@ -255,7 +272,7 @@ export interface ServerTableHandler<DB extends SyncCoreDb = SyncCoreDb> {
    * Build a bootstrap snapshot page.
    */
   snapshot(
-    ctx: ServerSnapshotContext<DB>,
+    ctx: ServerSnapshotContext<DB, string, Auth>,
     params: Record<string, unknown> | undefined
   ): Promise<{ rows: unknown[]; nextCursor: string | null }>;
 
@@ -263,7 +280,7 @@ export interface ServerTableHandler<DB extends SyncCoreDb = SyncCoreDb> {
    * Apply a single operation.
    */
   applyOperation(
-    ctx: ServerApplyOperationContext<DB>,
+    ctx: ServerApplyOperationContext<DB, Auth>,
     op: SyncOperation,
     opIndex: number
   ): Promise<ApplyOperationResult>;