@symbo.ls/sdk 3.1.1 → 3.2.3

package/src/services/BasedService.js

@@ -1,9 +1,10 @@
 import { BaseService } from './BaseService.js'
-import { buildProjectQuery, buildUserQuery } from '../utils/basedQuerys.js'
+import { buildProjectQuery, buildUserQuery, buildGetProjectsByKeysQuery, buildGetUserDataQuery, buildGetProjectDataQuery, buildGetProjectByKeyDataQuery } from '../utils/basedQuerys.js'
 import Based from '@based/client'
 import { isFunction, isString } from '@domql/utils'
 import environment from '../config/environment.js'
 
+// DEPRECATED
 export class BasedService extends BaseService {
   constructor (config) {
     super(config)
@@ -122,7 +123,7 @@ export class BasedService extends BaseService {
         joinedAt: Date.now()
       })
 
-      await Promise.all([
+      return await Promise.all([
         this._client.call('db:set', {
           $id: userId,
           memberProjects: { $add: membershipId }
@@ -132,7 +133,6 @@ export class BasedService extends BaseService {
           members: { $add: membershipId }
         })
       ])
-      return await this._client.call('db:set', obj)
     } catch (error) {
       throw new Error(`Failed to set bucket: ${error.message}`)
     }
@@ -176,6 +176,7 @@ export class BasedService extends BaseService {
     }
   }
 
+  // DEPRECATED
   async fetchUser (userId) {
     if (!userId) {
       throw new Error('User Id is required')
@@ -184,15 +185,158 @@ export class BasedService extends BaseService {
   }
 
   async getUser (userId) {
-    this._requireReady()
     if (!userId) {
-      throw new Error('User Id is required')
+      throw new Error("UserId is required")
+    }
+
+    // Get user data and memberProjects in a single query
+    const userData = await this._client
+      .query("db", buildGetUserDataQuery(userId))
+      .get()
+
+    // Extract user data
+    const user = {
+      id: userData.id,
+      name: userData.name,
+      email: userData.email,
+      username: userData.username,
+      globalRole: userData.globalRole,
+      createdAt: userData.createdAt,
+      updatedAt: userData.updatedAt
+    }
+
+    if (!user) {
+      throw new Error("User not found")
+    }
+
+    let memberProjects = []
+
+    if (userData.memberProjects && userData.memberProjects.length > 0) {
+      // Extract project keys from the direct query
+      const projectKeys = userData.memberProjects
+        .filter(membership => membership.project && membership.project.key)
+        .map(membership => membership.project.key)
+
+      if (projectKeys.length > 0) {
+        // Fetch projects in chunks to avoid PayloadTooLarge errors
+        const allProjects = await this._fetchProjectsByKeysInChunks(projectKeys)
+
+        // Map the project data with original membership data
+        memberProjects = userData.memberProjects
+          .filter(membership => membership.project && membership.project.key)
+          .map(membership => {
+            const projectKey = membership.project.key
+            const correctProject = allProjects.find(
+              p => p.key === projectKey
+            )
+
+            return {
+              project: correctProject || membership.project,
+              role: membership.role,
+              updatedAt: membership.updatedAt,
+              createdAt: membership.createdAt
+            }
+          })
+      }
+    } else {
+      console.log(`[getUser] No member projects found with ID: ${userId}`)
+    }
+
+    // Format projects data
+    const formattedProjects =
+      memberProjects
+        .filter(membership => membership.project)
+        .map(membership => ({
+          id: membership.project.id,
+          name: membership.project.name,
+          key: membership.project.key,
+          thumbnail: membership.project.thumbnail,
+          icon: membership.project.icon,
+          tier: membership.project.tier,
+          visibility: membership.project.visibility,
+          access: membership.project.access,
+          role: membership.role,
+          joinedAt: membership.createdAt,
+          updatedAt: membership.updatedAt,
+          members: membership.project.members
+        })) || []
+
+    return {
+      id: userId,
+      name: user.name,
+      email: user.email,
+      username: user.username,
+      globalRole: user.globalRole,
+      projects: formattedProjects,
+      createdAt: user.createdAt,
+      updatedAt: user.updatedAt
     }
-    try {
-      return await this.call('users:get', { userId })
-    } catch (error) {
-      throw new Error(`Failed to get user: ${error.message}`)
+  }
+
+  /**
+   * Fetches projects by keys in chunks with adaptive chunk sizing
+   * @param {Array<string>} allKeys - All project keys to fetch
+   * @returns {Promise<Array>} - All projects found
+   */
+  async _fetchProjectsByKeysInChunks(allKeys) {
+    if (!allKeys.length) {return []}
+
+    // Initial chunk size and limits
+    const INITIAL_CHUNK_SIZE = 50
+    const MAX_CHUNK_SIZE = 1000
+    const MIN_CHUNK_SIZE = 10
+
+    // Track the optimal chunk size as we learn from responses
+    const optimalChunkSize = INITIAL_CHUNK_SIZE
+
+    /**
+     * Recursively process chunks of keys with adaptive sizing
+     * @param {Array<string>} keys - Keys to process
+     * @param {number} size - Current chunk size
+     * @returns {Promise<Array>} - Projects found
+     */
+    const processChunks = async (keys, size) => {
+      if (!keys.length) {return []}
+
+      const chunks = []
+      for (let i = 0; i < keys.length; i += size) {
+        chunks.push(keys.slice(i, i + size))
+      }
+
+      try {
+        const result = await this._client
+          .query("db", buildGetProjectsByKeysQuery(chunks[0]))
+          .get()
+
+        const newSize = Math.min(Math.floor(size * 1.5), MAX_CHUNK_SIZE)
+
+        const firstChunkProjects = result.projects || []
+
+        const remainingKeys = keys.slice(chunks[0].length)
+        const remainingProjects = await processChunks(remainingKeys, newSize)
+
+        return [...firstChunkProjects, ...remainingProjects]
+      } catch (error) {
+        if (error.message && error.message.includes('PayloadTooLarge')) {
+          const newSize = Math.max(Math.floor(size / 2), MIN_CHUNK_SIZE)
+          console.warn(`Reducing chunk size to ${newSize} due to PayloadTooLarge error`)
+
+          if (newSize === MIN_CHUNK_SIZE && chunks[0].length <= MIN_CHUNK_SIZE) {
+            console.error(`Cannot process chunk, skipping ${chunks[0].length} keys`)
+            const remainingKeys = keys.slice(chunks[0].length)
+            return processChunks(remainingKeys, newSize)
+          }
+
+          return processChunks(keys, newSize)
+        }
+          console.error(`Error fetching projects: ${error.message}`)
+          const remainingKeys = keys.slice(chunks[0].length)
+          return processChunks(remainingKeys, size)
+
+      }
     }
+
+    return await processChunks(allKeys, optimalChunkSize)
   }
 
   async getUserByEmail (email) {
@@ -368,6 +512,7 @@ export class BasedService extends BaseService {
 
   async createProject (projectData) {
     this._requireReady()
+
     try {
       return await this.call('projects:create', projectData)
     } catch (error) {
@@ -375,33 +520,32 @@ export class BasedService extends BaseService {
     }
   }
 
-  async getProject (projectId, fields = { $all: true }) {
+  async getProject (projectId) {
     this._requireReady()
     if (!projectId) {
       throw new Error('Project ID is required')
     }
     try {
-      return await this.call('projects:get', {
-        projectId,
-        fields: { ...fields }
-      })
+      return await this._client
+          .query("db", buildGetProjectDataQuery(projectId))
+          .get()
     } catch (error) {
       throw new Error(`Failed to get project: ${error.message}`)
     }
   }
 
-  async getProjectByKey (key, fields = { $all: true }) {
+  async getProjectByKey (key) {
     this._requireReady()
     try {
-      return await this.call('projects:get', {
-        key,
-        fields: { ...fields }
-      })
+      return await this._client
+          .query("db", buildGetProjectByKeyDataQuery(key))
+          .get()
     } catch (error) {
       throw new Error(`Failed to get project by key: ${error.message}`)
     }
   }
 
+  // DEPRECATED
   async fetchProject (projectId) {
     this._requireReady()
     if (!projectId) {
@@ -489,7 +633,9 @@ export class BasedService extends BaseService {
     pkg = 2,
     seats = 1,
     interval = 'monthly',
-    plan = 'startup'
+    plan = 'startup',
+    successUrl = `${window.location.origin}/success`,
+    cancelUrl = `${window.location.origin}/pricing`
   }) {
     this._requireReady()
 
@@ -516,7 +662,9 @@ export class BasedService extends BaseService {
       return await this.call('checkout', {
         price,
         seats,
-        projectId
+        projectId,
+        successUrl,
+        cancelUrl
       })
     } catch (error) {
       throw new Error(`Failed to checkout: ${error.message}`)
@@ -707,16 +855,448 @@ export class BasedService extends BaseService {
    * @param {string} newKey - The new key of the project (optional)
    * @returns {Promise<Object>} The duplicated project
    */
-  async duplicateProject (projectId, newName, newKey) {
+  async duplicateProject (projectId, newName, newKey, targetUserId) {
     this._requireReady()
     try {
       return await this.call('projects:duplicate', {
         projectId,
         newName,
-        newKey
+        newKey,
+        targetUserId
       })
     } catch (error) {
       throw new Error(`Failed to duplicate project: ${error.message}`)
     }
   }
+
+  /**
+   * List available subscription plans
+   * @param {Object} options - Options for filtering plans
+   * @param {number} options.page - Page number (default: 1)
+   * @param {number} options.limit - Number of plans per page (default: 20)
+   * @param {string} options.status - Filter plans by status (admin only)
+   * @param {boolean} options.includeSubscriptionCounts - Include subscription counts (admin only)
+   * @param {string} options.sortBy - Field to sort by (default: 'displayOrder')
+   * @param {string} options.sortOrder - Sort order ('asc' or 'desc', default: 'asc')
+   * @returns {Promise<Object>} List of plans with pagination info
+   */
+  async listPlans(options = {}) {
+    this._requireReady();
+    try {
+      return await this.call('plans:list', options);
+    } catch (error) {
+      throw new Error(`Failed to list plans: ${error.message}`);
+    }
+  }
+
+  /**
+   * Subscribe to a plan
+   * @param {string} planId - ID of the plan to subscribe to
+   * @param {Object} options - Options for the subscription
+   * @param {string} options.paymentMethod - Payment method
+   * @param {Object} options.billingAddress - Billing address
+   * @param {string} options.stripeCustomerId - Stripe customer ID
+   * @param {string} options.stripeSubscriptionId - Stripe subscription ID
+   * @returns {Promise<Object>} Subscription details
+   */
+  async subscribeToPlan(planId, options = {}) {
+    this._requireReady()
+    try {
+      return await this.call('subscriptions:create', { planId, ...options })
+    } catch (error) {
+      throw new Error(`Failed to subscribe to plan: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get details of user's current subscription
+   * @param {string} subscriptionId - ID of the subscription to get details for
+   * @returns {Promise<Object>} Subscription details
+   */
+  async getSubscriptionDetails(subscriptionId) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:details', {
+        subscriptionId
+      });
+    } catch (error) {
+      throw new Error(`Failed to get subscription details: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if the current subscription is active
+   * @param {string} subscriptionId - ID of the subscription to check
+   * @returns {Promise<Object>} Subscription status info
+   */
+  async checkSubscriptionStatus(subscriptionId) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:check-status', {
+        subscriptionId
+      });
+    } catch (error) {
+      throw new Error(`Failed to check subscription status: ${error.message}`);
+    }
+  }
+
+  /**
+   * Upgrade the current subscription to a new plan
+   * @param {string} planId - ID of the plan to upgrade to
+   * @param {string} stripeSubscriptionId - ID of the Stripe subscription to upgrade
+   * @returns {Promise<Object>} Updated subscription details
+   */
+  async upgradeSubscription(planId, stripeSubscriptionId) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:upgrade', {
+        planId,
+        stripeSubscriptionId
+      });
+    } catch (error) {
+      throw new Error(`Failed to upgrade subscription: ${error.message}`);
+    }
+  }
+
+  /**
+   * Downgrade the current subscription to a new plan
+   * @param {string} planId - ID of the plan to downgrade to
+   * @param {boolean} applyImmediately - Whether to apply the downgrade immediately
+   * @param {string} stripeSubscriptionId - ID of the Stripe subscription to downgrade
+   * @returns {Promise<Object>} Updated subscription details
+   */
+  async downgradeSubscription(planId, stripeSubscriptionId, applyImmediately = false) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:downgrade', {
+        planId,
+        applyImmediately,
+        stripeSubscriptionId
+      });
+    } catch (error) {
+      throw new Error(`Failed to downgrade subscription: ${error.message}`);
+    }
+  }
+
+  /**
+   * Cancel the current subscription
+   * @param {boolean} cancelImmediately - Whether to cancel immediately or at period end
+   * @param {string} reason - Reason for cancellation
+   * @returns {Promise<Object>} Result of cancellation
+   */
+  async cancelSubscription(cancelImmediately = false, reason = '') {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:cancel', {
+        cancelImmediately,
+        reason
+      });
+    } catch (error) {
+      throw new Error(`Failed to cancel subscription: ${error.message}`);
+    }
+  }
+
+  /**
+   * Reactivate a subscription that was scheduled for cancellation
+   * @returns {Promise<Object>} Updated subscription details
+   */
+  async reactivateSubscription(stripeSubscriptionId) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:reactivate', {
+        stripeSubscriptionId
+      });
+    } catch (error) {
+      throw new Error(`Failed to reactivate subscription: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate an invoice for the current subscription
+   * @param {string} subscriptionId - ID of the subscription to generate the invoice for
+   * @param {boolean} forceGenerate - Whether to force the generation of the invoice
+   * @param {Array} customItems - Custom items to add to the invoice
+   * @returns {Promise<Object>} Generated invoice
+   */
+  async generateInvoice(subscriptionId, forceGenerate = false, customItems = []) {
+    this._requireReady();
+    try {
+      return await this.call('billing:generate-invoice', {
+        subscriptionId,
+        forceGenerate,
+        customItems
+      });
+    } catch (error) {
+      throw new Error(`Failed to generate invoice: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get usage report for the current subscription
+   * @param {string} subscriptionId - ID of the subscription to get the usage report for
+   * @param {boolean} forceRefresh - Whether to force the refresh of the usage report
+   * @returns {Promise<Object>} Usage report
+   */
+  async getUsageReport(subscriptionId, forceRefresh = false) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:get-usage-report', {
+        subscriptionId,
+        forceRefresh
+      });
+    } catch (error) {
+      throw new Error(`Failed to get usage report: ${error.message}`);
+    }
+  }
+
+  /**
+   * Invite a user to be an account owner for the current subscription
+   * @param {string} email - Email of the user to invite
+   * @param {string} name - Name of the user to invite
+   * @param {string} callbackUrl - URL to redirect the user to after accepting the invitation
+   * @returns {Promise<Object>} Result of invitation
+   */
+  async inviteAccountOwner(email, name, callbackUrl) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:invite', {
+        email,
+        name,
+        callbackUrl
+      });
+    } catch (error) {
+      throw new Error(`Failed to invite account owner: ${error.message}`);
+    }
+  }
+
+  /**
+   * Accept an invitation to become an account owner
+   * @param {string} token - Invitation token
+   * @returns {Promise<Object>} Result of accepting invitation
+   */
+  async acceptOwnerInvitation(token) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:accept-owner-invitation', {
+        token
+      });
+    } catch (error) {
+      throw new Error(`Failed to accept owner invitation: ${error.message}`);
+    }
+  }
+
+  /**
+   * Remove an account owner from the current subscription
+   * @param {string} userId - ID of the user to remove
+   * @returns {Promise<Object>} Result of removal
+   */
+  async removeAccountOwner(userId) {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:remove-account-owner', {
+        targetUserId: userId
+      });
+    } catch (error) {
+      throw new Error(`Failed to remove account owner: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a resource limit has been reached
+   * @param {string} resourceType - Type of resource to check
+   * @param {string} projectId - ID of the project to check the resource limit for
+   * @param {number} quantity - Amount being requested
+   * @param {string} userId - ID of user to check (admin only, defaults to current user)
+   * @returns {Promise<Object>} Result of check
+   */
+  async checkResourceLimit(resourceType, projectId, quantity = 1, userId = '') {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:check-resource-limit', {
+        resourceType,
+        projectId,
+        quantity,
+        userId
+      });
+    } catch (error) {
+      throw new Error(`Failed to check resource limit: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a user has access to a feature
+   * @param {string} featureKey - Key of the feature to check
+   * @param {string} userId - ID of user to check (admin only, defaults to current user)
+   * @returns {Promise<Object>} Access check result
+   */
+  async checkFeatureAccess(featureKey, userId) {
+    this._requireReady();
+    try {
+      return await this.call('features:check-access', {
+        featureKey,
+        userId
+      });
+    } catch (error) {
+      throw new Error(`Failed to check feature access: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get all features available to the current user
+   * @returns {Promise<Object>} Available features
+   */
+  async getUserFeatures() {
+    this._requireReady();
+    try {
+      return await this.call('subscriptions:get-user-features', {});
+    } catch (error) {
+      throw new Error(`Failed to get user features: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get all available features across all plans
+   * @param {string} subscriptionId - ID of the subscription to get the available features for
+   * @param {string} userId - ID of user to get the available features for (admin only, defaults to current user)
+   * @param {boolean} includeDetails - Whether to include details about the features
+   * @returns {Promise<Object>} Available features
+   */
+  async getAvailableFeatures(subscriptionId, userId = '', includeDetails = false) {
+    this._requireReady();
+    try {
+      return await this.call('features:get-available', {
+        subscriptionId,
+        userId,
+        includeDetails
+      });
+    } catch (error) {
+      throw new Error(`Failed to get available features: ${error.message}`);
+    }
+  }
+
+  /**
+   * List all feature flags (admin only)
+   * @param {Object} options - Options for listing feature flags
+   * @param {number} options.page - Page number
+   * @param {number} options.limit - Number of items per page
+   * @param {string} options.status - Filter by status
+   * @returns {Promise<Object>} List of feature flags
+   */
+  async listFeatureFlags(options = {}) {
+    this._requireReady();
+    try {
+      return await this.call('features:list', options);
+    } catch (error) {
+      throw new Error(`Failed to list feature flags: ${error.message}`);
+    }
+  }
+
+  /**
+   * Update a feature flag (admin only)
+   * @param {string} flagId - ID of the feature flag to update
+   * @param {Object} options - Update data
+   * @param {string} options.key - Key of the feature flag
+   * @param {string} options.name - Name of the feature flag
+   * @param {string} options.description - Description of the feature flag
+   * @param {string} options.defaultValue - Default value of the feature flag
+   * @param {Object} options.planOverrides - Plan overrides for the feature flag
+   * @param {Object} options.userOverrides - User overrides for the feature flag
+   * @param {string} options.status - Status of the feature flag
+   * @returns {Promise<Object>} Updated feature flag
+   */
+  async updateFeatureFlag(flagId, options) {
+    this._requireReady();
+    try {
+      return await this.call('features:update', {
+        flagId,
+        ...options
+      });
+    } catch (error) {
+      throw new Error(`Failed to update feature flag: ${error.message}`);
+    }
+  }
+
+  /**
+   * Remove a feature flag (admin only)
+   * @param {string} flagId - ID of the feature flag to remove
+   * @returns {Promise<Object>} Result of removal
+   */
+  async removeFeatureFlag(flagId) {
+    this._requireReady();
+    try {
+      return await this.call('features:remove', {
+        flagId
+      });
+    } catch (error) {
+      throw new Error(`Failed to remove feature flag: ${error.message}`);
+    }
+  }
+
+  /**
+   * Batch update feature flags (admin only)
+   * @param {Array} operations - Array of feature flag operations
+   * @param {string} operations.flagId - ID of the feature flag to update
+   * @param {string} operations.key - Key of the feature flag
+   * @param {string} operations.name - Name of the feature flag
+   * @param {string} operations.description - Description of the feature flag
+   * @param {boolean} operations.defaultValue - Default value of the feature flag
+   * @param {Object} operations.planOverrides - Plan overrides for the feature flag
+   * @param {Object} operations.userOverrides - User overrides for the feature flag
+   * @param {string} operations.status - Status of the feature flag
+   * @returns {Promise<Object>} Result of batch update
+   */
+  async batchUpdateFeatureFlags(operations) {
+    this._requireReady();
+    try {
+      return await this.call('features:batch-update', {
+        operations
+      });
+    } catch (error) {
+      throw new Error(`Failed to batch update feature flags: ${error.message}`);
+    }
+  }
+
+  /**
+   * Update plan details (admin only)
+   * @param {string} planId - ID of the plan to update
+   * @param {Object} data - Update data
+   * @param {string} data.name - Display name (e.g., "Pro", "Team")
+   * @param {string} data.description - Marketing description
+   * @param {number} data.price - Monthly price in cents
+   * @param {number} data.annualPrice - Annual price in cents (discounted)
+   * @param {number} data.lifetimePrice - One-time lifetime price in cents
+   * @param {string} data.billingType - Payment type
+   * @param {string} data.status - Status
+   * @param {Object} data.features - Detailed feature configuration
+   * @returns {Promise<Object>} Updated plan
+   */
+  async updatePlanDetails(planId, data) {
+    this._requireReady();
+    try {
+      return await this.call('plans:update-details', {
+        planId,
+        data
+      });
+    } catch (error) {
+      throw new Error(`Failed to update plan details: ${error.message}`);
+    }
+  }
+
+  /**
+   * Update plan status (admin only)
+   * @param {string} planId - ID of the plan to update
+   * @param {string} status - New status
+   * @returns {Promise<Object>} Updated plan
+   */
+  async updatePlanStatus(planId, status) {
+    this._requireReady();
+    try {
+      return await this.call('plans:update-status', {
+        planId,
+        status
+      });
+    } catch (error) {
+      throw new Error(`Failed to update plan status: ${error.message}`);
+    }
+  }
 }