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

package/dist/index.js

@@ -1,39 +1,46 @@
+import {
+  createAuthMiddleware,
+  createSupabaseAuthMiddleware
+} from "./chunk-F7TBIH6W.js";
+
 // src/index.ts
-import { NextResponse } from "next/server";
+import { NextResponse as NextResponse7 } 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 +110,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 +123,245 @@ 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;
+}
+
+// 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;
 }
-async function checkSubscription(request, options = {}) {
+
+// 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/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 NextResponse7.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 NextResponse7.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 NextResponse7.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/dist/middleware.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  createAuthMiddleware: () => createAuthMiddleware,
+  createSupabaseAuthMiddleware: () => createSupabaseAuthMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+
+// src/helpers/middleware.ts
+var import_server = 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_server.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_server.NextResponse.next({
+        request: {
+          headers: requestHeaders2
+        }
+      });
+    }
+    if (!userId) {
+      return import_server.NextResponse.json(
+        { error: "Unauthorized", details: "Valid authentication required" },
+        { status: 401 }
+      );
+    }
+    const requestHeaders = new Headers(req.headers);
+    requestHeaders.set(userIdHeader, userId);
+    return import_server.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
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAuthMiddleware,
+  createSupabaseAuthMiddleware
+});

package/dist/middleware.d.cts

