@doubling/compound-sync 1.12.4 → 1.12.5

package/folder-chain.d.ts

@@ -0,0 +1,44 @@
+export interface FolderDoc {
+    id: string;
+    type: 'folder' | string;
+    name: string;
+    parentId?: string | null;
+    path?: string;
+    scope: string;
+    teamId?: string | null;
+    ownerId?: string | null;
+}
+export interface ScopeKey {
+    scope: string;
+    teamId?: string | null | undefined;
+    ownerId?: string | null | undefined;
+}
+export interface FolderChainCreate {
+    tempId: string;
+    doc: {
+        type: 'folder';
+        name: string;
+        parentId: string | null;
+        path: string;
+        scope: string;
+        teamId: string | null;
+        ownerId: string | null;
+        sharedWith: string[];
+    };
+}
+export interface FolderChainBackfill {
+    id: string;
+    path: string;
+}
+export interface FolderChainPlan {
+    creates: FolderChainCreate[];
+    backfills: FolderChainBackfill[];
+    leafId: string | null;
+}
+export interface PlanFolderChainInput extends ScopeKey {
+    existingFolders: FolderDoc[] | null | undefined;
+    segments: string[] | null | undefined;
+}
+export declare function splitPath(p: string | null | undefined): string[];
+export declare function planFolderChain({ existingFolders, segments, scope, teamId, ownerId, }: PlanFolderChainInput): FolderChainPlan;
+//# sourceMappingURL=folder-chain.d.ts.map

package/folder-chain.js

@@ -12,23 +12,24 @@
 //     planner with `segments` set to the dir's path and apply.
 //
 // Pure: no I/O. Tests exercise it with synthetic inputs.
-
 export function splitPath(p) {
-  if (!p) return [];
-  return p.split('/').filter(Boolean);
+    if (!p)
+        return [];
+    return p.split('/').filter(Boolean);
 }
-
 function matchesScope(folder, { scope, teamId, ownerId }) {
-  if (folder.scope !== scope) return false;
-  const folderTeam = folder.teamId == null ? null : folder.teamId;
-  const wantTeam = teamId == null ? null : teamId;
-  if (folderTeam !== wantTeam) return false;
-  const folderOwner = folder.ownerId == null ? null : folder.ownerId;
-  const wantOwner = ownerId == null ? null : ownerId;
-  if (folderOwner !== wantOwner) return false;
-  return true;
+    if (folder.scope !== scope)
+        return false;
+    const folderTeam = folder.teamId == null ? null : folder.teamId;
+    const wantTeam = teamId == null ? null : teamId;
+    if (folderTeam !== wantTeam)
+        return false;
+    const folderOwner = folder.ownerId == null ? null : folder.ownerId;
+    const wantOwner = ownerId == null ? null : ownerId;
+    if (folderOwner !== wantOwner)
+        return false;
+    return true;
 }
-
 // Plan the folder chain. Inputs:
 //   - existingFolders: array of folder docs from the org's files
 //     collection. Each has { id, type:'folder', name, parentId, path?,
