@solvapay/server 1.0.0-preview.5 → 1.0.0-preview.7

package/dist/edge.js

@@ -20,15 +20,10 @@ function createSolvaPayClient(opts) {
       console.log(...args);
     }
   };
-  log(`\u{1F50C} SolvaPay API Client initialized`);
-  log(`   Backend URL: ${base}`);
-  log(`   API Key: ${opts.apiKey.substring(0, 10)}...`);
   return {
     // POST: /v1/sdk/limits
     async checkLimits(params) {
       const url = `${base}/v1/sdk/limits`;
-      log(`\u{1F4E1} API Request: POST ${url}`);
-      log(`   Params:`, JSON.stringify(params, null, 2));
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -40,20 +35,11 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Check limits failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
-      log(`\u{1F50D} DEBUG - checkLimits breakdown:`);
-      log(`   - withinLimits: ${result.withinLimits}`);
-      log(`   - remaining: ${result.remaining}`);
-      log(`   - plan: ${result.plan || "N/A"}`);
-      log(`   - checkoutUrl: ${result.checkoutUrl || "N/A"}`);
-      log(`   - Full response keys:`, Object.keys(result));
       return result;
     },
     // POST: /v1/sdk/usages
     async trackUsage(params) {
       const url = `${base}/v1/sdk/usages`;
-      log(`\u{1F4E1} API Request: POST ${url}`);
-      log(`   Params:`, JSON.stringify(params, null, 2));
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -64,13 +50,10 @@ function createSolvaPayClient(opts) {
         log(`\u274C API Error: ${res.status} - ${error}`);
         throw new SolvaPayError(`Track usage failed (${res.status}): ${error}`);
       }
-      log(`\u2705 Usage tracked successfully`);
     },
     // POST: /v1/sdk/customers
     async createCustomer(params) {
       const url = `${base}/v1/sdk/customers`;
-      log(`\u{1F4E1} API Request: POST ${url}`);
-      log(`   Params:`, JSON.stringify(params, null, 2));
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -82,18 +65,11 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Create customer failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
-      log(`\u{1F50D} DEBUG - createCustomer response:`);
-      log(`   - reference/customerRef: ${result.reference || result.customerRef}`);
-      log(`   - Has plan info: ${result.plan ? "YES" : "NO"}`);
-      log(`   - Has subscription info: ${result.subscription ? "YES" : "NO"}`);
-      log(`   - Full response keys:`, Object.keys(result));
       return result;
     },
     // GET: /v1/sdk/customers/{reference}
     async getCustomer(params) {
       const url = `${base}/v1/sdk/customers/${params.customerRef}`;
-      log(`\u{1F4E1} API Request: GET ${url}`);
       const res = await fetch(url, {
         method: "GET",
         headers
@@ -104,14 +80,40 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Get customer failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
-      return result;
+      return {
+        customerRef: result.reference || result.customerRef,
+        email: result.email,
+        name: result.name,
+        externalRef: result.externalRef,
+        subscriptions: result.subscriptions || []
+      };
+    },
+    // GET: /v1/sdk/customers?externalRef={externalRef}
+    async getCustomerByExternalRef(params) {
+      const url = `${base}/v1/sdk/customers?externalRef=${encodeURIComponent(params.externalRef)}`;
+      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 by externalRef failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      const customer = Array.isArray(result) ? result[0] : result;
+      return {
+        customerRef: customer.reference || customer.customerRef,
+        email: customer.email,
+        name: customer.name,
+        externalRef: customer.externalRef,
+        subscriptions: customer.subscriptions || []
+      };
     },
     // Management methods (primarily for integration tests)
     // GET: /v1/sdk/agents
     async listAgents() {
       const url = `${base}/v1/sdk/agents`;
-      log(`\u{1F4E1} API Request: GET ${url}`);
       const res = await fetch(url, {
         method: "GET",
         headers
@@ -122,7 +124,6 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`List agents failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
       const agents = Array.isArray(result) ? result : result.agents || [];
       return agents.map((agent) => ({
         ...agent,
@@ -132,8 +133,6 @@ function createSolvaPayClient(opts) {
     // POST: /v1/sdk/agents
     async createAgent(params) {
       const url = `${base}/v1/sdk/agents`;
-      log(`\u{1F4E1} API Request: POST ${url}`);
-      log(`   Params:`, JSON.stringify(params, null, 2));
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -145,13 +144,11 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Create agent failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
       return result;
     },
     // DELETE: /v1/sdk/agents/{agentRef}
     async deleteAgent(agentRef) {
       const url = `${base}/v1/sdk/agents/${agentRef}`;
-      log(`\u{1F4E1} API Request: DELETE ${url}`);
       const res = await fetch(url, {
         method: "DELETE",
         headers
@@ -161,12 +158,10 @@ function createSolvaPayClient(opts) {
         log(`\u274C API Error: ${res.status} - ${error}`);
         throw new SolvaPayError(`Delete agent failed (${res.status}): ${error}`);
       }
-      log(`\u2705 Agent deleted successfully`);
     },
     // GET: /v1/sdk/agents/{agentRef}/plans
     async listPlans(agentRef) {
       const url = `${base}/v1/sdk/agents/${agentRef}/plans`;
-      log(`\u{1F4E1} API Request: GET ${url}`);
       const res = await fetch(url, {
         method: "GET",
         headers
@@ -177,18 +172,22 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`List plans failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
       const plans = Array.isArray(result) ? result : result.plans || [];
-      return plans.map((plan) => ({
-        ...plan,
-        ...plan.data || {}
-      }));
+      return plans.map((plan) => {
+        const price = plan.price ?? plan.data?.price;
+        const unwrapped = {
+          ...plan.data || {},
+          ...plan,
+          // Explicitly preserve price field to ensure it's not lost
+          ...price !== void 0 && { price }
+        };
+        delete unwrapped.data;
+        return unwrapped;
+      });
     },
     // POST: /v1/sdk/agents/{agentRef}/plans
     async createPlan(params) {
       const url = `${base}/v1/sdk/agents/${params.agentRef}/plans`;
-      log(`\u{1F4E1} API Request: POST ${url}`);
-      log(`   Params:`, JSON.stringify(params, null, 2));
       const res = await fetch(url, {
         method: "POST",
         headers,
@@ -200,13 +199,11 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Create plan failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 API Response:`, JSON.stringify(result, null, 2));
       return result;
     },
     // DELETE: /v1/sdk/agents/{agentRef}/plans/{planRef}
     async deletePlan(agentRef, planRef) {
       const url = `${base}/v1/sdk/agents/${agentRef}/plans/${planRef}`;
-      log(`\u{1F4E1} API Request: DELETE ${url}`);
       const res = await fetch(url, {
         method: "DELETE",
         headers
@@ -216,17 +213,11 @@ function createSolvaPayClient(opts) {
         log(`\u274C API Error: ${res.status} - ${error}`);
         throw new SolvaPayError(`Delete plan failed (${res.status}): ${error}`);
       }
-      log(`\u2705 Plan deleted successfully`);
     },
     // POST: /payment-intents
     async createPaymentIntent(params) {
       const idempotencyKey = params.idempotencyKey || `payment-${params.planRef}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
       const url = `${base}/v1/sdk/payment-intents`;
-      log(`\u{1F4E1} API Request: POST ${url}`);
-      log(`   Agent Ref: ${params.agentRef}`);
-      log(`   Plan Ref: ${params.planRef}`);
-      log(`   Customer Ref: ${params.customerRef}`);
-      log(`   Idempotency Key: ${idempotencyKey}`);
       const res = await fetch(url, {
         method: "POST",
         headers: {
@@ -245,12 +236,77 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Create payment intent failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      log(`\u2705 Payment intent created:`, {
-        id: result.id,
-        hasClientSecret: !!result.clientSecret,
-        hasPublishableKey: !!result.publishableKey,
-        accountId: result.accountId
+      return result;
+    },
+    // POST: /v1/sdk/payment-intents/{paymentIntentId}/process
+    async processPayment(params) {
+      const url = `${base}/v1/sdk/payment-intents/${params.paymentIntentId}/process`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...headers,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          agentRef: params.agentRef,
+          customerRef: params.customerRef,
+          planRef: params.planRef
+        })
       });
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        throw new SolvaPayError(`Process payment failed (${res.status}): ${error}`);
+      }
+      const result = await res.json();
+      return result;
+    },
+    // POST: /v1/sdk/subscriptions/{subscriptionRef}/cancel
+    async cancelSubscription(params) {
+      const url = `${base}/v1/sdk/subscriptions/${params.subscriptionRef}/cancel`;
+      const requestOptions = {
+        method: "POST",
+        headers
+      };
+      if (params.reason) {
+        requestOptions.body = JSON.stringify({ reason: params.reason });
+      }
+      const res = await fetch(url, requestOptions);
+      if (!res.ok) {
+        const error = await res.text();
+        log(`\u274C API Error: ${res.status} - ${error}`);
+        if (res.status === 404) {
+          throw new SolvaPayError(`Subscription not found: ${error}`);
+        }
+        if (res.status === 400) {
+          throw new SolvaPayError(`Subscription cannot be cancelled or does not belong to provider: ${error}`);
+        }
+        throw new SolvaPayError(`Cancel subscription 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 cancel subscription 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 cancel subscription endpoint`);
+      }
+      let result;
+      if (responseData.subscription && typeof responseData.subscription === "object") {
+        result = responseData.subscription;
+      } else if (responseData.reference) {
+        result = responseData;
+      } else {
+        result = responseData.subscription || responseData;
+      }
+      if (!result || typeof result !== "object") {
+        log(`\u274C Invalid subscription data in response. Full response:`, responseData);
+        throw new SolvaPayError(`Invalid subscription data in cancel subscription response`);
+      }
       return result;
     }
   };
@@ -302,6 +358,95 @@ function calculateDelay(initialDelay, attempt, strategy) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function createRequestDeduplicator(options = {}) {
+  const {
+    cacheTTL = 2e3,
+    maxCacheSize = 1e3,
+    cacheErrors = true
+  } = options;
+  const inFlightRequests = /* @__PURE__ */ new Map();
+  const resultCache = /* @__PURE__ */ new Map();
+  let cleanupInterval = null;
+  if (cacheTTL > 0) {
+    cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      const entriesToDelete = [];
+      for (const [key, cached] of resultCache.entries()) {
+        if (now - cached.timestamp >= cacheTTL) {
+          entriesToDelete.push(key);
+        }
+      }
+      for (const key of entriesToDelete) {
+        resultCache.delete(key);
+      }
+      if (resultCache.size > maxCacheSize) {
+        const sortedEntries = Array.from(resultCache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+        const toRemove = sortedEntries.slice(0, resultCache.size - maxCacheSize);
+        for (const [key] of toRemove) {
+          resultCache.delete(key);
+        }
+      }
+    }, Math.min(cacheTTL, 1e3));
+  }
+  const deduplicate = async (key, fn) => {
+    if (cacheTTL > 0) {
+      const cached = resultCache.get(key);
+      if (cached && Date.now() - cached.timestamp < cacheTTL) {
+        return cached.data;
+      } else if (cached) {
+        resultCache.delete(key);
+      }
+    }
+    let requestPromise = inFlightRequests.get(key);
+    if (!requestPromise) {
+      requestPromise = (async () => {
+        try {
+          const result = await fn();
+          if (cacheTTL > 0) {
+            resultCache.set(key, {
+              data: result,
+              timestamp: Date.now()
+            });
+          }
+          return result;
+        } catch (error) {
+          if (cacheTTL > 0 && cacheErrors) {
+            resultCache.set(key, {
+              data: error,
+              timestamp: Date.now()
+            });
+          }
+          throw error;
+        } finally {
+          inFlightRequests.delete(key);
+        }
+      })();
+      const existingPromise = inFlightRequests.get(key);
+      if (existingPromise) {
+        requestPromise = existingPromise;
+      } else {
+        inFlightRequests.set(key, requestPromise);
+      }
+    }
+    return requestPromise;
+  };
+  const clearCache = (key) => {
+    resultCache.delete(key);
+  };
+  const clearAllCache = () => {
+    resultCache.clear();
+  };
+  const getStats = () => ({
+    inFlight: inFlightRequests.size,
+    cached: resultCache.size
+  });
+  return {
+    deduplicate,
+    clearCache,
+    clearAllCache,
+    getStats
+  };
+}
 
 // src/paywall.ts
 var PaywallError = class extends Error {
@@ -311,6 +456,14 @@ var PaywallError = class extends Error {
     this.name = "PaywallError";
   }
 };
+var sharedCustomerLookupDeduplicator = createRequestDeduplicator({
+  cacheTTL: 5e3,
+  // Cache results for 5 seconds (sufficient for concurrent requests)
+  maxCacheSize: 1e3,
+  // Maximum cache entries
+  cacheErrors: false
+  // Don't cache errors - retry on next request
+});
 var SolvaPayPaywall = class {
   constructor(apiClient, options = {}) {
     this.apiClient = apiClient;
@@ -380,7 +533,12 @@ var SolvaPayPaywall = class {
         this.log(`\u2705 Request completed successfully`);
         return result;
       } catch (error) {
-        this.log(`\u274C Error in paywall:`, error);
+        if (error instanceof Error) {
+          const errorType = error instanceof PaywallError ? "PaywallError" : "API Error";
+          this.log(`\u274C Error in paywall [${errorType}]: ${error.message}`);
+        } else {
+          this.log(`\u274C Error in paywall:`, error);
+        }
         const latencyMs = Date.now() - startTime;
         const outcome = error instanceof PaywallError ? "paywall" : "fail";
         const planRef = metadata.plan || toolName;
@@ -394,41 +552,91 @@ var SolvaPayPaywall = class {
    * This is a public helper for testing, pre-creating customers, and internal use.
    * Only attempts creation once per customer (idempotent).
    * Returns the backend customer reference to use in API calls.
+   * 
+   * @param customerRef - The customer reference (e.g., Supabase user ID)
+   * @param externalRef - Optional external reference for backend lookup (e.g., Supabase user ID)
+   *   If provided, will lookup existing customer by externalRef before creating new one
+   * @param options - Optional customer details (email, name) for customer creation
    */
-  async ensureCustomer(customerRef) {
+  async ensureCustomer(customerRef, externalRef, options) {
     if (this.customerRefMapping.has(customerRef)) {
       return this.customerRefMapping.get(customerRef);
     }
     if (customerRef === "anonymous") {
       return customerRef;
     }
-    if (this.customerCreationAttempts.has(customerRef)) {
-      return customerRef;
-    }
-    if (!this.apiClient.createCustomer) {
-      console.warn(`\u26A0\uFE0F  Cannot auto-create customer ${customerRef}: createCustomer method not available on API client`);
-      return customerRef;
+    const cacheKey = externalRef || customerRef;
+    if (this.customerRefMapping.has(customerRef)) {
+      const cached = this.customerRefMapping.get(customerRef);
+      this.log(`\u2705 [PER-INSTANCE CACHE HIT] Using cached customer lookup: ${customerRef} -> ${cached}`);
+      return cached;
     }
-    this.customerCreationAttempts.add(customerRef);
-    try {
-      this.log(`\u{1F527} Auto-creating customer: ${customerRef}`);
-      const result = await this.apiClient.createCustomer({
-        email: `${customerRef}@auto-created.local`,
-        name: customerRef
-      });
-      const backendRef = result.customerRef || result.reference || customerRef;
-      this.log(`\u2705 Successfully created customer: ${customerRef} -> ${backendRef}`, result);
-      this.log(`\u{1F50D} DEBUG - ensureCustomer analysis:`);
-      this.log(`   - Input customerRef: ${customerRef}`);
-      this.log(`   - Backend customerRef: ${backendRef}`);
-      this.log(`   - Has plan in response: ${result.plan ? "YES - " + result.plan : "NO"}`);
-      this.log(`   - Has subscription in response: ${result.subscription ? "YES" : "NO"}`);
+    const hadPerInstanceCache = this.customerRefMapping.has(customerRef);
+    const backendRef = await sharedCustomerLookupDeduplicator.deduplicate(
+      cacheKey,
+      async () => {
+        if (externalRef && this.apiClient.getCustomerByExternalRef) {
+          try {
+            this.log(`\u{1F50D} Looking up customer by externalRef: ${externalRef}`);
+            const existingCustomer = await this.apiClient.getCustomerByExternalRef({ externalRef });
+            if (existingCustomer && existingCustomer.customerRef) {
+              const ref = existingCustomer.customerRef;
+              this.log(`\u2705 Found existing customer by externalRef: ${externalRef} -> ${ref}`);
+              this.customerRefMapping.set(customerRef, ref);
+              this.customerCreationAttempts.add(customerRef);
+              if (externalRef !== customerRef) {
+                this.customerCreationAttempts.add(externalRef);
+              }
+              return ref;
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes("404") || errorMessage.includes("not found")) {
+              this.log(`\u{1F50D} Customer not found by externalRef, will create new: ${externalRef}`);
+            } else {
+              this.log(`\u26A0\uFE0F  Error looking up customer by externalRef: ${errorMessage}`);
+            }
+          }
+        }
+        if (this.customerCreationAttempts.has(customerRef) || externalRef && this.customerCreationAttempts.has(externalRef)) {
+          const mappedRef = this.customerRefMapping.get(customerRef);
+          return mappedRef || customerRef;
+        }
+        if (!this.apiClient.createCustomer) {
+          console.warn(`\u26A0\uFE0F  Cannot auto-create customer ${customerRef}: createCustomer method not available on API client`);
+          return customerRef;
+        }
+        this.customerCreationAttempts.add(customerRef);
+        try {
+          this.log(`\u{1F527} Auto-creating customer: ${customerRef}${externalRef ? ` (externalRef: ${externalRef})` : ""}`);
+          const createParams = {
+            email: options?.email || `${customerRef}@auto-created.local`,
+            name: options?.name || customerRef
+          };
+          if (externalRef) {
+            createParams.externalRef = externalRef;
+          }
+          const result = await this.apiClient.createCustomer(createParams);
+          const ref = result.customerRef || result.reference || customerRef;
+          this.log(`\u2705 Successfully created customer: ${customerRef} -> ${ref}`, result);
+          this.log(`\u{1F50D} DEBUG - ensureCustomer analysis:`);
+          this.log(`   - Input customerRef: ${customerRef}`);
+          this.log(`   - ExternalRef: ${externalRef || "none"}`);
+          this.log(`   - Backend customerRef: ${ref}`);
+          this.log(`   - Has plan in response: ${result.plan ? "YES - " + result.plan : "NO"}`);
+          this.log(`   - Has subscription in response: ${result.subscription ? "YES" : "NO"}`);
+          this.customerRefMapping.set(customerRef, ref);
+          return ref;
+        } catch (error) {
+          this.log(`\u274C Failed to auto-create customer ${customerRef}:`, error instanceof Error ? error.message : error);
+          return customerRef;
+        }
+      }
+    );
+    if (backendRef !== customerRef) {
       this.customerRefMapping.set(customerRef, backendRef);
-      return backendRef;
-    } catch (error) {
-      this.log(`\u274C Failed to auto-create customer ${customerRef}:`, error instanceof Error ? error.message : error);
-      return customerRef;
     }
+    return backendRef;
   }
   async trackUsage(customerRef, agentRef, planRef, toolName, outcome, requestId, actionDuration) {
     await withRetry(
@@ -720,11 +928,21 @@ var McpAdapter = class {
 };
 
 // src/factory.ts
-import { SolvaPayError as SolvaPayError2 } from "@solvapay/core";
+import { SolvaPayError as SolvaPayError2, getSolvaPayConfig } from "@solvapay/core";
 function createSolvaPay(config) {
-  const apiClient = config.apiClient || createSolvaPayClient({
-    apiKey: config.apiKey,
-    apiBaseUrl: config.apiBaseUrl
+  let resolvedConfig;
+  if (!config) {
+    const envConfig = getSolvaPayConfig();
+    resolvedConfig = {
+      apiKey: envConfig.apiKey,
+      apiBaseUrl: envConfig.apiBaseUrl
+    };
+  } else {
+    resolvedConfig = config;
+  }
+  const apiClient = resolvedConfig.apiClient || createSolvaPayClient({
+    apiKey: resolvedConfig.apiKey,
+    apiBaseUrl: resolvedConfig.apiBaseUrl
   });
   const paywall = new SolvaPayPaywall(apiClient, {
     debug: process.env.SOLVAPAY_DEBUG !== "false"
@@ -733,8 +951,8 @@ function createSolvaPay(config) {
     // Direct access to API client for advanced operations
     apiClient,
     // Common API methods exposed directly for convenience
-    ensureCustomer(customerRef) {
-      return paywall.ensureCustomer(customerRef);
+    ensureCustomer(customerRef, externalRef, options) {
+      return paywall.ensureCustomer(customerRef, externalRef, options);
     },
     createPaymentIntent(params) {
       if (!apiClient.createPaymentIntent) {
@@ -742,6 +960,12 @@ function createSolvaPay(config) {
       }
       return apiClient.createPaymentIntent(params);
     },
+    processPayment(params) {
+      if (!apiClient.processPayment) {
+        throw new SolvaPayError2("processPayment is not available on this API client");
+      }
+      return apiClient.processPayment(params);
+    },
     checkLimits(params) {
       return apiClient.checkLimits(params);
     },