NestJS is a progressive Node.js framework for building efficient, reliable, and scalable server-side applications. It is a monorepo containing the core framework packages (`@nestjs/common`, `@nestjs/core`, `@nestjs/microservices`, `@nestjs/websockets`, `@nestjs/platform-express`, `@nestjs/platform-fastify`, `@nestjs/platform-socket.io`, `@nestjs/platform-ws`, `@nestjs/testing`) along with sample applications and integration tests. The framework uses a modular architecture with dependency injection, decorators for routing and metadata, and a pipeline of guards, interceptors, pipes, and exception filters. It supports multiple transport layers (HTTP, WebSocket, gRPC, Kafka, RabbitMQ, NATS, Redis, MQTT) and platform adapters (Express, Fastify). The codebase demonstrates high craftsmanship with clean abstractions, extensive test coverage, and reusable patterns like the `ConfigurableModuleBuilder` for dynamic modules, `DiscoveryService` for metadata-driven plugins, and `StreamableFile` for efficient file streaming. It is actively maintained with a large ecosystem and community.
Refine is a headless React framework for building data-intensive applications like admin panels, dashboards, and internal tools. It provides a UI-agnostic core with adapters for Ant Design, Material UI, Mantine, and Chakra UI, plus data providers for REST, GraphQL, Supabase, Strapi, and other backends. The architecture centers around provider patterns (dataProvider, authProvider, etc.) and React Query-based hooks for data fetching and mutations. Key features include automatic CRUD generation via inferencer, undoable notifications, access control, i18n, and live updates. The monorepo structure manages numerous packages and examples, demonstrating a mature ecosystem with active development and comprehensive documentation.
TREK is a full-featured, self-hosted travel planning application built with NestJS (server) and React (client). It enables users to create trips, manage day-by-day itineraries, add places and reservations, track budgets, maintain packing lists, collaborate via real-time chat/notes/polls, and journal memories. The architecture is a monorepo with client, server, shared schemas, and a plugin SDK. Key capabilities include offline-first support via IndexedDB with a mutation queue, real-time WebSocket collaboration, MCP (Model Context Protocol) integration for AI tools, a plugin system with sandboxed RPC host, OAuth 2.1, OIDC SSO, passkeys, and a storage abstraction layer supporting local and S3 backends. The application is production-ready with extensive test coverage (Vitest, Playwright E2E, MSW mocks) and internationalization across 23 locales. The codebase demonstrates strong engineering practices: modular NestJS domains, Zod schema-first validation shared between client and server, idempotent mutation handling, and a well-designed plugin SDK with permission gating and digital signatures.
Hoppscotch is an open-source, multi-platform API development ecosystem that serves as a full-featured alternative to Postman. It supports REST, GraphQL, WebSocket, SSE, Socket.IO, and MQTT protocols, with advanced features like pre-request and test scripting (sandboxed), environment variables, team collaboration, mock servers, published documentation, AI assistant, and extensive import/export (Postman, Insomnia, OpenAPI, HAR, cURL). The monorepo is organized into packages: a Vue 3 frontend (hoppscotch-common), a NestJS/GraphQL/Prisma backend (hoppscotch-backend), a Tauri desktop app (hoppscotch-desktop), a Node.js CLI (hoppscotch-cli), a Tauri agent for interceptor (hoppscotch-agent), a shared kernel abstraction layer (hoppscotch-kernel), versioned data schemas (hoppscotch-data), a JavaScript sandbox engine (hoppscotch-js-sandbox), and self-hosted web/admin panels. The architecture emphasizes functional programming with fp-ts, reactive state management via RxJS DispatchingStores, dependency injection with dioc, and a kernel/relay pattern that abstracts HTTP execution across platforms. The codebase is actively maintained with extensive test coverage and demonstrates high craftsmanship in areas like versioned data migration, sandboxed script execution, and cross-platform kernel design.
Vendure is a mature, open-source headless commerce platform built on NestJS, GraphQL, and TypeORM. It provides a complete backend for e-commerce operations including product catalog management, order lifecycle, payment/shipping/tax processing, promotions, and multi-channel support. The monorepo contains a core backend package, two parallel admin UIs (an older Angular-based admin-ui and a newer React-based dashboard), a CLI tool for scaffolding and migrations, and a plugin ecosystem with official plugins for email, asset server, job queues (BullMQ), caching (Redis), telemetry (OpenTelemetry), and AI integration via the MCP (Model Context Protocol) plugin. The architecture is modular with a strategy pattern for extensibility, an event bus for domain events, a job queue system, and a custom fields system. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, and active maintenance. Notable reusable components include a generic finite state machine framework, a runtime-resolved custom fields system, an OAuth 2.1 authorization server, a dynamic form engine, and a tag-based cache invalidation service.
Necord is a NestJS module for creating Discord bots that integrates Discord.js with the NestJS dependency injection system. It provides decorators for defining Discord interactions (slash commands, context menus, message components, modals, etc.) and handles event listening through a discovery mechanism. The architecture follows NestJS patterns with modules, providers, and decorators, using explorer services to scan for decorated methods at runtime. Key features include automatic command registration, custom parameter decorators for interaction data, and advanced context management for asynchronous event handlers using Node.js async_hooks.
The e-invoice-eu repository is a monorepo providing a toolchain for generating EN16931-compliant electronic invoices (UBL, CII, Factur-X/ZUGFeRD, XRechnung) from spreadsheet data or JSON. It consists of a core TypeScript library, a CLI tool, a NestJS-based REST API server, and documentation. The core library implements a strategy pattern for format services, a factory for creating them, a mapping service for spreadsheet-to-invoice transformation, and validation services. The architecture is modular and well-tested, with clear separation of concerns.
Immich is a high-performance, self-hosted photo and video management platform composed of a NestJS backend server, a SvelteKit SPA frontend, a Python FastAPI machine-learning service, a Flutter mobile client (iOS/Android), a CLI tool, and a TypeScript SDK. The server orchestrates asset ingestion, metadata extraction (EXIF, OCR, facial recognition, CLIP embeddings), video transcoding (HLS), and background job processing via BullMQ/Redis, with PostgreSQL (Kysely ORM + vector extensions for smart search) as the primary data store. The ML service provides ONNX-based inference for CLIP visual/textual embeddings, face detection/recognition (InsightFace), and OCR (RapidOCR), supporting multiple hardware accelerators (CUDA, ROCm, OpenVINO, ARM NN, RKNN). The architecture uses a multi-worker process model (API, microservices, maintenance) managed by a main process that handles lifecycle and restarts. Key data flows include: mobile/web upload → asset processing pipeline → metadata extraction → ML inference → search indexing, with real-time sync via WebSocket/Redis adapter and a full incremental sync API for mobile clients. The codebase demonstrates strong engineering practices: comprehensive repository pattern with 50+ repositories, extensive medium/integration test suites, schema migrations managed via Kysely SQL tools, OpenAPI-driven SDK generation for both TypeScript and Dart, and a plugin system using Extism WASM.
This is a full-stack AI chat platform (DIAL Chat) built as a monorepo with a NestJS backend-for-frontend (BFF) and a React single-page application. The backend proxies all requests to an external DIAL Core service, handling authentication (OIDC providers, cookie sessions, header tokens, CSRF), configuration aggregation (env, static defaults, feature flags), file management (upload, archive download, sharing, batch operations), conversation lifecycle (CRUD, streaming with SSE, naming, publishing/unpublishing, sharing by invitation), and skills/prompts/toolsets management with manifest import/export. The frontend provides a rich chat UI with conversation panel, attachment input with canvas for previewing PDFs, Office docs, images, and MCP app iframes, a catalog browser for models/agents/toolsets, scheduled tasks with recurrence forms, skill and prompt editors, usage limits dashboards, and overlay embedding for third-party host apps. Both apps share extensive typed libraries (22 private packages) covering the catalog, conversation hooks, shared UI components, and a generated OpenAPI client. The system follows a strict BFF pattern: the frontend never communicates directly with DIAL Core—all API calls go through the NestJS server, which adds session validation, resource ownership checks, and caching. Streaming chat completions use server-sent events (SSE) with a consistent init payload format. The overlay embedding protocol uses postMessage with a documented state machine, feature flags gated by backend configuration. Observable telemetry via OpenTelemetry instruments HTTP lifecycle, generation metrics, and runtime diagnostics with Prometheus endpoints. The codebase is thoroughly tested (Vitest for frontend, Supertest for NestJS integration, browser-level CSP tests) and includes CI/CD pipelines for OpenAPI regeneration, deployment, and e2e testing. Architecture is modular: domain-specific NestJS services are split into focused sub-services (e.g., ConversationsService delegates to ConversationListingService, ConversationPersistenceService, ConversationLifecycleService, ConversationStreamingService). React contexts are used for state management (no Redux), with custom hooks for entity operations. The monorepo leverages Nx for task orchestration, dependency graph enforcement, and bundle budget checks in libraries. External dependencies include DIAL Core (for AI model inference and file storage), various OIDC providers, and optional libraries like MCP UI client for sandboxed app rendering.
NocoDB is an open-source no-code database platform that provides a spreadsheet-like interface for managing relational databases. It supports multiple view types (grid, form, calendar, kanban, gallery, map, timeline, gantt), rich field types (formula, rollup, lookup, links, attachments, AI prompt), and automations via webhooks and scripts. The architecture is a full-stack monorepo: a NestJS backend with REST APIs (v1–v3), a Vue 3/Nuxt frontend with a custom canvas-based grid renderer, and a shared SDK (`nocodb-sdk`) for types, column helpers, and API client. Key entry points include the server bootstrap (`Noco.ts`), the Nuxt app, and the SDK. Data flows involve Knex-based query building with dialect-specific field handlers, caching via Redis, real-time updates via Socket.io, and background job processing via Bull. External dependencies include PostgreSQL, MySQL, SQLite, MSSQL, Oracle, Redis, and various storage/notification plugins. The codebase demonstrates high craftsmanship with reusable patterns such as column helpers, field handlers, builder generators, caching abstractions, and composables, though it contains many CE stubs for enterprise features and a large migration history.
Twenty is a production-grade, open-source CRM delivered as a large Nx monorepo. The system is a full-stack TypeScript application: a NestJS backend (twenty-server) exposing GraphQL/REST APIs, a React frontend (twenty-front) with Jotai-based state management, a shared UI component library (twenty-ui), and shared TypeScript packages (twenty-shared). It provides multi-tenant workspaces, object-record CRUD with custom data models, role-based permissions, AI chat/agent capabilities (model tiers, tool calls, streaming), analytics via ClickHouse, and a CLI scaffolding tool (create-twenty-app) for bootstrapping custom apps. The architecture is modular with NestJS ConfigurableModuleBuilder patterns, event-driven design using Zod-validated schemas, and component-scoped state via atom families and component instance contexts.
Postiz is a full-stack, open-source social media scheduling and publishing platform that supports 30+ platforms (Instagram, TikTok, LinkedIn, YouTube, X, Facebook, etc.). The system is built as a pnpm monorepo with four main applications: a Next.js frontend (App Router), a NestJS backend REST API, a Temporal-based workflow orchestrator for reliable post publishing and token refresh, and a Chrome extension for cookie-based authentication. It also includes a CLI app, a public SDK (@postiz/node), and a shared libraries layer for business logic, database access (Prisma + PostgreSQL), and integrations. Key architectural patterns include an abstract social provider base class (SocialAbstract) that all platform integrations extend, a Temporal v1.8+ workflow engine with versioned posting workflows (v1.0.1 through v1.0.8), an upload factory abstracting local and Cloudflare storage, an MCP server for AI agent tools (scheduling, content generation via LangGraph), a plug/auto-reply system, and a short-link abstraction with multiple providers. The frontend uses Zustand for state management, SWR for data fetching, CopilotKit for AI textarea integration, and Mantine/Tailwind for UI. The system handles OAuth flows, subscription billing via Stripe, team collaboration, webhooks, and admin monitoring. The codebase demonstrates strong engineering with reusable abstractions for social integrations, storage, email, and short-linking, though it carries some technical debt from organic growth (multiple workflow versions, hardcoded strings, and suppressed TypeScript strictness).
HeyForm is an open-source form builder and management platform designed for small businesses. It provides a full-stack solution with a React-based drag-and-drop form builder, a NestJS GraphQL API backend, a standalone form renderer for public-facing forms, and an embed script for third-party sites. The system supports a wide range of field types (text, choice, rating, payment, signature, etc.), conditional logic with branching, multi-language internationalization, Stripe payments, AI-assisted form generation via OpenAI, and integrations with popular services like Slack, Notion, and Google Sheets. The architecture follows a monorepo pattern with shared packages for answer validation, utility functions, and type definitions, enabling code reuse across the server, webapp, and renderer. The backend is built with NestJS, MongoDB (Mongoose), Redis (Bull queues), and Apollo GraphQL, with scheduled jobs for cleanup and async task processing. The frontend uses React 19, Tailwind CSS, Zustand for state management, and Apollo Client for GraphQL communication. Security is a strong focus: the codebase includes SSRF protection, upload content validation, rate limiting, atomic verification codes, and extensive input sanitization. The project has a comprehensive test suite covering unit, integration, and end-to-end scenarios, including a permission matrix with over 270 cases. Despite some duplicated logic and large locale files, the overall code quality is high, with well-structured modules and clear separation of concerns.
TSRPC is a TypeScript RPC framework designed for building type-safe, high-performance client-server applications. It provides both HTTP and WebSocket transports with optional JSON compatibility. The framework is built on a custom binary serialization algorithm (TSBuffer) that supports advanced TypeScript type features like union types, intersection types, and mapped types, eliminating the need for external IDL languages. TSRPC includes a rich middleware system called Flows, allowing interception and transformation of data at various stages of request/response processing. The core architecture is abstract and extensible: BaseServer, BaseConnection, and BaseCall form the foundation, with concrete implementations for HTTP (HttpServer, HttpConnection, ApiCallHttp) and WebSocket (WsServer, WsConnection, ApiCallWs). The client side mirrors this with HttpClient and WsClient that handle protocol encoding/decoding, timeouts, and automatic request aborting. The framework also supports server-to-client messages, broadcasting, heartbeat management, and graceful shutdown. With over 1900 GitHub stars and an active maintenance history (latest version 3.4.21), the codebase demonstrates solid engineering practices: comprehensive test coverage across multiple transport modes (HTTP, HTTPS, WS, WSS, both binary and JSON), clean separation of concerns, and robust error handling. The repository includes benchmarking tools and integration tests that verify correctness under various conditions.
Cal.diy is a fully open-source, MIT-licensed fork of Cal.com, providing a self-hostable scheduling platform. It is a large monorepo containing a Next.js web application (apps/web) for booking pages, settings, and admin, a NestJS API (apps/api/v2) for platform REST endpoints, and extensive packages for business logic (packages/features), integrations (packages/app-store with 50+ apps), embeddable booking widgets (packages/embeds), and reusable React atoms (packages/platform/atoms). The architecture uses tRPC for client-server communication, Prisma ORM with PostgreSQL, Redis caching, and a custom dependency injection system (ioctopus) alongside NestJS DI. Key patterns include a tasker abstraction for async/sync background jobs (webhooks, emails, calendar sync), a versioned webhook payload builder factory, repository pattern over Prisma, and a consistent app-store integration structure. The platform exposes a public API with OAuth2, webhooks, and embeddable components for third-party developers. The codebase is actively maintained with frequent schema migrations and CI/CD pipelines, but exhibits some technical drift due to dual API surfaces (tRPC vs REST), stub implementations for enterprise features, and generated files that require regeneration.
Novu is a comprehensive notification infrastructure platform designed for multi-channel delivery (Email, SMS, Push, Chat, In-App) and workflow orchestration. It functions as both a SaaS product and a self-hosted solution, providing a unified API to manage subscribers, triggers, and notification templates. The system integrates deeply with AI agents, supporting Model Context Protocol (MCP) and managed runtimes (e.g., Anthropic) for conversational notifications. The architecture is a TypeScript monorepo managed by Nx and pnpm, featuring a NestJS backend (API, Worker, WebSocket), React/Next.js frontend (Dashboard, Playground), and MongoDB/Redis/ClickHouse data stores. It emphasizes extensibility through a provider factory pattern and a programmatic workflow DSL.
Ghostfolio is an open-source wealth management application that enables individuals to track and analyze their personal investment portfolios. It supports multiple asset classes (stocks, ETFs, cryptocurrencies, bonds, real estate) and integrates with numerous financial data providers (Yahoo Finance, CoinGecko, Alpha Vantage, etc.) to automatically fetch market prices, historical data, and asset profiles. The system provides comprehensive portfolio performance calculations (ROAI, TWR, MWR), benchmark comparisons, dividend tracking, and a rule-based X-ray analysis for risk assessment (currency/asset class/regional cluster risk, emergency fund coverage, fee ratios). It also includes a FIRE calculator, watchlist, and import/export functionality for activities. The architecture follows a full-stack monorepo pattern using Nx, with an Angular 22 frontend (standalone components, Material Design, Chart.js) and a NestJS 11 backend (Prisma ORM with PostgreSQL, Redis caching, Bull queues for background data gathering). Authentication supports JWT, OAuth (Google, OIDC), API keys, and WebAuthn passkeys. The system is self-hostable via Docker Compose and includes a premium subscription tier managed through Stripe. The codebase is modular with shared libraries (`libs/common` for DTOs, interfaces, utilities; `libs/ui` for reusable Angular components) and a clear separation of concerns across API modules, services, and queue processors. Key highlights include a pluggable data provider abstraction, an abstract portfolio calculator with caching and retry logic, a comprehensive permission and scope system for fine-grained access control, and a rich UI component library with Storybook documentation. The project is actively maintained with frequent releases, extensive Prisma migrations, and a large test suite for portfolio calculations and import validation. While the codebase shows some technical drift (proliferation of environment variables, deprecated endpoints, and multiple data provider integrations), the overall engineering quality is strong, with well-structured modules and reusable patterns that could be extracted for other financial applications.
RedisInsight is a full-stack graphical user interface for managing and interacting with Redis databases. It is built as an Electron desktop application with a React frontend (utilizing styled-components and a custom component library) and a NestJS backend that communicates with Redis instances. The application covers a wide range of Redis features: key-value browser with support for all data types (strings, hashes, lists, sets, sorted sets, streams, JSON, arrays, vector sets), a workbench with a Monaco-based query editor, CLI, pub/sub, slow log, profiler, database analysis with optimization recommendations, cloud integration (Redis Cloud, Azure Cache, Redis Enterprise), Redis Data Integration (RDI) pipeline management, and an AI assistant. The architecture is modular with clear separation of concerns, using repository and strategy patterns extensively. The codebase includes comprehensive CI/CD, end-to-end Playwright tests, and a plugin system for custom visualizations.
OpenAPI Generator CLI is a Node.js/TypeScript command-line wrapper around the Java-based OpenAPITools/openapi-generator JAR. Despite using NestJS, it is not a server: NestJS provides a DI application context that wires a Commander CLI. On every invocation (main.ts → AppModule.onApplicationBootstrap), it reads openapitools.json, resolves a generator version (querying Sonatype's Solr search for the latest stable when unset), writes it back to config, downloads and caches the JAR — atomically, via temp file + rename — then asks the Java CLI itself (via `help` and `completion` output) what commands it exposes, registers them dynamically, and spawns `java -jar ... <command>` with inherited stdio. It supports HTTP(S) proxies, JAVA_OPTS, custom generator JARs (classpath merge), and a Docker execution mode. Beyond pass-through, the CLI adds value the raw Java tool lacks: a `version-manager` subcommand (list/set/remove tagged versions backed by an interactive table picker) and a config-driven batch generator in openapitools.json where named generators map glob patterns to invocations with placeholder tokens (#{name}, #{cwd}, #{relPath}, #{ext}, ...), executed concurrently (max 10 processes). The repo is an Nx single-app monorepo bundled into a shebang'd main.js and released via semantic-release; GitHub Actions CI runs lint, unit tests, and real Java-based E2E on Ubuntu and macOS. Unit test coverage is thorough across config, version management, command pass-through, and command construction. Genuinely clever parts: dynamic discovery of an external CLI's command surface, atomic binary caching, and a table-to-interactive-select UI. The warts: a ~100-entry hardcoded fallback version list embedded in source, a legacy root lib/index.js publishing script superseded by the webpack package plugin, leftover NestJS scaffolding (environment stubs, 'not a production server' comment), deprecated RxJS toPromise() usage, an ESLint root config that effectively ignores all files, and a Nix flake pinned to Node 18 while the package requires Node 22. It does what it claims and is actively maintained, but the residue keeps it from being exemplary.
ToolJet is a comprehensive low-code/no-code application development platform designed for building internal tools, workflows, and AI agents. The system features a visual drag-and-drop editor (AppBuilder) that allows users to construct UIs using a library of widgets, connect to diverse data sources via a plugin architecture, and manage application logic through a backend NestJS service. It supports multi-tenancy, version control (Git), and enterprise-grade security features like SSO and RBAC. The architecture is a monorepo with a React-based frontend and a NestJS-based backend, utilizing PostgreSQL for persistence and Redis for caching.