@@ -47,51 +48,43 @@ function matchesScope(folder, { scope, teamId, ownerId }) {
 //   - leafId: id of the leaf folder (the deepest segment), either a
 //     real id (if it existed) or a tempId (if planned for creation).
 //     null if `segments` is empty.
-export function planFolderChain({ existingFolders, segments, scope, teamId, ownerId }) {
-  const creates = [];
-  const backfills = [];
-
-  if (!segments || segments.length === 0) {
-    return { creates, backfills, leafId: null };
-  }
-
-  let parentId = null;
-  let pathSoFar = '';
-
-  for (const name of segments) {
-    pathSoFar = pathSoFar ? `${pathSoFar}/${name}` : name;
-
-    const existing = (existingFolders || []).find(f =>
-      f && f.type === 'folder'
-      && f.name === name
-      && (f.parentId == null ? null : f.parentId) === parentId
-      && matchesScope(f, { scope, teamId, ownerId })
-    );
-
-    if (existing) {
-      if (existing.path !== pathSoFar) {
-        backfills.push({ id: existing.id, path: pathSoFar });
-      }
-      parentId = existing.id;
-      continue;
+export function planFolderChain({ existingFolders, segments, scope, teamId, ownerId, }) {
+    const creates = [];
+    const backfills = [];
+    if (!segments || segments.length === 0) {
+        return { creates, backfills, leafId: null };
     }
-
-    const tempId = `__plan_folder_${creates.length}`;
-    creates.push({
-      tempId,
-      doc: {
-        type: 'folder',
-        name,
-        parentId,
-        path: pathSoFar,
-        scope,
-        teamId: scope === 'team' ? (teamId == null ? null : teamId) : null,
-        ownerId: scope === 'private' ? (ownerId == null ? null : ownerId) : null,
-        sharedWith: [],
-      },
-    });
-    parentId = tempId;
-  }
-
-  return { creates, backfills, leafId: parentId };
+    let parentId = null;
+    let pathSoFar = '';
+    for (const name of segments) {
+        pathSoFar = pathSoFar ? `${pathSoFar}/${name}` : name;
+        const existing = (existingFolders || []).find((f) => f && f.type === 'folder'
+            && f.name === name
+            && (f.parentId == null ? null : f.parentId) === parentId
+            && matchesScope(f, { scope, teamId, ownerId }));
+        if (existing) {
+            if (existing.path !== pathSoFar) {
+                backfills.push({ id: existing.id, path: pathSoFar });
+            }
+            parentId = existing.id;
+            continue;
+        }
+        const tempId = `__plan_folder_${creates.length}`;
+        creates.push({
+            tempId,
+            doc: {
+                type: 'folder',
+                name,
+                parentId,
+                path: pathSoFar,
+                scope,
+                teamId: scope === 'team' ? (teamId == null ? null : teamId) : null,
+                ownerId: scope === 'private' ? (ownerId == null ? null : ownerId) : null,
+                sharedWith: [],
+            },
+        });
+        parentId = tempId;
+    }
+    return { creates, backfills, leafId: parentId };
 }
+//# sourceMappingURL=folder-chain.js.map

package/manifest.d.ts

@@ -0,0 +1,38 @@
+export interface ManifestEntry {
+    fileId: string;
+    contentHash: string;
+    lastSyncedAt: string;
+}
+export interface ManifestState {
+    version: number;
+    entries: Record<string, ManifestEntry>;
+}
+export interface ManifestStore {
+    upsertEntry(trackingKey: string, entry: ManifestEntry): void;
+    removeEntry(trackingKey: string): void;
+    getEntry(trackingKey: string): ManifestEntry | null;
+    getState(): ManifestState;
+    flush(): void;
+}
+export interface CreateManifestStoreOptions {
+    debounceMs?: number;
+}
+export declare function manifestPath(localPath: string): string;
+export declare function loadManifest(localPath: string): ManifestState;
+/**
+ * Persists the in-memory manifest state to disk.
+ *
+ * PERFORMANCE & SAFETY NOTES:
+ * 1. Atomic Writes: We write to `.compound-sync/manifest.json.tmp` first,
+ *    then use `fs.renameSync` to overwrite the actual manifest. This ensures
+ *    that if the daemon crashes mid-write, we do not corrupt the JSON.
+ * 2. Unsorted Keys: We do not sort the object keys before calling
+ *    `JSON.stringify()`. Sorting requires significant CPU overhead for large
+ *    workspaces. The in-memory object map is the source of truth; disk
+ *    order does not matter.
+ * 3. Synchronous I/O: All disk operations use `*Sync` APIs. A flush blocks
+ *    the Node event loop briefly; see docs/features/sync/sync-manifest-design.md.
+ */
+export declare function saveManifest(localPath: string, manifestState: ManifestState): void;
+export declare function createManifestStore(localPath: string, { debounceMs }?: CreateManifestStoreOptions): ManifestStore;
+//# sourceMappingURL=manifest.d.ts.map

package/manifest.js

@@ -3,50 +3,53 @@
 // Maps `scope:docPath` → Firestore fileId so the daemon can reconcile
 // local disk vs cloud on startup (e.g. web deletes while offline must
 // remove local orphans instead of re-uploading them).
-
 import fs from 'node:fs';
 import path from 'node:path';
-
 const MANIFEST_DIR = '.compound-sync';
 const MANIFEST_FILE = 'manifest.json';
 const FLUSH_DEBOUNCE_MS = 500;
-
 export function manifestPath(localPath) {
-  return path.join(localPath, MANIFEST_DIR, MANIFEST_FILE);
+    return path.join(localPath, MANIFEST_DIR, MANIFEST_FILE);
 }
-
 function normalizeEntry(raw) {
-  if (!raw || typeof raw !== 'object') return null;
-  if (typeof raw.fileId !== 'string' || !raw.fileId) return null;
-  if (typeof raw.contentHash !== 'string' || !raw.contentHash) return null;
-  return {
-    fileId: raw.fileId,
-    contentHash: raw.contentHash,
-    lastSyncedAt: typeof raw.lastSyncedAt === 'string' ? raw.lastSyncedAt : new Date().toISOString(),
-  };
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    if (typeof r['fileId'] !== 'string' || !r['fileId'])
+        return null;
+    if (typeof r['contentHash'] !== 'string' || !r['contentHash'])
+        return null;
+    return {
+        fileId: r['fileId'],
+        contentHash: r['contentHash'],
+        lastSyncedAt: typeof r['lastSyncedAt'] === 'string' ? r['lastSyncedAt'] : new Date().toISOString(),
+    };
 }
-
 export function loadManifest(localPath) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(manifestPath(localPath), 'utf8'));
-    if (parsed && typeof parsed === 'object' && parsed.entries && typeof parsed.entries === 'object') {
-      const entries = {};
-      for (const [key, raw] of Object.entries(parsed.entries)) {
-        const entry = normalizeEntry(raw);
-        if (entry) {
-          entries[key] = entry;
-        } else {
-          console.error(`[sync-manifest] dropped invalid entry for ${key}`);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(manifestPath(localPath), 'utf8'));
+        if (parsed && typeof parsed === 'object') {
+            const p = parsed;
+            if (p.entries && typeof p.entries === 'object') {
+                const entries = {};
+                for (const [key, raw] of Object.entries(p.entries)) {
+                    const entry = normalizeEntry(raw);
+                    if (entry) {
+                        entries[key] = entry;
+                    }
+                    else {
+                        console.error(`[sync-manifest] dropped invalid entry for ${key}`);
+                    }
+                }
+                return { version: typeof p.version === 'number' ? p.version : 1, entries };
+            }
         }
-      }
-      return { version: parsed.version ?? 1, entries };
     }
-  } catch {
-    // Missing or corrupt file reads as empty so first run can't crash sync.
-  }
-  return { version: 1, entries: {} };
+    catch {
+        // Missing or corrupt file reads as empty so first run can't crash sync.
+    }
+    return { version: 1, entries: {} };
 }
