@solvapay/next 1.0.0-preview.9 → 1.0.1-preview.1

package/dist/index.cjs

@@ -30,47 +30,59 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  checkSubscription: () => checkSubscription,
-  clearAllSubscriptionCache: () => clearAllSubscriptionCache,
-  clearSubscriptionCache: () => clearSubscriptionCache,
-  getSubscriptionCacheStats: () => getSubscriptionCacheStats
+  cancelRenewal: () => cancelRenewal,
+  checkPurchase: () => checkPurchase,
+  clearAllPurchaseCache: () => clearAllPurchaseCache,
+  clearPurchaseCache: () => clearPurchaseCache,
+  createAuthMiddleware: () => createAuthMiddleware,
+  createCheckoutSession: () => createCheckoutSession,
+  createCustomerSession: () => createCustomerSession,
+  createPaymentIntent: () => createPaymentIntent,
+  createSupabaseAuthMiddleware: () => createSupabaseAuthMiddleware,
+  getAuthenticatedUser: () => getAuthenticatedUser,
+  getPurchaseCacheStats: () => getPurchaseCacheStats,
+  listPlans: () => listPlans,
+  processPaymentIntent: () => processPaymentIntent,
+  syncCustomer: () => syncCustomer
 });
 module.exports = __toCommonJS(index_exports);
-var import_server = require("next/server");
-var import_server2 = require("@solvapay/server");
+var import_server16 = require("next/server");
+var import_server17 = require("@solvapay/server");
 var import_core = require("@solvapay/core");
+
+// src/cache.ts
 function createRequestDeduplicator(options = {}) {
-  const {
-    cacheTTL = 2e3,
-    maxCacheSize = 1e3,
-    cacheErrors = true
-  } = 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);
+    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) {
+        for (const key of entriesToDelete) {
           resultCache.delete(key);
           cacheInvalidatedAt.delete(key);
         }
-      }
-    }, Math.min(cacheTTL, 1e3));
+        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) {
@@ -140,10 +152,10 @@ function createRequestDeduplicator(options = {}) {
     getStats
   };
 }
