@solvapay/next 1.0.0-preview.10

package/dist/index.cjs

@@ -0,0 +1,477 @@
+"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, {
+  cancelSubscription: () => cancelSubscription,
+  checkSubscription: () => checkSubscription,
+  clearAllSubscriptionCache: () => clearAllSubscriptionCache,
+  clearSubscriptionCache: () => clearSubscriptionCache,
+  createAuthMiddleware: () => createAuthMiddleware,
+  createCheckoutSession: () => createCheckoutSession,
+  createCustomerSession: () => createCustomerSession,
+  createPaymentIntent: () => createPaymentIntent,
+  createSupabaseAuthMiddleware: () => createSupabaseAuthMiddleware,
+  getAuthenticatedUser: () => getAuthenticatedUser,
+  getSubscriptionCacheStats: () => getSubscriptionCacheStats,
+  listPlans: () => listPlans,
+  processPayment: () => processPayment,
+  syncCustomer: () => syncCustomer
+});
+module.exports = __toCommonJS(index_exports);
+var import_server16 = require("next/server");
+var import_server17 = require("@solvapay/server");
+var import_core = require("@solvapay/core");
+
+// 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)) {
+      clearSubscriptionCache(userResult.userId);
+    }
+  } catch {
+  }
+  return result;
+}
+async function processPayment(request, body, options = {}) {
+  const result = await (0, import_server6.processPaymentCore)(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)) {
+      clearSubscriptionCache(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/subscription.ts
+var import_server10 = require("next/server");
+var import_server11 = require("@solvapay/server");
+var import_server12 = require("@solvapay/server");
+async function cancelSubscription(request, body, options = {}) {
+  const result = await (0, import_server11.cancelSubscriptionCore)(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)) {
+      clearSubscriptionCache(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 { pathname } = request.nextUrl;
+    if (!pathname.startsWith("/api")) {
+      return import_server15.NextResponse.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 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(request.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
+  });
+}
+
+// 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 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 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 import_core.SolvaPayError) {
+      return import_server16.NextResponse.json(
+        { error: error.message },
+        { status: 500 }
+      );
+    }
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return import_server16.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 = {
+  cancelSubscription,
+  checkSubscription,
+  clearAllSubscriptionCache,
+  clearSubscriptionCache,
+  createAuthMiddleware,
+  createCheckoutSession,
+  createCustomerSession,
+  createPaymentIntent,
+  createSupabaseAuthMiddleware,
+  getAuthenticatedUser,
+  getSubscriptionCacheStats,
+  listPlans,
+  processPayment,
+  syncCustomer
+});