-
 /**
  * Persists the in-memory manifest state to disk.
  *
@@ -60,68 +63,63 @@ export function loadManifest(localPath) {
  *    order does not matter.
  * 3. Synchronous I/O: All disk operations use `*Sync` APIs. A flush blocks
  *    the Node event loop briefly; see docs/features/sync/sync-manifest-design.md.
- *
- * @param {string} localPath - Sync folder root
- * @param {Object} manifestState - The current in-memory manifest dictionary
  */
 export function saveManifest(localPath, manifestState) {
-  const finalPath = manifestPath(localPath);
-  const tmpPath = path.join(path.dirname(finalPath), 'manifest.json.tmp');
-  try {
-    fs.mkdirSync(path.dirname(finalPath), { recursive: true });
-    fs.writeFileSync(tmpPath, JSON.stringify(manifestState));
-    fs.renameSync(tmpPath, finalPath);
-  } catch (err) {
-    console.error(
-      `[sync-manifest] failed to persist manifest at ${finalPath}: ${err && err.message}`,
-    );
+    const finalPath = manifestPath(localPath);
+    const tmpPath = path.join(path.dirname(finalPath), 'manifest.json.tmp');
     try {
-      fs.unlinkSync(tmpPath);
-    } catch (cleanupErr) {
-      // A leftover .tmp is ignored on load (only the canonical path is read).
-      // ENOENT means the tmp never landed or rename already consumed it.
-      if (cleanupErr?.code !== 'ENOENT') {
-        console.error(
-          `[sync-manifest] failed to remove temp manifest ${tmpPath}: ${cleanupErr && cleanupErr.message}`,
-        );
-      }
+        fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+        fs.writeFileSync(tmpPath, JSON.stringify(manifestState));
+        fs.renameSync(tmpPath, finalPath);
+    }
+    catch (err) {
+        console.error(`[sync-manifest] failed to persist manifest at ${finalPath}: ${err?.message}`);
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch (cleanupErr) {
+            // A leftover .tmp is ignored on load (only the canonical path is read).
+            // ENOENT means the tmp never landed or rename already consumed it.
+            const code = cleanupErr?.code;
+            if (code !== 'ENOENT') {
+                console.error(`[sync-manifest] failed to remove temp manifest ${tmpPath}: ${cleanupErr?.message}`);
+            }
+        }
     }
-  }
 }