-var sharedSubscriptionDeduplicator = null;
+var sharedPurchaseDeduplicator = null;
 function getSharedDeduplicator(options) {
-  if (!sharedSubscriptionDeduplicator) {
-    sharedSubscriptionDeduplicator = createRequestDeduplicator({
+  if (!sharedPurchaseDeduplicator) {
+    sharedPurchaseDeduplicator = createRequestDeduplicator({
       cacheTTL: 2e3,
       // Cache results for 2 seconds
       maxCacheSize: 1e3,
@@ -153,90 +165,305 @@ function getSharedDeduplicator(options) {
       ...options
     });
   }
-  return sharedSubscriptionDeduplicator;
+  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
+var import_server = require("next/server");
+var import_server2 = require("@solvapay/server");
+async function getAuthenticatedUser(request, options = {}) {
+  const result = await (0, import_server2.getAuthenticatedUserCore)(request, options);
+  if ((0, import_server2.isErrorResult)(result)) {
+    return import_server.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/customer.ts
+var import_server3 = require("next/server");
+var import_server4 = require("@solvapay/server");
+async function syncCustomer(request, options = {}) {
+  const result = await (0, import_server4.syncCustomerCore)(request, options);
+  if ((0, import_server4.isErrorResult)(result)) {
+    return import_server3.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/payment.ts
+var import_server5 = require("next/server");
+var import_server6 = require("@solvapay/server");
+var import_server7 = require("@solvapay/server");
+async function createPaymentIntent(request, body, options = {}) {
+  const result = await (0, import_server6.createPaymentIntentCore)(request, body, options);
+  if ((0, import_server6.isErrorResult)(result)) {
+    return import_server5.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await (0, import_server7.getAuthenticatedUserCore)(request);
+    if (!(0, import_server6.isErrorResult)(userResult)) {
+      clearPurchaseCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+async function processPaymentIntent(request, body, options = {}) {
+  const result = await (0, import_server6.processPaymentIntentCore)(request, body, options);
+  if ((0, import_server6.isErrorResult)(result)) {
+    return import_server5.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await (0, import_server7.getAuthenticatedUserCore)(request);
+    if (!(0, import_server6.isErrorResult)(userResult)) {
+      clearPurchaseCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/helpers/checkout.ts
+var import_server8 = require("next/server");
+var import_server9 = require("@solvapay/server");
+async function createCheckoutSession(request, body, options = {}) {
+  const result = await (0, import_server9.createCheckoutSessionCore)(request, body, options);
+  if ((0, import_server9.isErrorResult)(result)) {
+    return import_server8.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+async function createCustomerSession(request, options = {}) {
+  const result = await (0, import_server9.createCustomerSessionCore)(request, options);
+  if ((0, import_server9.isErrorResult)(result)) {
+    return import_server8.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/renewal.ts
+var import_server10 = require("next/server");
+var import_server11 = require("@solvapay/server");
+var import_server12 = require("@solvapay/server");
+async function cancelRenewal(request, body, options = {}) {
+  const result = await (0, import_server11.cancelPurchaseCore)(request, body, options);
+  if ((0, import_server11.isErrorResult)(result)) {
+    return import_server10.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await (0, import_server12.getAuthenticatedUserCore)(request);
+    if (!(0, import_server11.isErrorResult)(userResult)) {
+      clearPurchaseCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/helpers/plans.ts
+var import_server13 = require("next/server");
+var import_server14 = require("@solvapay/server");
+async function listPlans(request) {
+  const result = await (0, import_server14.listPlansCore)(request);
+  if ((0, import_server14.isErrorResult)(result)) {
+    return import_server13.NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/middleware.ts
+var import_server15 = require("next/server");
+function createAuthMiddleware(options) {
+  const { adapter, publicRoutes = [], userIdHeader = "x-user-id" } = options;
+  return async function middleware(request) {
+    const req = request;
+    const { pathname } = req.nextUrl;
+    if (!pathname.startsWith("/api")) {
+      return import_server15.NextResponse.next();
+    }
+    const isPublicRoute = publicRoutes.some((route) => pathname.startsWith(route));
+    const userId = await adapter.getUserIdFromRequest(req);
+    if (isPublicRoute) {
+      const requestHeaders2 = new Headers(req.headers);
+      if (userId) {
+        requestHeaders2.set(userIdHeader, userId);
+      }
+      return import_server15.NextResponse.next({
+        request: {
+          headers: requestHeaders2
+        }
+      });
+    }
+    if (!userId) {
+      return import_server15.NextResponse.json(
+        { error: "Unauthorized", details: "Valid authentication required" },
+        { status: 401 }
+      );
+    }
+    const requestHeaders = new Headers(req.headers);
+    requestHeaders.set(userIdHeader, userId);
+    return import_server15.NextResponse.next({
+      request: {
+        headers: requestHeaders
+      }
+    });
+  };
+}
+function createSupabaseAuthMiddleware(options = {}) {
+  const { jwtSecret, publicRoutes = [], userIdHeader = "x-user-id" } = options;
+  let authAdapter = null;
+  let adapterPromise = null;
+  const lazyAdapter = {
+    async getUserIdFromRequest(req) {
+      if (!authAdapter) {
+        if (!adapterPromise) {
+          adapterPromise = (async () => {
+            const secret = jwtSecret || process.env.SUPABASE_JWT_SECRET;
+            if (!secret) {
+              throw new Error(
+                "SUPABASE_JWT_SECRET environment variable is required. Please set it in your .env.local file. Get it from: Supabase Dashboard \u2192 Settings \u2192 API \u2192 JWT Secret"
+              );
+            }
+            const { SupabaseAuthAdapter } = await import("@solvapay/auth/supabase");
+            authAdapter = new SupabaseAuthAdapter({ jwtSecret: secret });
+            return authAdapter;
+          })();
+        }
+        authAdapter = await adapterPromise;
+      }
+      return authAdapter.getUserIdFromRequest(req);
+    }
+  };
+  return createAuthMiddleware({
+    adapter: lazyAdapter,
+    publicRoutes,
+    userIdHeader
+  });
 }
-async function checkSubscription(request, options = {}) {
+
+// src/index.ts
+async function checkPurchase(request, options = {}) {
   try {
     const { requireUserId, getUserEmailFromRequest, getUserNameFromRequest } = await import("@solvapay/auth");
     const userIdOrError = requireUserId(request);
     if (userIdOrError instanceof Response) {
       const clonedResponse = userIdOrError.clone();
       const body = await clonedResponse.json().catch(() => ({ error: "Unauthorized" }));
-      return import_server.NextResponse.json(body, { status: userIdOrError.status });
+      return import_server16.NextResponse.json(body, { status: userIdOrError.status });
     }
     const userId = userIdOrError;
     const email = options.includeEmail !== false ? await getUserEmailFromRequest(request) : null;
     const name = options.includeName !== false ? await getUserNameFromRequest(request) : null;
+    const cachedCustomerRef = request.headers.get("x-solvapay-customer-ref");
+    const solvaPay = options.solvaPay || (0, import_server17.createSolvaPay)();
+    if (cachedCustomerRef) {
+      try {
+        const customer = await solvaPay.getCustomer({ customerRef: cachedCustomerRef });
+        if (customer && customer.customerRef) {
+          if (customer.externalRef && customer.externalRef === userId) {
+            const filteredPurchases = (customer.purchases || []).filter(
+              (p) => p.status === "active"
+            );
+            return {
+              customerRef: customer.customerRef,
+              email: customer.email,
+              name: customer.name,
+              purchases: filteredPurchases
+            };
+          }
+        }
+      } catch {
+      }
+    }
     const deduplicator = getSharedDeduplicator(options.deduplication);
     const response = await deduplicator.deduplicate(userId, async () => {
       try {
-        const solvaPay = options.solvaPay || (0, import_server2.createSolvaPay)();
         const ensuredCustomerRef = await solvaPay.ensureCustomer(userId, userId, {
           email: email || void 0,
           name: name || void 0
         });
         const customer = await solvaPay.getCustomer({ customerRef: ensuredCustomerRef });
-        const now = /* @__PURE__ */ new Date();
-        const filteredSubscriptions = (customer.subscriptions || []).filter((sub) => {
-          const subAny = sub;
-          const isCancelled = sub.status === "cancelled" || subAny.cancelledAt;
-          if (!isCancelled) {
-            return true;
-          }
-          if (isCancelled && subAny.endDate) {
-            const endDate = new Date(subAny.endDate);
-            const isFuture = endDate > now;
-            return isFuture;
-          }
-          return false;
-        });
+        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 import_core.SolvaPayError) {
-      return import_server.NextResponse.json(
-        { error: error.message },
-        { status: 500 }
-      );
+      return import_server16.NextResponse.json({ error: error.message }, { status: 500 });
     }
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    return import_server.NextResponse.json(
-      { error: "Failed to check subscription", details: errorMessage },
+    return import_server16.NextResponse.json(
+      { 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();
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  checkSubscription,
-  clearAllSubscriptionCache,
-  clearSubscriptionCache,
-  getSubscriptionCacheStats
+  cancelRenewal,
+  checkPurchase,
+  clearAllPurchaseCache,
+  clearPurchaseCache,
+  createAuthMiddleware,
+  createCheckoutSession,
+  createCustomerSession,
+  createPaymentIntent,
+  createSupabaseAuthMiddleware,
+  getAuthenticatedUser,
+  getPurchaseCacheStats,
+  listPlans,
+  processPaymentIntent,
+  syncCustomer
 });