@powerhousedao/connect 1.0.0-dev.244 → 1.0.0-dev.246

package/dist/modules/@powerhousedao/reactor-browser/{chunk-YOX3ZAET.js → chunk-A4GIWVYS.js}

@@ -688,30 +688,79 @@ var require_lib = __commonJS({
   }
 });
 
+// ../../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 } };
+};
+
 // ../../packages/document-drive/dist/src/cache/memory.js
 var InMemoryCache = class {
-  cache = /* @__PURE__ */ new Map();
-  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());
+  idTodocument = /* @__PURE__ */ new Map();
+  idToDrive = /* @__PURE__ */ new Map();
+  slugToDriveId = /* @__PURE__ */ new Map();
+  clear() {
+    this.idTodocument.clear();
+    this.idToDrive.clear();
+    this.slugToDriveId.clear();
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // ICache
+  /////////////////////////////////////////////////////////////////////////////
+  async setDocument(documentId, document) {
+    const doc = trimResultingState(document);
+    this.idTodocument.set(documentId, doc);
+  }
+  async getDocument(documentId) {
+    return this.idTodocument.get(documentId);
+  }
+  async deleteDocument(documentId) {
+    return this.idTodocument.delete(documentId);
+  }
+  async setDrive(driveId, drive) {
+    const doc = trimResultingState(drive);
+    this.idToDrive.set(driveId, doc);
+  }
+  async getDrive(driveId) {
+    return this.idToDrive.get(driveId);
+  }
+  async deleteDrive(driveId) {
+    const drive = this.idToDrive.get(driveId);
+    if (!drive) {
+      return false;
     }
-    this.cache.get(drive)?.set(id, doc);
-    return true;
+    const slug = drive.state.global.slug;
+    if (slug) {
+      this.slugToDriveId.delete(slug);
+    }
+    return this.idToDrive.delete(driveId);
   }
-  async deleteDocument(drive, id) {
-    return this.cache.get(drive)?.delete(id) ?? false;
+  async setDriveBySlug(slug, drive) {
+    const driveId = drive.state.global.id;
+    this.slugToDriveId.set(slug, driveId);
+    this.setDrive(driveId, drive);
   }
-  async getDocument(drive, id) {
-    return this.cache.get(drive)?.get(id);
+  async getDriveBySlug(slug) {
+    const driveId = this.slugToDriveId.get(slug);
+    if (!driveId) {
+      return void 0;
+    }
+    return this.getDrive(driveId);
+  }
+  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;
@@ -1652,19 +1701,16 @@ var ReadDocumentNotFoundError = class extends ReadDriveError {
 // ../../packages/document-drive/dist/src/storage/memory.js
 var MemoryStorage = class {
   documents;
-  drives;
   driveManifests;
-  slugToDriveId = {};
   constructor() {
     this.documents = {};
-    this.drives = {};
     this.driveManifests = {};
   }
   ////////////////////////////////
   // IDocumentStorage
   ////////////////////////////////
   exists(documentId) {
-    return Promise.resolve(!!this.documents[documentId]);
+    return Promise.resolve(!!this.documents[documentId] || !!this.documents[`drive/${documentId}`]);
   }
   create(documentId, document) {
     this.documents[documentId] = document;
@@ -1673,10 +1719,52 @@ var MemoryStorage = class {
   get(documentId) {
     const document = this.documents[documentId];
     if (!document) {
+      const drive = this.documents[`drive/${documentId}`];
+      if (drive) {
+        return Promise.resolve(drive);
+      }
       throw new Error(`Document with id ${documentId} not found`);
     }
     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
   ////////////////////////////////
@@ -1684,27 +1772,19 @@ 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) {
     return this.get(id);
   }
-  async saveDocument(drive, id, document) {
-    this.documents[id] = document;
-    const manifest = this.getDriveManifest(drive);
-    manifest.documentIds.add(id);
-    this.updateDriveManifest(drive, manifest);
-  }
   async clearStorage() {
     this.documents = {};
-    this.drives = {};
     this.driveManifests = {};
-    this.slugToDriveId = {};
   }
   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);
   }
@@ -1721,59 +1801,60 @@ 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.drives);
+    return Object.keys(this.driveManifests);
   }
   async getDrive(id) {
-    const drive = this.drives[id];
+    const drive = this.documents[`drive/${id}`];
     if (!drive) {
       throw new DriveNotFoundError(id);
     }
     return drive;
   }
   async getDriveBySlug(slug) {
-    const driveId = this.slugToDriveId[slug];
-    if (!driveId) {
-      throw new Error(`Drive with slug ${slug} not found`);
+    for (const driveId of Object.keys(this.driveManifests)) {
+      const drive = this.documents[`drive/${driveId}`];
+      if (drive.initialState.state.global.slug === slug) {
+        return drive;
+      }
     }
-    return this.getDrive(driveId);
+    throw new Error(`Drive with slug ${slug} not found`);
   }
   async createDrive(id, drive) {
-    this.drives[id] = drive;
-    this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
-    const { slug } = drive.initialState.state.global;
+    const slug = drive.initialState.state.global.slug;
     if (slug) {
-      this.slugToDriveId[slug] = id;
+      let existingDrive;
+      try {
+        existingDrive = await this.getDriveBySlug(slug);
+      } catch {
+      }
+      if (existingDrive) {
+        throw new Error(`Drive with slug ${slug} already exists`);
+      }
     }
+    await this.create(`drive/${id}`, drive);
+    this.updateDriveManifest(id, { documentIds: /* @__PURE__ */ new Set() });
   }
   async addDriveOperations(id, operations, header) {
     const drive = await this.getDrive(id);
     const mergedOperations = mergeOperations(drive.operations, operations);
-    this.drives[id] = {
+    this.documents[`drive/${id}`] = {
       ...drive,
       ...header,
       operations: mergedOperations
     };
   }
   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;
         }
@@ -1781,24 +1862,18 @@ var MemoryStorage = class {
       delete this.documents[docId];
     }));
     delete this.driveManifests[id];
-    delete this.drives[id];
-    for (const [slug, driveId] of Object.entries(this.slugToDriveId)) {
-      if (driveId === id) {
-        delete this.slugToDriveId[slug];
-      }
-    }
+    delete this.documents[id];
   }
   async getSynchronizationUnitsRevision(units) {
     const results = await Promise.allSettled(units.map(async (unit) => {
       try {
-        const document = await (unit.documentId ? this.getDocument(unit.driveId, unit.documentId) : this.getDrive(unit.driveId));
+        const document = await this.get(unit.documentId);
         if (!document) {
           return void 0;
         }
         const operation = document.operations[unit.scope].at(-1);
         if (operation) {
           return {
-            driveId: unit.driveId,
             documentId: unit.documentId,
             scope: unit.scope,
             branch: unit.branch,
@@ -1820,7 +1895,7 @@ var MemoryStorage = class {
   ////////////////////////////////
   // Private
   ////////////////////////////////
-  getDriveManifest(driveId) {
+  getManifest(driveId) {
     if (!this.driveManifests[driveId]) {
       this.driveManifests[driveId] = { documentIds: /* @__PURE__ */ new Set() };
     }
@@ -11851,7 +11926,7 @@ var PullResponderTransmitter = class _PullResponderTransmitter {
     const syncUnits = await this.manager.getListenerSyncUnitIds(driveId, listenerId);
     let success = true;
     for (const revision of revisions) {
-      const syncUnit = syncUnits.find((s) => s.scope === revision.scope && s.branch === revision.branch && s.driveId === revision.driveId && s.documentId == revision.documentId);
+      const syncUnit = syncUnits.find((s) => s.scope === revision.scope && s.branch === revision.branch && s.documentId == revision.documentId);
       if (!syncUnit) {
         this.logger.warn("Unknown sync unit was acknowledged", revision);
         success = false;
@@ -12185,17 +12260,6 @@ var BaseDocumentDriveServer = class {
       taskQueueMethod: options?.taskQueueMethod === void 0 ? RunAsap.runAsap : options.taskQueueMethod
     };
     this.defaultDrivesManager = new DefaultDrivesManager(this, this.defaultDrivesManagerDelegate, options);
-    this.storage.setStorageDelegate?.({
-      getCachedOperations: async (drive, id) => {
-        try {
-          const document = await this.cache.getDocument(drive, id);
-          return document?.operations;
-        } catch (error) {
-          logger.error(error);
-          return void 0;
-        }
-      }
-    });
     this.initializePromise = this._initialize();
   }
   // workaround for testing the ephemeral listeners -- we don't have DI in place yet
@@ -12380,7 +12444,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);
@@ -12412,7 +12476,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) => {
@@ -12427,7 +12491,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)) {
@@ -12443,16 +12507,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);
@@ -12462,14 +12526,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;
       }
@@ -12479,7 +12543,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;
   }
@@ -12536,7 +12600,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) {
@@ -12824,7 +12888,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)) {
@@ -12986,7 +13050,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));
@@ -12995,7 +13059,6 @@ var BaseDocumentDriveServer = class {
         this.listenerManager.updateSynchronizationRevisions(driveId, [
           {
             syncId: "0",
-            driveId,
             documentId: "",
             scope: "global",
             branch: "main",
@@ -13306,7 +13369,7 @@ var ListenerManager = class _ListenerManager {
             this.logger.verbose(`Abandoning push for sync unit ${syncUnit.syncId}: already up-to-date (${unitState.listenerRev} >= ${syncUnit.revision})`);
             return;
           } else {
-            this.logger.verbose(`Listener out-of-date for sync unit (${syncUnit.driveId}, ${syncUnit.scope}, ${syncUnit.documentId}): ${unitState?.listenerRev} < ${syncUnit.revision}`);
+            this.logger.verbose(`Listener out-of-date for sync unit (${syncUnit.scope}, ${syncUnit.documentId}): ${unitState?.listenerRev} < ${syncUnit.revision}`);
           }
           const opData = [];
           try {
@@ -13461,11 +13524,11 @@ var ListenerManager = class _ListenerManager {
       if (entry && entry.listenerRev >= syncUnit.revision) {
         return;
       }
-      const { documentId, driveId: driveId2, scope, branch } = syncUnit;
+      const { documentId, scope, branch } = syncUnit;
       try {
         const operations = await this.syncManager.getOperationData(
           // DEAL WITH INVALID SYNC ID ERROR
-          driveId2,
+          driveId,
           syncUnit.syncId,
           {
             since: options?.since,
@@ -13478,7 +13541,7 @@ var ListenerManager = class _ListenerManager {
         }
         operationsCount += operations.length;
         strands.push({
-          driveId: driveId2,
+          driveId,
           documentId,
           scope,
           branch,
@@ -13639,26 +13702,18 @@ var SynchronizationManager = class {
   async getSynchronizationUnitsRevision(driveId, syncUnitsQuery) {
     const drive = await this.getDrive(driveId);
     const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
-    const synchronizationUnits = syncUnitsQuery.map((s) => ({
+    return syncUnitsQuery.map((s) => ({
       ...s,
       lastUpdated: drive.created,
-      revision: -1
+      revision: revisions.find((r) => r.documentId === s.documentId && r.scope === s.scope && r.branch === s.branch)?.revision ?? -1
     }));
-    for (const revision of revisions) {
-      const syncUnit = synchronizationUnits.find((s) => revision.driveId === s.driveId && revision.documentId === s.documentId && revision.scope === s.scope && revision.branch === s.branch);
-      if (syncUnit) {
-        syncUnit.revision = revision.revision;
-        syncUnit.lastUpdated = revision.lastUpdated;
-      }
-    }
-    return synchronizationUnits;
   }
   async getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType2) {
     const drive = await this.getDrive(driveId);
     const nodes = drive.state.global.nodes.filter((node) => isFileNode(node) && (!documentId?.length || documentId.includes(node.id) || documentId.includes("*")) && (!documentType2?.length || documentType2.includes(node.documentType) || documentType2.includes("*")));
     if ((!documentId || documentId.includes("*") || documentId.includes("")) && (!documentType2?.length || documentType2.includes("powerhouse/document-drive") || documentType2.includes("*"))) {
       nodes.unshift({
-        id: "",
+        id: drive.state.global.id,
         documentType: "powerhouse/document-drive",
         synchronizationUnits: [
           {
@@ -13700,7 +13755,6 @@ var SynchronizationManager = class {
       syncId,
       scope: syncUnit.scope,
       branch: syncUnit.branch,
-      driveId,
       documentId: node.id,
       documentType: node.documentType
     };
@@ -13718,7 +13772,6 @@ var SynchronizationManager = class {
       syncId,
       scope,
       branch,
-      driveId,
       documentId,
       documentType: documentType2,
       lastUpdated: lastOperation.timestamp ?? document.lastModified,
@@ -13747,7 +13800,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;
       }
@@ -13763,7 +13816,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;
       }

package/dist/modules/@powerhousedao/reactor-browser/{chunk-6AXML2S3.js → chunk-PQ4UODLR.js}

@@ -8,7 +8,7 @@ import {
   isFolderNode,
   moveNode,
   updateNode
-} from "./chunk-YOX3ZAET.js";
+} from "./chunk-A4GIWVYS.js";
 import {
   generateId
 } from "./chunk-FQF4YAVC.js";

package/dist/modules/@powerhousedao/reactor-browser/{chunk-P46ZMPJ3.js → chunk-UP4DC4D2.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-P6NJ6IAQ.js";
 import {
   ReadDriveNotFoundError
-} from "./chunk-YOX3ZAET.js";
+} from "./chunk-A4GIWVYS.js";
 
 // ../../packages/reactor-browser/dist/src/context/read-mode.js
 import { jsx as _jsx } from "react/jsx-runtime";