-
 export function createManifestStore(localPath, { debounceMs = FLUSH_DEBOUNCE_MS } = {}) {
-  const state = loadManifest(localPath);
-  let timer = null;
-
-  function scheduleFlush() {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      saveManifest(localPath, state);
-    }, debounceMs);
-  }
-
-  return {
-    upsertEntry(trackingKey, entry) {
-      state.entries[trackingKey] = entry;
-      scheduleFlush();
-    },
-    removeEntry(trackingKey) {
-      delete state.entries[trackingKey];
-      scheduleFlush();
-    },
-    getEntry(trackingKey) {
-      return state.entries[trackingKey] ?? null;
-    },
-    getState() {
-      return state;
-    },
-    flush() {
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      saveManifest(localPath, state);
-    },
-  };
+    const state = loadManifest(localPath);
+    let timer = null;
+    function scheduleFlush() {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            saveManifest(localPath, state);
+        }, debounceMs);
+    }
+    return {
+        upsertEntry(trackingKey, entry) {
+            state.entries[trackingKey] = entry;
+            scheduleFlush();
+        },
+        removeEntry(trackingKey) {
+            delete state.entries[trackingKey];
+            scheduleFlush();
+        },
+        getEntry(trackingKey) {
+            return state.entries[trackingKey] ?? null;
+        },
+        getState() {
+            return state;
+        },
+        flush() {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            saveManifest(localPath, state);
+        },
+    };
 }
+//# sourceMappingURL=manifest.js.map

package/org-sync.d.ts

@@ -0,0 +1,16 @@
+import { type Firestore } from 'firebase/firestore';
+import type { FirebaseStorage } from 'firebase/storage';
+export interface StartOrgSyncInput {
+    db: Firestore;
+    storage: FirebaseStorage;
+    userId: string;
+    orgId: string;
+    localPath: string;
+    maxUploadBytes?: number;
+    statePath?: string;
+}
+export interface OrgSyncHandle {
+    stop(): Promise<void>;
+}
+export declare function startOrgSync({ db, storage, userId, orgId, localPath, maxUploadBytes, statePath, }: StartOrgSyncInput): Promise<OrgSyncHandle>;
+//# sourceMappingURL=org-sync.d.ts.map