@symbo.ls/sdk 3.1.2 → 3.2.3

package/src/utils/TokenManager.js

@@ -147,7 +147,28 @@ export class TokenManager {
     if (!this.tokens.expiresAt) {return true} // No expiry info, assume valid
 
     const now = Date.now()
-    return now < (this.tokens.expiresAt - this.config.refreshBuffer)
+    const isValid = now < (this.tokens.expiresAt - this.config.refreshBuffer)
+
+    if (!isValid) {
+      console.log('[TokenManager] Access token is expired or near expiry:', {
+        now: new Date(now).toISOString(),
+        expiresAt: new Date(this.tokens.expiresAt).toISOString(),
+        refreshBuffer: this.config.refreshBuffer
+      })
+    }
+
+    return isValid
+  }
+
+  /**
+   * Check if access token exists and is not expired (without refresh buffer)
+   */
+  isAccessTokenActuallyValid () {
+    if (!this.tokens.accessToken) {return false}
+    if (!this.tokens.expiresAt) {return true} // No expiry info, assume valid
+
+    const now = Date.now()
+    return now < this.tokens.expiresAt
   }
 
   /**
@@ -303,23 +324,30 @@ export class TokenManager {
    * Save tokens to storage
    */
   saveTokens () {
-    const {storage} = this
-    const keys = this.storageKeys
+    try {
+      const {storage} = this
+      const keys = this.storageKeys
 
-    if (this.tokens.accessToken) {
-      storage.setItem(keys.accessToken, this.tokens.accessToken)
-    }
+      if (this.tokens.accessToken) {
+        storage.setItem(keys.accessToken, this.tokens.accessToken)
+      }
 
-    if (this.tokens.refreshToken) {
-      storage.setItem(keys.refreshToken, this.tokens.refreshToken)
-    }
+      if (this.tokens.refreshToken) {
+        storage.setItem(keys.refreshToken, this.tokens.refreshToken)
+      }
 
-    if (this.tokens.expiresAt) {
-      storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString())
-    }
+      if (this.tokens.expiresAt) {
+        storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString())
+      }
 
-    if (this.tokens.expiresIn) {
-      storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString())
+      if (this.tokens.expiresIn) {
+        storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString())
+      }
+
+    } catch (error) {
+      console.error('[TokenManager] Error saving tokens to storage:', error)
+      // Don't throw here as it would break the token setting flow
+      // but log the error for debugging
     }
   }
 
