mrmd-server 0.2.3 → 0.2.5

package/src/cloud-seed.js

@@ -0,0 +1,377 @@
+/**
+ * Cloud Seeding — materialize relay documents to the local filesystem
+ *
+ * When the editor container starts in cloud mode, this module fetches
+ * all the user's documents from the sync relay and writes them as .md
+ * files so they appear in the nav tree. It also writes Yjs binary
+ * snapshots so that local mrmd-sync loads the relay's exact Yjs state
+ * (avoiding Yjs content duplication when the bridge connects).
+ *
+ * Usage:
+ *   import { seedFromRelay } from './cloud-seed.js';
+ *   await seedFromRelay({
+ *     relayUrl: 'http://localhost:3006',
+ *     userId: '31bdffb9-...',
+ *     homeDir: '/home/ubuntu',
+ *   });
+ */
+
+import { mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { createHash } from 'crypto';
+import { tmpdir } from 'os';
+
+/**
+ * Seed the local filesystem with documents from the sync relay.
+ *
+ * @param {object} opts
+ * @param {string} opts.relayUrl - HTTP URL of the sync relay (e.g. 'http://localhost:3006')
+ * @param {string} opts.userId - User UUID
+ * @param {string} opts.homeDir - User's home directory (where projects are created)
+ * @returns {Promise<{seededProjects: string[], seededDocs: number, errors: string[]}>}
+ */
+export async function seedFromRelay(opts) {
+  const { relayUrl, userId, homeDir } = opts;
+  const errors = [];
+  const seededProjects = [];
+  let seededDocs = 0;
+
+  console.log(`[cloud-seed] Seeding from relay ${relayUrl} for user ${userId}`);
+
+  // 1. Fetch all projects and their documents from the relay
+  let projectData;
+  try {
+    const listUrl = `${relayUrl}/api/documents/${encodeURIComponent(userId)}`;
+    const res = await fetch(listUrl, {
+      headers: { 'X-User-Id': userId },
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!res.ok) {
+      const msg = `Failed to list documents: HTTP ${res.status}`;
+      console.error(`[cloud-seed] ${msg}`);
+      return { seededProjects: [], seededDocs: 0, errors: [msg] };
+    }
+
+    projectData = await res.json();
+  } catch (err) {
+    const msg = `Failed to fetch document list: ${err.message}`;
+    console.error(`[cloud-seed] ${msg}`);
+    return { seededProjects: [], seededDocs: 0, errors: [msg] };
+  }
+
+  if (!projectData?.projects) {
+    console.log('[cloud-seed] No projects found in relay');
+    return { seededProjects: [], seededDocs: 0, errors: [] };
+  }
+
+  // 2. For each project, fetch documents with content + Yjs state
+  for (const [projectName, projectInfo] of Object.entries(projectData.projects)) {
+    // Skip empty projects
+    if (!projectInfo.docCount || projectInfo.docCount === 0) continue;
+
+    // Skip 'desktop-e2e' test projects
+    if (projectName === 'desktop-e2e') continue;
+
+    console.log(`[cloud-seed] Seeding project "${projectName}" (${projectInfo.docCount} docs)`);
+
+    // Determine project directory
+    const projectDir = join(homeDir, projectName);
+
+    try {
+      // Fetch documents with content and Yjs state for this project
+      const docsUrl = `${relayUrl}/api/documents/${encodeURIComponent(userId)}/${encodeURIComponent(projectName)}?content=1&yjs=1`;
+      const docsRes = await fetch(docsUrl, {
+        headers: { 'X-User-Id': userId },
+        signal: AbortSignal.timeout(30000),
+      });
+
+      if (!docsRes.ok) {
+        errors.push(`Failed to fetch docs for ${projectName}: HTTP ${docsRes.status}`);
+        continue;
+      }
+
+      const docsData = await docsRes.json();
+      if (!docsData?.documents?.length) continue;
+
+      // Ensure project directory exists
+      mkdirSync(projectDir, { recursive: true });
+
+      // Create mrmd.md config if it doesn't exist
+      const mrmdPath = join(projectDir, 'mrmd.md');
+      if (!existsSync(mrmdPath)) {
+        const mrmdContent = `# ${projectName}\n\n\`\`\`yaml config\nname: "${projectName}"\nsession:\n  python:\n    venv: ".venv"\n\`\`\`\n`;
+        writeFileSync(mrmdPath, mrmdContent, 'utf8');
+        console.log(`[cloud-seed]   Created ${mrmdPath}`);
+      }
+
+      // Compute dirHash for Yjs snapshot directory
+      const dirHash = createHash('sha256').update(projectDir).digest('hex').slice(0, 12);
+      const snapshotDir = join(tmpdir(), `mrmd-sync-${dirHash}`);
+      mkdirSync(snapshotDir, { recursive: true });
+
+      // Write each document
+      for (const doc of docsData.documents) {
+        try {
+          const filePath = join(projectDir, `${doc.docPath}.md`);
+          const fileDir = dirname(filePath);
+          mkdirSync(fileDir, { recursive: true });
+
+          // Write .md file (only if content changed or file doesn't exist)
+          const existingContent = existsSync(filePath)
+            ? readFileSync(filePath, 'utf8')
+            : null;
+
+          if (existingContent !== doc.content) {
+            writeFileSync(filePath, doc.content || '', 'utf8');
+          }
+
+          // Write Yjs snapshot (critical: prevents content duplication)
+          if (doc.yjsState) {
+            const safeSnapshotName = doc.docPath.replace(/\//g, '__').replace(/^_+/, '');
+            const snapshotPath = join(snapshotDir, `${safeSnapshotName}.yjs`);
+            writeFileSync(snapshotPath, doc.yjsState, 'utf8'); // Already base64
+          }
+
+          seededDocs++;
+        } catch (err) {
+          errors.push(`Failed to write ${doc.docPath}: ${err.message}`);
+        }
+      }
+
+      seededProjects.push(projectName);
+      console.log(`[cloud-seed]   Seeded ${docsData.documents.length} docs to ${projectDir}`);
+    } catch (err) {
+      errors.push(`Failed to seed project ${projectName}: ${err.message}`);
+    }
+  }
+
+  console.log(`[cloud-seed] Done: ${seededProjects.length} projects, ${seededDocs} docs, ${errors.length} errors`);
+  if (errors.length > 0) {
+    console.warn('[cloud-seed] Errors:', errors);
+  }
+
+  return { seededProjects, seededDocs, errors };
+}
+
+/**
+ * Periodically poll the relay for new projects/documents and seed them.
+ * Returns a stop function to cancel the watcher.
+ *
+ * @param {object} opts
+ * @param {string} opts.relayUrl - HTTP URL of the sync relay
+ * @param {string} opts.userId - User UUID
+ * @param {string} opts.homeDir - User's home directory
+ * @param {number} [opts.intervalMs=30000] - Poll interval
+ * @param {function} [opts.onNewDocs] - Callback({project, docs[]}) when new docs are seeded
+ * @returns {{ stop: () => void }}
+ */
+export function startProjectWatcher(opts) {
+  const { relayUrl, userId, homeDir, intervalMs = 30000, onNewDocs } = opts;
+
+  /** Set of "project/docPath" strings we've already seeded */
+  const seededSet = new Set();
+
+  // Pre-populate with what's already on disk
+  _scanExistingDocs(homeDir, seededSet);
+
+  let timer = null;
+  let running = false;
+
+  async function poll() {
+    if (running) return;
+    running = true;
+    try {
+      const listUrl = `${relayUrl}/api/documents/${encodeURIComponent(userId)}`;
+      const res = await fetch(listUrl, {
+        headers: { 'X-User-Id': userId },
+        signal: AbortSignal.timeout(10000),
+      });
+      if (!res.ok) return;
+      const projectData = await res.json();
+      if (!projectData?.projects) return;
+
+      for (const [projectName, projectInfo] of Object.entries(projectData.projects)) {
+        if (!projectInfo.docCount || projectName === 'desktop-e2e') continue;
+
+        // Check if any docs in this project are new
+        const knownCount = _countProjectDocs(projectName, seededSet);
+        if (knownCount >= projectInfo.docCount) continue;
+
+        // Fetch and seed new docs
+        console.log(`[cloud-seed:watcher] New docs detected in "${projectName}" (known: ${knownCount}, relay: ${projectInfo.docCount})`);
+        const docsUrl = `${relayUrl}/api/documents/${encodeURIComponent(userId)}/${encodeURIComponent(projectName)}?content=1&yjs=1`;
+        const docsRes = await fetch(docsUrl, {
+          headers: { 'X-User-Id': userId },
+          signal: AbortSignal.timeout(30000),
+        });
+        if (!docsRes.ok) continue;
+        const docsData = await docsRes.json();
+        if (!docsData?.documents?.length) continue;
+
+        const projectDir = join(homeDir, projectName);
+        mkdirSync(projectDir, { recursive: true });
+
+        // Create mrmd.md config if missing
+        const mrmdPath = join(projectDir, 'mrmd.md');
+        if (!existsSync(mrmdPath)) {
+          const mrmdContent = `# ${projectName}\n\n\`\`\`yaml config\nname: "${projectName}"\nsession:\n  python:\n    venv: ".venv"\n\`\`\`\n`;
+          writeFileSync(mrmdPath, mrmdContent, 'utf8');
+        }
+
+        const dirHash = createHash('sha256').update(projectDir).digest('hex').slice(0, 12);
+        const snapshotDir = join(tmpdir(), `mrmd-sync-${dirHash}`);
+        mkdirSync(snapshotDir, { recursive: true });
+
+        const newDocs = [];
+        for (const doc of docsData.documents) {
+          const key = `${projectName}/${doc.docPath}`;
+          if (seededSet.has(key)) continue;
+
+          try {
+            const filePath = join(projectDir, `${doc.docPath}.md`);
+            mkdirSync(dirname(filePath), { recursive: true });
+
+            const existingContent = existsSync(filePath)
+              ? readFileSync(filePath, 'utf8')
+              : null;
+            if (existingContent !== doc.content) {
+              writeFileSync(filePath, doc.content || '', 'utf8');
+            }
+
+            if (doc.yjsState) {
+              const safeSnapshotName = doc.docPath.replace(/\//g, '__').replace(/^_+/, '');
+              const snapshotPath = join(snapshotDir, `${safeSnapshotName}.yjs`);
+              writeFileSync(snapshotPath, doc.yjsState, 'utf8');
+            }
+
+            seededSet.add(key);
+            newDocs.push(doc.docPath);
+          } catch { /* ignore individual doc errors */ }
+        }
+
+        if (newDocs.length > 0) {
+          console.log(`[cloud-seed:watcher] Seeded ${newDocs.length} new docs for "${projectName}"`);
+          if (onNewDocs) {
+            try { onNewDocs({ project: projectName, projectDir, docs: newDocs }); } catch { /* ignore */ }
+          }
+        }
+      }
+    } catch (err) {
+      // Silent — don't spam logs on transient relay issues
+    } finally {
+      running = false;
+    }
+  }
+
+  /**
+   * Poll the catalog API to create stub files for docs that exist on machines
+   * but haven't been bridged yet (so they won't be in the documents table).
+   * This ensures the file browser shows all docs from all connected machines.
+   */
+  async function pollCatalog() {
+    try {
+      const catalogUrl = `${relayUrl}/api/catalog/${encodeURIComponent(userId)}`;
+      const res = await fetch(catalogUrl, {
+        headers: { 'X-User-Id': userId },
+        signal: AbortSignal.timeout(10000),
+      });
+      if (!res.ok) return;
+      const data = await res.json();
+      if (!data?.machines) return;
+
+      for (const machine of data.machines) {
+        for (const proj of machine.projects || []) {
+          const projectName = proj.name;
+          if (projectName === 'desktop-e2e') continue;
+
+          for (const doc of proj.documents || []) {
+            const key = `${projectName}/${doc.docPath}`;
+            if (seededSet.has(key)) continue;
+
+            // Create stub file so it appears in the nav tree
+            const projectDir = join(homeDir, projectName);
+            const filePath = join(projectDir, `${doc.docPath}.md`);
+
+            if (existsSync(filePath)) {
+              seededSet.add(key);
+              continue;
+            }
+
+            try {
+              mkdirSync(dirname(filePath), { recursive: true });
+
+              // Create mrmd.md config if missing
+              const mrmdPath = join(projectDir, 'mrmd.md');
+              if (!existsSync(mrmdPath)) {
+                const mrmdContent = `# ${projectName}\n\n\`\`\`yaml config\nname: "${projectName}"\nsession:\n  python:\n    venv: ".venv"\n\`\`\`\n`;
+                writeFileSync(mrmdPath, mrmdContent, 'utf8');
+              }
+
+              // Write empty stub — real content loads on-demand when user opens it
+              writeFileSync(filePath, '', 'utf8');
+              seededSet.add(key);
+              console.log(`[cloud-seed:catalog] Stub: ${projectName}/${doc.docPath}`);
+            } catch { /* ignore */ }
+          }
+        }
+      }
+    } catch {
+      // Silent
+    }
+  }
+
+  timer = setInterval(poll, intervalMs);
+  // Run first poll after a short delay (let initial seed + bridges settle)
+  setTimeout(poll, 5000);
+  // Also poll catalog periodically for stub creation
+  setInterval(pollCatalog, intervalMs * 2);
+  setTimeout(pollCatalog, 8000);
+
+  return {
+    stop() {
+      if (timer) { clearInterval(timer); timer = null; }
+    },
+  };
+}
+
+/** Scan existing .md files on disk and populate the seeded set */
+function _scanExistingDocs(homeDir, seededSet) {
+  try {
+    const entries = readdirSync(homeDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+      const projectName = entry.name;
+      const projectDir = join(homeDir, projectName);
+      _walkMd(projectDir, projectDir, projectName, seededSet);
+    }
+  } catch { /* ignore */ }
+}
+
+function _walkMd(dir, projectDir, projectName, seededSet) {
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules' ||
+          entry.name === '.venv' || entry.name === '__pycache__' ||
+          entry.name === '_assets') continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        _walkMd(full, projectDir, projectName, seededSet);
+      } else if (entry.name.endsWith('.md') && entry.name !== 'mrmd.md') {
+        const rel = full.slice(projectDir.length + 1).replace(/\.md$/, '');
+        seededSet.add(`${projectName}/${rel}`);
+      }
+    }
+  } catch { /* ignore */ }
+}
+
+function _countProjectDocs(projectName, seededSet) {
+  let count = 0;
+  for (const key of seededSet) {
+    if (key.startsWith(projectName + '/')) count++;
+  }
+  return count;
+}
+
+export default { seedFromRelay, startProjectWatcher };

