@solvapay/next 1.0.0-preview.18 → 1.0.0-preview.20

package/dist/index.js

@@ -3,6 +3,136 @@ import { NextResponse as NextResponse8 } from "next/server";
 import { createSolvaPay } from "@solvapay/server";
 import { SolvaPayError } from "@solvapay/core";
 
+// src/cache.ts
+function createRequestDeduplicator(options = {}) {
+  const { cacheTTL = 2e3, maxCacheSize = 1e3, cacheErrors = true } = options;
+  const inFlightRequests = /* @__PURE__ */ new Map();
+  const resultCache = /* @__PURE__ */ new Map();
+  const cacheInvalidatedAt = /* @__PURE__ */ new Map();
+  if (cacheTTL > 0) {
+    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);
+          cacheInvalidatedAt.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);
+            cacheInvalidatedAt.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) {
+      const requestStartTime = Date.now();
+      requestPromise = (async () => {
+        try {
+          const result = await fn();
+          const invalidatedAt = cacheInvalidatedAt.get(key);
+          const shouldCache = !invalidatedAt || invalidatedAt < requestStartTime;
+          if (cacheTTL > 0 && shouldCache) {
+            resultCache.set(key, {
+              data: result,
+              timestamp: Date.now()
+            });
+          }
+          return result;
+        } catch (error) {
+          const invalidatedAt = cacheInvalidatedAt.get(key);
+          const shouldCache = !invalidatedAt || invalidatedAt < requestStartTime;
+          if (cacheTTL > 0 && cacheErrors && shouldCache) {
+            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);
+    cacheInvalidatedAt.set(key, Date.now());
+    inFlightRequests.delete(key);
+  };
+  const clearAllCache = () => {
+    resultCache.clear();
+    cacheInvalidatedAt.clear();
+    inFlightRequests.clear();
+  };
+  const getStats = () => ({
+    inFlight: inFlightRequests.size,
+    cached: resultCache.size
+  });
+  return {
+    deduplicate,
+    clearCache,
+    clearAllCache,
+    getStats
+  };
+}
+var sharedPurchaseDeduplicator = null;
+function getSharedDeduplicator(options) {
+  if (!sharedPurchaseDeduplicator) {
+    sharedPurchaseDeduplicator = createRequestDeduplicator({
+      cacheTTL: 2e3,
+      // Cache results for 2 seconds
+      maxCacheSize: 1e3,
+      // Maximum cache entries
+      cacheErrors: true,
+      // Cache error results too
+      ...options
+    });
+  }
+  return sharedPurchaseDeduplicator;
+}
+function clearPurchaseCache(userId) {
+  const deduplicator = getSharedDeduplicator();
+  deduplicator.clearCache(userId);
+}
+function clearAllPurchaseCache() {
+  const deduplicator = getSharedDeduplicator();
+  deduplicator.clearAllCache();
+}
+function getPurchaseCacheStats() {
+  const deduplicator = getSharedDeduplicator();
+  return deduplicator.getStats();
+}
+
 // src/helpers/auth.ts
 import { NextResponse } from "next/server";
 import {
@@ -22,10 +152,7 @@ async function getAuthenticatedUser(request, options = {}) {
 
 // src/helpers/customer.ts
 import { NextResponse as NextResponse2 } from "next/server";
-import {
-  syncCustomerCore,
-  isErrorResult as isErrorResult2
-} from "@solvapay/server";
+import { syncCustomerCore, isErrorResult as isErrorResult2 } from "@solvapay/server";
 async function syncCustomer(request, options = {}) {
   const result = await syncCustomerCore(request, options);
   if (isErrorResult2(result)) {
@@ -41,7 +168,7 @@ async function syncCustomer(request, options = {}) {
 import { NextResponse as NextResponse3 } from "next/server";
 import {
   createPaymentIntentCore,
-  processPaymentCore,
+  processPaymentIntentCore,
   isErrorResult as isErrorResult3
 } from "@solvapay/server";
 import { getAuthenticatedUserCore as getAuthenticatedUserCore2 } from "@solvapay/server";
@@ -56,14 +183,14 @@ async function createPaymentIntent(request, body, options = {}) {
   try {
     const userResult = await getAuthenticatedUserCore2(request);
     if (!isErrorResult3(userResult)) {
-      clearSubscriptionCache(userResult.userId);
+      clearPurchaseCache(userResult.userId);
     }
   } catch {
   }
   return result;
 }
-async function processPayment(request, body, options = {}) {
-  const result = await processPaymentCore(request, body, options);
+async function processPaymentIntent(request, body, options = {}) {
+  const result = await processPaymentIntentCore(request, body, options);
   if (isErrorResult3(result)) {
     return NextResponse3.json(
       { error: result.error, details: result.details },
@@ -73,7 +200,7 @@ async function processPayment(request, body, options = {}) {
   try {
     const userResult = await getAuthenticatedUserCore2(request);
     if (!isErrorResult3(userResult)) {
-      clearSubscriptionCache(userResult.userId);
+      clearPurchaseCache(userResult.userId);
     }
   } catch {
   }
@@ -108,15 +235,12 @@ async function createCustomerSession(request, options = {}) {
   return result;
 }
 
-// src/helpers/subscription.ts
+// src/helpers/renewal.ts
 import { NextResponse as NextResponse5 } from "next/server";
-import {
-  cancelSubscriptionCore,
-  isErrorResult as isErrorResult5
-} from "@solvapay/server";
+import { cancelPurchaseCore, isErrorResult as isErrorResult5 } from "@solvapay/server";
 import { getAuthenticatedUserCore as getAuthenticatedUserCore3 } from "@solvapay/server";
-async function cancelSubscription(request, body, options = {}) {
-  const result = await cancelSubscriptionCore(request, body, options);
+async function cancelRenewal(request, body, options = {}) {
+  const result = await cancelPurchaseCore(request, body, options);
   if (isErrorResult5(result)) {
     return NextResponse5.json(
       { error: result.error, details: result.details },
@@ -126,7 +250,7 @@ async function cancelSubscription(request, body, options = {}) {
   try {
     const userResult = await getAuthenticatedUserCore3(request);
     if (!isErrorResult5(userResult)) {
-      clearSubscriptionCache(userResult.userId);
+      clearPurchaseCache(userResult.userId);
     }
   } catch {
   }
@@ -135,10 +259,7 @@ async function cancelSubscription(request, body, options = {}) {
 
 // src/helpers/plans.ts
 import { NextResponse as NextResponse6 } from "next/server";
-import {
-  listPlansCore,
-  isErrorResult as isErrorResult6
-} from "@solvapay/server";
+import { listPlansCore, isErrorResult as isErrorResult6 } from "@solvapay/server";
 async function listPlans(request) {
   const result = await listPlansCore(request);
   if (isErrorResult6(result)) {
@@ -153,20 +274,17 @@ async function listPlans(request) {
 // src/helpers/middleware.ts
 import { NextResponse as NextResponse7 } from "next/server";
 function createAuthMiddleware(options) {
-  const {
-    adapter,
-    publicRoutes = [],
-    userIdHeader = "x-user-id"
-  } = options;
+  const { adapter, publicRoutes = [], userIdHeader = "x-user-id" } = options;
   return async function middleware(request) {
-    const { pathname } = request.nextUrl;
+    const req = request;
+    const { pathname } = req.nextUrl;
     if (!pathname.startsWith("/api")) {
       return NextResponse7.next();
     }
     const isPublicRoute = publicRoutes.some((route) => pathname.startsWith(route));
-    const userId = await adapter.getUserIdFromRequest(request);
+    const userId = await adapter.getUserIdFromRequest(req);
     if (isPublicRoute) {
-      const requestHeaders2 = new Headers(request.headers);
+      const requestHeaders2 = new Headers(req.headers);
       if (userId) {
         requestHeaders2.set(userIdHeader, userId);
       }
@@ -182,7 +300,7 @@ function createAuthMiddleware(options) {
         { status: 401 }
       );
     }
-    const requestHeaders = new Headers(request.headers);
+    const requestHeaders = new Headers(req.headers);
     requestHeaders.set(userIdHeader, userId);
     return NextResponse7.next({
       request: {
@@ -192,11 +310,7 @@ function createAuthMiddleware(options) {
   };
 }
 function createSupabaseAuthMiddleware(options = {}) {
-  const {
-    jwtSecret,
-    publicRoutes = [],
-    userIdHeader = "x-user-id"
-  } = options;
+  const { jwtSecret, publicRoutes = [], userIdHeader = "x-user-id" } = options;
   let authAdapter = null;
   let adapterPromise = null;
   const lazyAdapter = {
@@ -228,123 +342,7 @@ function createSupabaseAuthMiddleware(options = {}) {
 }
 
 // src/index.ts
-function createRequestDeduplicator(options = {}) {
-  const {
-    cacheTTL = 2e3,
-    maxCacheSize = 1e3,
-    cacheErrors = true
-  } = options;
-  const inFlightRequests = /* @__PURE__ */ new Map();
-  const resultCache = /* @__PURE__ */ new Map();
-  const cacheInvalidatedAt = /* @__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);
-        cacheInvalidatedAt.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);
-          cacheInvalidatedAt.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) {
-      const requestStartTime = Date.now();
-      requestPromise = (async () => {
-        try {
-          const result = await fn();
-          const invalidatedAt = cacheInvalidatedAt.get(key);
-          const shouldCache = !invalidatedAt || invalidatedAt < requestStartTime;
-          if (cacheTTL > 0 && shouldCache) {
-            resultCache.set(key, {
-              data: result,
-              timestamp: Date.now()
-            });
-          }
-          return result;
-        } catch (error) {
-          const invalidatedAt = cacheInvalidatedAt.get(key);
-          const shouldCache = !invalidatedAt || invalidatedAt < requestStartTime;
-          if (cacheTTL > 0 && cacheErrors && shouldCache) {
-            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);
-    cacheInvalidatedAt.set(key, Date.now());
-    inFlightRequests.delete(key);
-  };
-  const clearAllCache = () => {
-    resultCache.clear();
-    cacheInvalidatedAt.clear();
-    inFlightRequests.clear();
-  };
-  const getStats = () => ({
-    inFlight: inFlightRequests.size,
-    cached: resultCache.size
-  });
-  return {
-    deduplicate,
-    clearCache,
-    clearAllCache,
-    getStats
-  };
-}
-var sharedSubscriptionDeduplicator = null;
-function getSharedDeduplicator(options) {
-  if (!sharedSubscriptionDeduplicator) {
-    sharedSubscriptionDeduplicator = createRequestDeduplicator({
-      cacheTTL: 2e3,
-      // Cache results for 2 seconds
-      maxCacheSize: 1e3,
-      // Maximum cache entries
-      cacheErrors: true,
-      // Cache error results too
-      ...options
-    });
-  }
-  return sharedSubscriptionDeduplicator;
-}
-async function checkSubscription(request, options = {}) {
+async function checkPurchase(request, options = {}) {
   try {
     const { requireUserId, getUserEmailFromRequest, getUserNameFromRequest } = await import("@solvapay/auth");
     const userIdOrError = requireUserId(request);
@@ -363,18 +361,18 @@ async function checkSubscription(request, options = {}) {
         const customer = await solvaPay.getCustomer({ customerRef: cachedCustomerRef });
         if (customer && customer.customerRef) {
           if (customer.externalRef && customer.externalRef === userId) {
-            const filteredSubscriptions = (customer.subscriptions || []).filter(
-              (sub) => sub.status === "active"
+            const filteredPurchases = (customer.purchases || []).filter(
+              (p) => p.status === "active"
             );
             return {
               customerRef: customer.customerRef,
               email: customer.email,
               name: customer.name,
-              subscriptions: filteredSubscriptions
+              purchases: filteredPurchases
             };
           }
         }
-      } catch (error) {
+      } catch {
       }
     }
     const deduplicator = getSharedDeduplicator(options.deduplication);
@@ -385,65 +383,50 @@ async function checkSubscription(request, options = {}) {
           name: name || void 0
         });
         const customer = await solvaPay.getCustomer({ customerRef: ensuredCustomerRef });
-        const filteredSubscriptions = (customer.subscriptions || []).filter(
-          (sub) => sub.status === "active"
+        const filteredPurchases = (customer.purchases || []).filter(
+          (p) => p.status === "active"
         );
         const result = {
           customerRef: customer.customerRef || userId,
           email: customer.email,
           name: customer.name,
-          subscriptions: filteredSubscriptions
+          purchases: filteredPurchases
         };
         return result;
       } catch (error) {
-        console.error("[checkSubscription] Error fetching customer:", error);
+        console.error("[checkPurchase] Error fetching customer:", error);
         return {
           customerRef: userId,
-          subscriptions: []
+          purchases: []
         };
       }
     });
     return response;
   } catch (error) {
-    console.error("Check subscription failed:", error);
+    console.error("Check purchase failed:", error);
     if (error instanceof SolvaPayError) {
-      return NextResponse8.json(
-        { error: error.message },
-        { status: 500 }
-      );
+      return NextResponse8.json({ error: error.message }, { status: 500 });
     }
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     return NextResponse8.json(
-      { error: "Failed to check subscription", details: errorMessage },
+      { error: "Failed to check purchase", details: errorMessage },
       { status: 500 }
     );
   }
 }
-function clearSubscriptionCache(userId) {
-  const deduplicator = getSharedDeduplicator();
-  deduplicator.clearCache(userId);
-}
-function clearAllSubscriptionCache() {
-  const deduplicator = getSharedDeduplicator();
-  deduplicator.clearAllCache();
-}
-function getSubscriptionCacheStats() {
-  const deduplicator = getSharedDeduplicator();
-  return deduplicator.getStats();
-}
 export {
-  cancelSubscription,
-  checkSubscription,
-  clearAllSubscriptionCache,
-  clearSubscriptionCache,
+  cancelRenewal,
+  checkPurchase,
+  clearAllPurchaseCache,
+  clearPurchaseCache,
   createAuthMiddleware,
   createCheckoutSession,
   createCustomerSession,
   createPaymentIntent,
   createSupabaseAuthMiddleware,
   getAuthenticatedUser,
-  getSubscriptionCacheStats,
+  getPurchaseCacheStats,
   listPlans,
-  processPayment,
+  processPaymentIntent,
   syncCustomer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solvapay/next",
-  "version": "1.0.0-preview.18",
+  "version": "1.0.0-preview.20",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -29,15 +29,15 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@solvapay/auth": "1.0.0-preview.18",
-    "@solvapay/server": "1.0.0-preview.18",
-    "@solvapay/core": "1.0.0-preview.18"
+    "@solvapay/auth": "1.0.0-preview.20",
+    "@solvapay/core": "1.0.0-preview.20",
+    "@solvapay/server": "1.0.0-preview.20"
   },
   "peerDependencies": {
     "next": ">=13.0.0"
   },
   "devDependencies": {
-    "next": "^14.0.0",
+    "next": "^15.5.7",
     "tsup": "^8.0.1",
     "typescript": "^5.5.4",
     "vitest": "^2.0.5",
@@ -47,6 +47,7 @@
     "build": "tsup src/index.ts --format esm,cjs --dts --tsconfig tsconfig.build.json --external next",
     "test": "vitest run || exit 0",
     "test:watch": "vitest",
-    "lint": "echo 'no lint yet'"
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix"
   }
 }