Compatibility <span class="bg-gradient-to-r from-primary to-primary/70 bg-clip-text text-transparent">Checks

Official support with dedicated @supabase/ssr package for SvelteKit. SSR support with cookies for session management.

Sveltekit+Prisma

Compatible in Node.js environments. Edge runtime requires special configuration with @prisma/client/edge and Prisma Accelerate.

Remix+Supabase

No official 2026 compatibility guarantee. Works in practice but has known issues around OAuth authentication and cookie management.

Remix+Prisma

Compatible in Node.js environments with loader/action patterns. Edge runtime has significant limitations due to WASM compilation issues.

Nuxt+Supabase

Official module exists (@nuxtjs/supabase v2.0.3) with Nuxt v4 compatibility. Known issues with TypeScript exports and Pinia integration.

Nuxt+Prisma

Official @prisma/nuxt module exists but has edge deployment limitations and production build issues. Works best with Node.js server environments.

Next.js+Turso

Fully compatible including Edge Runtime. @libsql/client supports HTTP, WebSocket, and lib:// URL schemes. Works in both Node.js and Edge runtimes.

Next.js+Supabase

Official integration with comprehensive documentation. @supabase/ssr package provides full Next.js SSR support.

Next.js+Prisma

Compatible in Node.js runtime but does NOT work in Edge Runtime (middleware, edge functions). Use Node.js runtime for API routes.

Next.js+PostgreSQL

Standard pg driver works in Node.js runtime but NOT in Edge Functions. Neon serverless driver required for Edge Runtime.

Next.js+Planetscale

Official support exists with Prisma adapter. Edge Runtime requires Prisma Edge preview features with bundle size constraints.

Next.js+Mongodb Atlas

Works in Node.js runtime (API routes, Server Actions) but NOT compatible with Edge Runtime due to missing Node.js modules (crypto, stream).

Next.js+Firebase Firestore

Compatible for SSR and Server Components using FirebaseServerApp, but does NOT work in Edge Runtime (middleware, edge functions).

Express+PostgreSQL

Fully compatible through node-postgres (pg) driver. Supports all recent LTS Node.js versions and latest PostgreSQL versions.

Express+Mongodb Atlas

Generally compatible but requires careful version management. Critical security vulnerabilities discovered in late 2024 (CVE-2025-23061, CVE-2024-53900).

Vercel Edge+Upstash

Fully compatible. @upstash/redis uses HTTP/REST API instead of TCP, designed specifically for edge runtimes.

Vercel Edge+Turso

Compatible with Cloudflare Workers/Pages but has known issues with Vercel Edge Runtime (build failures, 401 auth errors).

Vercel Edge+Planetscale

Compatible via PlanetScale serverless driver using HTTP connections instead of TCP. Works in all Edge Runtime environments.

@upstash/redis+Edge Runtime

HTTP-based Redis access designed for Edge and serverless

Turso+Drizzle Orm

Native libSQL/Turso support - recommended Edge database pairing

Supabase+Vercel

Official integration with optimized connection pooling via Supavisor

Ssh2+Edge Runtime

Requires net module for TCP sockets and native crypto bindings

Socket.io+Edge Runtime

Requires persistent server process and net module; incompatible with stateless edge

Planetscale+Prisma

Requires driver adapter for serverless environments

@planetscale/database+Edge Runtime

HTTP protocol works on all Edge platforms

Pdf Parse+Edge Runtime

Uses fs module and PDF.js which requires DOM-like environment

Pdf Lib+Edge Runtime

Pure JavaScript PDF library; bundle size (~400KB) may concern edge limits

Next.js+Cloudflare Pages

Limited Node.js API support via @cloudflare/next-on-pages

@neondatabase/serverless+Vercel Edge

Designed for Edge Runtime - works natively via HTTP/WebSocket

Multer+Serverless

Works with memoryStorage but disk streaming fails; requires binary config

Multer+Edge Runtime

