@powerhousedao/reactor-api 1.20.2 → 1.21.1

package/CHANGELOG.md

@@ -1,21 +1,18 @@
-## 1.20.2 (2025-02-10)
-
-### 🚀 Features
-
-- **design-system:** add danger zone settings page ([572345bc](https://github.com/powerhouse-inc/powerhouse/commit/572345bc))
+## 1.21.1 (2025-02-18)
 
 ### 🩹 Fixes
 
-- **reactor-api:** sanitize document model name before using it as __typename ([adcca457](https://github.com/powerhouse-inc/powerhouse/commit/adcca457))
+- **reactor-api:** inject missing node __typenames in drive subgraph ([8571ba3f](https://github.com/powerhouse-inc/powerhouse/commit/8571ba3f))
+- **reactor-api:** inject missing node __typenames in drive subgraph ([083f711a](https://github.com/powerhouse-inc/powerhouse/commit/083f711a))
+- **reactor-api:** sanitize document model name before using it as __typename ([07c3be7d](https://github.com/powerhouse-inc/powerhouse/commit/07c3be7d))
 
 ### 🧱 Updated Dependencies
 
-- Updated document-model-libs to 1.131.2
-- Updated document-drive to 1.17.2
+- Updated document-model-libs to 1.132.1
+- Updated document-drive to 1.19.0
 
 ### ❤️ Thank You
 
-- ryanwolhuter @ryanwolhuter
 - Wouter Kampmann
 
 ## 1.2.0 (2024-10-29)

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { PGlite } from '@electric-sql/pglite';
 import * as document_model_libs_document_drive from 'document-model-libs/document-drive';
-import { Trigger, PullResponderTriggerData, DocumentDriveDocument, ListenerFilter, DocumentDriveState, DocumentDriveLocalState, ListenerCallInfo, DocumentDriveAction } from 'document-model-libs/document-drive';
-import { Operation, Document, DocumentModel, Action, OperationScope, State, BaseAction, CreateChildDocumentInput, ActionContext, ReducerOptions, Signal } from 'document-model/document';
+import { DocumentDriveDocument, ListenerFilter, Trigger, PullResponderTriggerData, DocumentDriveState, DocumentDriveLocalState, ListenerCallInfo, DocumentDriveAction } from 'document-model-libs/document-drive';
+import { Operation, Document, DocumentModel, Action, OperationScope, State, BaseAction, ActionContext, ReducerOptions, Signal } from 'document-model/document';
 import { Unsubscribe } from 'nanoevents';
 import express, { Express } from 'express';
 import { Pool } from 'pg';
@@ -15,21 +15,6 @@ import { GraphQLResolverMap as GraphQLResolverMap$1 } from '@apollo/subgraph/dis
 import { AnalyticsModel } from '@powerhousedao/analytics-engine-graphql';
 import { GraphQLResolverMap } from '@apollo/subgraph/dist/schema-helper/resolverMap.js';
 
-type StrandUpdateSource = {
-    type: "local";
-} | {
-    type: "trigger";
-    trigger: Trigger;
-};
-interface ITransmitter {
-    transmit?(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
-    disconnect?(): Promise<void>;
-}
-type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
-    data: PullResponderTriggerData;
-    type: "PullResponder";
-};
-
 declare class DocumentModelNotFoundError extends Error {
     id: string;
     constructor(id: string, cause?: unknown);
@@ -93,6 +78,28 @@ interface IReadModeDriveService {
     deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined>;
 }
 
+interface IDefaultDrivesManager {
+    initializeDefaultRemoteDrives(): Promise<void>;
+    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
+    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
+    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
+}
+
+type StrandUpdateSource = {
+    type: "local";
+} | {
+    type: "trigger";
+    trigger: Trigger;
+};
+interface ITransmitter {
+    transmit?(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
+    disconnect?(): Promise<void>;
+}
+type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
+    data: PullResponderTriggerData;
+    type: "PullResponder";
+};
+
 interface IReceiver<T extends Document = Document, S extends OperationScope = OperationScope> {
     onStrands: (strands: InternalTransmitterUpdate<T, S>[]) => Promise<void>;
     onDisconnect: () => Promise<void>;
@@ -113,13 +120,6 @@ interface IInternalTransmitter extends ITransmitter {
     setReceiver(receiver: IReceiver): void;
 }
 
-interface IDefaultDrivesManager {
-    initializeDefaultRemoteDrives(): Promise<void>;
-    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
-    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel): Promise<void>;
-    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel): Promise<void>;
-}
-
 type DriveInput = State<Omit<DocumentDriveState, "__typename" | "id" | "nodes"> & {
     id?: string;
 }, DocumentDriveLocalState>;
@@ -130,7 +130,6 @@ type RemoteDriveOptions = DocumentDriveLocalState & {
     expectedDriveInfo?: DriveInfo;
     accessLevel?: RemoteDriveAccessLevel;
 };
-type CreateDocumentInput = CreateChildDocumentInput;
 type SignalResult = {
     signal: Signal;
     result: unknown;
@@ -161,6 +160,7 @@ type Listener = {
     system: boolean;
     filter: ListenerFilter;
     callInfo?: ListenerCallInfo;
+    transmitter?: ITransmitter;
 };
 type ListenerRevision = {
     driveId: string;
@@ -232,65 +232,52 @@ type GetStrandsOptions = {
     since?: string;
     fromRevision?: number;
 };
-declare abstract class AbstractDocumentDriveServer {
-    /** Public methods **/
-    abstract initialize(): Promise<Error[] | null>;
-    abstract setDocumentModels(models: DocumentModel[]): void;
-    abstract getDrives(): Promise<string[]>;
-    abstract addDrive(drive: DriveInput): Promise<DocumentDriveDocument>;
-    abstract addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
-    abstract deleteDrive(id: string): Promise<void>;
-    abstract getDrive(id: string, options?: GetDocumentOptions): Promise<DocumentDriveDocument>;
-    abstract getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
-    abstract getDocuments(drive: string): Promise<string[]>;
-    abstract getDocument(drive: string, id: string, options?: GetDocumentOptions): Promise<Document>;
-    abstract addOperation(drive: string, id: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addOperations(drive: string, id: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueOperation(drive: string, id: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueOperations(drive: string, id: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueAction(drive: string, id: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract queueActions(drive: string, id: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract addDriveOperations(drive: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveOperations(drive: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveAction(drive: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract queueDriveActions(drive: string, actions: Array<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract addAction(drive: string, id: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addActions(drive: string, id: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
-    abstract addDriveAction(drive: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract addDriveActions(drive: string, actions: (DocumentDriveAction | BaseAction)[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
-    abstract getSyncStatus(syncUnitId: string): SyncStatus | SynchronizationUnitNotFoundError;
-    abstract addInternalListener(driveId: string, receiver: IReceiver, options: {
+interface IBaseDocumentDriveServer {
+    initialize(): Promise<Error[] | null>;
+    setDocumentModels(models: DocumentModel[]): void;
+    getDrives(): Promise<string[]>;
+    addDrive(input: DriveInput): Promise<DocumentDriveDocument>;
+    addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
+    deleteDrive(driveId: string): Promise<void>;
+    getDrive(driveId: string, options?: GetDocumentOptions): Promise<DocumentDriveDocument>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    getDocuments(driveId: string): Promise<string[]>;
+    getDocument(driveId: string, documentId: string, options?: GetDocumentOptions): Promise<Document>;
+    addOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+    addOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+    queueOperation(driveId: string, documentId: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+    queueOperations(driveId: string, documentId: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+    queueAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+    queueActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+    addDriveOperation(driveId: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    addDriveOperations(driveId: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveOperation(driveId: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveOperations(driveId: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveAction(driveId: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    queueDriveActions(driveId: string, actions: Array<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    addAction(driveId: string, documentId: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+    addActions(driveId: string, documentId: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+    addDriveAction(driveId: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    addDriveActions(driveId: string, actions: (DocumentDriveAction | BaseAction)[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    getSyncStatus(syncUnitId: string): SyncStatus | SynchronizationUnitNotFoundError;
+    addInternalListener(driveId: string, receiver: IReceiver, options: {
         listenerId: string;
         label: string;
         block: boolean;
         filter: ListenerFilter;
     }): Promise<IInternalTransmitter>;
     /** Synchronization methods */
-    abstract getSynchronizationUnits(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[], loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit[]>;
-    abstract getSynchronizationUnit(driveId: string, syncId: string, loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit | undefined>;
-    abstract getSynchronizationUnitsIds(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
-    abstract getOperationData(driveId: string, syncId: string, filter: GetStrandsOptions, loadedDrive?: DocumentDriveDocument): Promise<OperationUpdate[]>;
+    getSynchronizationUnits(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[], loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit[]>;
+    getSynchronizationUnit(driveId: string, syncId: string, loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit | undefined>;
+    getSynchronizationUnitsIds(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
+    getOperationData(driveId: string, syncId: string, filter: GetStrandsOptions, loadedDrive?: DocumentDriveDocument): Promise<OperationUpdate[]>;
     /** Internal methods **/
-    protected abstract createDocument(drive: string, document: CreateDocumentInput): Promise<Document>;
-    protected abstract deleteDocument(drive: string, id: string): Promise<void>;
-    protected abstract getDocumentModel(documentType: string): DocumentModel;
-    abstract getDocumentModels(): DocumentModel[];
-    /** Event methods **/
-    protected abstract emit<K extends keyof DriveEvents>(event: K, ...args: Parameters<DriveEvents[K]>): void;
-    abstract on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
-    abstract getTransmitter(driveId: string, listenerId: string): Promise<ITransmitter | undefined>;
-    abstract clearStorage(): Promise<void>;
-    abstract registerPullResponderTrigger(id: string, url: string, options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">): Promise<PullResponderTrigger>;
+    getDocumentModels(): DocumentModel[];
+    getTransmitter(driveId: string, listenerId: string): Promise<ITransmitter | undefined>;
+    clearStorage(): Promise<void>;
+    registerPullResponderTrigger(id: string, url: string, options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">): Promise<PullResponderTrigger>;
+    on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
 }
-type PublicKeys<T> = {
-    [K in keyof T]: T extends {
-        [P in K]: T[K];
-    } ? K : never;
-}[keyof T];
-type PublicPart<T> = Pick<T, PublicKeys<T>>;
-type IBaseDocumentDriveServer = PublicPart<AbstractDocumentDriveServer>;
 type IDocumentDriveServer = IBaseDocumentDriveServer & IDefaultDrivesManager & IReadModeDriveServer;
 
 type ProcessorUpdate<D extends Document = Document, S extends OperationScope = OperationScope> = InternalTransmitterUpdate<D, S>;
@@ -360,6 +347,9 @@ declare namespace index$3 {
 }
 
 declare class DriveSubgraph extends Subgraph {
+    private debugID;
+    constructor(args: SubgraphArgs);
+    private debugLog;
     name: string;
     typeDefs: graphql.DocumentNode;
     resolvers: GraphQLResolverMap$1<Context>;

package/dist/index.js

@@ -25926,7 +25926,68 @@ index.documentHelpers;
 
 // ../document-drive/src/server/listener/transmitter/switchboard-push.ts
 __toESM(require_lib4());
+
+// src/sync/utils.ts
+var processPushUpdate = async (reactor, strand) => {
+  const result = await (strand.documentId !== undefined ? reactor.queueOperations(
+    strand.driveId,
+    strand.documentId,
+    strand.operations
+  ) : reactor.queueDriveOperations(
+    strand.driveId,
+    strand.operations
+  ));
+  const scopeOperations = result.document?.operations[strand.scope] ?? [];
+  if (scopeOperations.length === 0) {
+    return {
+      revision: -1,
+      branch: strand.branch,
+      documentId: strand.documentId ?? "",
+      driveId: strand.driveId,
+      scope: strand.scope,
+      status: result.status
+    };
+  }
+  const revision = scopeOperations.slice().pop()?.index ?? -1;
+  return {
+    revision,
+    branch: strand.branch,
+    documentId: strand.documentId ?? "",
+    driveId: strand.driveId,
+    scope: strand.scope,
+    status: result.status,
+    error: result.error?.message || undefined
+  };
+};
+var processAcknowledge = async (reactor, driveId, listenerId, revisions) => {
+  const transmitter = await reactor.getTransmitter(
+    driveId,
+    listenerId
+  );
+  return transmitter.processAcknowledge(driveId, listenerId, revisions);
+};
+var processGetStrands = async (reactor, driveId, listenerId, since) => {
+  const transmitter = await reactor.getTransmitter(
+    driveId,
+    listenerId
+  );
+  return transmitter.getStrands({ since });
+};
+var driveKindTypeNames = {
+  file: "DocumentDrive_FileNode",
+  folder: "DocumentDrive_FolderNode"
+};
 var DriveSubgraph = class extends Subgraph {
+  debugID = `[DSG #${Math.floor(Math.random() * 999)}]`;
+  constructor(args) {
+    super(args);
+    this.debugLog(`constructor()`);
+  }
+  debugLog(...data) {
+    {
+      return;
+    }
+  }
   name = "d/:drive";
   typeDefs = gql`
     type Query {
@@ -26090,16 +26151,25 @@ var DriveSubgraph = class extends Subgraph {
     },
     Query: {
       drive: async (_, args, ctx) => {
+        this.debugLog(`drive()`, args);
         if (!ctx.driveId) throw new Error("Drive ID is required");
         const drive = await this.reactor.getDrive(ctx.driveId);
-        return drive.state.global;
+        return {
+          ...drive.state.global,
+          nodes: drive.state.global.nodes.map((n2) => ({
+            ...n2,
+            __typename: driveKindTypeNames[n2.kind] || "UnkownDriveNode"
+          }))
+        };
       },
       documents: async (_, args, ctx) => {
+        this.debugLog(`documents(drive: ${ctx.driveId})`, args);
         if (!ctx.driveId) throw new Error("Drive ID is required");
         const documents = await this.reactor.getDocuments(ctx.driveId);
         return documents;
       },
       document: async (_, { id }, ctx) => {
+        this.debugLog(`document(drive: ${ctx.driveId}, id: ${id})`);
         if (!ctx.driveId) throw new Error("Drive ID is required");
         const document = await this.reactor.getDocument(ctx.driveId, id);
         const dms = this.reactor.getDocumentModels();
@@ -26129,6 +26199,10 @@ var DriveSubgraph = class extends Subgraph {
     },
     Mutation: {
       registerPullResponderListener: async (_, { filter }, ctx) => {
+        this.debugLog(
+          `registerPullResponderListener(drive: ${ctx.driveId})`,
+          filter
+        );
         if (!ctx.driveId) throw new Error("Drive ID is required");
         const uuid = generateUUID2();
         const listener = {
@@ -26159,54 +26233,36 @@ var DriveSubgraph = class extends Subgraph {
         }
         return listener;
       },
-      pushUpdates: async (_, { strands }, ctx) => {
+      pushUpdates: async (_, { strands: strandsGql }, ctx) => {
         if (!ctx.driveId) throw new Error("Drive ID is required");
-        const listenerRevisions = await Promise.all(
-          strands.map(async (s2) => {
-            const operations = s2.operations.map((o) => ({
-              ...o,
-              input: JSON.parse(o.input),
-              skip: o.skip ?? 0,
-              scope: s2.scope,
+        this.debugLog(`pushUpdates(drive: ${ctx.driveId})`, strandsGql);
+        const strands = strandsGql.map((strandGql) => {
+          return {
+            operations: strandGql.operations.map((op) => ({
+              ...op,
+              input: JSON.parse(op.input),
+              skip: op.skip ?? 0,
+              scope: strandGql.scope,
               branch: "main"
-            })) ?? [];
-            const result = await (s2.documentId !== undefined ? this.reactor.queueOperations(
-              s2.driveId,
-              s2.documentId,
-              operations
-            ) : this.reactor.queueDriveOperations(
-              s2.driveId,
-              operations
-            ));
-            const scopeOperations = result.document?.operations[s2.scope] ?? [];
-            if (scopeOperations.length === 0) {
-              return {
-                revision: -1,
-                branch: s2.branch,
-                documentId: s2.documentId ?? "",
-                driveId: s2.driveId,
-                scope: s2.scope,
-                status: result.status
-              };
-            }
-            const revision = scopeOperations.slice().pop()?.index ?? -1;
-            return {
-              revision,
-              branch: s2.branch,
-              documentId: s2.documentId ?? "",
-              driveId: s2.driveId,
-              scope: s2.scope,
-              status: result.status,
-              error: result.error?.message || undefined
-            };
-          })
+            })),
+            documentId: strandGql.documentId,
+            driveId: strandGql.driveId,
+            scope: strandGql.scope,
+            branch: strandGql.branch
+          };
+        });
+        return await Promise.all(
+          strands.map((strand) => processPushUpdate(this.reactor, strand))
         );
-        return listenerRevisions;
       },
       acknowledge: async (_, {
         listenerId,
         revisions
       }, ctx) => {
+        this.debugLog(
+          `acknowledge(drive: ${ctx.driveId}, listenerId: ${listenerId})`,
+          revisions
+        );
         if (!listenerId || !revisions) return false;
         if (!ctx.driveId) throw new Error("Drive ID is required");
         const validEntries = revisions.filter((r) => r !== null).map((e) => ({
@@ -26217,16 +26273,12 @@ var DriveSubgraph = class extends Subgraph {
           revision: e.revision,
           status: e.status
         }));
-        const transmitter = await this.reactor.getTransmitter(
+        return await processAcknowledge(
+          this.reactor,
           ctx.driveId,
-          listenerId
-        );
-        const result = await transmitter.processAcknowledge(
-          ctx.driveId ?? "1",
           listenerId,
           validEntries
         );
-        return result;
       }
     },
     System: {},
@@ -26235,27 +26287,31 @@ var DriveSubgraph = class extends Subgraph {
         listenerId,
         since
       }, ctx) => {
+        this.debugLog(
+          `strands(drive: ${ctx.driveId}, listenerId: ${listenerId}, since:${since})`
+        );
         if (!ctx.driveId) throw new Error("Drive ID is required");
-        const listener = await this.reactor.getTransmitter(
+        const strands = await processGetStrands(
+          this.reactor,
           ctx.driveId,
-          listenerId
+          listenerId,
+          since
         );
-        const strands = await listener.getStrands({ since });
-        return strands.map((e) => ({
-          driveId: e.driveId,
-          documentId: e.documentId,
-          scope: e.scope,
-          branch: e.branch,
-          operations: e.operations.map((o) => ({
-            index: o.index,
-            skip: o.skip,
-            name: o.type,
-            input: JSON.stringify(o.input),
-            hash: o.hash,
-            timestamp: o.timestamp,
-            type: o.type,
-            context: o.context,
-            id: o.id
+        return strands.map((update) => ({
+          driveId: update.driveId,
+          documentId: update.documentId,
+          scope: update.scope,
+          branch: update.branch,
+          operations: update.operations.map((op) => ({
+            index: op.index,
+            skip: op.skip,
+            name: op.type,
+            input: JSON.stringify(op.input),
+            hash: op.hash,
+            timestamp: op.timestamp,
+            type: op.type,
+            context: op.context,
+            id: op.id
           }))
         }));
       }