@insforge/sdk 1.3.0 → 1.3.2-razorpay.0

package/dist/ssr.mjs

@@ -1009,21 +1009,43 @@ var Auth = class {
       };
     }
   }
-  // ============================================================================
-  // OAuth Authentication
-  // ============================================================================
-  /**
-   * Sign in with OAuth provider using PKCE flow
-   */
-  async signInWithOAuth(options) {
+  async signInWithOAuth(providerOrOptions, options) {
     try {
-      const { provider, redirectTo, skipBrowserRedirect } = options;
+      let signInOptions;
+      if (typeof providerOrOptions === "object") {
+        signInOptions = providerOrOptions;
+      } else if (options) {
+        signInOptions = { provider: providerOrOptions, ...options };
+      } else {
+        return {
+          data: {},
+          error: new InsForgeError(
+            "OAuth sign-in options are required",
+            400,
+            ERROR_CODES.INVALID_INPUT
+          )
+        };
+      }
+      if (!signInOptions || !signInOptions.redirectTo) {
+        return {
+          data: {},
+          error: new InsForgeError(
+            "Redirect URI is required",
+            400,
+            ERROR_CODES.INVALID_INPUT
+          )
+        };
+      }
+      const { provider } = signInOptions;
       const providerKey = encodeURIComponent(provider.toLowerCase());
       const codeVerifier = generateCodeVerifier();
       const codeChallenge = await generateCodeChallenge(codeVerifier);
       storePkceVerifier(codeVerifier);
-      const params = { code_challenge: codeChallenge };
-      if (redirectTo) params.redirect_uri = redirectTo;
+      const params = {
+        ...signInOptions.additionalParams ?? {},
+        redirect_uri: signInOptions.redirectTo,
+        code_challenge: codeChallenge
+      };
       const isBuiltInProvider = oAuthProvidersSchema.options.includes(
         providerKey
       );
@@ -1032,7 +1054,7 @@ var Auth = class {
         params,
         skipAuthRefresh: true
       });
-      if (!this.isServerMode() && typeof window !== "undefined" && !skipBrowserRedirect) {
+      if (!this.isServerMode() && typeof window !== "undefined" && !signInOptions.skipBrowserRedirect) {
         window.location.href = response.authUrl;
         return { data: {}, error: null };
       }
@@ -2022,7 +2044,7 @@ var Images = class {
    *   model: 'dall-e-3',
    *   prompt: 'A sunset over mountains',
    * });
-   * console.log(response.images[0].url);
+   * console.log(response.data[0].b64_json);
    *
    * // Image-to-image (with input images)
    * const response = await client.ai.images.generate({
@@ -2463,7 +2485,10 @@ var Emails = class {
 };
 
 // src/modules/payments.ts
-var Payments = class {
+function providerEnvironmentPath(provider, environment) {
+  return `/api/payments/${provider}/${encodeURIComponent(environment)}`;
+}
+var StripePayments = class {
   constructor(http) {
     this.http = http;
   }
@@ -2472,9 +2497,9 @@ var Payments = class {
    *
    * @example
    * ```typescript
-   * const { data, error } = await client.payments.createCheckoutSession('test', {
+   * const { data, error } = await client.payments.stripe.createCheckoutSession('test', {
    *   mode: 'payment',
-   *   lineItems: [{ stripePriceId: 'price_123', quantity: 1 }],
+   *   lineItems: [{ priceId: 'price_123', quantity: 1 }],
    *   successUrl: `${window.location.origin}/success`,
    *   cancelUrl: `${window.location.origin}/pricing`
    * });
@@ -2487,7 +2512,7 @@ var Payments = class {
   async createCheckoutSession(environment, request) {
     try {
       const data = await this.http.post(
-        `/api/payments/${encodeURIComponent(environment)}/checkout-sessions`,
+        `${providerEnvironmentPath("stripe", environment)}/checkout-sessions`,
         request,
         { idempotent: !!request.idempotencyKey }
       );
@@ -2495,7 +2520,7 @@ var Payments = class {
     } catch (error) {
       return wrapError(
         error,
-        "Checkout session creation failed"
+        "Stripe checkout session creation failed"
       );
     }
   }
@@ -2505,17 +2530,132 @@ var Payments = class {
   async createCustomerPortalSession(environment, request) {
     try {
       const data = await this.http.post(
-        `/api/payments/${encodeURIComponent(environment)}/customer-portal-sessions`,
+        `${providerEnvironmentPath("stripe", environment)}/customer-portal-sessions`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Stripe customer portal session creation failed"
+      );
+    }
+  }
+};
+var RazorpayPayments = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createOrder(environment, request) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/orders`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Razorpay order creation failed"
+      );
+    }
+  }
+  async verifyOrder(environment, request) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/orders/verify`,
         request
       );
       return { data, error: null };
     } catch (error) {
       return wrapError(
         error,
-        "Customer portal session creation failed"
+        "Razorpay order verification failed"
       );
     }
   }
+  async createSubscription(environment, request) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/subscriptions`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Razorpay subscription creation failed"
+      );
+    }
+  }
+  async verifySubscription(environment, request) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/subscriptions/verify`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Razorpay subscription verification failed"
+      );
+    }
+  }
+  async cancelSubscription(environment, subscriptionId, request = {}) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/subscriptions/${encodeURIComponent(
+          subscriptionId
+        )}/cancel`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Razorpay subscription cancellation failed"
+      );
+    }
+  }
+  async pauseSubscription(environment, subscriptionId) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/subscriptions/${encodeURIComponent(
+          subscriptionId
+        )}/pause`,
+        {}
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Razorpay subscription pause failed"
+      );
+    }
+  }
+  async resumeSubscription(environment, subscriptionId) {
+    try {
+      const data = await this.http.post(
+        `${providerEnvironmentPath("razorpay", environment)}/subscriptions/${encodeURIComponent(
+          subscriptionId
+        )}/resume`,
+        {}
+      );
+      return { data, error: null };
+    } catch (error) {
+      return wrapError(
+        error,
+        "Razorpay subscription resume failed"
+      );
+    }
+  }
+};
+var Payments = class {
+  constructor(http) {
+    this.stripe = new StripePayments(http);
+    this.razorpay = new RazorpayPayments(http);
+  }
 };
 
 // src/client.ts