@@ -327,25 +355,35 @@ export class TokenManager {
    * Load tokens from storage
    */
   loadTokens () {
-    const {storage} = this
-    const keys = this.storageKeys
-
-    const accessToken = storage.getItem(keys.accessToken)
-    const refreshToken = storage.getItem(keys.refreshToken)
-    const expiresAt = storage.getItem(keys.expiresAt)
-    const expiresIn = storage.getItem(keys.expiresIn)
+    try {
+      const {storage} = this
+      const keys = this.storageKeys
+
+      const accessToken = storage.getItem(keys.accessToken)
+      const refreshToken = storage.getItem(keys.refreshToken)
+      const expiresAt = storage.getItem(keys.expiresAt)
+      const expiresIn = storage.getItem(keys.expiresIn)
+
+      if (accessToken) {
+        this.tokens = {
+          accessToken,
+          refreshToken,
+          expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
+          expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
+          tokenType: 'Bearer'
+        }
 
-    if (accessToken) {
+        // Schedule refresh for loaded tokens
+        this.scheduleRefresh()
+      }
+    } catch (error) {
+      console.error('[TokenManager] Error loading tokens from storage:', error)
       this.tokens = {
-        accessToken,
-        refreshToken,
-        expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
-        expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
-        tokenType: 'Bearer'
+        accessToken: null,
+        refreshToken: null,
+        expiresAt: null,
+        expiresIn: null
       }
-
-      // Schedule refresh for loaded tokens
-      this.scheduleRefresh()
     }
   }
 

package/src/utils/jsonDiff.js

@@ -0,0 +1,109 @@
+// Lightweight JSON diff & patch helpers for CollabClient
+// Each op: { action: 'set' | 'del', path: [...string], value?: any }
+
+// helper functions
+function isPlainObject (o) {
+  return o && typeof o === 'object' && !Array.isArray(o)
+}
+
+function deepEqual (a, b) {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b)
+  } catch (err) {
+    console.warn('deepEqual error', err)
+    return false
+  }
+}
+
+import * as Y from 'yjs'
+
+// Retrieve the shared root map. We deliberately avoid creating a nested
+// "root -> root" structure that previously caused an ever-growing tree.
+function getRootMap (ydoc) {
+  // `getMap()` lazily initialises the map if it does not yet exist, so the
+  // returned instance is always defined.
+  return ydoc.getMap('root')
+}
+
+// diff algorithm
+export function diffJson (prev, next, prefix = []) {
+  const ops = []
+  const _prefix = Array.isArray(prefix) ? prefix : []
+
+  // deletions
+  for (const key in prev) {
+    if (
+      Object.hasOwn(prev, key) &&
+      !(key in next)
+    ) {
+      ops.push({ action: 'del', path: [..._prefix, key] })
+    }
+  }
+
+  // additions / updates
+  for (const key in next) {
+    if (Object.hasOwn(next, key)) {
+      const pVal = prev?.[key]
+      const nVal = next[key]
+
+      if (isPlainObject(pVal) && isPlainObject(nVal)) {
+        ops.push(...diffJson(pVal, nVal, [..._prefix, key]))
+      } else if (!deepEqual(pVal, nVal)) {
+        ops.push({ action: 'set', path: [..._prefix, key], value: nVal })
+      }
+    }
+  }
+
+  return ops
+}
+
+// apply ops to Yjs
+export function applyOpsToJson (ops, ydoc) {
+  if (!ydoc || !Array.isArray(ops) || !ops.length) { return }
+
+  // Wrap modifications in a transaction so that we can tag them with the
+  // special "remote" origin. This ensures that our local change listener
+  // (`afterTransaction`) can safely ignore these updates and prevents
+  // feedback loops where we would echo remote changes back to the server.
+  ydoc.transact(() => {
+    const root = getRootMap(ydoc)
+
+    ops.forEach(op => {
+      const { action, path = [], value } = op || {}
+      if (!path.length) { return }
+
+      let target = root
+
+      // Traverse (or lazily create) intermediate maps.
+      for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i]
+        let next = target.get(key)
+
+        if (!(next instanceof Y.Map)) {
+          // If the key is missing or not a Y.Map, replace it with a new map so
+          // we have a consistent structure for nested updates.
+          const fresh = new Y.Map()
+
+          // Preserve any plain object that may have existed previously.
+          if (isPlainObject(next)) {
+            Object.entries(next).forEach(([k, v]) => fresh.set(k, v))
+          }
+
+          target.set(key, fresh)
+          next = fresh
+        }
+
+        target = next
+      }
+
+      const last = path[path.length - 1]
+
+      // Apply the leaf operation.
+      if (action === 'set') {
+        target.set(last, value)
+      } else if (action === 'del') {
+        target.delete(last)
+      }
+    })
+  }, 'remote')
+}

package/src/utils/services.js

