Better Auth is a framework-agnostic authentication and authorization framework for TypeScript, designed as a monorepo with a core library, multiple database adapters (Drizzle, Prisma, Kysely, MongoDB, in-memory), client SDKs (React, Vue, Svelte, Solid, Expo, Electron), and a plugin ecosystem. It supports email/password, OAuth2/OIDC, SAML, SCIM, passkeys, 2FA, phone number OTP, and more. The architecture is modular: the core package provides the `betterAuth()` function, which configures plugins, database adapters, and social providers, and exposes a REST API for authentication flows. Client libraries use nanostores for reactive state management. The CLI offers project scaffolding, migration generation, and schema validation. External dependencies include jose for JWT, zod for validation, and various ORMs for database access. The codebase is well-tested with unit, integration, and e2e tests across all packages, and includes a release tooling package with AI-assisted changelog generation.
Hyperswitch is a composable open-source payments infrastructure built in Rust that provides a modular platform for processing payments through multiple connectors. The system handles the complete payment lifecycle including authorization, capture, refunds, and dispute management, while offering features like intelligent routing, 3DS authentication, revenue recovery, and analytics. Built with a microservices architecture using Actix-web, it features a plugin-based connector system, event-driven design with Redis/Kafka, and comprehensive SDK support for web and mobile platforms. The codebase demonstrates strong engineering practices with typesafe ID generation, robust encryption utilities, and well-abstracted interfaces that promote reusability and maintainability.
stripe-node is the official Stripe API client library for Node.js and JavaScript runtimes. It provides a comprehensive, typed interface to the entire Stripe REST API (both V1 and V2), covering payments, billing, Connect, Treasury, Issuing, Terminal, and more. The library is auto-generated from Stripe's OpenAPI spec, ensuring tight alignment with the API surface. It supports multiple JavaScript runtimes (Node.js, Deno, Cloudflare Workers, browsers) via platform abstraction layers for HTTP, crypto, and event emission. Key architectural features include a pluggable HTTP client hierarchy (Node native, Fetch, custom endpoints), runtime type coercion for V2 decimal and int64 fields, robust error generation with typed error classes, automatic pagination with async iterators, and webhook signature verification. The codebase is well-tested with unit and integration tests across runtimes, and follows semantic versioning. While the vast majority of resource files are generated boilerplate, the core infrastructure (request sender, platform functions, crypto providers, auto-pagination) demonstrates solid engineering craftsmanship and is designed for extensibility.
Payum is a framework-agnostic PHP payment processing library that unifies dozens of payment providers (PayPal, Stripe, Klarna, Authorize.Net, Be2Bill, Payex, Sofort, Offline, and others) behind a common API. The code reveals a dual architecture in transition: the mature 1.x action/request/reply model coexists with a newer 2.x command/handler/context model that returns typed result objects and executes through a middleware pipeline. Core capabilities include gateway factories, registry and container abstractions, token-based security URLs, pluggable storage backends (Doctrine ORM, MongoDB ODM, filesystem, Laminas), Twig template rendering, PSR-7/14/18 support, event dispatching, and currency/money handling. It is a library meant to be embedded inside Symfony, Laravel, or plain PHP applications, not a standalone service. The architecture is genuinely well-engineered: the middleware pipeline, handler map, token factory, and storage abstractions are cleanly separated and heavily unit-tested. However, the codebase is mid-migration between 1.x and 2.x APIs, with many deprecated legacy adapters and bridge classes still present. This dual-path design increases complexity and can confuse new users, but the core abstractions remain sound and reusable. The repository is a monorepo with per-gateway subpackages, extensive PHPUnit coverage, CI workflows, static analysis, and release automation. Technical drift is moderate: gateway integrations using old SOAP/XML-RPC SDKs and deprecated Symfony/Httplug bridges are aging, while the core 2.x architecture is actively maintained.
Read the Docs is a Django-based web application for building, hosting, and serving documentation from version control repositories (GitHub, GitLab, Bitbucket). It supports Sphinx, MkDocs, and other documentation generators, with automated builds triggered by webhooks, versioning (semver, calver, custom), custom domains, subprojects, translations, and a full-text search powered by Elasticsearch. The platform includes a multi-tenant organization system with teams, invitations, and Stripe-based subscriptions for commercial features like concurrent builds and private documentation. Architecturally, it is a monolithic Django application with multiple apps (projects, builds, search, analytics, oauth, embed, proxito, etc.) communicating via Celery task queues for async operations (builds, indexing, email). It exposes REST APIs (v2 and v3) for programmatic access, and serves documentation through a custom proxito middleware that handles domain resolution, caching, redirects, and CDN integration. The codebase demonstrates strong engineering practices with extensive use of mixins, class overrides via SettingsOverrideObject, structured logging with structlog, and a comprehensive test suite. Key features include OAuth-based repository synchronization, automation rules for version management, an embed API for content fragments, file tree diff for pull request previews, audit logging, and spam detection. The system is designed for extensibility, with many components replaceable through Django settings, and relies on external services like AWS S3 for storage, Elasticsearch for search, and Stripe for payments.
The stripe/java repository is the official Java client library for the Stripe API, providing type-safe access to Stripe's payment processing and financial services. It features a layered architecture with model classes representing Stripe objects, service classes for API resource access, parameter builders for request configuration, and webhook handling infrastructure. The library supports both legacy static API patterns and a modern instance-based StripeClient entry point, with comprehensive telemetry, expandable fields, and extra parameters for accessing beta features. Code generation from OpenAPI specs ensures consistency with Stripe's API evolution, while hand-crafted components like utility classes and webhook verification demonstrate engineering excellence.
WaterCrawl is a full-stack web crawling and data extraction platform, built as a SaaS-style multi-tenant application. The backend is implemented in Django 5.1 with Django REST Framework, providing REST APIs for crawl requests (single/batch URL), web search (Google Custom Search integration), sitemap generation, and proxy server management. Asynchronous task execution is handled by Celery workers that invoke Scrapy spiders (SiteScrapper, GoogleCustomSearchScrapper, SitemapScrapper) and optionally use Playwright for JavaScript rendering. Real-time status updates are pushed to the frontend via Redis Pub/Sub and Server-Sent Events (SSE). The frontend is a React SPA (with TypeScript, Tailwind CSS, react-hook-form) that provides dashboard pages for configuring and monitoring crawl/search/sitemap jobs, managing teams and API keys, viewing usage statistics, and handling subscription billing through Stripe. Authentication supports JWT (simplejwt) and OAuth (Google, GitHub), with email verification and team invitation flows. The application stores extracted content (markdown, HTML, attachments) in MinIO or S3-compatible storage, and metadata in PostgreSQL.
Liberapay is a production web application for recurrent monetary donations, operating as a non-profit platform. It allows donors to set up weekly, monthly, or yearly contributions to creators, teams, and organizations. The architecture is a monolithic Python web application built on the custom Aspen/Pando framework (a fork of Aspen), using PostgreSQL for persistence, Jinja2 for server-side rendering, and a mix of Stripe and PayPal for payment processing. Key entry points include the homepage (`www/index.html.spt`), user profile pages (`www/%username/index.html.spt`), donation management (`www/%username/giving/`), payment flows (`www/%username/giving/pay/stripe/%payin_id.spt`), and admin dashboards (`www/admin/`). Data flows involve user authentication via sessions and OAuth, tip creation and scheduling, payin execution through Stripe/PayPal, weekly payday settlement, and email notifications. External dependencies include Stripe, PayPal, Amazon SES (email), Sentry (error tracking), S3 (file storage), and multiple OAuth providers (GitHub, Twitter, Mastodon, etc.). The codebase is well-structured with reusable modules for payment prospect calculation, encryption, content security policy, currency handling, and OAuth abstraction, though it carries technical debt from a custom framework and aging dependencies.
PayKit is an open-source, embedded billing framework for TypeScript applications. It provides a core library (`paykitjs`) that handles subscription management, metered usage tracking, feature entitlements, and webhook processing – all backed by PostgreSQL and currently integrated exclusively with Stripe as the payment provider. The monorepo includes a CLI for project scaffolding and migration, a client SDK, a dashboard plugin (`@paykitjs/dash`), a documentation website (Next.js + Fumadocs), a demo application, and a webhook tunnel worker (Cloudflare Workers + Durable Objects). The architecture is modular: a core `createPayKit()` instance orchestrates services for customers, subscriptions, entitlements, products, and invoices, each following a service pattern with Drizzle ORM models. A plugin system allows custom endpoints, and a provider abstraction (currently only Stripe) handles payment operations. The codebase is well-structured with TypeScript end-to-end, extensive E2E testing against Stripe test clocks, and a clean separation of concerns. However, it is in alpha stage, has duplicated UI component libraries across apps, and is tightly coupled to Stripe – factors that limit immediate reuse without adaptation.
svelte-stripe is a Svelte component library that wraps Stripe Elements and Stripe.js, providing drop-in Svelte components for building payment UIs. It exposes context-based components such as Elements, PaymentElement, CardNumber, CardExpiry, and CardCvc, and handles Stripe.js loading, element lifecycle, and SSR safety. The repository also includes a SvelteKit demo application with examples for credit card, SEPA, iDEAL, and express checkout, plus server-side payment intent creation and webhook signature verification. It is a library and example app, not a data pipeline.
ResumeLM is an AI-powered resume builder application built with Next.js 15, React 19, and TypeScript. It provides a SaaS platform for creating, editing, and optimizing resumes for tech job applications, featuring AI-assisted content generation, resume tailoring for specific job applications, ATS optimization, and cover letter generation. The application uses Supabase for authentication and data storage, Stripe for subscription management, and integrates with multiple AI providers (OpenAI, Anthropic, Google, etc.) via OpenRouter or direct API keys. The architecture follows a modular structure with separate concerns for authentication, dashboard, resume editor, admin panel, and settings, leveraging server actions for data mutations and a robust AI abstraction layer for model selection and usage tracking.
This is a modern Next.js 16 starter template using the App Router, designed to jumpstart full-stack web applications. It provides a production-ready monolith with authentication via NextAuth (GitHub provider), payment processing through Stripe subscriptions, and a PostgreSQL database layer using Drizzle ORM and Neon serverless. The application includes internationalization (i18n) with next-intl, dark mode theming, custom fonts, and standard SEO features like sitemap and robots.txt. The codebase demonstrates disciplined engineering with TypeScript, Zod environment validation, Biome linting, Husky git hooks, and both unit (Jest) and end-to-end (Playwright) testing. While functionally complete and well-structured, it is fundamentally a starter kit composed of framework boilerplate and standard integrations, without innovative or deeply reusable custom abstractions beyond what is typical for such templates.
This is a production-oriented full-stack SaaS starter kit (not a data/research project). It is a monorepo template pairing a Next.js web app (landing page, auth flow, account dashboard, marketing sections) with a Flutter cross-platform app (iOS/Android/macOS/Windows/Linux/web) on top of a shared Supabase backend. The backend is a Postgres schema (users, customers, products, prices, subscriptions, invoices) protected by row-level security, plus Deno edge functions that orchestrate Stripe Checkout sessions and process Stripe webhooks. PostHog handles analytics on both frontends, Loops.so handles transactional email, and an optional Monero cryptocurrency payment variant can be toggled in via patch scripts, giving the template two billing backends.
Stripe-ruby-mock is a Ruby library that provides in-memory mocking of the Stripe API for testing purposes. It intercepts Stripe HTTP requests and returns simulated responses, enabling offline, deterministic testing without real API keys or network access. The library supports both local mocking (via `StripeMock.start`/`stop`) and a remote mock server for integration tests across processes. It covers a wide range of Stripe endpoints including charges, customers, subscriptions, invoices, payment intents, and webhooks, with extensive shared RSpec examples and webhook fixtures. The architecture follows a modular request-handler pattern, with helpers for token generation, param validation, and search simulation. While the codebase is well-structured and popular (996 stars), it shows signs of maintenance strain (199 open issues, call for core maintainers) and technical drift (vendored Trollop CLI parser, outdated webhook fixtures, limited Stripe API version coverage). It remains a valuable tool for legacy Stripe testing but may require updates to fully align with current Stripe API changes.
This repository is a monorepo containing the `@react-google-maps/api` library, which provides React components and hooks for the Google Maps JavaScript API (v3.x). It includes sub-packages for InfoBox and MarkerClusterer overlays. The library is the primary product, offering declarative React wrappers for map features like markers, info windows, polygons, directions, street view, and more. The codebase also includes a full-stack web application (`web-app`) built with React Router v7, Hono, and Cloudflare Workers, serving as the library's documentation site, license sales platform, and user dashboard. The web-app features authentication, Stripe payment integration, multi-language support (9 locales), and a comprehensive interactive documentation page with code examples. The library itself follows a consistent functional component pattern with hooks for lifecycle management, but suffers from some code duplication and verbose event listener handling. The commercial license change in v3.0.0 may impact community adoption. Overall, the repository is actively maintained and functional, but not exceptionally polished.
This repository implements a full-featured graphic design SaaS application, a clone of Canva. It is built with Next.js 14 (App Router), React 18, TypeScript, Tailwind CSS, and uses Fabric.js 5.3.0 for the canvas editor. The application allows users to create visual projects (designs) with layers including shapes, text, images, drawings, and AI-generated content. It supports background removal, image filters, color manipulation, and font adjustments. Authentication is handled via NextAuth v5 with credentials, GitHub, and Google OAuth, integrated with a PostgreSQL database through Drizzle ORM. Subscriptions (Free/Pro tiers) are managed via Stripe, limiting certain features like unlimited projects and AI capabilities. The dashboard lists user projects and templates, while the editor provides a rich toolbar, collapsible sidebars, and keyboard shortcuts. External dependencies include Unsplash for stock images, UploadThing for user file uploads, Replicate for AI inference (image generation, background removal), and Stripe for payments. The architecture follows a feature-based module structure with dedicated folders for auth, editor, projects, subscriptions, AI, and images. Server API routes are built using Hono.js mounted under a catch-all route, and client-side data fetching uses TanStack Query. State management for modals and UI is handled by Zustand. The codebase is well-organized for a production-grade tutorial project but lacks automated tests and contains some type safety shortcuts.