@solvapay/server 1.0.5 → 1.0.7

package/dist/edge.js

@@ -38,12 +38,10 @@ function createSolvaPayClient(opts) {
     // POST: /v1/sdk/usages
     async trackUsage(params) {
       const url = `${base}/v1/sdk/usages`;
-      const { customerRef, ...rest } = params;
-      const body = { ...rest, customerId: customerRef };
       const res = await fetch(url, {
         method: "POST",
         headers,
-        body: JSON.stringify(body)
+        body: JSON.stringify(params)
       });
       if (!res.ok) {
         const error = await res.text();
@@ -288,7 +286,7 @@ function createSolvaPayClient(opts) {
         body: JSON.stringify({
           productRef: params.productRef,
           planRef: params.planRef,
-          customerReference: params.customerRef
+          customerRef: params.customerRef
         })
       });
       if (!res.ok) {
@@ -296,8 +294,32 @@ function createSolvaPayClient(opts) {
         log(`\u274C API Error: ${res.status} - ${error}`);
         throw new SolvaPayError(`Create payment intent failed (${res.status}): ${error}`);
       }
-      const result = await res.json();
-      return result;
+      return await res.json();
+    },
+    // POST: /v1/sdk/payment-intents (purpose: credit_topup)
+    async createTopupPaymentIntent(params) {
+      const idempotencyKey = params.idempotencyKey || `topup-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const url = `${base}/v1/sdk/payment-intents`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...headers,
+          "Idempotency-Key": idempotencyKey
+        },
+        body: JSON.stringify({
+          customerRef: params.customerRef,
+          purpose: "credit_topup",
+          amount: params.amount,
+          currency: params.currency,
+          description: params.description
+        })
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Create topup payment intent failed (${res.status}): ${error}`);
+      }
+      return await res.json();
     },
     // POST: /v1/sdk/payment-intents/{paymentIntentId}/process
     async processPaymentIntent(params) {
@@ -374,6 +396,54 @@ function createSolvaPayClient(opts) {
       }
       return result;
     },
+    // POST: /v1/sdk/purchases/{purchaseRef}/reactivate
+    async reactivatePurchase(params) {
+      const url = `${base}/v1/sdk/purchases/${params.purchaseRef}/reactivate`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        if (res.status === 404) {
+          throw new SolvaPayError(`Purchase not found: ${error}`);
+        }
+        if (res.status === 400) {
+          throw new SolvaPayError(
+            `Purchase cannot be reactivated: ${error}`
+          );
+        }
+        throw new SolvaPayError(`Reactivate purchase failed (${res.status}): ${error}`);
+      }
+      const responseText = await res.text();
+      let responseData;
+      try {
+        responseData = JSON.parse(responseText);
+      } catch (parseError) {
+        log(`\u274C Failed to parse response as JSON: ${parseError}`);
+        throw new SolvaPayError(
+          `Invalid JSON response from reactivate purchase endpoint: ${responseText.substring(0, 200)}`
+        );
+      }
+      if (!responseData || typeof responseData !== "object") {
+        log(`\u274C Invalid response structure: ${JSON.stringify(responseData)}`);
+        throw new SolvaPayError(`Invalid response structure from reactivate purchase endpoint`);
+      }
+      let result;
+      if (responseData.purchase && typeof responseData.purchase === "object") {
+        result = responseData.purchase;
+      } else if (responseData.reference) {
+        result = responseData;
+      } else {
+        result = responseData.purchase || responseData;
+      }
+      if (!result || typeof result !== "object") {
+        log(`\u274C Invalid purchase data in response. Full response:`, responseData);
+        throw new SolvaPayError(`Invalid purchase data in reactivate purchase response`);
+      }
+      return result;
+    },
     // POST: /v1/sdk/user-info
     async getUserInfo(params) {
       const url = `${base}/v1/sdk/user-info`;
@@ -389,6 +459,20 @@ function createSolvaPayClient(opts) {
       }
       return await res.json();
     },
+    // GET: /v1/sdk/customers/:customerRef/balance
+    async getCustomerBalance(params) {
+      const url = `${base}/v1/sdk/customers/${params.customerRef}/balance`;
+      const res = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Get customer balance failed (${res.status}): ${error}`);
+      }
+      return await res.json();
+    },
     // POST: /v1/sdk/checkout-sessions
     async createCheckoutSession(params) {
       const url = `${base}/v1/sdk/checkout-sessions`;
@@ -420,6 +504,21 @@ function createSolvaPayClient(opts) {
       }
       const result = await res.json();
       return result;
+    },
+    // POST: /v1/sdk/activate
+    async activatePlan(params) {
+      const url = `${base}/v1/sdk/activate`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Activate plan failed (${res.status}): ${error}`);
+      }
+      return await res.json();
     }
   };
 }