Uses fs.diskStorage by default; streaming uploads incompatible with edge

Formidable+Edge Runtime

Saves files to temporary directory using fs; edge has no writable filesystem

Drizzle Orm+Cloudflare D1

Native D1 support with official driver - recommended pairing

Zustand+React Server Components

Store hooks use useState internally; subscriptions require client-side hydration

Sharp+Serverless

Works on Lambda with pre-compiled Linux binaries; requires correct build environment

Sharp+Edge Runtime

Uses native C++ bindings to libvips; native modules cannot run in V8 isolates

Redux+React Server Components

React-Redux Provider uses Context; useSelector/useDispatch hooks incompatible

Recharts+React Server Components

Chart components use useEffect, access DOM for SVG; responsive containers require window

React Hot Toast+React Server Components

Toaster component uses useState, useEffect; toast() requires browser

Puppeteer+Serverless

Chromium exceeds Lambda 250MB limit

Puppeteer+Edge Runtime

Requires Chromium binary (~280MB) and child_process to spawn browser

Playwright+Edge Runtime

Requires browser binary and child_process; fundamentally incompatible

Otplib+Edge Runtime

Uses crypto.createHmac which throws 'createHmac is not a function'

Canvas+Edge Runtime

Uses native Cairo library via C++ bindings

Next Themes+React Server Components

ThemeProvider uses React Context; useTheme hook requires client component

Jsonwebtoken+Edge Runtime

Uses Node.js crypto module (createHmac, createSign)

Jotai+React Server Components

Provider uses React Context; useAtom hooks require client component

Jimp+Edge Runtime

Pure JavaScript; may exceed CPU time limits on free edge tiers

Gsap+React Server Components

Accesses window and document objects; throws 'window is not defined' in RSC

Gm+Edge Runtime

Wrapper for GraphicsMagick/ImageMagick CLI; requires child_process and native binaries

Glob+Edge Runtime

Requires fs module for directory traversal; no filesystem in edge

Fs Extra+Edge Runtime

Extends fs module unavailable in edge; cannot read/write filesystem

Framer Motion+React Server Components

Animation components use useEffect, useRef, access DOM APIs; MotionConfig uses Context

Chokidar+Serverless

Serverless functions are ephemeral; file watching requires persistent process

Chokidar+Edge Runtime

File system watcher using fs.watch; no persistent filesystem in edge

Bcrypt+Serverless

Native module requires compilation for Amazon Linux; 'invalid ELF header' errors

Bcrypt+Edge Runtime

Uses native C++ bindings via node-pre-gyp; cannot load .node files

Argon2+Edge Runtime

Uses native C++ bindings compiled for specific OS

@supabase/auth Ui React+React Server Components

Auth UI components use useState, useEffect, browser APIs

@stripe/react Stripe Js+React Server Components

Elements provider uses React Context; Stripe.js accesses window

@sentry/nextjs+React Server Components

setUser() must be called separately; error.tsx requires 'use client'

@sentry/browser+React Server Components

Browser SDK accesses window, document; error boundaries use useState/useEffect

@segment/analytics Next+React Server Components

Analytics.js accesses window, document, localStorage

@tanstack/react Query+React Server Components

QueryClientProvider uses React Context; useQuery hooks use useState/useEffect

React Ga4+React Server Components

Accesses window.gtag and window.dataLayer; requires browser environment

Posthog Js+React Server Components

PostHogProvider uses React Context; usePostHog hooks require client components

Plausible Tracker+React Server Components

Accesses window.location and uses sendBeacon for client-side tracking

@paypal/react Paypal Js+React Server Components

PayPalScriptProvider uses React Context; PayPal buttons require browser APIs

@okta/okta React+React Server Components

Security component and useOktaAuth hook use React Context and browser APIs

Next Auth+React Server Components

SessionProvider uses React Context; useSession() hook requires client component

Mixpanel Browser+React Server Components

