@symbo.ls/sdk 2.34.35 → 3.1.2

package/dist/node/services/PaymentService.js

@@ -1,252 +0,0 @@
-import { BaseService } from "./BaseService.js";
-class PaymentService extends 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;
-    }
-  }
-}
-export {
-  PaymentService
-};

package/dist/node/services/PlanService.js

@@ -1,407 +0,0 @@
-import { BaseService } from "./BaseService.js";
-class PlanService extends 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
-      });
-    }
-  }
-}
-export {
-  PlanService
-};