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

package/dist/index.js

@@ -1,39 +1,41 @@
 // src/index.ts
-import { NextResponse } from "next/server";
+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 { 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) {
@@ -103,10 +105,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,
@@ -116,89 +118,315 @@ 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
+import { NextResponse } from "next/server";
+import {
+  getAuthenticatedUserCore,
+  isErrorResult
+} from "@solvapay/server";
+async function getAuthenticatedUser(request, options = {}) {
+  const result = await getAuthenticatedUserCore(request, options);
+  if (isErrorResult(result)) {
+    return NextResponse.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
 }
-async function checkSubscription(request, options = {}) {
+
+// src/helpers/customer.ts
+import { NextResponse as NextResponse2 } from "next/server";
+import { syncCustomerCore, isErrorResult as isErrorResult2 } from "@solvapay/server";
+async function syncCustomer(request, options = {}) {
+  const result = await syncCustomerCore(request, options);
+  if (isErrorResult2(result)) {
+    return NextResponse2.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/payment.ts
+import { NextResponse as NextResponse3 } from "next/server";
+import {
+  createPaymentIntentCore,
+  processPaymentIntentCore,
+  isErrorResult as isErrorResult3
+} from "@solvapay/server";
+import { getAuthenticatedUserCore as getAuthenticatedUserCore2 } from "@solvapay/server";
+async function createPaymentIntent(request, body, options = {}) {
+  const result = await createPaymentIntentCore(request, body, options);
+  if (isErrorResult3(result)) {
+    return NextResponse3.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await getAuthenticatedUserCore2(request);
+    if (!isErrorResult3(userResult)) {
+      clearPurchaseCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+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 },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await getAuthenticatedUserCore2(request);
+    if (!isErrorResult3(userResult)) {
+      clearPurchaseCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/helpers/checkout.ts
+import { NextResponse as NextResponse4 } from "next/server";
+import {
+  createCheckoutSessionCore,
+  createCustomerSessionCore,
+  isErrorResult as isErrorResult4
+} from "@solvapay/server";
+async function createCheckoutSession(request, body, options = {}) {
+  const result = await createCheckoutSessionCore(request, body, options);
+  if (isErrorResult4(result)) {
+    return NextResponse4.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+async function createCustomerSession(request, options = {}) {
+  const result = await createCustomerSessionCore(request, options);
+  if (isErrorResult4(result)) {
+    return NextResponse4.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/renewal.ts
+import { NextResponse as NextResponse5 } from "next/server";
+import { cancelPurchaseCore, isErrorResult as isErrorResult5 } from "@solvapay/server";
+import { getAuthenticatedUserCore as getAuthenticatedUserCore3 } from "@solvapay/server";
+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 },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await getAuthenticatedUserCore3(request);
+    if (!isErrorResult5(userResult)) {
+      clearPurchaseCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/helpers/plans.ts
+import { NextResponse as NextResponse6 } from "next/server";
+import { listPlansCore, isErrorResult as isErrorResult6 } from "@solvapay/server";
+async function listPlans(request) {
+  const result = await listPlansCore(request);
+  if (isErrorResult6(result)) {
+    return NextResponse6.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  return result;
+}
+
+// src/helpers/middleware.ts
+import { NextResponse as NextResponse7 } from "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 NextResponse7.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 NextResponse7.next({
+        request: {
+          headers: requestHeaders2
+        }
+      });
+    }
+    if (!userId) {
+      return NextResponse7.json(
+        { error: "Unauthorized", details: "Valid authentication required" },
+        { status: 401 }
+      );
+    }
+    const requestHeaders = new Headers(req.headers);
+    requestHeaders.set(userIdHeader, userId);
+    return NextResponse7.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
+  });
+}
+
+// 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 NextResponse.json(body, { status: userIdOrError.status });
+      return NextResponse8.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 || 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 || 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 SolvaPayError) {
-      return NextResponse.json(
-        { error: error.message },
-        { status: 500 }
-      );
+      return NextResponse8.json({ error: error.message }, { status: 500 });
     }
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    return NextResponse.json(
-      { error: "Failed to check subscription", details: errorMessage },
+    return NextResponse8.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();
-}
 export {
-  checkSubscription,
-  clearAllSubscriptionCache,
-  clearSubscriptionCache,
-  getSubscriptionCacheStats
+  cancelRenewal,
+  checkPurchase,
+  clearAllPurchaseCache,
+  clearPurchaseCache,
+  createAuthMiddleware,
+  createCheckoutSession,
+  createCustomerSession,
+  createPaymentIntent,
+  createSupabaseAuthMiddleware,
+  getAuthenticatedUser,
+  getPurchaseCacheStats,
+  listPlans,
+  processPaymentIntent,
+  syncCustomer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solvapay/next",
-  "version": "1.0.0-preview.9",
+  "version": "1.0.1-preview.1",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -29,24 +29,25 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@solvapay/auth": "1.0.0-preview.9",
-    "@solvapay/core": "1.0.0-preview.9",
-    "@solvapay/server": "1.0.0-preview.9"
+    "@solvapay/server": "1.0.1-preview.1",
+    "@solvapay/auth": "1.0.1-preview.1",
+    "@solvapay/core": "1.0.1-preview.1"
   },
   "peerDependencies": {
     "next": ">=13.0.0"
   },
   "devDependencies": {
-    "next": "^14.0.0",
-    "tsup": "^8.0.1",
-    "typescript": "^5.5.4",
-    "vitest": "^2.0.5",
+    "next": "^16.2.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2",
     "@solvapay/test-utils": "0.0.0"
   },
   "scripts": {
     "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"
   }
 }