Browser SDK accesses localStorage, document.cookie, window

Lucia Auth+Edge Runtime

Database session validation in middleware difficult; most DB drivers don't work in Edge

Launchdarkly React Client Sdk+React Server Components

withLDProvider uses React Context; useFlags hooks require client component

@intercom/messenger Js Sdk+React Server Components

Intercom messenger requires window object; boot() accesses browser APIs

Firebase+React Server Components

Requires browser APIs (window, document, localStorage, IndexedDB)

Firebase Admin+Edge Runtime

Requires Node.js modules (fs, net, tls) for service account authentication and gRPC

@clerk/nextjs+React Server Components

ClerkProvider uses React Context; useAuth()/useUser() hooks require client-side

Braintree Web Drop In React+React Server Components

Drop-in UI requires browser DOM access; uses useRef, useEffect, window/document

Better Auth+Edge Runtime

getCookieCache() doesn't work in Edge; depends on Node APIs like process.platform

Authjs+Edge Runtime

Some providers require Node.js APIs; database adapters with TCP may not work

@auth0/nextjs Auth0+React Server Components

useUser() hook and UserProvider use React Context API

@apollo/client+React Server Components

ApolloProvider uses React Context; useQuery/useMutation hooks require client

@amplitude/analytics Browser+React Server Components

Browser SDK uses localStorage, sessionStorage, window APIs

Typeorm+Edge Runtime

Depends on Node.js net module for TCP sockets and reflect-metadata

Sequelize+Serverless

Connection pool race conditions with Lambda freeze/thaw cause ConnectionAcquireTimeoutError

Sequelize+Nextjs Middleware

Dynamic require() statements and Node.js runtime dependencies cause compilation errors

Sequelize+Edge Runtime

Requires TCP sockets via net module; large bundle size exceeds edge limits

Redis+Edge Runtime

TCP socket requirement incompatible with edge runtimes

Prisma+Vercel Edge

Native Rust query engine binary incompatible with V8 isolates; requires TCP sockets

Prisma+Serverless

Connection pool exhaustion; 200 concurrent functions creates 600+ connections

Prisma+Cloudflare Workers

Prisma doesn't support Cloudflare Workers V8 isolate runtime without adapters

Postgres+Edge Runtime

Supports Cloudflare Workers via TCP socket API but causes bundle errors with Vercel Edge

Pg+Serverless

Connection exhaustion from Lambda scaling; zombie connections when containers freeze

Pg+Edge Runtime

Requires net.Socket for TCP connections; TypeError in edge environments

Objection+Edge Runtime

Built entirely on Knex.js requiring TCP connections

Mysql2+Serverless

Connection exhaustion from Lambda scaling; traditional pooling breaks across invocations

Mysql2+Edge Runtime

Requires TCP sockets via net module; uses Node.js stream module

Mongoose+Serverless

Model loading and TCP connection management cause severe cold start delays

Mongoose+Edge Runtime

Built on mongodb driver which requires TCP sockets

MongoDB+Serverless

Lambda freeze/thaw causes zombie connections; 4-5 second wait without connection reuse

MongoDB+Edge Runtime

Uses TCP sockets for wire protocol; edge runtimes don't support raw TCP

Mikro Orm+Edge Runtime

Built on Knex requiring TCP; CommonJS prevents tree-shaking resulting in 4-5MB bundles

Kysely+Edge Runtime

Core query builder is edge-compatible; requires edge-compatible dialects

Knex+Edge Runtime

Depends on Node.js net module; imports unavailable modules (fs, path, stream)

Ioredis+Serverless

ETIMEDOUT errors after Lambda freeze/thaw; connections become stale

Ioredis+Edge Runtime

Requires TCP sockets which edge runtimes don't support

Drizzle Orm+Edge Runtime

Core ORM is edge-compatible (~7kb) but standard drivers use unavailable Node.js APIs

Better Sqlite3+Edge Runtime