@@ -575,6 +674,24 @@ var PaywallError = class extends Error {
     this.name = "PaywallError";
   }
 };
+function paywallErrorToClientPayload(error) {
+  const sc = error.structuredContent;
+  const base = {
+    success: false,
+    error: sc.kind === "activation_required" ? "Activation required" : "Payment required",
+    product: sc.product,
+    checkoutUrl: sc.checkoutUrl,
+    message: sc.message
+  };
+  if (sc.kind === "activation_required") {
+    base.kind = "activation_required";
+    if (sc.plans !== void 0) base.plans = sc.plans;
+    if (sc.balance !== void 0) base.balance = sc.balance;
+    if (sc.productDetails !== void 0) base.productDetails = sc.productDetails;
+    if (sc.confirmationUrl !== void 0) base.confirmationUrl = sc.confirmationUrl;
+  }
+  return base;
+}
 var sharedCustomerLookupDeduplicator = createRequestDeduplicator({
   cacheTTL: 6e4,
   // Cache results for 60 seconds (reduces API calls significantly)
@@ -613,8 +730,6 @@ var SolvaPayPaywall = class {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async protect(handler, metadata = {}, getCustomerRef) {
     const product = this.resolveProduct(metadata);
-    const configuredPlanRef = metadata.plan?.trim();
-    const usagePlanRef = configuredPlanRef || "unspecified";
     const usageType = metadata.usageType || "requests";
     return async (args) => {
       const startTime = Date.now();
@@ -628,12 +743,13 @@ var SolvaPayPaywall = class {
       }
       let resolvedMeterName;
       try {
-        const limitsCacheKey = `${backendCustomerRef}:${product}:${configuredPlanRef || ""}:${usageType}`;
+        const limitsCacheKey = `${backendCustomerRef}:${product}:${usageType}`;
         const cachedLimits = this.limitsCache.get(limitsCacheKey);
         const now = Date.now();
         let withinLimits;
         let remaining;
         let checkoutUrl;
+        let lastLimitsCheck;
         const hasFreshCachedLimits = cachedLimits && now - cachedLimits.timestamp < this.limitsCacheTTL;
         if (hasFreshCachedLimits) {
           checkoutUrl = cachedLimits.checkoutUrl;
@@ -657,9 +773,9 @@ var SolvaPayPaywall = class {
           const limitsCheck = await this.apiClient.checkLimits({
             customerRef: backendCustomerRef,
             productRef: product,
-            ...configuredPlanRef ? { planRef: configuredPlanRef } : {},
             meterName: usageType
           });
+          lastLimitsCheck = limitsCheck;
           withinLimits = limitsCheck.withinLimits;
           remaining = limitsCheck.remaining;
           checkoutUrl = limitsCheck.checkoutUrl;
@@ -682,12 +798,25 @@ var SolvaPayPaywall = class {
           this.trackUsage(
             backendCustomerRef,
             product,
-            usagePlanRef,
             resolvedMeterName || usageType,
             "paywall",
             requestId,
             latencyMs2
           );
+          if (lastLimitsCheck?.activationRequired) {
+            const confirmationUrl = lastLimitsCheck.confirmationUrl;
+            const payCheckoutUrl = confirmationUrl || lastLimitsCheck.checkoutUrl || checkoutUrl || "";
+            throw new PaywallError("Activation required", {
+              kind: "activation_required",
+              product,
+              message: "Product activation is required before this tool can be used.",
+              checkoutUrl: payCheckoutUrl,
+              confirmationUrl,
+              plans: lastLimitsCheck.plans,
+              balance: lastLimitsCheck.balance,
+              productDetails: lastLimitsCheck.product
+            });
+          }
           throw new PaywallError("Payment required", {
             kind: "payment_required",
             product,
@@ -700,7 +829,6 @@ var SolvaPayPaywall = class {
         this.trackUsage(
           backendCustomerRef,
           product,
-          usagePlanRef,
           resolvedMeterName || usageType,
           "success",
           requestId,
@@ -719,7 +847,6 @@ var SolvaPayPaywall = class {
           this.trackUsage(
             backendCustomerRef,
             product,
-            usagePlanRef,
             resolvedMeterName || usageType,
             "fail",
             requestId,
@@ -790,7 +917,8 @@ var SolvaPayPaywall = class {
       this.customerCreationAttempts.add(customerRef);
       try {
         const createParams = {
-          email: options?.email || `${customerRef}-${Date.now()}@auto-created.local`
+          email: options?.email || `${customerRef}-${Date.now()}@auto-created.local`,
+          metadata: {}
         };
         if (options?.name) {
           createParams.name = options.name;
@@ -814,7 +942,10 @@ var SolvaPayPaywall = class {
                 return searchResult.customerRef;
               }
             } catch (lookupError) {
-              this.log(`\u26A0\uFE0F Failed to lookup existing customer by externalRef after 409:`, lookupError instanceof Error ? lookupError.message : lookupError);
+              this.log(
+                `\u26A0\uFE0F Failed to lookup existing customer by externalRef after 409:`,
+                lookupError instanceof Error ? lookupError.message : lookupError
+              );
             }
           }
           const isEmailConflict = errorMessage.includes("email") || errorMessage.includes("identifier email");
@@ -837,7 +968,8 @@ var SolvaPayPaywall = class {
             try {
               const retryParams = {
                 email: `${customerRef}-${Date.now()}@auto-created.local`,
-                externalRef
+                externalRef,
+                metadata: {}
               };
               if (options?.name) {
                 retryParams.name = options.name;
@@ -874,14 +1006,14 @@ var SolvaPayPaywall = class {
     }
     return backendRef;
   }
-  async trackUsage(customerRef, _productRef, _planRef, action, outcome, requestId, actionDuration) {
+  async trackUsage(customerRef, productRef, action, outcome, requestId, actionDuration) {
     await withRetry(
       () => this.apiClient.trackUsage({
         customerRef,
         actionType: "api_call",
         units: 1,
         outcome,
-        productReference: _productRef,
+        productRef,
         duration: actionDuration,
         metadata: { action: action || "api_requests", requestId },
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1133,8 +1265,10 @@ var McpAdapter = class {
       const ref = await this.options.getCustomerRef(args, extra);
       return AdapterUtils.ensureCustomerRef(ref);
     }
-    const customerRefFromExtra = extra?.authInfo?.extra?.customer_ref;
-    const customerRef = typeof customerRefFromExtra === "string" && customerRefFromExtra.trim() ? customerRefFromExtra.trim() : "anonymous";
+    const customerRefFromExtra = typeof extra?.authInfo?.extra?.customer_ref === "string" ? String(extra.authInfo.extra.customer_ref) : void 0;
+    const customerRefFromArgs = typeof args.auth === "object" && args.auth !== null && typeof args.auth.customer_ref === "string" ? String(args.auth.customer_ref) : void 0;
+    const directCustomerRef = typeof args.customer_ref === "string" ? args.customer_ref : void 0;
+    const customerRef = (customerRefFromExtra || customerRefFromArgs || directCustomerRef || "anonymous").trim();
     return AdapterUtils.ensureCustomerRef(customerRef);
   }
   formatResponse(result, _context) {
@@ -1158,17 +1292,7 @@ var McpAdapter = class {
         content: [
           {
             type: "text",
-            text: JSON.stringify(
-              {
-                success: false,
-                error: "Payment required",
-                product: error.structuredContent.product,
-                checkoutUrl: error.structuredContent.checkoutUrl,
-                message: error.structuredContent.message
-              },
-              null,
-              2
-            )
+            text: JSON.stringify(paywallErrorToClientPayload(error), null, 2)
           }
         ],
         isError: true,
@@ -1454,6 +1578,12 @@ function createSolvaPay(config) {
       }
       return apiClient.createPaymentIntent(params);
     },
+    createTopupPaymentIntent(params) {
+      if (!apiClient.createTopupPaymentIntent) {
+        throw new SolvaPayError2("createTopupPaymentIntent is not available on this API client");
+      }
+      return apiClient.createTopupPaymentIntent(params);
+    },
     processPaymentIntent(params) {
       if (!apiClient.processPaymentIntent) {
         throw new SolvaPayError2("processPaymentIntent is not available on this API client");
@@ -1470,11 +1600,17 @@ function createSolvaPay(config) {
       if (!apiClient.createCustomer) {
         throw new SolvaPayError2("createCustomer is not available on this API client");
       }
-      return apiClient.createCustomer(params);
+      return apiClient.createCustomer({ ...params, metadata: params.metadata ?? {} });
     },
     getCustomer(params) {
       return apiClient.getCustomer(params);
     },
+    getCustomerBalance(params) {
+      if (!apiClient.getCustomerBalance) {
+        throw new SolvaPayError2("getCustomerBalance is not available on this API client");
+      }
+      return apiClient.getCustomerBalance(params);
+    },
     createCheckoutSession(params) {
       return apiClient.createCheckoutSession({
         customerRef: params.customerRef,
@@ -1485,6 +1621,12 @@ function createSolvaPay(config) {
     createCustomerSession(params) {
       return apiClient.createCustomerSession(params);
     },
+    activatePlan(params) {
+      if (!apiClient.activatePlan) {
+        throw new SolvaPayError2("activatePlan is not available on this API client");
+      }
+      return apiClient.activatePlan(params);
+    },
     bootstrapMcpProduct(params) {
       if (!apiClient.bootstrapMcpProduct) {
         throw new SolvaPayError2("bootstrapMcpProduct is not available on this API client");
@@ -1506,9 +1648,8 @@ function createSolvaPay(config) {
     // Payable API for framework-specific handlers
     payable(options = {}) {
       const product = options.productRef || options.product || process.env.SOLVAPAY_PRODUCT || "default-product";
-      const plan = options.planRef || options.plan;
       const usageType = options.usageType || "requests";
-      const metadata = { product, plan, usageType };
+      const metadata = { product, usageType };
       return {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         http(businessLogic, adapterOptions) {
@@ -1660,7 +1801,7 @@ async function createPaymentIntentCore(request, body, options = {}) {
       customerRef
     });
     return {
-      id: paymentIntent.id,
+      processorPaymentId: paymentIntent.processorPaymentId,
       clientSecret: paymentIntent.clientSecret,
       publishableKey: paymentIntent.publishableKey,
       accountId: paymentIntent.accountId,
@@ -1670,6 +1811,57 @@ async function createPaymentIntentCore(request, body, options = {}) {
     return handleRouteError(error, "Create payment intent", "Payment intent creation failed");
   }
 }
+async function createTopupPaymentIntentCore(request, body, options = {}) {
+  try {
+    if (!body.amount || body.amount <= 0) {
+      return {
+        error: "Missing or invalid amount: must be a positive number",
+        status: 400
+      };
+    }
+    if (!body.currency) {
+      return {
+        error: "Missing required parameter: currency",
+        status: 400
+      };
+    }
+    if (body.currency !== body.currency.toUpperCase()) {
+      return {
+        error: `Invalid currency "${body.currency}": must be an uppercase ISO 4217 code (e.g. "USD", "EUR")`,
+        status: 400
+      };
+    }
+    const customerResult = await syncCustomerCore(request, {
+      solvaPay: options.solvaPay,
+      includeEmail: options.includeEmail,
+      includeName: options.includeName
+    });
+    if (isErrorResult(customerResult)) {
+      return customerResult;
+    }
+    const customerRef = customerResult;
+    const solvaPay = options.solvaPay || createSolvaPay();
+    const paymentIntent = await solvaPay.createTopupPaymentIntent({
+      customerRef,
+      amount: body.amount,
+      currency: body.currency,
+      description: body.description
+    });
+    return {
+      processorPaymentId: paymentIntent.processorPaymentId,
+      clientSecret: paymentIntent.clientSecret,
+      publishableKey: paymentIntent.publishableKey,
+      accountId: paymentIntent.accountId,
+      customerRef
+    };
+  } catch (error) {
+    return handleRouteError(
+      error,
+      "Create topup payment intent",
+      "Topup payment intent creation failed"
+    );
+  }
+}
 async function processPaymentIntentCore(request, body, options = {}) {
   try {
     if (!body.paymentIntentId || !body.productRef) {
@@ -1934,10 +2126,12 @@ export {
   createPaymentIntentCore,
   createSolvaPay,
   createSolvaPayClient,
+  createTopupPaymentIntentCore,
   getAuthenticatedUserCore,
   handleRouteError,
   isErrorResult,
   listPlansCore,
+  paywallErrorToClientPayload,
   processPaymentIntentCore,
   syncCustomerCore,
   verifyWebhook,