Appwrite is an open-source backend-as-a-service (BaaS) platform that provides a comprehensive set of APIs for authentication, databases, storage, serverless functions, messaging, realtime, and more. The codebase is a hybrid monolithic-microservice architecture: a central PHP application (using the Swoole coroutine-based HTTP server) handles REST, GraphQL, and WebSocket requests, while background workers (over 20 types) process asynchronous tasks such as email delivery, function execution, database migrations, and usage analytics. The platform supports multiple database backends (MariaDB, MongoDB, PostgreSQL, ClickHouse) and a variety of messaging providers (SMS, email, push). It is designed for multi-tenant deployments with per-project isolation, OAuth2 social login, and extensive API versioning. The repository also contains a large collection of reusable PHP packages (the Utopia framework) that provide caching, queueing, query building, DNS resolution, NATS messaging, HTTP client, PSR-7 implementation, and more. These packages are independently published and can be extracted for use in other projects.
Liam ERD is a full-stack application for database schema visualization, design, and collaboration. It parses schemas from multiple formats (PostgreSQL, Prisma, Drizzle, Rails, tbls) and renders interactive ER diagrams in the browser via a CLI tool and a Next.js web app. The system integrates AI agents built with LangGraph that assist users in evolving schemas: a lead agent classifies intent, a PM agent analyzes requirements, a DB agent generates migrations via JSON Patch operations, and a QA agent produces and validates pgTAP tests. The web app supports organization/project management, GitHub OAuth, real-time streaming chat with agents, schema versioning with diff view, public sharing, and a command palette for navigating ERDs. The backend uses Supabase for auth, database, realtime, and blob-based checkpoint persistence. The monorepo also includes a component library, MCP server for Cursor IDE, schema evaluation benchmarks, and comprehensive test coverage (Vitest, Playwright, Storybook).
This is the Supabase JavaScript SDK monorepo, providing isomorphic client libraries for Supabase backend services. It is a well-structured TypeScript monorepo managed with pnpm and Nx, containing six core packages: auth-js (authentication), postgrest-js (database queries via PostgREST), realtime-js (WebSocket-based realtime subscriptions), storage-js (file storage and vector index API), functions-js (edge function invocation), and the umbrella supabase-js package that combines them into a single `createClient()` entry point. The SDK supports multiple runtimes (Node.js, Deno, browsers, Bun, React Native, Cloudflare Workers) and includes optional OpenTelemetry tracing support. The codebase demonstrates high craftsmanship with extensive TypeScript generics for type-safe query building, fluent builder patterns, robust error handling hierarchies, and comprehensive integration tests against local Supabase infrastructure. It is actively maintained with frequent releases, automated CI/CD, and a strong focus on backward compatibility.
pgflow is a PostgreSQL/Supabase-native workflow orchestration engine for defining and executing typed DAGs as background jobs. The system is split into six coordinated packages: a PL/pgSQL core (pkgs/core) that implements the complete workflow state machine in the database — flows, steps, runs, step states, tasks, retries with exponential backoff, map/reduce fan-out, conditional step execution, skip-cascade propagation, and realtime event broadcasting — plus a type-safe TypeScript DSL (pkgs/dsl) for declaring flows with compile-time-enforced inputs/outputs, a Deno/edge worker runtime (pkgs/edge-worker) that consumes PGMQ messages and executes step handlers via platform adapters (Supabase vs. plain process), a realtime-subscription client library (pkgs/client), and a CLI (pkgs/cli) for scaffolding new Supabase projects. Execution relies on pgmq for task queues, pg_cron for stalled-task recovery and worker health, pg_net for HTTP worker invocation, supabase_vault for credentials, and Supabase Realtime for atomic state-transition broadcasts.
Onlook is a browser-based visual editor for building and modifying Next.js + Tailwind CSS websites. It provides a Figma-like canvas where users can directly manipulate React components, with changes written back to source code via AST-based transformation. The application integrates an AI chat assistant that can generate code, edit files, and run terminal commands through a set of well-defined tools (e.g., search-replace, file edit, bash). The monorepo architecture separates concerns into packages for AI agents, code parsing, font management, UI components, database access (Drizzle + Supabase), git operations, and sandbox management (CodeSandbox). It also includes a complete billing system (Stripe), GitHub integration for project import, custom domain management, and a publish/deployment pipeline. The codebase demonstrates strong engineering practices with type-safe tRPC APIs, MobX state management in the editor, extensive use of Radix UI primitives, and a consistent monorepo toolchain (Bun workspaces, ESLint, Prettier). While the editor engine is somewhat monolithic, individual packages like the AST parser, font helpers, and utility library are well-isolated and testable.
ra-supabase is a TypeScript library that integrates react-admin with Supabase. It provides a dataProvider, an authProvider, and OpenAPI-schema-driven UI guessers, allowing developers to generate a complete admin interface from a Supabase project with minimal configuration. The dataProvider translates react-admin CRUD operations into Supabase REST queries, supporting pagination, sorting, filtering, and embedded relationships through a custom `@` syntax. The authProvider wraps Supabase Auth, handling email/password login, OAuth callbacks, password reset, and session management. The guessers fetch the Supabase OpenAPI schema and generate List, Show, Edit, and Create pages, or a full `<AdminGuesser>` scaffold.
This is the official Supabase SSR library (`@supabase/ssr`), a TypeScript package that provides `createBrowserClient` and `createServerClient` functions for using Supabase authentication in server-side rendering frameworks like Next.js, Remix, SvelteKit, and React Router. The library manages user sessions entirely via cookies, handling cookie chunking (splitting large JSON payloads across multiple cookies to respect browser size limits), base64url encoding for safe cookie values, and PKCE code verifier lifecycle. It exposes a `getAll`/`setAll` cookie interface that framework adapters implement to read and write cookies from request/response objects. The server client uses lazy session initialization and writes updated tokens back to cookies on auth state changes, with cache-control headers to prevent CDN caching of auth responses. The package also includes a `clearAuthCookiesAtScopes` migration helper for cleaning up stale cookies after domain/path changes. The codebase is well-tested, actively maintained, and follows modern TypeScript practices with strict mode and no top-level side effects.
CADAM is a production-grade, open-source web application that converts natural language descriptions into fully parametric 3D CAD models. It operates in two primary modes: parametric (generating OpenSCAD code via an AI agent that can iterate with live previews) and creative (producing 3D meshes via external providers like Meshy and Tripo). The application is built with React 19, TypeScript, TanStack Start, Vite, and Tailwind CSS, with a Supabase backend for authentication, database, and file storage. AI integration spans multiple providers (Anthropic, OpenAI, Google, xAI, and others) via the Vercel AI SDK, and the generated OpenSCAD code is compiled in-browser using a vendored WebAssembly build of OpenSCAD. The system includes a token-based billing model, real-time preview updates, parameter editing, and export to STL, OBJ, GLB, and other formats. Although primarily an application, the benchmarks directory serves as a research record of the quality of generated parametric models, covering complex assemblies like a V8 engine and turbofan.
BookWith is a next-generation e-reader application that enhances traditional book reading with AI capabilities. The system allows users to upload and read EPUB books, annotate text, interact with an AI chatbot for contextual questions about the content, and generate AI-powered podcasts from book material. The architecture follows a client-server model with a Next.js/React frontend and a FastAPI/Python backend, employing domain-driven design principles. Key features include a multi-layer memory system for maintaining conversation context, semantic search via Weaviate vector database, and integration with external AI services like Gemini and Google Cloud Text-to-Speech. The frontend uses modern React patterns with Zustand/Jotai for state management, Tailwind CSS for styling, and shadcn/ui-inspired components. The backend utilizes PostgreSQL for relational data, implements clean architecture with separate domain/application/infrastructure layers, and provides a well-structured API with automatic OpenAPI schema generation.
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 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.
This repository contains the source code for a personal link-in-bio website (moure.dev) built with the Reflex Python web framework. It serves as both a live production site and a practical example for a 13-hour web development course. The application is a full-stack Python app with a static frontend (React/Reflex) and a Dockerized backend. It integrates multiple external APIs: Twitch (live status), Supabase (featured content), ConfigCat (feature flags), and Beehiiv (newsletter). The architecture follows a component-based design with reusable UI elements (link buttons, cards, navbar, footer) and a centralized state management pattern. The frontend is exported as static HTML/JS and hosted on Vercel, while the backend runs on Railway. The code is well-structured, uses modern Reflex with Radix UI, and includes deployment scripts and a GitHub Actions CI pipeline. It is primarily a learning resource and a functional personal site, not a generic library or framework.
This repository provides a fully automated, one-command deployment of a self-hosted Supabase stack. The setup script (`setup.sh`) orchestrates the entire process: it installs dependencies, clones the repository, generates cryptographic secrets and JWT tokens, configures environment variables, and layers optional docker-compose overrides for Authelia 2FA, Nginx or Caddy reverse proxy, and SSL via Let's Encrypt. The architecture is a Docker Compose multi-service deployment including Supabase Studio, Kong API gateway, GoTrue auth, PostgREST, Realtime, Storage, Edge Functions, and a custom Postgres image. The code is production-grade with robust error handling, CI/CD pipelines (GitHub Actions) that test every configuration matrix (caddy/nginx, basic auth/authelia/redis), and comprehensive integration tests covering CRUD operations, storage, realtime subscriptions, and edge functions. The repository also includes advanced utilities for key management (asymmetric JWTs, opaque API keys) and a sophisticated Postgres 15-to-17 upgrade script (`upgrade-pg17.sh`) that handles binary extraction, pg_upgrade, and post-migration patches. While primarily a deployment tool, the scripts demonstrate high craftsmanship and are safely reusable as templates for similar self-hosting scenarios.
This repository is a large, personal competitive programming solution archive spanning multiple platforms (LeetCode, Codeforces, CSES, AtCoder, etc.) with a companion Next.js web application (LeetGoat) for managing and browsing problems. The codebase contains over 3,900 files, predominantly short algorithmic solution scripts in Python, C++, and JavaScript, accompanied by reusable algorithm templates and a structured problem metadata system using Prisma and Supabase. While the primary content is the solution library, the integrated web application provides authentication, admin CRUD for problems and tags, drill grouping, and practice pages. The app uses tRPC for type-safe APIs, Supabase for auth, and Prisma for database access. However, many site pages are placeholders ("Coming Soon"), indicating an early-stage product. Code quality varies widely: many solutions are well-commented and demonstrate strong algorithmic thinking (DP, segment trees, graph algorithms), while others are incomplete, contain known bugs, or carry disclaimers like "BAD SOLUTION". The templates directory contains genuinely reusable components (sparse tables, DSU, segment trees, centroid decomposition) that could be extracted for other projects. Maintenance is ongoing with frequent commit activity, but the sheer volume and mixed concerns (solutions + web app) introduce technical drift. No testing suite or CI is evident, and some solutions depend on external libraries (sortedcontainers) not always available in competitive programming environments.