@symbo.ls/sdk 3.1.2 → 3.2.6

package/dist/cjs/services/PaymentService.js

@@ -0,0 +1,271 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PaymentService_exports = {};
+__export(PaymentService_exports, {
+  PaymentService: () => PaymentService
+});
+module.exports = __toCommonJS(PaymentService_exports);
+var import_BaseService = require("./BaseService.js");
+class PaymentService extends import_BaseService.BaseService {
+  // ==================== PAYMENT METHODS ====================
+  async checkout(options = {}) {
+    this._requireReady("checkout");
+    const {
+      projectId,
+      seats = 1,
+      price = "starter_monthly",
+      successUrl = `${window.location.origin}/success`,
+      cancelUrl = `${window.location.origin}/pricing`
+    } = options;
+    if (!projectId) {
+      throw new Error("Project ID is required for checkout");
+    }
+    try {
+      const response = await this._request("/payments/checkout", {
+        method: "POST",
+        body: JSON.stringify({
+          projectId,
+          seats,
+          price,
+          successUrl,
+          cancelUrl
+        }),
+        methodName: "checkout"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to checkout: ${error.message}`, { cause: error });
+    }
+  }
+  async getSubscriptionStatus(projectId) {
+    this._requireReady("getSubscriptionStatus");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/payments/subscription/${projectId}`,
+        {
+          method: "GET",
+          methodName: "getSubscriptionStatus"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get subscription status: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== PAYMENT HELPER METHODS ====================
+  /**
+   * Helper method to create checkout with validation
+   */
+  async checkoutWithValidation(options = {}) {
+    const {
+      projectId,
+      seats,
+      price,
+      successUrl,
+      cancelUrl
+    } = options;
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (seats && (typeof seats !== "number" || seats < 1)) {
+      throw new Error("Seats must be a positive number");
+    }
+    if (price && typeof price !== "string") {
+      throw new Error("Price must be a string");
+    }
+    if (successUrl && !this._isValidUrl(successUrl)) {
+      throw new Error("Success URL must be a valid URL");
+    }
+    if (cancelUrl && !this._isValidUrl(cancelUrl)) {
+      throw new Error("Cancel URL must be a valid URL");
+    }
+    return await this.checkout(options);
+  }
+  /**
+   * Helper method to get subscription status with validation
+   */
+  async getSubscriptionStatusWithValidation(projectId) {
+    if (!projectId || typeof projectId !== "string") {
+      throw new Error("Project ID must be a valid string");
+    }
+    return await this.getSubscriptionStatus(projectId);
+  }
+  /**
+   * Helper method to check if project has active subscription
+   */
+  async hasActiveSubscription(projectId) {
+    try {
+      const status = await this.getSubscriptionStatus(projectId);
+      return (status == null ? void 0 : status.active) === true;
+    } catch (error) {
+      console.warn("Failed to check subscription status:", error.message);
+      return false;
+    }
+  }
+  /**
+   * Helper method to get subscription details
+   */
+  async getSubscriptionDetails(projectId) {
+    try {
+      const status = await this.getSubscriptionStatus(projectId);
+      if (!status) {
+        return {
+          hasSubscription: false,
+          active: false,
+          message: "No subscription found"
+        };
+      }
+      return {
+        hasSubscription: true,
+        active: status.active || false,
+        plan: status.plan,
+        seats: status.seats,
+        nextBillingDate: status.nextBillingDate,
+        amount: status.amount,
+        currency: status.currency,
+        status: status.status
+      };
+    } catch (error) {
+      throw new Error(`Failed to get subscription details: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to create checkout for specific plan
+   */
+  async checkoutForPlan(projectId, planKey, options = {}) {
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!planKey) {
+      throw new Error("Plan key is required");
+    }
+    const checkoutOptions = {
+      projectId,
+      price: planKey,
+      ...options
+    };
+    return await this.checkoutWithValidation(checkoutOptions);
+  }
+  /**
+   * Helper method to create checkout for team plan
+   */
+  async checkoutForTeam(projectId, seats, options = {}) {
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!seats || seats < 1) {
+      throw new Error("Seats must be a positive number");
+    }
+    const checkoutOptions = {
+      projectId,
+      seats,
+      price: "team_monthly",
+      ...options
+    };
+    return await this.checkoutWithValidation(checkoutOptions);
+  }
+  /**
+   * Helper method to validate subscription status
+   */
+  validateSubscriptionStatus(status) {
+    if (!status || typeof status !== "object") {
+      return {
+        isValid: false,
+        error: "Invalid subscription status format"
+      };
+    }
+    const requiredFields = ["active", "plan", "seats"];
+    const missingFields = requiredFields.filter((field) => !(field in status));
+    if (missingFields.length > 0) {
+      return {
+        isValid: false,
+        error: `Missing required fields: ${missingFields.join(", ")}`
+      };
+    }
+    return {
+      isValid: true,
+      error: null
+    };
+  }
+  /**
+   * Helper method to format subscription amount
+   */
+  formatSubscriptionAmount(amount, currency = "USD") {
+    if (!amount || typeof amount !== "number") {
+      return "N/A";
+    }
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency
+    }).format(amount / 100);
+  }
+  /**
+   * Helper method to get subscription summary
+   */
+  async getSubscriptionSummary(projectId) {
+    try {
+      const details = await this.getSubscriptionDetails(projectId);
+      if (!details.hasSubscription) {
+        return {
+          status: "no_subscription",
+          message: "No active subscription",
+          action: "subscribe"
+        };
+      }
+      if (!details.active) {
+        return {
+          status: "inactive",
+          message: "Subscription is inactive",
+          action: "reactivate"
+        };
+      }
+      return {
+        status: "active",
+        message: `Active ${details.plan} plan with ${details.seats} seats`,
+        action: "manage",
+        details
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Failed to get subscription: ${error.message}`,
+        action: "retry"
+      };
+    }
+  }
+  /**
+   * Private helper to validate URL
+   */
+  _isValidUrl(string) {
+    try {
+      const url = new URL(string);
+      return Boolean(url);
+    } catch {
+      return false;
+    }
+  }
+}

package/dist/cjs/services/PlanService.js

@@ -0,0 +1,426 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PlanService_exports = {};
+__export(PlanService_exports, {
+  PlanService: () => PlanService
+});
+module.exports = __toCommonJS(PlanService_exports);
+var import_BaseService = require("./BaseService.js");
+class PlanService extends import_BaseService.BaseService {
+  // ==================== PLAN METHODS ====================
+  /**
+   * Get list of public plans (no authentication required)
+   */
+  async getPlans() {
+    try {
+      const response = await this._request("/plans", {
+        method: "GET",
+        methodName: "getPlans"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get plans: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Get list of public plans with enhanced pricing information (no authentication required)
+   */
+  async getPlansWithPricing() {
+    try {
+      const response = await this._request("/plans/pricing", {
+        method: "GET",
+        methodName: "getPlansWithPricing"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get plans with pricing: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get a specific plan by ID (no authentication required)
+   */
+  async getPlan(planId) {
+    if (!planId) {
+      throw new Error("Plan ID is required");
+    }
+    try {
+      const response = await this._request(`/plans/${planId}`, {
+        method: "GET",
+        methodName: "getPlan"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get plan: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== ADMIN PLAN METHODS ====================
+  /**
+   * Get all plans including inactive ones (admin only)
+   */
+  async getAdminPlans() {
+    this._requireReady("getAdminPlans");
+    try {
+      const response = await this._request("/admin/plans", {
+        method: "GET",
+        methodName: "getAdminPlans"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get admin plans: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Create a new plan (admin only)
+   */
+  async createPlan(planData) {
+    this._requireReady("createPlan");
+    if (!planData || typeof planData !== "object") {
+      throw new Error("Plan data is required");
+    }
+    try {
+      const response = await this._request("/admin/plans", {
+        method: "POST",
+        body: JSON.stringify(planData),
+        methodName: "createPlan"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create plan: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Update an existing plan (admin only)
+   */
+  async updatePlan(planId, planData) {
+    this._requireReady("updatePlan");
+    if (!planId) {
+      throw new Error("Plan ID is required");
+    }
+    if (!planData || typeof planData !== "object") {
+      throw new Error("Plan data is required");
+    }
+    try {
+      const response = await this._request(`/admin/plans/${planId}`, {
+        method: "PATCH",
+        body: JSON.stringify(planData),
+        methodName: "updatePlan"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update plan: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Delete a plan (soft delete + archive Stripe product) (admin only)
+   */
+  async deletePlan(planId) {
+    this._requireReady("deletePlan");
+    if (!planId) {
+      throw new Error("Plan ID is required");
+    }
+    try {
+      const response = await this._request(`/admin/plans/${planId}`, {
+        method: "DELETE",
+        methodName: "deletePlan"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to delete plan: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Initialize default plans (admin only)
+   */
+  async initializePlans() {
+    this._requireReady("initializePlans");
+    try {
+      const response = await this._request("/admin/plans/initialize", {
+        method: "POST",
+        methodName: "initializePlans"
+      });
+      if (response.success) {
+        return response;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to initialize plans: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  // ==================== PLAN HELPER METHODS ====================
+  /**
+   * Helper method to get plans with validation
+   */
+  async getPlansWithValidation() {
+    try {
+      const plans = await this.getPlans();
+      if (!Array.isArray(plans)) {
+        throw new Error("Invalid response format: plans should be an array");
+      }
+      return plans;
+    } catch (error) {
+      throw new Error(`Failed to get plans with validation: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Helper method to get a plan by ID with validation
+   */
+  async getPlanWithValidation(planId) {
+    if (!planId || typeof planId !== "string") {
+      throw new Error("Plan ID must be a valid string");
+    }
+    try {
+      const plan = await this.getPlan(planId);
+      if (!plan || typeof plan !== "object") {
+        throw new Error("Invalid plan data received");
+      }
+      return plan;
+    } catch (error) {
+      throw new Error(`Failed to get plan with validation: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Helper method to create a plan with validation (admin only)
+   */
+  async createPlanWithValidation(planData) {
+    if (!planData || typeof planData !== "object") {
+      throw new Error("Plan data must be a valid object");
+    }
+    const requiredFields = ["name", "description"];
+    for (const field of requiredFields) {
+      if (!planData[field]) {
+        throw new Error(`Required field '${field}' is missing`);
+      }
+    }
+    if (Object.hasOwn(planData, "price")) {
+      throw new Error(
+        'Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.'
+      );
+    }
+    if (planData.pricingOptions != null) {
+      if (!Array.isArray(planData.pricingOptions) || planData.pricingOptions.length === 0) {
+        throw new Error(
+          "pricingOptions must be a non-empty array when provided"
+        );
+      }
+      const allowedIntervals = /* @__PURE__ */ new Set(["month", "year", "week", "day", null]);
+      planData.pricingOptions.forEach((option, index) => {
+        if (!option || typeof option !== "object") {
+          throw new Error(`Pricing option at index ${index} must be an object`);
+        }
+        const { key, displayName, amount, interval, lookupKey } = option;
+        if (!key || typeof key !== "string") {
+          throw new Error(
+            `Pricing option at index ${index} is missing required field 'key'`
+          );
+        }
+        if (!/^[a-z0-9-]+$/u.test(key)) {
+          throw new Error(
+            `Pricing option key '${key}' must contain only lowercase letters, numbers, and hyphens`
+          );
+        }
+        if (!displayName || typeof displayName !== "string") {
+          throw new Error(
+            `Pricing option '${key}' is missing required field 'displayName'`
+          );
+        }
+        if (typeof amount !== "number" || amount < 0) {
+          throw new Error(
+            `Pricing option '${key}' must have a non-negative numeric 'amount'`
+          );
+        }
+        if (interval !== null && !allowedIntervals.has(interval)) {
+          throw new Error(
+            `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          );
+        }
+        if (!lookupKey || typeof lookupKey !== "string") {
+          throw new Error(
+            `Pricing option '${key}' is missing required field 'lookupKey'`
+          );
+        }
+      });
+    }
+    if (Object.hasOwn(planData, "key") && planData.key == null) {
+      throw new Error("Plan key must be a valid string");
+    }
+    if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
+      throw new Error(
+        "Plan key must contain only lowercase letters, numbers, and hyphens"
+      );
+    }
+    return await this.createPlan(planData);
+  }
+  /**
+   * Helper method to update a plan with validation (admin only)
+   */
+  async updatePlanWithValidation(planId, planData) {
+    if (!planId || typeof planId !== "string") {
+      throw new Error("Plan ID must be a valid string");
+    }
+    if (!planData || typeof planData !== "object") {
+      throw new Error("Plan data must be a valid object");
+    }
+    if (Object.hasOwn(planData, "price")) {
+      throw new Error(
+        'Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.'
+      );
+    }
+    if (planData.pricingOptions != null) {
+      if (!Array.isArray(planData.pricingOptions) || planData.pricingOptions.length === 0) {
+        throw new Error(
+          "pricingOptions must be a non-empty array when provided"
+        );
+      }
+      const allowedIntervals = /* @__PURE__ */ new Set(["month", "year", "week", "day", null]);
+      planData.pricingOptions.forEach((option, index) => {
+        if (!option || typeof option !== "object") {
+          throw new Error(`Pricing option at index ${index} must be an object`);
+        }
+        const { key, displayName, amount, interval, lookupKey } = option;
+        if (!key || typeof key !== "string") {
+          throw new Error(
+            `Pricing option at index ${index} is missing required field 'key'`
+          );
+        }
+        if (!/^[a-z0-9-]+$/u.test(key)) {
+          throw new Error(
+            `Pricing option key '${key}' must contain only lowercase letters, numbers, and hyphens`
+          );
+        }
+        if (!displayName || typeof displayName !== "string") {
+          throw new Error(
+            `Pricing option '${key}' is missing required field 'displayName'`
+          );
+        }
+        if (typeof amount !== "number" || amount < 0) {
+          throw new Error(
+            `Pricing option '${key}' must have a non-negative numeric 'amount'`
+          );
+        }
+        if (interval !== null && !allowedIntervals.has(interval)) {
+          throw new Error(
+            `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          );
+        }
+        if (!lookupKey || typeof lookupKey !== "string") {
+          throw new Error(
+            `Pricing option '${key}' is missing required field 'lookupKey'`
+          );
+        }
+      });
+    }
+    if (Object.hasOwn(planData, "key") && planData.key == null) {
+      throw new Error("Plan key must be a valid string");
+    }
+    if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
+      throw new Error(
+        "Plan key must contain only lowercase letters, numbers, and hyphens"
+      );
+    }
+    return await this.updatePlan(planId, planData);
+  }
+  /**
+   * Helper method to get active plans only
+   */
+  async getActivePlans() {
+    try {
+      const plans = await this.getPlans();
+      return plans.filter(
+        (plan) => plan.status === "active" && plan.isVisible !== false
+      );
+    } catch (error) {
+      throw new Error(`Failed to get active plans: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Helper method to get plans by price range
+   */
+  async getPlansByPriceRange(minPrice = 0, maxPrice = Infinity) {
+    try {
+      const plans = await this.getPlansWithPricing();
+      return plans.filter((plan) => {
+        var _a, _b;
+        const price = ((_b = (_a = plan == null ? void 0 : plan.pricing) == null ? void 0 : _a.bestPrice) == null ? void 0 : _b.amount) ?? 0;
+        return price >= minPrice && price <= maxPrice;
+      });
+    } catch (error) {
+      throw new Error(`Failed to get plans by price range: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Helper method to find plan by key
+   */
+  async getPlanByKey(key) {
+    if (!key) {
+      throw new Error("Plan key is required");
+    }
+    try {
+      const plans = await this.getPlans();
+      const plan = plans.find((p) => p.key === key);
+      if (!plan) {
+        throw new Error(`Plan with key '${key}' not found`);
+      }
+      return plan;
+    } catch (error) {
+      throw new Error(`Failed to get plan by key: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+}