@solvapay/next 1.0.0-preview.10

package/dist/index.js

@@ -0,0 +1,449 @@
+// src/index.ts
+import { NextResponse as NextResponse8 } from "next/server";
+import { createSolvaPay } from "@solvapay/server";
+import { SolvaPayError } from "@solvapay/core";
+
+// 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,
+  processPaymentCore,
+  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)) {
+      clearSubscriptionCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+async function processPayment(request, body, options = {}) {
+  const result = await processPaymentCore(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)) {
+      clearSubscriptionCache(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/subscription.ts
+import { NextResponse as NextResponse5 } from "next/server";
+import {
+  cancelSubscriptionCore,
+  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);
+  if (isErrorResult5(result)) {
+    return NextResponse5.json(
+      { error: result.error, details: result.details },
+      { status: result.status }
+    );
+  }
+  try {
+    const userResult = await getAuthenticatedUserCore3(request);
+    if (!isErrorResult5(userResult)) {
+      clearSubscriptionCache(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 { pathname } = request.nextUrl;
+    if (!pathname.startsWith("/api")) {
+      return NextResponse7.next();
+    }
+    const isPublicRoute = publicRoutes.some((route) => pathname.startsWith(route));
+    const userId = await adapter.getUserIdFromRequest(request);
+    if (isPublicRoute) {
+      const requestHeaders2 = new Headers(request.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(request.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
+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 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 filteredSubscriptions = (customer.subscriptions || []).filter(
+              (sub) => sub.status === "active"
+            );
+            return {
+              customerRef: customer.customerRef,
+              email: customer.email,
+              name: customer.name,
+              subscriptions: filteredSubscriptions
+            };
+          }
+        }
+      } catch (error) {
+      }
+    }
+    const deduplicator = getSharedDeduplicator(options.deduplication);
+    const response = await deduplicator.deduplicate(userId, async () => {
+      try {
+        const ensuredCustomerRef = await solvaPay.ensureCustomer(userId, userId, {
+          email: email || void 0,
+          name: name || void 0
+        });
+        const customer = await solvaPay.getCustomer({ customerRef: ensuredCustomerRef });
+        const filteredSubscriptions = (customer.subscriptions || []).filter(
+          (sub) => sub.status === "active"
+        );
+        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 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 },
+      { 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,
+  createAuthMiddleware,
+  createCheckoutSession,
+  createCustomerSession,
+  createPaymentIntent,
+  createSupabaseAuthMiddleware,
+  getAuthenticatedUser,
+  getSubscriptionCacheStats,
+  listPlans,
+  processPayment,
+  syncCustomer
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@solvapay/next",
+  "version": "1.0.0-preview.10",
+  "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.10",
+    "@solvapay/core": "1.0.0-preview.10",
+    "@solvapay/server": "1.0.0-preview.10"
+  },
+  "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'"
+  }
+}