@@ -20,95 +20,147 @@ export const SERVICE_METHODS = {
   subscribeToAuthChanges: 'auth',
   getStoredAuthState: 'core',
 
-  // AI service methods
-  prompt: 'ai',
+  // Collab service methods
+  connect: 'collab',
+  disconnect: 'collab',
+  isConnected: 'collab',
+  updateData: 'collab',
+  addItem: 'collab',
+  addMultipleItems: 'collab',
+  updateItem: 'collab',
+  deleteItem: 'collab',
+  undo: 'collab',
+  redo: 'collab',
+  checkpoint: 'collab',
 
-  // Based service methods
-  query: 'based',
-  setProject: 'based',
-  setUser: 'based',
-  setUserForced: 'based',
-  subscribe: 'based',
-  call: 'based',
-  getProject: 'based',
-  getProjectByKey: 'based',
-  createProject: 'based',
-  fetchUser: 'based',
-  fetchProject: 'based',
-  setBucket: 'based',
-  getUser: 'based',
-  getUserByEmail: 'based',
-  setProjectDomains: 'based',
-  checkProjectKeyAvailability: 'based',
-  removeProject: 'based',
-  getAvailableLibraries: 'based',
-  addProjectLibraries: 'based',
-  removeProjectLibraries: 'based',
-  getProjectLibraries: 'based',
-  checkout: 'based',
-  uploadFile: 'based',
-  updateProjectIcon: 'based',
-  updateProject: 'based',
-  updateProjectSettings: 'based',
-  updateProjectComponents: 'based',
-  updateProjectName: 'based',
-  updateProjectPackage: 'based',
-  createDnsRecord: 'based',
-  getDnsRecord: 'based',
-  removeDnsRecord: 'based',
-  createStorageBucket: 'based',
-  getStorageBucket: 'based',
-  removeStorageBucket: 'based',
-  requestPasswordChange: 'based',
-  confirmPasswordChange: 'based',
-  updateUserProfile: 'based',
-  duplicateProject: 'based',
-  listPlans: 'based',
-  subscribeToPlan: 'based',
-  getSubscriptionDetails: 'based',
-  checkSubscriptionStatus: 'based',
-  upgradeSubscription: 'based',
-  downgradeSubscription: 'based',
-  cancelSubscription: 'based',
-  reactivateSubscription: 'based',
-  generateInvoice: 'based',
-  getUsageReport: 'based',
-  inviteAccountOwner: 'based',
-  acceptOwnerInvitation: 'based',
-  removeAccountOwner: 'based',
-  checkResourceLimit: 'based',
-  checkFeatureAccess: 'based',
-  getUserFeatures: 'based',
-  getAvailableFeatures: 'based',
-  listFeatureFlags: 'based',
-  updateFeatureFlag: 'based',
-  removeFeatureFlag: 'based',
-  batchUpdateFeatureFlags: 'based',
-  updatePlanDetails: 'based',
-  updatePlanStatus: 'based',
+  // Realtime collaboration helper methods
+  sendCursor: 'collab',
+  sendPresence: 'collab',
+  toggleLive: 'collab',
 
-  // Symstory service methods
-  set: 'symstory',
-  getData: 'symstory',
-  updateData: 'symstory',
-  getBranches: 'symstory',
-  editBranch: 'symstory',
-  restoreVersion: 'symstory',
-  getItem: 'symstory',
-  addItem: 'symstory',
-  addMultipleItems: 'symstory',
-  updateItem: 'symstory',
-  deleteItem: 'symstory',
-  switchVersion: 'symstory',
-  switchBranch: 'symstory',
-  undo: 'symstory',
-  redo: 'symstory',
-  publish: 'symstory',
-  getChanges: 'symstory',
+  // Core service methods (new - replaces most based/auth functionality)
+  // Auth methods
+  register: 'core',
+  login: 'core',
+  logout: 'core',
+  refreshToken: 'core',
+  googleAuth: 'core',
+  googleAuthCallback: 'core',
+  githubAuth: 'core',
+  requestPasswordReset: 'core',
+  confirmPasswordReset: 'core',
+  confirmRegistration: 'core',
+  requestPasswordChange: 'core',
+  confirmPasswordChange: 'core',
+  getMe: 'core',
 
-  // Socket service methods
-  send: 'socket',
-  subscribeChannel: 'socket',
-  connect: 'socket',
-  reconnect: 'socket'
+  // User methods
+  getUserProfile: 'core',
+  updateUserProfile: 'core',
+  getUserProjects: 'core',
+  getUser: 'core',
+  getUserByEmail: 'core',
+
+  // Project methods
+  createProject: 'core',
+  getProjects: 'core',
+  getProject: 'core',
+  getProjectByKey: 'core',
+  getPublicProject: 'core',
+  listPublicProjects: 'core',
+  listProjects: 'core',
+  updateProject: 'core',
+  updateProjectComponents: 'core',
+  updateProjectSettings: 'core',
+  updateProjectName: 'core',
+  updateProjectPackage: 'core',
+  duplicateProject: 'core',
+  removeProject: 'core',
+  checkProjectKeyAvailability: 'core',
+
+  // Project member methods
+  getProjectMembers: 'core',
+  inviteMember: 'core',
+  acceptInvite: 'core',
+  updateMemberRole: 'core',
+  removeMember: 'core',
+
+  // Project library methods
+  getAvailableLibraries: 'core',
+  getProjectLibraries: 'core',
+  addProjectLibraries: 'core',
+  removeProjectLibraries: 'core',
+
+  // File methods
+  uploadFile: 'core',
+  updateProjectIcon: 'core',
+
+  // Payment methods
+  checkout: 'core',
+  getSubscriptionStatus: 'core',
+
+  // DNS methods
+  createDnsRecord: 'core',
+  getDnsRecord: 'core',
+  removeDnsRecord: 'core',
+  setProjectDomains: 'core',
+
+  // Utility methods
+  getHealthStatus: 'core',
+  getTokenDebugInfo: 'core',
+
+  // Project Data methods (Symstory replacement)
+  applyProjectChanges: 'core',
+  getProjectData: 'core',
+  getProjectVersions: 'core',
+  restoreProjectVersion: 'core',
+  updateProjectItem: 'core',
+  deleteProjectItem: 'core',
+  setProjectValue: 'core',
+  addProjectItems: 'core',
+  getProjectItemByPath: 'core',
+
+  // Pull Request methods
+  createPullRequest: 'core',
+  listPullRequests: 'core',
+  getPullRequest: 'core',
+  reviewPullRequest: 'core',
+  addPullRequestComment: 'core',
+  mergePullRequest: 'core',
+  getPullRequestDiff: 'core',
+  createPullRequestWithValidation: 'core',
+  approvePullRequest: 'core',
+  requestPullRequestChanges: 'core',
+  getOpenPullRequests: 'core',
+  getClosedPullRequests: 'core',
+  getMergedPullRequests: 'core',
+  isPullRequestMergeable: 'core',
+  getPullRequestStatusSummary: 'core',
+
+  // Branch Management methods
+  listBranches: 'core',
+  createBranch: 'core',
+  deleteBranch: 'core',
+  renameBranch: 'core',
+  getBranchChanges: 'core',
+  mergeBranch: 'core',
+  resetBranch: 'core',
+  publishVersion: 'core',
+  createBranchWithValidation: 'core',
+  branchExists: 'core',
+  previewMerge: 'core',
+  commitMerge: 'core',
+  createFeatureBranch: 'core',
+  createHotfixBranch: 'core',
+  getBranchStatus: 'core',
+  deleteBranchSafely: 'core',
+
+  // Admin methods
+  getAdminUsers: 'core',
+  assignProjectsToUser: 'core',
+  searchAdminUsers: 'core',
+  getAdminUsersByEmails: 'core',
+  getAdminUsersByIds: 'core',
+  assignSpecificProjectsToUser: 'core',
+  assignAllProjectsToUser: 'core'
 }

