@syncvault/sdk 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncvault/sdk",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "SyncVault SDK - Zero-knowledge encrypted sync for Node.js and browsers",
   "type": "module",
   "main": "src/index.js",

package/src/index.d.ts

@@ -35,6 +35,20 @@ export interface QuotaInfo {
   unlimited: boolean;
 }
 
+export interface SharedVault {
+  id: string;
+  name: string;
+  ownerId: string;
+  ownerUsername: string;
+  memberCount: number;
+  isOwner: boolean;
+  createdAt: string;
+}
+
+export interface PutOptions {
+  updatedAt?: number | Date;
+}
+
 export declare class SyncVault {
   constructor(options: SyncVaultOptions);
   
@@ -48,7 +62,7 @@ export declare class SyncVault {
   register(username: string, password: string): Promise<User>;
   
   // Data operations
-  put<T = unknown>(path: string, data: T): Promise<PutResponse>;
+  put<T = unknown>(path: string, data: T, options?: PutOptions): Promise<PutResponse>;
   get<T = unknown>(path: string): Promise<T>;
   list(): Promise<FileInfo[]>;
   delete(path: string): Promise<DeleteResponse>;
@@ -64,6 +78,13 @@ export declare class SyncVault {
   // Quota info
   getQuota(): Promise<QuotaInfo>;
   
+  // Shared vaults
+  getSharedVaults(): Promise<SharedVault[]>;
+  listShared(vaultId: string): Promise<FileInfo[]>;
+  putShared<T = unknown>(vaultId: string, path: string, data: T, sharedPassword?: string): Promise<PutResponse>;
+  getShared<T = unknown>(vaultId: string, path: string, sharedPassword?: string): Promise<T>;
+  deleteShared(vaultId: string, path: string): Promise<DeleteResponse>;
+  
   // State
   isAuthenticated(): boolean;
   logout(): void;
@@ -79,6 +100,7 @@ export interface PendingOperation {
   type: 'put' | 'delete';
   path: string;
   data?: string;
+  updatedAt?: number;
   createdAt: number;
   retries: number;
 }

package/src/index.js

@@ -107,15 +107,24 @@ export class SyncVault {
 
   /**
    * Store encrypted data
+   * @param {string} path - File path
+   * @param {any} data - Data to encrypt and store
+   * @param {Object} options - Optional settings
+   * @param {number} options.updatedAt - Timestamp for LWW conflict resolution
    */
-  async put(path, data) {
+  async put(path, data, options = {}) {
     this._checkAuth();
 
     const encrypted = await encrypt(data, this.password);
+    const body = { path, data: encrypted };
+    
+    if (options.updatedAt) {
+      body.updatedAt = new Date(options.updatedAt).toISOString();
+    }
 
     const response = await this._request('/api/sync/put', {
       method: 'POST',
-      body: JSON.stringify({ path, data: encrypted })
+      body: JSON.stringify(body)
     });
 
     return response;
@@ -215,6 +224,63 @@ export class SyncVault {
     return this._request('/api/sync/quota');
   }
 
+  // --- Shared Vaults ---
+
+  /**
+   * Get all shared vaults the user has access to in this app
+   */
+  async getSharedVaults() {
+    this._checkAuth();
+
+    return this._request('/api/sync/shared/vaults');
+  }
+
+  /**
+   * List files in a shared vault
+   */
+  async listShared(vaultId) {
+    this._checkAuth();
+
+    const response = await this._request(`/api/sync/shared/${vaultId}/list`);
+    return response.files;
+  }
+
+  /**
+   * Store encrypted data in a shared vault
+   */
+  async putShared(vaultId, path, data, sharedPassword) {
+    this._checkAuth();
+
+    const encrypted = await encrypt(data, sharedPassword || this.password);
+
+    return this._request(`/api/sync/shared/${vaultId}/put`, {
+      method: 'POST',
+      body: JSON.stringify({ path, data: encrypted })
+    });
+  }
+
+  /**
+   * Retrieve and decrypt data from a shared vault
+   */
+  async getShared(vaultId, path, sharedPassword) {
+    this._checkAuth();
+
+    const response = await this._request(`/api/sync/shared/${vaultId}/get?path=${encodeURIComponent(path)}`);
+    return decrypt(response.data, sharedPassword || this.password);
+  }
+
+  /**
+   * Delete a file from a shared vault
+   */
+  async deleteShared(vaultId, path) {
+    this._checkAuth();
+
+    return this._request(`/api/sync/shared/${vaultId}/delete`, {
+      method: 'POST',
+      body: JSON.stringify({ path })
+    });
+  }
+
   /**
    * Check if user is authenticated
    */

package/src/offline.js

@@ -219,15 +219,16 @@ export class OfflineSyncVault {
   }
   
   /**
-   * Put with offline support
+   * Put with offline support (LWW enabled)
    */
   async put(path, data) {
     await this.init();
     
+    const timestamp = Date.now();
     const encrypted = await encrypt(data, this.client.password);
     
     try {
-      const result = await this.client.put(path, data);
+      const result = await this.client.put(path, data, { updatedAt: timestamp });
       await this.store.setCache(path, encrypted);
       return result;
     } catch (error) {
@@ -236,7 +237,8 @@ export class OfflineSyncVault {
         await this.store.queueOperation({
           type: 'put',
           path,
-          data: encrypted
+          data: encrypted,
+          updatedAt: timestamp
         });
         return { queued: true, path };
       }
@@ -391,10 +393,31 @@ export class OfflineSyncVault {
   }
   
   async _syncPut(op) {
-    await this.client._request('/api/sync/put', {
-      method: 'POST',
-      body: JSON.stringify({ path: op.path, data: op.data })
-    });
+    const body = { path: op.path, data: op.data };
+    if (op.updatedAt) {
+      body.updatedAt = new Date(op.updatedAt).toISOString();
+    }
+    
+    try {
+      await this.client._request('/api/sync/put', {
+        method: 'POST',
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      // LWW conflict - server has newer data, discard local change
+      if (error.statusCode === 409 && error.data?.code === 'CONFLICT_STALE') {
+        // Fetch fresh data from server to update cache
+        try {
+          const result = await this.client.get(op.path);
+          const encrypted = await encrypt(result, this.client.password);
+          await this.store.setCache(op.path, encrypted);
+        } catch (cacheErr) {
+          console.warn('Failed to update cache after LWW conflict:', cacheErr.message);
+        }
+        return; // Consider this "synced" - we accepted server's version
+      }
+      throw error;
+    }
   }
   
   async _syncDelete(op) {