@@ -0,0 +1,178 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { AuthAdapter } from '@solvapay/auth';
+
+/**
+ * Next.js Middleware Helpers
+ *
+ * Helpers for creating authentication middleware in Next.js.
+ * Works with any AuthAdapter implementation (Supabase, custom, etc.)
+ */
+
+/**
+ * Configuration options for authentication middleware
+ */
+interface AuthMiddlewareOptions {
+    /**
+     * Auth adapter instance to use for extracting user IDs from requests
+     * You can use SupabaseAuthAdapter, MockAuthAdapter, or create your own
+     */
+    adapter: AuthAdapter;
+    /**
+     * Public routes that don't require authentication
+     * Routes are matched using pathname.startsWith()
+     */
+    publicRoutes?: string[];
+    /**
+     * Header name to store the user ID (default: 'x-user-id')
+     */
+    userIdHeader?: string;
+}
+/**
+ * Creates a Next.js middleware function for authentication
+ *
+ * This helper:
+ * 1. Uses the provided AuthAdapter to extract userId from requests
+ * 2. Handles public vs protected routes
+ * 3. Adds userId to request headers for downstream routes
+ * 4. Returns appropriate error responses for auth failures
+ *
+ * @param options - Configuration options
+ * @returns Next.js middleware function (can be exported as `middleware` or `proxy`)
+ *
+ * @example Next.js 15
+ * ```typescript
+ * // middleware.ts (at project root)
+ * import { createAuthMiddleware } from '@solvapay/next';
+ * import { SupabaseAuthAdapter } from '@solvapay/auth/supabase';
+ *
+ * const adapter = new SupabaseAuthAdapter({
+ *   jwtSecret: process.env.SUPABASE_JWT_SECRET!,
+ * });
+ *
+ * export const middleware = createAuthMiddleware({
+ *   adapter,
+ *   publicRoutes: ['/api/list-plans'],
+ * });
+ *
+ * export const config = {
+ *   matcher: ['/api/:path*'],
+ * };
+ * ```
+ *
+ * @example Next.js 16 with src/ folder
+ * ```typescript
+ * // src/proxy.ts (in src/ folder, not project root)
+ * import { createAuthMiddleware } from '@solvapay/next';
+ * import { SupabaseAuthAdapter } from '@solvapay/auth/supabase';
+ *
+ * const adapter = new SupabaseAuthAdapter({
+ *   jwtSecret: process.env.SUPABASE_JWT_SECRET!,
+ * });
+ *
+ * // Use 'proxy' export for Next.js 16 (no deprecation warning)
+ * export const proxy = createAuthMiddleware({
+ *   adapter,
+ *   publicRoutes: ['/api/list-plans'],
+ * });
+ *
+ * export const config = {
+ *   matcher: ['/api/:path*'],
+ * };
+ * ```
+ *
+ * @example Custom adapter
+ * ```typescript
+ * import { createAuthMiddleware } from '@solvapay/next';
+ * import type { AuthAdapter } from '@solvapay/auth';
+ *
+ * const myAdapter: AuthAdapter = {
+ *   async getUserIdFromRequest(req) {
+ *     // Your custom auth logic
+ *     return userId;
+ *   },
+ * };
+ *
+ * export const middleware = createAuthMiddleware({
+ *   adapter: myAdapter,
+ * });
+ * ```
+ *
+ * **File Location Notes:**
+ * - **Next.js 15**: Place `middleware.ts` at project root
+ * - **Next.js 16 without `src/` folder**: Place `middleware.ts` or `proxy.ts` at project root
+ * - **Next.js 16 with `src/` folder**: Place `src/proxy.ts` or `src/middleware.ts` (in `src/` folder, not root)
+ *
+ * **Note:** Next.js 16 renamed "middleware" to "proxy". You can export the return value as either
+ * `middleware` or `proxy` - both work, but `proxy` is recommended to avoid deprecation warnings.
+ */
+declare function createAuthMiddleware(options: AuthMiddlewareOptions): (request: NextRequest) => Promise<NextResponse<unknown>>;
+/**
+ * Configuration options for Supabase authentication middleware
+ */
+interface SupabaseAuthMiddlewareOptions {
+    /**
+     * Supabase JWT secret (from Supabase dashboard: Settings → API → JWT Secret)
+     * If not provided, will use SUPABASE_JWT_SECRET environment variable
+     */
+    jwtSecret?: string;
+    /**
+     * Public routes that don't require authentication
+     * Routes are matched using pathname.startsWith()
+     */
+    publicRoutes?: string[];
+    /**
+     * Header name to store the user ID (default: 'x-user-id')
+     */
+    userIdHeader?: string;
+}
+/**
+ * Creates a Next.js middleware function for Supabase authentication
+ *
+ * Convenience function that creates a SupabaseAuthAdapter and wraps it with createAuthMiddleware.
+ * Only use this if you're using Supabase - otherwise use createAuthMiddleware with your own adapter.
+ *
+ * Uses dynamic import to avoid requiring Supabase as a dependency in @solvapay/next.
+ *
+ * @param options - Configuration options
+ * @returns Next.js middleware function (can be exported as `middleware` or `proxy`)
+ *
+ * @example Next.js 15
+ * ```typescript
+ * // middleware.ts (at project root)
+ * import { createSupabaseAuthMiddleware } from '@solvapay/next';
+ *
+ * export const middleware = createSupabaseAuthMiddleware({
+ *   publicRoutes: ['/api/list-plans'],
+ * });
+ *
+ * export const config = {
+ *   matcher: ['/api/:path*'],
+ * };
+ * ```
+ *
+ * @example Next.js 16 with src/ folder
+ * ```typescript
+ * // src/proxy.ts (in src/ folder, not project root)
+ * import { createSupabaseAuthMiddleware } from '@solvapay/next';
+ *
+ * // Use 'proxy' export for Next.js 16 (no deprecation warning)
+ * export const proxy = createSupabaseAuthMiddleware({
+ *   publicRoutes: ['/api/list-plans'],
+ * });
+ *
+ * export const config = {
+ *   matcher: ['/api/:path*'],
+ * };
+ * ```
+ *
+ * **File Location Notes:**
+ * - **Next.js 15**: Place `middleware.ts` at project root
+ * - **Next.js 16 without `src/` folder**: Place `middleware.ts` or `proxy.ts` at project root
+ * - **Next.js 16 with `src/` folder**: Place `src/proxy.ts` or `src/middleware.ts` (in `src/` folder, not root)
+ *
+ * **Note:** Next.js 16 renamed "middleware" to "proxy". You can export the return value as either
+ * `middleware` or `proxy` - both work, but `proxy` is recommended to avoid deprecation warnings.
+ */
+declare function createSupabaseAuthMiddleware(options?: SupabaseAuthMiddlewareOptions): (request: NextRequest) => Promise<NextResponse<unknown>>;
+
+export { type AuthMiddlewareOptions, type SupabaseAuthMiddlewareOptions, createAuthMiddleware, createSupabaseAuthMiddleware };