@powerhousedao/connect 1.0.0-dev.245 → 1.0.0-dev.247

package/dist/modules/@powerhousedao/reactor-browser/{chunk-4AV4NYOH.js → chunk-N5UNGAA6.js}

@@ -688,140 +688,79 @@ var require_lib = __commonJS({
   }
 });
 
-// ../../packages/document-drive/dist/src/utils/logger.js
-var LEVELS = {
-  verbose: 1,
-  debug: 2,
-  info: 3,
-  warn: 4,
-  error: 5,
-  silent: 6
+// ../../packages/document-drive/dist/src/cache/util.js
+var trimResultingState = (document) => {
+  const global2 = document.operations.global.map((e) => {
+    delete e.resultingState;
+    return e;
+  });
+  const local = document.operations.local.map((e) => {
+    delete e.resultingState;
+    return e;
+  });
+  return { ...document, operations: { global: global2, local } };
 };
-var ConsoleLogger = class {
-  #tags;
-  #levelString = "env";
-  #errorHandler;
-  constructor(tags, errorHandler2) {
-    this.#tags = (tags || []).map((tag) => `[${tag}]`);
-    this.#errorHandler = errorHandler2;
-    this.log = this.log.bind(this);
-    this.info = this.info.bind(this);
-    this.warn = this.warn.bind(this);
-    this.error = this.error.bind(this);
-    this.debug = this.debug.bind(this);
-    this.verbose = this.verbose.bind(this);
-  }
-  get level() {
-    return this.#levelString;
-  }
-  set level(level) {
-    this.#levelString = level;
-  }
-  get errorHandler() {
-    return this.#errorHandler;
-  }
-  set errorHandler(handler) {
-    this.#errorHandler = handler;
-  }
-  get #levelValue() {
-    if (this.#levelString === "env") {
-      const envLevel = typeof process !== "undefined" ? process.env.LOG_LEVEL : void 0;
-      if (!envLevel) {
-        return LEVELS.debug;
-      }
-      if (!(envLevel in LEVELS)) {
-        return LEVELS.debug;
-      }
-      return LEVELS[envLevel];
-    }
-    return LEVELS[this.#levelString];
+
+// ../../packages/document-drive/dist/src/cache/memory.js
+var InMemoryCache = class {
+  idTodocument = /* @__PURE__ */ new Map();
+  idToDrive = /* @__PURE__ */ new Map();
+  slugToDriveId = /* @__PURE__ */ new Map();
+  clear() {
+    this.idTodocument.clear();
+    this.idToDrive.clear();
+    this.slugToDriveId.clear();
   }
-  log(...data) {
-    return this.debug(...data);
+  /////////////////////////////////////////////////////////////////////////////
+  // ICache
+  /////////////////////////////////////////////////////////////////////////////
+  async setDocument(documentId, document) {
+    const doc = trimResultingState(document);
+    this.idTodocument.set(documentId, doc);
   }
-  verbose(...data) {
-    if (this.#levelValue > LEVELS.verbose) {
-      return;
-    }
-    return this.debug(...data);
+  async getDocument(documentId) {
+    return this.idTodocument.get(documentId);
   }
-  debug(...data) {
-    if (this.#levelValue > LEVELS.debug) {
-      return;
-    }
-    return console.debug(...[...this.#tags, ...data]);
+  async deleteDocument(documentId) {
+    return this.idTodocument.delete(documentId);
   }
-  info(...data) {
-    if (this.#levelValue > LEVELS.info) {
-      return;
-    }
-    return console.info(...[...this.#tags, ...data]);
+  async setDrive(driveId, drive) {
+    const doc = trimResultingState(drive);
+    this.idToDrive.set(driveId, doc);
   }
-  warn(...data) {
-    if (this.#levelValue > LEVELS.warn) {
-      return;
-    }
-    return console.warn(...[...this.#tags, ...data]);
+  async getDrive(driveId) {
+    return this.idToDrive.get(driveId);
   }
-  error(...data) {
-    if (this.#levelValue > LEVELS.error) {
-      return;
+  async deleteDrive(driveId) {
+    const drive = this.idToDrive.get(driveId);
+    if (!drive) {
+      return false;
     }
-    if (this.#errorHandler) {
-      this.#errorHandler(...data);
+    const slug = drive.state.global.slug;
+    if (slug) {
+      this.slugToDriveId.delete(slug);
     }
-    return console.error(...[...this.#tags, ...data]);
+    return this.idToDrive.delete(driveId);
   }
-};
-var loggerInstance = new ConsoleLogger();
-var logLevel = "env";
-var errorHandler;
-loggerInstance.level = logLevel;
-loggerInstance.errorHandler = errorHandler;
-var logger = loggerInstance;
-var childLogger = (tags) => {
-  const logger2 = new ConsoleLogger(tags);
-  logger2.level = logLevel;
-  logger2.errorHandler = errorHandler;
-  return logger2;
-};
-
-// ../../packages/document-drive/dist/src/cache/memory.js
-var InMemoryCache = class {
-  cache = /* @__PURE__ */ new Map();
-  clear() {
-    this.cache.clear();
+  async setDriveBySlug(slug, drive) {
+    const driveId = drive.state.global.id;
+    this.slugToDriveId.set(slug, driveId);
+    this.setDrive(driveId, drive);
   }
-  async setDocument(drive, id, document) {
-    const global2 = document.operations.global.map((e) => {
-      delete e.resultingState;
-      return e;
-    });
-    const local = document.operations.local.map((e) => {
-      delete e.resultingState;
-      return e;
-    });
-    const doc = { ...document, operations: { global: global2, local } };
-    if (!this.cache.has(drive)) {
-      this.cache.set(drive, /* @__PURE__ */ new Map());
+  async getDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return void 0;
     }
-    this.cache.get(drive)?.set(id, doc);
-    return true;
-  }
-  async deleteDocument(drive, id) {
-    return this.cache.get(drive)?.delete(id) ?? false;
-  }
-  async getDocument(drive, id) {
-    return this.cache.get(drive)?.get(id);
+    return this.getDrive(driveId);
   }
-  async getCachedOperations(drive, id) {
-    try {
-      const document = await this.getDocument(drive, id);
-      return document?.operations;
-    } catch (error) {
-      logger.error(error);
-      return void 0;
+  async deleteDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return false;
     }
+    this.slugToDriveId.delete(slug);
+    return this.deleteDrive(driveId);
   }
 };
 var memory_default = InMemoryCache;
@@ -1187,6 +1126,104 @@ function handleTargetNameCollisions(params) {
   return targetName;
 }
 
+// ../../packages/document-drive/dist/src/utils/logger.js
+var LEVELS = {
+  verbose: 1,
+  debug: 2,
+  info: 3,
+  warn: 4,
+  error: 5,
+  silent: 6
+};
+var ConsoleLogger = class {
+  #tags;
+  #levelString = "env";
+  #errorHandler;
+  constructor(tags, errorHandler2) {
+    this.#tags = (tags || []).map((tag) => `[${tag}]`);
+    this.#errorHandler = errorHandler2;
+    this.log = this.log.bind(this);
+    this.info = this.info.bind(this);
+    this.warn = this.warn.bind(this);
+    this.error = this.error.bind(this);
+    this.debug = this.debug.bind(this);
+    this.verbose = this.verbose.bind(this);
+  }
+  get level() {
+    return this.#levelString;
+  }
+  set level(level) {
+    this.#levelString = level;
+  }
+  get errorHandler() {
+    return this.#errorHandler;
+  }
+  set errorHandler(handler) {
+    this.#errorHandler = handler;
+  }
+  get #levelValue() {
+    if (this.#levelString === "env") {
+      const envLevel = typeof process !== "undefined" ? process.env.LOG_LEVEL : void 0;
+      if (!envLevel) {
+        return LEVELS.debug;
+      }
+      if (!(envLevel in LEVELS)) {
+        return LEVELS.debug;
+      }
+      return LEVELS[envLevel];
+    }
+    return LEVELS[this.#levelString];
+  }
+  log(...data) {
+    return this.debug(...data);
+  }
+  verbose(...data) {
+    if (this.#levelValue > LEVELS.verbose) {
+      return;
+    }
+    return this.debug(...data);
+  }
+  debug(...data) {
+    if (this.#levelValue > LEVELS.debug) {
+      return;
+    }
+    return console.debug(...[...this.#tags, ...data]);
+  }
+  info(...data) {
+    if (this.#levelValue > LEVELS.info) {
+      return;
+    }
+    return console.info(...[...this.#tags, ...data]);
+  }
+  warn(...data) {
+    if (this.#levelValue > LEVELS.warn) {
+      return;
+    }
+    return console.warn(...[...this.#tags, ...data]);
+  }
+  error(...data) {
+    if (this.#levelValue > LEVELS.error) {
+      return;
+    }
+    if (this.#errorHandler) {
+      this.#errorHandler(...data);
+    }
+    return console.error(...[...this.#tags, ...data]);
+  }
+};
+var loggerInstance = new ConsoleLogger();
+var logLevel = "env";
+var errorHandler;
+loggerInstance.level = logLevel;
+loggerInstance.errorHandler = errorHandler;
+var logger = loggerInstance;
+var childLogger = (tags) => {
+  const logger2 = new ConsoleLogger(tags);
+  logger2.level = logLevel;
+  logger2.errorHandler = errorHandler;
+  return logger2;
+};
+
 // ../../packages/document-drive/dist/src/drive-document-model/gen/constants.js
 var fileExtension = "phdd";
 var documentType = "powerhouse/document-drive";
@@ -1690,6 +1727,44 @@ var MemoryStorage = class {
     }
     return Promise.resolve(document);
   }
+  async delete(documentId) {
+    const drives = await this.getDrives();
+    for (const driveId of drives) {
+      if (driveId === documentId)
+        continue;
+      await this.removeChild(driveId, documentId);
+    }
+    delete this.driveManifests[documentId];
+    if (this.documents[documentId]) {
+      delete this.documents[documentId];
+      return Promise.resolve(true);
+    }
+    return Promise.resolve(false);
+  }
+  async addChild(parentId, childId) {
+    if (parentId === childId) {
+      throw new Error("Cannot associate a document with itself");
+    }
+    const children = await this.getChildren(childId);
+    if (children.includes(parentId)) {
+      throw new Error("Cannot associate a document with its child");
+    }
+    const manifest = this.getManifest(parentId);
+    manifest.documentIds.add(childId);
+    this.updateDriveManifest(parentId, manifest);
+  }
+  async removeChild(parentId, childId) {
+    const manifest = this.getManifest(parentId);
+    if (manifest.documentIds.delete(childId)) {
+      this.updateDriveManifest(parentId, manifest);
+      return true;
+    }
+    return false;
+  }
+  async getChildren(parentId) {
+    const manifest = this.getManifest(parentId);
+    return [...manifest.documentIds];
+  }
   ////////////////////////////////
   // IDriveStorage
   ////////////////////////////////
@@ -1697,7 +1772,7 @@ var MemoryStorage = class {
     return this.exists(id);
   }
   getDocuments(drive) {
-    const manifest = this.getDriveManifest(drive);
+    const manifest = this.getManifest(drive);
     return Promise.resolve([...manifest.documentIds]);
   }
   getDocument(driveId, id) {
@@ -1709,7 +1784,7 @@ var MemoryStorage = class {
   }
   async createDocument(drive, id, document) {
     await this.create(id, document);
-    const manifest = this.getDriveManifest(drive);
+    const manifest = this.getManifest(drive);
     manifest.documentIds.add(id);
     this.updateDriveManifest(drive, manifest);
   }
@@ -1726,15 +1801,7 @@ var MemoryStorage = class {
     };
   }
   async deleteDocument(drive, id) {
-    const drives = await this.getDrives();
-    for (const driveId of drives) {
-      const manifest = this.getDriveManifest(driveId);
-      if (manifest.documentIds.has(id)) {
-        manifest.documentIds.delete(id);
-        this.updateDriveManifest(driveId, manifest);
-      }
-    }
-    delete this.documents[id];
+    this.delete(id);
   }
   async getDrives() {
     return Object.keys(this.driveManifests);
@@ -1780,14 +1847,14 @@ var MemoryStorage = class {
     };
   }
   async deleteDrive(id) {
-    const manifest = this.getDriveManifest(id);
+    const manifest = this.getManifest(id);
     const drives = await this.getDrives();
     await Promise.all([...manifest.documentIds].map((docId) => {
       for (const driveId of drives) {
         if (driveId === id) {
           continue;
         }
-        const manifest2 = this.getDriveManifest(driveId);
+        const manifest2 = this.getManifest(driveId);
         if (manifest2.documentIds.has(docId)) {
           return;
         }
@@ -1828,7 +1895,7 @@ var MemoryStorage = class {
   ////////////////////////////////
   // Private
   ////////////////////////////////
-  getDriveManifest(driveId) {
+  getManifest(driveId) {
     if (!this.driveManifests[driveId]) {
       this.driveManifests[driveId] = { documentIds: /* @__PURE__ */ new Set() };
     }
@@ -12096,6 +12163,80 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
   }
 };
 
+// ../../packages/document-drive/dist/src/server/listener/transmitter/switchboard-push.js
+var import_json_stringify_deterministic = __toESM(require_lib(), 1);
+var SYNC_OPS_BATCH_LIMIT = 10;
+var SwitchboardPushTransmitter = class {
+  targetURL;
+  logger = childLogger([
+    "SwitchboardPushTransmitter",
+    Math.floor(Math.random() * 999).toString()
+  ]);
+  constructor(targetURL) {
+    this.targetURL = targetURL;
+  }
+  async transmit(strands, source) {
+    if (source.type === "trigger" && source.trigger.data?.url === this.targetURL) {
+      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
+      return strands.map((strand) => ({
+        driveId: strand.driveId,
+        documentId: strand.documentId,
+        scope: strand.scope,
+        branch: strand.branch,
+        status: "SUCCESS",
+        revision: strand.operations.at(-1)?.index ?? -1
+      }));
+    }
+    const culledStrands = [];
+    let opsCounter = 0;
+    for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
+      const currentStrand = strands.at(s);
+      if (!currentStrand) {
+        break;
+      }
+      const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
+      culledStrands.push({
+        ...currentStrand,
+        operations: currentStrand.operations.slice(0, newOps)
+      });
+      opsCounter += newOps;
+    }
+    this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
+    this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
+    try {
+      const { pushUpdates } = await requestGraphql(this.targetURL, gql`
+          mutation pushUpdates($strands: [InputStrandUpdate!]) {
+            pushUpdates(strands: $strands) {
+              driveId
+              documentId
+              scope
+              branch
+              status
+              revision
+              error
+            }
+          }
+        `, {
+        strands: culledStrands.map((strand) => ({
+          ...strand,
+          operations: strand.operations.map((op) => ({
+            ...op,
+            input: (0, import_json_stringify_deterministic.default)(op.input)
+          }))
+        }))
+      });
+      if (!pushUpdates) {
+        throw new Error("Couldn't update listener revision");
+      }
+      return pushUpdates;
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+    return [];
+  }
+};
+
 // ../../packages/document-drive/dist/src/server/types.js
 var TransmitterType;
 (function(TransmitterType2) {
@@ -12336,6 +12477,26 @@ var BaseDocumentDriveServer = class {
     if (this.shouldSyncRemoteDrive(drive)) {
       await this.startSyncRemoteDrive(driveId);
     }
+    for (const zodListener of drive.state.local.listeners) {
+      if (zodListener.callInfo?.transmitterType === "SwitchboardPush") {
+        const transmitter = new SwitchboardPushTransmitter(zodListener.callInfo?.data ?? "");
+        this.listenerManager.setListener(driveId, {
+          block: zodListener.block,
+          driveId: drive.state.global.id,
+          filter: {
+            branch: zodListener.filter?.branch ?? [],
+            documentId: zodListener.filter?.documentId ?? [],
+            documentType: zodListener.filter?.documentType ?? [],
+            scope: zodListener.filter?.scope ?? []
+          },
+          listenerId: zodListener.listenerId,
+          callInfo: zodListener.callInfo,
+          system: zodListener.system,
+          label: zodListener.label ?? "",
+          transmitter
+        });
+      }
+    }
   }
   // Delegate synchronization methods to synchronizationManager
   getSynchronizationUnits(driveId, documentId, scope, branch, documentType2) {
@@ -12377,7 +12538,7 @@ var BaseDocumentDriveServer = class {
     };
     await this.storage.createDrive(id, document);
     if (input.global.slug) {
-      await this.cache.deleteDocument("drives-slug", input.global.slug);
+      await this.cache.deleteDriveBySlug(input.global.slug);
     }
     await this._initializeDrive(id);
     this.eventEmitter.emit("driveAdded", document);
@@ -12409,7 +12570,7 @@ var BaseDocumentDriveServer = class {
     const result = await Promise.allSettled([
       this.stopSyncRemoteDrive(driveId),
       this.listenerManager.removeDrive(driveId),
-      this.cache.deleteDocument("drives", driveId),
+      this.cache.deleteDrive(driveId),
       this.storage.deleteDrive(driveId)
     ]);
     result.forEach((r) => {
@@ -12424,7 +12585,7 @@ var BaseDocumentDriveServer = class {
   async getDrive(driveId, options) {
     let document;
     try {
-      const cachedDocument = await this.cache.getDocument("drives", driveId);
+      const cachedDocument = await this.cache.getDrive(driveId);
       if (cachedDocument && isDocumentDrive(cachedDocument)) {
         document = cachedDocument;
         if (isAtRevision(document, options?.revisions)) {
@@ -12440,16 +12601,16 @@ var BaseDocumentDriveServer = class {
       throw new Error(`Document with id ${driveId} is not a Document Drive`);
     } else {
       if (!options?.revisions) {
-        this.cache.setDocument("drives", driveId, result).catch(logger.error);
+        this.cache.setDrive(driveId, result).catch(logger.error);
       }
       return result;
     }
   }
   async getDriveBySlug(slug, options) {
     try {
-      const document2 = await this.cache.getDocument("drives-slug", slug);
-      if (document2 && isDocumentDrive(document2)) {
-        return document2;
+      const drive = await this.cache.getDriveBySlug(slug);
+      if (drive) {
+        return drive;
       }
     } catch (e) {
       logger.error("Error getting drive from cache", e);
@@ -12459,14 +12620,14 @@ var BaseDocumentDriveServer = class {
     if (!isDocumentDrive(document)) {
       throw new Error(`Document with slug ${slug} is not a Document Drive`);
     } else {
-      this.cache.setDocument("drives-slug", slug, document).catch(logger.error);
+      this.cache.setDriveBySlug(slug, document).catch(logger.error);
       return document;
     }
   }
   async getDocument(driveId, documentId, options) {
     let cachedDocument;
     try {
-      cachedDocument = await this.cache.getDocument(driveId, documentId);
+      cachedDocument = await this.cache.getDocument(documentId);
       if (cachedDocument && isAtRevision(cachedDocument, options?.revisions)) {
         return cachedDocument;
       }
@@ -12476,7 +12637,7 @@ var BaseDocumentDriveServer = class {
     const documentStorage = cachedDocument ?? await this.storage.getDocument(driveId, documentId);
     const document = this._buildDocument(documentStorage, options);
     if (!options?.revisions) {
-      this.cache.setDocument(driveId, documentId, document).catch(logger.error);
+      this.cache.setDocument(documentId, document).catch(logger.error);
     }
     return document;
   }
@@ -12533,7 +12694,7 @@ var BaseDocumentDriveServer = class {
     } catch (error) {
       logger.warn("Error deleting document", error);
     }
-    await this.cache.deleteDocument(driveId, documentId);
+    await this.cache.deleteDocument(documentId);
     return this.storage.deleteDocument(driveId, documentId);
   }
   async _processOperations(driveId, documentId, documentStorage, operations) {
@@ -12821,7 +12982,7 @@ var BaseDocumentDriveServer = class {
         };
       });
       if (document) {
-        this.cache.setDocument(driveId, documentId, document).catch(logger.error);
+        this.cache.setDocument(documentId, document).catch(logger.error);
       }
       const { scopes, branches } = operationsApplied.reduce((acc, operation) => {
         if (!acc.scopes.includes(operation.scope)) {
@@ -12983,7 +13144,7 @@ var BaseDocumentDriveServer = class {
       if (!document || !isDocumentDrive(document)) {
         throw error ?? new Error("Invalid Document Drive document");
       }
-      this.cache.setDocument("drives", driveId, document).catch(logger.error);
+      this.cache.setDrive(driveId, document).catch(logger.error);
       const lastOperation = operationsApplied.filter((op) => op.scope === "global").slice().pop();
       if (lastOperation) {
         const newOp = operationsApplied.find((appliedOp) => !operations.find((o) => o.id === appliedOp.id && o.index === appliedOp.index && o.skip === appliedOp.skip && o.hash === appliedOp.hash));
@@ -13516,80 +13677,6 @@ var ListenerManager = class _ListenerManager {
   }
 };
 
-// ../../packages/document-drive/dist/src/server/listener/transmitter/switchboard-push.js
-var import_json_stringify_deterministic = __toESM(require_lib(), 1);
-var SYNC_OPS_BATCH_LIMIT = 10;
-var SwitchboardPushTransmitter = class {
-  targetURL;
-  logger = childLogger([
-    "SwitchboardPushTransmitter",
-    Math.floor(Math.random() * 999).toString()
-  ]);
-  constructor(targetURL) {
-    this.targetURL = targetURL;
-  }
-  async transmit(strands, source) {
-    if (source.type === "trigger" && source.trigger.data?.url === this.targetURL) {
-      this.logger.verbose(`Cutting trigger loop from ${this.targetURL}.`);
-      return strands.map((strand) => ({
-        driveId: strand.driveId,
-        documentId: strand.documentId,
-        scope: strand.scope,
-        branch: strand.branch,
-        status: "SUCCESS",
-        revision: strand.operations.at(-1)?.index ?? -1
-      }));
-    }
-    const culledStrands = [];
-    let opsCounter = 0;
-    for (let s = 0; opsCounter <= SYNC_OPS_BATCH_LIMIT && s < strands.length; s++) {
-      const currentStrand = strands.at(s);
-      if (!currentStrand) {
-        break;
-      }
-      const newOps = Math.min(SYNC_OPS_BATCH_LIMIT - opsCounter, currentStrand.operations.length);
-      culledStrands.push({
-        ...currentStrand,
-        operations: currentStrand.operations.slice(0, newOps)
-      });
-      opsCounter += newOps;
-    }
-    this.logger.verbose(` Total update: [${strands.map((s) => s.operations.length).join(", ")}] operations`);
-    this.logger.verbose(`Culled update: [${culledStrands.map((s) => s.operations.length).join(", ")}] operations`);
-    try {
-      const { pushUpdates } = await requestGraphql(this.targetURL, gql`
-          mutation pushUpdates($strands: [InputStrandUpdate!]) {
-            pushUpdates(strands: $strands) {
-              driveId
-              documentId
-              scope
-              branch
-              status
-              revision
-              error
-            }
-          }
-        `, {
-        strands: culledStrands.map((strand) => ({
-          ...strand,
-          operations: strand.operations.map((op) => ({
-            ...op,
-            input: (0, import_json_stringify_deterministic.default)(op.input)
-          }))
-        }))
-      });
-      if (!pushUpdates) {
-        throw new Error("Couldn't update listener revision");
-      }
-      return pushUpdates;
-    } catch (e) {
-      this.logger.error(e);
-      throw e;
-    }
-    return [];
-  }
-};
-
 // ../../packages/document-drive/dist/src/server/listener/transmitter/factory.js
 var TransmitterFactory = class {
   listenerManager;
@@ -13733,7 +13820,7 @@ var SynchronizationManager = class {
   }
   async getDrive(driveId) {
     try {
-      const cachedDocument = await this.cache.getDocument("drives", driveId);
+      const cachedDocument = await this.cache.getDrive(driveId);
       if (cachedDocument && isDocumentDrive(cachedDocument)) {
         return cachedDocument;
       }
@@ -13749,7 +13836,7 @@ var SynchronizationManager = class {
   }
   async getDocument(driveId, documentId) {
     try {
-      const cachedDocument = await this.cache.getDocument(driveId, documentId);
+      const cachedDocument = await this.cache.getDocument(documentId);
       if (cachedDocument) {
         return cachedDocument;
       }