package/src/relay-bridge.js

@@ -0,0 +1,301 @@
+/**
+ * Relay Bridge — bidirectional sync between local mrmd-sync and the cloud relay
+ *
+ * Runs inside the editor container. For each document, creates a DocBridge
+ * that forwards Yjs WebSocket messages between the local mrmd-sync server
+ * and the cloud relay. This keeps:
+ *   - Local filesystem in sync with relay (via local mrmd-sync's file writer)
+ *   - Relay in sync with local edits (via bridge forwarding)
+ *   - Other devices (Electron, phone) see changes in real-time
+ *
+ * Uses X-User-Id header for auth (trusted internal network, host networking).
+ *
+ * Usage:
+ *   import { RelayBridge } from './relay-bridge.js';
+ *   const bridge = new RelayBridge({
+ *     relayWsUrl: 'ws://localhost:3006',
+ *     userId: '31bdffb9-...',
+ *   });
+ *   bridge.bridgeProject(localSyncPort, projectDir, projectName, docNames);
+ *   bridge.stopAll();
+ */
+
+import { WebSocket } from 'ws';
+
+function encodePathSegments(value) {
+  return String(value).split('/').map(encodeURIComponent).join('/');
+}
+
+/**
+ * Bridges a single document between local mrmd-sync and cloud relay.
+ * Just forwards raw WS messages — no Yjs dependency needed.
+ */
+class DocBridge {
+  constructor(opts) {
+    this.localUrl = opts.localUrl;
+    this.remoteUrl = opts.remoteUrl;
+    this.remoteHeaders = opts.remoteHeaders || {};
+    this.docName = opts.docName;
+
+    this.localWs = null;
+    this.remoteWs = null;
+    this._destroyed = false;
+    this._reconnectLocal = null;
+    this._reconnectRemote = null;
+    this._localReady = false;
+    this._remoteReady = false;
+    this._lastError = null;
+    this._startedAt = Date.now();
+    // Buffer messages when the other side isn't ready yet.
+    // Critical: without this, sync step 1/2 messages are dropped during
+    // the race between local and remote WS connections opening, causing
+    // the Yjs sync to never complete for many documents.
+    this._localBuffer = [];   // messages from remote waiting for local
+    this._remoteBuffer = [];  // messages from local waiting for remote
+  }
+
+  start() {
+    this._connectLocal();
+    this._connectRemote();
+  }
+
+  _connectLocal() {
+    if (this._destroyed) return;
+    try {
+      this.localWs = new WebSocket(this.localUrl);
+    } catch {
+      this._scheduleReconnect('local');
+      return;
+    }
+
+    this.localWs.binaryType = 'arraybuffer';
+
+    this.localWs.on('open', () => {
+      this._localReady = true;
+      // Flush buffered messages from remote that arrived before local was ready
+      for (const msg of this._localBuffer) {
+        try { this.localWs.send(msg.data, { binary: msg.isBinary }); } catch { /* ignore */ }
+      }
+      this._localBuffer = [];
+    });
+
+    this.localWs.on('message', (data, isBinary) => {
+      if (this._remoteReady && this.remoteWs?.readyState === WebSocket.OPEN) {
+        try { this.remoteWs.send(data, { binary: isBinary }); } catch { /* ignore */ }
+      } else {
+        this._remoteBuffer.push({ data, isBinary });
+      }
+    });
+
+    this.localWs.on('close', () => {
+      this._localReady = false;
+      this._localBuffer = [];
+      if (!this._destroyed) this._scheduleReconnect('local');
+    });
+
+    this.localWs.on('error', (err) => {
+      this._lastError = `local:${err?.code || err?.message || 'error'}`;
+    });
+  }
+
+  _connectRemote() {
+    if (this._destroyed) return;
+    try {
+      this.remoteWs = new WebSocket(this.remoteUrl, { headers: this.remoteHeaders });
+    } catch {
+      this._scheduleReconnect('remote');
+      return;
+    }
+
+    this.remoteWs.binaryType = 'arraybuffer';
+
+    this.remoteWs.on('open', () => {
+      this._remoteReady = true;
+      // Flush buffered messages from local that arrived before remote was ready
+      for (const msg of this._remoteBuffer) {
+        try { this.remoteWs.send(msg.data, { binary: msg.isBinary }); } catch { /* ignore */ }
+      }
+      this._remoteBuffer = [];
+    });
+
+    this.remoteWs.on('message', (data, isBinary) => {
+      if (this._localReady && this.localWs?.readyState === WebSocket.OPEN) {
+        try { this.localWs.send(data, { binary: isBinary }); } catch { /* ignore */ }
+      } else {
+        this._localBuffer.push({ data, isBinary });
+      }
+    });
+
+    this.remoteWs.on('close', () => {
+      this._remoteReady = false;
+      this._remoteBuffer = [];
+      if (!this._destroyed) this._scheduleReconnect('remote');
+    });
+
+    this.remoteWs.on('error', (err) => {
+      this._lastError = `remote:${err?.code || err?.message || 'error'}`;
+    });
+  }
+
+  _scheduleReconnect(which) {
+    if (this._destroyed) return;
+    const key = which === 'local' ? '_reconnectLocal' : '_reconnectRemote';
+    if (this[key]) return;
+    this[key] = setTimeout(() => {
+      this[key] = null;
+      if (which === 'local') this._connectLocal();
+      else this._connectRemote();
+    }, 3000);
+  }
+
+  getStatus() {
+    return {
+      docName: this.docName,
+      localReady: this._localReady,
+      remoteReady: this._remoteReady,
+      connected: this._localReady && this._remoteReady,
+      lastError: this._lastError,
+    };
+  }
+
+  async stop() {
+    this._destroyed = true;
+    clearTimeout(this._reconnectLocal);
+    clearTimeout(this._reconnectRemote);
+    try { this.localWs?.close(); } catch { /* ignore */ }
+    try { this.remoteWs?.close(); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Manages document bridges between local mrmd-sync and the cloud relay.
+ */
+export class RelayBridge {
+  /**
+   * @param {object} opts
+   * @param {string} opts.relayWsUrl - WebSocket URL of relay (e.g. 'ws://localhost:3006')
+   * @param {string} opts.userId - User UUID for auth + doc routing
+   */
+  constructor(opts) {
+    this.relayWsUrl = opts.relayWsUrl;
+    this.userId = opts.userId;
+
+    /** @type {Map<string, { bridges: Map<string, DocBridge>, port: number, projectName: string }>} */
+    this._projects = new Map();
+  }
+
+  /**
+   * Bridge a local project's sync server to the cloud relay.
+   *
+   * @param {number} localSyncPort - Local mrmd-sync port
+   * @param {string} projectDir - Local project directory
+   * @param {string} projectName - Project name/slug
+   * @param {string[]} docNames - Document names to bridge
+   */
+  bridgeProject(localSyncPort, projectDir, projectName, docNames = []) {
+    if (this._projects.has(projectDir)) {
+      // Already bridged — add any new docs
+      const existing = this._projects.get(projectDir);
+      for (const docName of docNames) {
+        if (!existing.bridges.has(docName)) {
+          this._bridgeDoc(projectDir, localSyncPort, projectName, docName);
+        }
+      }
+      return;
+    }
+
+    console.log(`[relay-bridge] Bridging "${projectName}" (port ${localSyncPort}, ${docNames.length} docs)`);
+
+    const bridges = new Map();
+    this._projects.set(projectDir, { bridges, port: localSyncPort, projectName });
+
+    for (const docName of docNames) {
+      this._bridgeDoc(projectDir, localSyncPort, projectName, docName);
+    }
+  }
+
+  /**
+   * Add a single document to an existing project bridge.
+   */
+  bridgeDoc(projectDir, docName) {
+    const project = this._projects.get(projectDir);
+    if (!project || project.bridges.has(docName)) return;
+    this._bridgeDoc(projectDir, project.port, project.projectName, docName);
+  }
+
+  _bridgeDoc(projectDir, localSyncPort, projectName, docName) {
+    const project = this._projects.get(projectDir);
+    if (!project) return;
+
+    const encodedDoc = encodePathSegments(docName);
+    const encodedProject = encodePathSegments(projectName);
+    const encodedUserId = encodeURIComponent(this.userId);
+
+    const localUrl = `ws://127.0.0.1:${localSyncPort}/${encodedDoc}`;
+    const remoteUrl = `${this.relayWsUrl}/sync/${encodedUserId}/${encodedProject}/${encodedDoc}`;
+
+    const bridge = new DocBridge({
+      localUrl,
+      remoteUrl,
+      remoteHeaders: { 'X-User-Id': this.userId },
+      docName,
+    });
+
+    bridge.start();
+    project.bridges.set(docName, bridge);
+  }
+
+  /**
+   * Stop syncing a specific project.
+   */
+  async stopProject(projectDir) {
+    const project = this._projects.get(projectDir);
+    if (!project) return;
+
+    for (const bridge of project.bridges.values()) {
+      await bridge.stop();
+    }
+    project.bridges.clear();
+    this._projects.delete(projectDir);
+    console.log(`[relay-bridge] Stopped project: ${projectDir}`);
+  }
+
+  /**
+   * Stop all project bridges.
+   */
+  async stopAll() {
+    for (const projectDir of [...this._projects.keys()]) {
+      await this.stopProject(projectDir);
+    }
+    console.log('[relay-bridge] All bridges stopped');
+  }
+
+  /**
+   * Get sync status.
+   */
+  getStatus() {
+    const projects = [];
+    let connectedDocs = 0;
+    let totalDocs = 0;
+
+    for (const [dir, info] of this._projects) {
+      const docs = [];
+      for (const [name, bridge] of info.bridges) {
+        const status = bridge.getStatus();
+        docs.push(status);
+        totalDocs++;
+        if (status.connected) connectedDocs++;
+      }
+      projects.push({
+        dir,
+        projectName: info.projectName,
+        port: info.port,
+        documents: docs,
+      });
+    }
+
+    return { projects, connectedDocs, totalDocs };
+  }
+}
+
+export default RelayBridge;