package/src/utils/symstoryClient.js

@@ -1,7 +1,7 @@
 import config from '../config/environment.js'
 
 const DEFAULT_OPTIONS = {
-  baseUrl: config.baseUrl
+  apiUrl: config.apiUrl
 }
 
 class SymstoryClient {
@@ -30,7 +30,7 @@ class SymstoryClient {
    * @returns {Promise<any>} - The response data.
    */
   async request (path = '', options = {}) {
-    const url = `${this.options.baseUrl}/symstory/${this.appKey}${path}`
+    const url = `${this.options.apiUrl}/symstory/${this.appKey}${path}`
     const response = await fetch(url, {
       ...options,
       headers: { ...this.headers, ...options.headers }
@@ -202,7 +202,7 @@ class SymstoryClient {
    * @param {string} [options.branch='main'] - The branch name. (Only if version number is provided)
    * @returns {Promise<any>} - The response data.
    */
-  publishVersion (version, { branch = 'main' } = {}) {
+  publishVersion (version) {
     return this.request('/publish', {
       method: 'POST',
       body: JSON.stringify({ version })
@@ -219,12 +219,12 @@ class SymstoryClient {
    */
   getChanges ({ versionId, versionValue, branch } = {}) {
     return this.request(
-      '/changes?' +
+      `/changes?${
         new URLSearchParams({
           ...(versionId ? { versionId } : {}),
           ...(versionValue ? { versionValue } : {}),
           ...(branch ? { branch } : {})
-        }).toString(),
+        }).toString()}`,
       {}
     )
   }