@symbo.ls/sdk 3.1.1 → 3.2.3

package/dist/cjs/services/BasedService.js

@@ -137,7 +137,7 @@ class BasedService extends import_BaseService.BaseService {
         role: obj.role,
         joinedAt: Date.now()
       });
-      await Promise.all([
+      return await Promise.all([
         this._client.call("db:set", {
           $id: userId,
           memberProjects: { $add: membershipId }
@@ -147,7 +147,6 @@ class BasedService extends import_BaseService.BaseService {
           members: { $add: membershipId }
         })
       ]);
-      return await this._client.call("db:set", obj);
     } catch (error) {
       throw new Error(`Failed to set bucket: ${error.message}`);
     }
@@ -185,6 +184,7 @@ class BasedService extends import_BaseService.BaseService {
       throw new Error(`Query failed: ${error.message}`);
     }
   }
+  // DEPRECATED
   async fetchUser(userId) {
     if (!userId) {
       throw new Error("User Id is required");
@@ -192,15 +192,113 @@ class BasedService extends import_BaseService.BaseService {
     return await this.query("db", (0, import_basedQuerys.buildUserQuery)(userId));
   }
   async getUser(userId) {
-    this._requireReady();
     if (!userId) {
-      throw new Error("User Id is required");
-    }
-    try {
-      return await this.call("users:get", { userId });
-    } catch (error) {
-      throw new Error(`Failed to get user: ${error.message}`);
-    }
+      throw new Error("UserId is required");
+    }
+    const userData = await this._client.query("db", (0, import_basedQuerys.buildGetUserDataQuery)(userId)).get();
+    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) {
+      const projectKeys = userData.memberProjects.filter((membership) => membership.project && membership.project.key).map((membership) => membership.project.key);
+      if (projectKeys.length > 0) {
+        const allProjects = await this._fetchProjectsByKeysInChunks(projectKeys);
+        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}`);
+    }
+    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
+    };
+  }
+  /**
+   * 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 [];
+    }
+    const INITIAL_CHUNK_SIZE = 50;
+    const MAX_CHUNK_SIZE = 1e3;
+    const MIN_CHUNK_SIZE = 10;
+    const optimalChunkSize = INITIAL_CHUNK_SIZE;
+    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", (0, import_basedQuerys.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 remainingKeys2 = keys.slice(chunks[0].length);
+            return processChunks(remainingKeys2, 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) {
     this._requireReady();
@@ -362,31 +460,26 @@ class BasedService extends import_BaseService.BaseService {
       throw new Error(`Failed to create project: ${error.message}`);
     }
   }
-  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", (0, import_basedQuerys.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", (0, import_basedQuerys.buildGetProjectByKeyDataQuery)(key)).get();
     } catch (error) {
       throw new Error(`Failed to get project by key: ${error.message}`);
     }
   }
+  // DEPRECATED
   async fetchProject(projectId) {
     this._requireReady();
     if (!projectId) {
@@ -467,7 +560,9 @@ class BasedService extends import_BaseService.BaseService {
     pkg = 2,
     seats = 1,
     interval = "monthly",
-    plan = "startup"
+    plan = "startup",
+    successUrl = `${window.location.origin}/success`,
+    cancelUrl = `${window.location.origin}/pricing`
   }) {
     this._requireReady();
     const prices = {
@@ -489,7 +584,9 @@ class BasedService extends import_BaseService.BaseService {
       return await this.call("checkout", {
         price,
         seats,
-        projectId
+        projectId,
+        successUrl,
+        cancelUrl
       });
     } catch (error) {
       throw new Error(`Failed to checkout: ${error.message}`);
@@ -664,16 +761,425 @@ class BasedService extends import_BaseService.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}`);
+    }
+  }
 }