@stackbe/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -20,10 +20,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AuthClient: () => AuthClient,
+  CheckoutClient: () => CheckoutClient,
   CustomersClient: () => CustomersClient,
   EntitlementsClient: () => EntitlementsClient,
   StackBE: () => StackBE,
   StackBEError: () => StackBEError,
+  SubscriptionsClient: () => SubscriptionsClient,
   UsageClient: () => UsageClient
 });
 module.exports = __toCommonJS(index_exports);
@@ -43,6 +46,9 @@ var HttpClient = class {
   constructor(config) {
     this.config = config;
   }
+  get baseUrl() {
+    return this.config.baseUrl;
+  }
   async request(method, path, options = {}) {
     const url = new URL(path, this.config.baseUrl);
     if (options.params) {
@@ -409,6 +415,379 @@ var CustomersClient = class {
   }
 };
 
+// src/checkout.ts
+var CheckoutClient = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Create a checkout session for a customer to subscribe to a plan.
+   * Returns a URL to redirect the customer to Stripe checkout.
+   *
+   * @example
+   * ```typescript
+   * // With existing customer ID
+   * const { url } = await stackbe.checkout.createSession({
+   *   customer: 'cust_123',
+   *   planId: 'plan_pro_monthly',
+   *   successUrl: 'https://myapp.com/success',
+   *   cancelUrl: 'https://myapp.com/pricing',
+   * });
+   *
+   * // Redirect to checkout
+   * res.redirect(url);
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With new customer (will be created)
+   * const { url } = await stackbe.checkout.createSession({
+   *   customer: { email: 'user@example.com', name: 'John' },
+   *   planId: 'plan_pro_monthly',
+   *   successUrl: 'https://myapp.com/success',
+   *   trialDays: 14,
+   * });
+   * ```
+   */
+  async createSession(options) {
+    const body = {
+      planId: options.planId,
+      successUrl: options.successUrl,
+      cancelUrl: options.cancelUrl,
+      allowPromotionCodes: options.allowPromotionCodes,
+      trialDays: options.trialDays,
+      metadata: options.metadata
+    };
+    if (typeof options.customer === "string") {
+      body.customerId = options.customer;
+    } else {
+      body.customerEmail = options.customer.email;
+      body.customerName = options.customer.name;
+    }
+    return this.http.post("/v1/checkout/session", body);
+  }
+  /**
+   * Get an existing checkout session by ID.
+   *
+   * @example
+   * ```typescript
+   * const session = await stackbe.checkout.getSession('cs_123');
+   * if (session.status === 'complete') {
+   *   // Payment successful
+   * }
+   * ```
+   */
+  async getSession(sessionId) {
+    return this.http.get(`/v1/checkout/session/${sessionId}`);
+  }
+  /**
+   * Generate a checkout URL for a plan.
+   * Convenience method that creates a session and returns just the URL.
+   *
+   * @example
+   * ```typescript
+   * const checkoutUrl = await stackbe.checkout.getCheckoutUrl({
+   *   customer: 'cust_123',
+   *   planId: 'plan_pro_monthly',
+   *   successUrl: 'https://myapp.com/success',
+   * });
+   *
+   * // Send to frontend
+   * res.json({ checkoutUrl });
+   * ```
+   */
+  async getCheckoutUrl(options) {
+    const session = await this.createSession(options);
+    return session.url;
+  }
+};
+
+// src/subscriptions.ts
+var SubscriptionsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a customer's current active subscription.
+   *
+   * @example
+   * ```typescript
+   * const subscription = await stackbe.subscriptions.get('cust_123');
+   *
+   * if (subscription) {
+   *   console.log(`Plan: ${subscription.plan.name}`);
+   *   console.log(`Status: ${subscription.status}`);
+   *   console.log(`Renews: ${subscription.currentPeriodEnd}`);
+   * } else {
+   *   console.log('No active subscription');
+   * }
+   * ```
+   */
+  async get(customerId) {
+    try {
+      return await this.http.get(
+        `/v1/subscriptions/current`,
+        { customerId }
+      );
+    } catch (error) {
+      if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get a subscription by ID.
+   *
+   * @example
+   * ```typescript
+   * const subscription = await stackbe.subscriptions.getById('sub_123');
+   * ```
+   */
+  async getById(subscriptionId) {
+    return this.http.get(`/v1/subscriptions/${subscriptionId}`);
+  }
+  /**
+   * List all subscriptions for a customer.
+   *
+   * @example
+   * ```typescript
+   * const subscriptions = await stackbe.subscriptions.list('cust_123');
+   * ```
+   */
+  async list(customerId) {
+    return this.http.get("/v1/subscriptions", { customerId });
+  }
+  /**
+   * Cancel a subscription.
+   *
+   * @example
+   * ```typescript
+   * // Cancel at end of billing period (default)
+   * await stackbe.subscriptions.cancel('sub_123');
+   *
+   * // Cancel immediately
+   * await stackbe.subscriptions.cancel('sub_123', { immediate: true });
+   *
+   * // Cancel with reason
+   * await stackbe.subscriptions.cancel('sub_123', {
+   *   reason: 'Too expensive'
+   * });
+   * ```
+   */
+  async cancel(subscriptionId, options = {}) {
+    return this.http.post(
+      `/v1/subscriptions/${subscriptionId}/cancel`,
+      {
+        immediate: options.immediate ?? false,
+        reason: options.reason
+      }
+    );
+  }
+  /**
+   * Update a subscription (change plan).
+   *
+   * @example
+   * ```typescript
+   * // Upgrade/downgrade to a different plan
+   * await stackbe.subscriptions.update('sub_123', {
+   *   planId: 'plan_enterprise_monthly',
+   *   prorate: true,
+   * });
+   * ```
+   */
+  async update(subscriptionId, options) {
+    return this.http.patch(
+      `/v1/subscriptions/${subscriptionId}`,
+      options
+    );
+  }
+  /**
+   * Reactivate a canceled subscription (before it ends).
+   *
+   * @example
+   * ```typescript
+   * // Customer changed their mind
+   * await stackbe.subscriptions.reactivate('sub_123');
+   * ```
+   */
+  async reactivate(subscriptionId) {
+    return this.http.post(
+      `/v1/subscriptions/${subscriptionId}/reactivate`
+    );
+  }
+  /**
+   * Check if a customer has an active subscription.
+   *
+   * @example
+   * ```typescript
+   * const isActive = await stackbe.subscriptions.isActive('cust_123');
+   * if (!isActive) {
+   *   return res.redirect('/pricing');
+   * }
+   * ```
+   */
+  async isActive(customerId) {
+    const subscription = await this.get(customerId);
+    return subscription !== null && (subscription.status === "active" || subscription.status === "trialing");
+  }
+};
+
+// src/auth.ts
+var AuthClient = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Send a magic link email to a customer for passwordless authentication.
+   *
+   * @example
+   * ```typescript
+   * // Send magic link
+   * await stackbe.auth.sendMagicLink('user@example.com');
+   *
+   * // With redirect URL
+   * await stackbe.auth.sendMagicLink('user@example.com', {
+   *   redirectUrl: 'https://myapp.com/dashboard',
+   * });
+   *
+   * // For localhost development
+   * await stackbe.auth.sendMagicLink('user@example.com', {
+   *   useDev: true,
+   * });
+   * ```
+   */
+  async sendMagicLink(email, options = {}) {
+    return this.http.post(
+      `/v1/apps/${this.appId}/auth/magic-link`,
+      {
+        email,
+        redirectUrl: options.redirectUrl,
+        useDev: options.useDev
+      }
+    );
+  }
+  /**
+   * Verify a magic link token and get a session token.
+   * Call this when the user clicks the magic link.
+   *
+   * @example
+   * ```typescript
+   * // In your /verify route handler
+   * const { token } = req.query;
+   *
+   * const result = await stackbe.auth.verifyToken(token);
+   *
+   * if (result.valid) {
+   *   // Set session cookie
+   *   res.cookie('session', result.token, { httpOnly: true });
+   *   res.redirect('/dashboard');
+   * } else {
+   *   res.redirect('/login?error=invalid_token');
+   * }
+   * ```
+   */
+  async verifyToken(token) {
+    return this.http.post(
+      `/v1/apps/${this.appId}/auth/verify`,
+      { token }
+    );
+  }
+  /**
+   * Get the current session for an authenticated customer.
+   * Use this to validate session tokens and get customer data.
+   *
+   * @example
+   * ```typescript
+   * // Validate session on each request
+   * const sessionToken = req.cookies.session;
+   *
+   * const session = await stackbe.auth.getSession(sessionToken);
+   *
+   * if (session) {
+   *   req.customer = session.customer;
+   *   req.subscription = session.subscription;
+   *   req.entitlements = session.entitlements;
+   * }
+   * ```
+   */
+  async getSession(sessionToken) {
+    try {
+      const response = await fetch(
+        `${this.http.baseUrl}/v1/apps/${this.appId}/auth/session?appId=${this.appId}`,
+        {
+          headers: {
+            "Authorization": `Bearer ${sessionToken}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      if (!response.ok) {
+        if (response.status === 401) {
+          return null;
+        }
+        throw new Error("Failed to get session");
+      }
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create Express middleware that validates session tokens.
+   *
+   * @example
+   * ```typescript
+   * // Protect routes with authentication
+   * app.use('/dashboard', stackbe.auth.middleware({
+   *   getToken: (req) => req.cookies.session,
+   *   onUnauthenticated: (req, res) => res.redirect('/login'),
+   * }));
+   *
+   * app.get('/dashboard', (req, res) => {
+   *   // req.customer is available
+   *   res.json({ email: req.customer.email });
+   * });
+   * ```
+   */
+  middleware(options) {
+    return async (req, res, next) => {
+      const token = options.getToken(req);
+      if (!token) {
+        if (options.onUnauthenticated) {
+          return options.onUnauthenticated(req, res);
+        }
+        return res.status(401).json({ error: "Not authenticated" });
+      }
+      const session = await this.getSession(token);
+      if (!session) {
+        if (options.onUnauthenticated) {
+          return options.onUnauthenticated(req, res);
+        }
+        return res.status(401).json({ error: "Invalid session" });
+      }
+      req.customer = session.customer;
+      req.subscription = session.subscription;
+      req.entitlements = session.entitlements;
+      next();
+    };
+  }
+  /**
+   * Check if a session token is valid.
+   *
+   * @example
+   * ```typescript
+   * const isValid = await stackbe.auth.isAuthenticated(sessionToken);
+   * ```
+   */
+  async isAuthenticated(sessionToken) {
+    const session = await this.getSession(sessionToken);
+    return session !== null;
+  }
+};
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.stackbe.io";
 var DEFAULT_TIMEOUT = 3e4;
@@ -431,8 +810,18 @@ var StackBE = class {
    * // Check entitlements
    * const { hasAccess } = await stackbe.entitlements.check('customer_123', 'premium');
    *
-   * // Get customer
-   * const customer = await stackbe.customers.get('customer_123');
+   * // Create checkout session
+   * const { url } = await stackbe.checkout.createSession({
+   *   customer: 'cust_123',
+   *   planId: 'plan_pro',
+   *   successUrl: 'https://myapp.com/success',
+   * });
+   *
+   * // Get subscription
+   * const subscription = await stackbe.subscriptions.get('cust_123');
+   *
+   * // Send magic link
+   * await stackbe.auth.sendMagicLink('user@example.com');
    * ```
    */
   constructor(config) {
@@ -442,6 +831,7 @@ var StackBE = class {
     if (!config.appId) {
       throw new StackBEError("appId is required", 400, "INVALID_CONFIG");
     }
+    this.appId = config.appId;
     this.http = new HttpClient({
       baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
       apiKey: config.apiKey,
@@ -451,6 +841,9 @@ var StackBE = class {
     this.usage = new UsageClient(this.http);
     this.entitlements = new EntitlementsClient(this.http);
     this.customers = new CustomersClient(this.http);
+    this.checkout = new CheckoutClient(this.http, config.appId);
+    this.subscriptions = new SubscriptionsClient(this.http);
+    this.auth = new AuthClient(this.http, config.appId);
   }
   /**
    * Create a middleware for Express that tracks usage automatically.
@@ -584,9 +977,12 @@ var StackBE = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthClient,
+  CheckoutClient,
   CustomersClient,
   EntitlementsClient,
   StackBE,
   StackBEError,
+  SubscriptionsClient,
   UsageClient
 });