@solvapay/next 1.0.0-preview.7

package/README.md

@@ -0,0 +1,71 @@
+# @solvapay/next
+
+Next.js-specific utilities and helpers for SolvaPay SDK.
+
+This package provides framework-specific helpers for Next.js API routes with built-in optimizations like request deduplication and caching.
+
+## Installation
+
+```bash
+npm install @solvapay/next @solvapay/server next
+```
+
+## Usage
+
+### Check Subscription
+
+The `checkSubscription` helper provides a simple way to check user subscription status in Next.js API routes with built-in request deduplication:
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server';
+import { checkSubscription } from '@solvapay/next';
+
+export async function GET(request: NextRequest) {
+  const result = await checkSubscription(request);
+  
+  // If result is a NextResponse, it's an error response - return it
+  if (result instanceof NextResponse) {
+    return result;
+  }
+  
+  // Otherwise, return the subscription data
+  return NextResponse.json(result);
+}
+```
+
+### Features
+
+- **Automatic Deduplication**: Prevents duplicate API calls by deduplicating concurrent requests
+- **Caching**: Caches results for 2 seconds to prevent duplicate sequential requests
+- **Automatic Cleanup**: Expired cache entries are automatically cleaned up
+- **Memory Safe**: Maximum cache size limits prevent memory issues
+
+### Cache Management
+
+```typescript
+import { 
+  clearSubscriptionCache, 
+  clearAllSubscriptionCache,
+  getSubscriptionCacheStats 
+} from '@solvapay/next';
+
+// Clear cache for a specific user
+clearSubscriptionCache(userId);
+
+// Clear all cache entries
+clearAllSubscriptionCache();
+
+// Get cache statistics
+const stats = getSubscriptionCacheStats();
+console.log(`In-flight: ${stats.inFlight}, Cached: ${stats.cached}`);
+```
+
+## Requirements
+
+- Next.js >= 13.0.0
+- Node.js >= 18.17
+
+## Why a Separate Package?
+
+This package is separate from `@solvapay/server` to keep the server package framework-agnostic. Users who use Express, Fastify, or other frameworks don't need Next.js as a dependency.
+

package/dist/index.cjs

@@ -0,0 +1,242 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  checkSubscription: () => checkSubscription,
+  clearAllSubscriptionCache: () => clearAllSubscriptionCache,
+  clearSubscriptionCache: () => clearSubscriptionCache,
+  getSubscriptionCacheStats: () => getSubscriptionCacheStats
+});
+module.exports = __toCommonJS(index_exports);
+var import_server = require("next/server");
+var import_server2 = require("@solvapay/server");
+var import_core = require("@solvapay/core");
+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 = {}) {
+  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 });
+    }
+    const userId = userIdOrError;
+    const email = options.includeEmail !== false ? await getUserEmailFromRequest(request) : null;
+    const name = options.includeName !== false ? await getUserNameFromRequest(request) : null;
+    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 result = {
+          customerRef: customer.customerRef || userId,
+          email: customer.email,
+          name: customer.name,
+          subscriptions: filteredSubscriptions
+        };
+        return result;
+      } catch (error) {
+        console.error("[checkSubscription] Error fetching customer:", error);
+        return {
+          customerRef: userId,
+          subscriptions: []
+        };
+      }
+    });
+    return response;
+  } catch (error) {
+    console.error("Check subscription failed:", error);
+    if (error instanceof import_core.SolvaPayError) {
+      return import_server.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 },
+      { 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
+});

package/dist/index.d.cts

@@ -0,0 +1,129 @@
+import { NextResponse } from 'next/server';
+import { SolvaPay } from '@solvapay/server';
+
+/**
+ * SolvaPay Next.js SDK
+ *
+ * Framework-specific helpers and utilities for Next.js API routes.
+ * These utilities provide common patterns with built-in optimizations
+ * like request deduplication and caching.
+ */
+
+/**
+ * Request deduplication and caching options
+ */
+interface RequestDeduplicationOptions {
+    /**
+     * Time-to-live for cached results in milliseconds (default: 2000)
+     * Set to 0 to disable caching (only deduplicate concurrent requests)
+     */
+    cacheTTL?: number;
+    /**
+     * Maximum cache size before cleanup (default: 1000)
+     * When exceeded, oldest entries are removed
+     */
+    maxCacheSize?: number;
+    /**
+     * Whether to cache error results (default: true)
+     * When false, only successful results are cached
+     */
+    cacheErrors?: boolean;
+}
+/**
+ * Subscription check result
+ */
+interface SubscriptionCheckResult {
+    customerRef: string;
+    email?: string;
+    name?: string;
+    subscriptions: Array<{
+        reference: string;
+        planName?: string;
+        agentName?: string;
+        status?: string;
+        startDate?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Options for checking subscriptions
+ */
+interface CheckSubscriptionOptions {
+    /**
+     * Request deduplication options
+     * Default: { cacheTTL: 2000, maxCacheSize: 1000, cacheErrors: true }
+     */
+    deduplication?: RequestDeduplicationOptions;
+    /**
+     * Custom SolvaPay instance (optional)
+     * If not provided, a new instance will be created
+     */
+    solvaPay?: SolvaPay;
+    /**
+     * Whether to include user email in customer data
+     * Default: true
+     */
+    includeEmail?: boolean;
+    /**
+     * Whether to include user name in customer data
+     * Default: true
+     */
+    includeName?: boolean;
+}
+/**
+ * Check user subscription status
+ *
+ * This helper function:
+ * 1. Extracts user ID from request (via requireUserId from @solvapay/auth)
+ * 2. Gets user email and name from Supabase JWT token
+ * 3. Ensures customer exists in SolvaPay
+ * 4. Returns customer subscription information
+ * 5. Handles deduplication automatically
+ *
+ * @param request - Next.js request object (NextRequest extends Request, so Request is accepted)
+ * @param options - Configuration options
+ * @returns Subscription check result or error response
+ *
+ * @example
+ * ```typescript
+ * import { NextRequest } from 'next/server';
+ * import { checkSubscription } from '@solvapay/next';
+ *
+ * export async function GET(request: NextRequest) {
+ *   const result = await checkSubscription(request);
+ *   if (result instanceof NextResponse) {
+ *     return result; // Error response
+ *   }
+ *   return NextResponse.json(result);
+ * }
+ * ```
+ */
+declare function checkSubscription(request: Request, options?: CheckSubscriptionOptions): Promise<SubscriptionCheckResult | NextResponse>;
+/**
+ * Clear subscription cache for a specific user
+ *
+ * Useful when you know subscription status has changed
+ * (e.g., after a successful checkout or subscription update)
+ *
+ * @param userId - User ID to clear cache for
+ */
+declare function clearSubscriptionCache(userId: string): void;
+/**
+ * Clear all subscription cache entries
+ *
+ * Useful for testing or when you need to force fresh lookups
+ */
+declare function clearAllSubscriptionCache(): void;
+/**
+ * Get subscription cache statistics
+ *
+ * Useful for monitoring and debugging
+ *
+ * @returns Cache statistics
+ */
+declare function getSubscriptionCacheStats(): {
+    inFlight: number;
+    cached: number;
+};
+
+export { type CheckSubscriptionOptions, type RequestDeduplicationOptions, type SubscriptionCheckResult, checkSubscription, clearAllSubscriptionCache, clearSubscriptionCache, getSubscriptionCacheStats };

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+import { NextResponse } from 'next/server';
+import { SolvaPay } from '@solvapay/server';
+
+/**
+ * SolvaPay Next.js SDK
+ *
+ * Framework-specific helpers and utilities for Next.js API routes.
+ * These utilities provide common patterns with built-in optimizations
+ * like request deduplication and caching.
+ */
+
+/**
+ * Request deduplication and caching options
+ */
+interface RequestDeduplicationOptions {
+    /**
+     * Time-to-live for cached results in milliseconds (default: 2000)
+     * Set to 0 to disable caching (only deduplicate concurrent requests)
+     */
+    cacheTTL?: number;
+    /**
+     * Maximum cache size before cleanup (default: 1000)
+     * When exceeded, oldest entries are removed
+     */
+    maxCacheSize?: number;
+    /**
+     * Whether to cache error results (default: true)
+     * When false, only successful results are cached
+     */
+    cacheErrors?: boolean;
+}
+/**
+ * Subscription check result
+ */
+interface SubscriptionCheckResult {
+    customerRef: string;
+    email?: string;
+    name?: string;
+    subscriptions: Array<{
+        reference: string;
+        planName?: string;
+        agentName?: string;
+        status?: string;
+        startDate?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Options for checking subscriptions
+ */
+interface CheckSubscriptionOptions {
+    /**
+     * Request deduplication options
+     * Default: { cacheTTL: 2000, maxCacheSize: 1000, cacheErrors: true }
+     */
+    deduplication?: RequestDeduplicationOptions;
+    /**
+     * Custom SolvaPay instance (optional)
+     * If not provided, a new instance will be created
+     */
+    solvaPay?: SolvaPay;
+    /**
+     * Whether to include user email in customer data
+     * Default: true
+     */
+    includeEmail?: boolean;
+    /**
+     * Whether to include user name in customer data
+     * Default: true
+     */
+    includeName?: boolean;
+}
+/**
+ * Check user subscription status
+ *
+ * This helper function:
+ * 1. Extracts user ID from request (via requireUserId from @solvapay/auth)
+ * 2. Gets user email and name from Supabase JWT token
+ * 3. Ensures customer exists in SolvaPay
+ * 4. Returns customer subscription information
+ * 5. Handles deduplication automatically
+ *
+ * @param request - Next.js request object (NextRequest extends Request, so Request is accepted)
+ * @param options - Configuration options
+ * @returns Subscription check result or error response
+ *
+ * @example
+ * ```typescript
+ * import { NextRequest } from 'next/server';
+ * import { checkSubscription } from '@solvapay/next';
+ *
+ * export async function GET(request: NextRequest) {
+ *   const result = await checkSubscription(request);
+ *   if (result instanceof NextResponse) {
+ *     return result; // Error response
+ *   }
+ *   return NextResponse.json(result);
+ * }
+ * ```
+ */
+declare function checkSubscription(request: Request, options?: CheckSubscriptionOptions): Promise<SubscriptionCheckResult | NextResponse>;
+/**
+ * Clear subscription cache for a specific user
+ *
+ * Useful when you know subscription status has changed
+ * (e.g., after a successful checkout or subscription update)
+ *
+ * @param userId - User ID to clear cache for
+ */
+declare function clearSubscriptionCache(userId: string): void;
+/**
+ * Clear all subscription cache entries
+ *
+ * Useful for testing or when you need to force fresh lookups
+ */
+declare function clearAllSubscriptionCache(): void;
+/**
+ * Get subscription cache statistics
+ *
+ * Useful for monitoring and debugging
+ *
+ * @returns Cache statistics
+ */
+declare function getSubscriptionCacheStats(): {
+    inFlight: number;
+    cached: number;
+};
+
+export { type CheckSubscriptionOptions, type RequestDeduplicationOptions, type SubscriptionCheckResult, checkSubscription, clearAllSubscriptionCache, clearSubscriptionCache, getSubscriptionCacheStats };

package/dist/index.js

@@ -0,0 +1,204 @@
+// src/index.ts
+import { NextResponse } from "next/server";
+import { createSolvaPay } from "@solvapay/server";
+import { SolvaPayError } from "@solvapay/core";
+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 = {}) {
+  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 });
+    }
+    const userId = userIdOrError;
+    const email = options.includeEmail !== false ? await getUserEmailFromRequest(request) : null;
+    const name = options.includeName !== false ? await getUserNameFromRequest(request) : null;
+    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 result = {
+          customerRef: customer.customerRef || userId,
+          email: customer.email,
+          name: customer.name,
+          subscriptions: filteredSubscriptions
+        };
+        return result;
+      } catch (error) {
+        console.error("[checkSubscription] Error fetching customer:", error);
+        return {
+          customerRef: userId,
+          subscriptions: []
+        };
+      }
+    });
+    return response;
+  } catch (error) {
+    console.error("Check subscription failed:", error);
+    if (error instanceof SolvaPayError) {
+      return NextResponse.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 },
+      { 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
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@solvapay/next",
+  "version": "1.0.0-preview.7",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solvapay/solvapay-sdk.git",
+    "directory": "packages/next"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@solvapay/auth": "1.0.0-preview.7",
+    "@solvapay/core": "1.0.0-preview.7",
+    "@solvapay/server": "1.0.0-preview.7"
+  },
+  "peerDependencies": {
+    "next": ">=13.0.0"
+  },
+  "devDependencies": {
+    "next": "^14.0.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5",
+    "@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'"
+  }
+}