express-slow-down is an Express.js middleware library that rate-limits clients by slowing down responses instead of blocking them outright. It wraps `express-rate-limit` internally, using a custom handler that computes a delay based on request count and configurable options like `delayAfter`, `delayMs`, and `maxDelayMs`. The middleware increments a per-client counter (via a store, defaulting to an in-memory store), and when the count exceeds a threshold, it delays subsequent responses. It supports custom stores, async functions for dynamic delays, and standard/legacy rate-limit headers. The codebase is well-structured TypeScript with comprehensive unit and integration tests, and follows modern ES module and TypeScript practices.
FreeAPI is an open-source API hub that provides free REST APIs for learning and demonstration purposes. The backend is a monolithic Express.js application with MongoDB, offering a range of endpoints: static public data (cats, dogs, quotes, etc.), kitchen-sink features (HTTP methods, status codes, cookies, redirects), and full-featured CRUD applications (ecommerce, social media, chat, todo) with authentication (JWT, OAuth via Google/GitHub), real-time chat via Socket.IO, file uploads, email notifications, and payment integration (Razorpay, PayPal). The codebase is well-structured with reusable utilities (asyncHandler, ApiError, pagination helpers), modular validators, and seeding scripts. It also includes multiple React/Vite frontend examples (ecommerce with Redux, chat with Socket.IO, todo app, status code quiz) that demonstrate best practices in consuming APIs. The project is clearly a learning resource and demo platform, not a production service.
HeadlessX is a self-hosted web scraping and browser automation platform with anti-detection capabilities. It provides a Next.js 16 dashboard, an Express 5 API with Prisma/PostgreSQL, a BullMQ queue worker, and a published CLI. The core value proposition is anti-detection scraping via the headfox-js package (Camoufox-compatible Firefox bundles), fingerprint generation, CAPTCHA solving, and LLM-friendly markdown output. The system supports multiple operators: website scraping/crawling/mapping, Google AI Search, Tavily search, Exa search, and YouTube extraction. It includes sidecar services for HTML-to-Markdown (Go) and YouTube extraction (Python FastAPI). The architecture is a monorepo with Nx orchestration, Docker Compose deployment, and an MCP endpoint for AI assistant integration. External dependencies include Redis, Postgres, Playwright, MaxMind GeoIP, and external APIs (Tavily, Exa, Google). The codebase is well-structured with clear separation of concerns, modern TypeScript, and reusable patterns in both frontend and backend.
Evolution API is a production-grade, multi-tenant WhatsApp API gateway built with Node.js, TypeScript, and Express. It manages independent WhatsApp instances via Baileys (WhatsApp Web), Meta Business API, and its own Evolution API channel, providing REST endpoints for messaging, chat management, groups, labels, and media. The system integrates deeply with chatbot platforms (Typebot, OpenAI, Dify, Flowise, N8N, EvoAI, EvolutionBot) and event systems (Webhook, WebSocket, RabbitMQ, SQS, NATS, Kafka, Pusher), and includes storage via S3/MinIO and CRM sync with Chatwoot. The architecture follows a modular controller-service pattern with Prisma ORM (supporting MySQL and PostgreSQL), Redis caching, and centralized configuration. It is actively maintained with frequent updates, extensive migrations, and CI/CD pipelines.
FoalTS is a full-featured Node.js/TypeScript web framework structured as a monorepo with modular packages (core, CLI, JWT, TypeORM, GraphQL, storage, social auth, etc.). The framework provides declarative routing via decorators, a hook system for middleware/validation/authorization, dependency injection, and built-in support for OpenAPI, GraphQL, WebSockets, and file storage. Under the hood it uses Express, AJV, and TypeORM, with session stores for Redis, MongoDB, and SQL databases. The CLI generates projects, controllers, entities, and REST APIs, and includes upgrade commands across major versions. The codebase demonstrates solid engineering: thorough unit/e2e tests (over 2100 tests), documentation-as-tests, and a consistent pattern of abstract services (Store, Disk, Logger) resolved via configuration. Key reusable patterns include the hook/decorator system for validation and authentication, the abstract OAuth2 provider base class, and the CLI generator template engine. However, some deprecations (e.g., hashPassword→PasswordService) and outdated Docker images in development config indicate moderate technical drift. The project is actively maintained with frequent releases, daily CI on Node 22/24, and a well-documented upgrade path.
Alumnet is a full-stack, AI-powered alumni exhibition and management system designed for school history museums. It consists of three workspaces: a touch-screen kiosk frontend (client) built with Vue 3, Three.js, and Tailwind CSS; an admin dashboard (admin) using Vue 3 and Element Plus; and a backend server (server) built with Express, TypeScript, PostgreSQL (with pgvector), and Qdrant for vector search. The system provides alumni CRUD, AI-powered natural language search via RAG, 3D galaxy visualization, timeline corridor, interactive message boards, video greetings, donation management, and comprehensive admin controls including content audit, backup/restore, and data import. It features JWT authentication with role-based access, privacy data masking, rate limiting, and a layered architecture (routes → services → repositories). The codebase includes extensive testing (unit, integration, property-based with fast-check) and is deployable via Docker Compose or PM2. While primarily an application, it incorporates data engineering patterns through its RAG pipeline and knowledge base management.
CloudSaver is a full-stack web application (Vue 3 + Express) for searching and saving cloud storage resources from multiple sources. It scrapes Telegram channels for shared files, parses links to popular cloud drives (115, Quark), and allows users to transfer them directly to their own cloud storage via cookie-based API. The system includes user authentication (JWT), role-based access, a responsive UI for desktop and mobile, and Docker support for easy deployment. The backend is structured with dependency injection (Inversify) and follows a controller-service-model pattern, while the frontend uses Pinia for state management and separate routing for PC and mobile views. The codebase is well-organized and demonstrates solid engineering practices, though it remains a typical CRUD application without exceptional innovation.
MTranServer is a high-performance, offline machine translation server that provides a REST API, web UI, and desktop Electron application. It leverages Mozilla's Bergamot (Marian NMT) engine compiled to WebAssembly for on-device translation, with no GPU required and average response times around 50ms. The server supports major world languages, language auto-detection via CLD2 (also compiled to WASM), and offers compatibility endpoints for popular browser translation plugins such as Immersive Translate, DeepL, Google Translate, and Kiss Translator. The architecture is a TypeScript/Node.js monolith using Express with tsoa for typed controllers and Swagger generation, a React frontend with shadcn/ui, and an Electron desktop wrapper. The system includes model auto-downloading, LRU caching, worker-per-language concurrency, and offline mode. The repository contains a large deprecated codebase (Go, Node.js v1, Rust, C++ versions) which is not actively used but remains in the source tree, potentially causing confusion. The active code is well-structured and follows modern TypeScript practices, though some vendored dependencies (CLD2, Bergamot) are old and have been compiled to WASM to mitigate drift.
Nunjucks is a full-featured JavaScript templating engine heavily inspired by Jinja2 (Python). It compiles templates into JavaScript functions for high-performance rendering, supporting template inheritance, macros, filters, tests, async control, and custom extensions. The library runs in both Node.js and browser environments, with a slim build for precompiled templates. It integrates with Express as a view engine and provides a CLI tool for precompiling templates offline. The architecture follows a classic compiler pipeline: lexer → parser → AST → compiler → JavaScript function. The public API exposes Environment, Template, Loader, and various configuration methods. Templates are loaded via loaders (FileSystemLoader, WebLoader, PrecompiledLoader) and rendered synchronously or asynchronously. The library includes a rich set of built-in filters (escape, default, sort, groupby, etc.) and tests (defined, odd, mapping, etc.), all extensible via addFilter/addTest. Key entry points include nunjucks/index.js (main module), bin/precompile (CLI), and browser/nunjucks.js (UMD build). External dependencies are minimal: a-sync-waterfall for async control flow, asap for microtask scheduling, and chokidar for file watching. The codebase is well-tested with Mocha and has CI via GitHub Actions. While the core engine is well-crafted and actively maintained, the repository carries technical debt from vendored documentation dependencies (Bootstrap 3, jQuery 2, Bower) and an outdated build toolchain (Babel beta, PhantomJS). The library itself is production-ready and widely used (8.9k stars).
DesignFlow Kit is an open-source, full-stack web application that provides an AI-powered UX/Product Design toolkit. It features 8 AI chat assistants for various design workflows (research, personas, journey maps, wireframes, testing, workshops, information architecture, and general analysis), a Kanban-style sprint board with drag-and-drop and voice recording, a dashboard for progress tracking, a catalog of 41+ integrations, and pre/post-design kits. The frontend is built with React 18, TypeScript, Tailwind CSS, and shadcn/ui components, using Wouter for routing and TanStack Query for data fetching. The backend is an Express.js server with Drizzle ORM and PostgreSQL (with in-memory fallback), integrating with OpenAI GPT-4o for streaming chat, Whisper for transcription, and Resend for email-based OTP authentication. The application is deployed as a monolith via Replit-specific integrations, though the core stack is portable. The codebase is well-structured with clear separation of concerns, but suffers from significant duplication across the 8 chat page components and relies heavily on static data files for tool/integration catalogs. No automated tests are present, and the OTP flow includes a visible demo code in development mode, signaling some immaturity. Overall, it is a functional and feature-rich tool with moderate reusability of its core components.
Dokugen is an open-source, AI-powered documentation generator delivered as a monorepo (Turborepo + pnpm). The core product is a CLI that generates, updates, and maintains README files, AI commit messages, licenses, changelogs, and OG social cards. It ships three CLI clients (TypeScript, Python, and a Go stub), a companion Express backend that proxies AI API calls (DeepSeek, OpenRouter, Gemini) and tracks usage via Supabase, a Next.js documentation site, a minimal VS Code extension, and a Remotion promotional video project. The architecture is client-server: CLIs detect project type using a heuristic pattern-matching algorithm, scan files, and send compressed payloads to the backend for AI generation, with streaming SSE responses. The system also includes auto-update mechanisms, interactive menus, and caching. While the product is functional and well-structured, there is significant duplication across CLI implementations (e.g., project detection logic is nearly identical in TypeScript and Python but drifts), a Go client that is only a placeholder, and a VS Code extension that is boilerplate. The codebase demonstrates solid engineering practices (rate limiting, security hardening, Docker multi-stage builds) but suffers from maintenance overhead due to the multi-language surface and some stale generated artifacts.
Overseerr is a full-stack self-hosted web application for managing media requests in a Plex ecosystem. Users can search for movies and TV shows via TMDB, submit requests (including 4K variants), and have those requests automatically pushed to Radarr/Sonarr for download. The application also tracks media availability by scanning Plex libraries, syncs Plex watchlists, and provides a comprehensive notification subsystem supporting Discord, Telegram, Slack, email, webhooks, and web push. It includes user management with granular permissions, quota enforcement, issue reporting, and a highly customizable discovery page built from TMDB-driven sliders, genres, networks, and studios. The frontend is Next.js (React) with Tailwind CSS, SWR, Formik, and react-intl i18n; the backend is Express with TypeORM on SQLite. The project is feature-rich and has been widely adopted, but the README states it is superseded by the Seerr community fork, and the codebase relies on several aging dependencies (Next.js 12, React 18, Tailwind 3) and a hardcoded TMDB API key. Despite this, the code is well-organized with clear separation between API clients, entities, routes, and UI components, and many parts are written with solid engineering patterns such as a base external API client with caching/rate limiting, a template-method scanner base class, and a clean notification agent interface.
Stb (图床) is a full-stack image hosting service built as a pnpm monorepo. The backend is a Node.js/Express application with MongoDB (Mongoose) providing REST APIs for user authentication, image upload, album management, admin operations, and system configuration. The frontend is a Vue 3 single-page application using Pinia for state management, Vue Router with lazy-loaded views, and a mix of Ant Design Vue and Element Plus UI libraries. The system supports multiple storage backends (local filesystem, S3-compatible, Alibaba OSS, Tencent COS, Qiniu, Upyun, SFTP, FTP, WebDAV, Telegram, GitHub) via a pluggable adapter pattern, and integrates AI-based content moderation (Tencent, Aliyun, NSFWJS). Deployment is Docker-based with a multi-stage build and GitHub Actions CI/CD for multi-architecture images. The application includes a comprehensive admin panel for user, image, log, album, role group, invite code, and configuration management, as well as OAuth login (GitHub, Google, Linux DO), email verification, and a slider captcha component. While the codebase is functional and well-structured with clear separation of concerns, it exhibits some technical debt: mixed UI libraries increase bundle size, the configuration view is monolithic and exposes sensitive credentials to the client, there are no automated tests, and some patterns (e.g., IP detection, Docker entrypoint sed) are fragile. Overall, it is a solid, production-ready image hosting solution with reusable utility modules.
This repository is a production-grade RESTful API service designed to serve Holy Bible text across multiple translations (NVI, RA, KJV, etc.) and languages (Portuguese, English, French, Spanish). Built on a Node.js/Express stack with MongoDB for persistence and Redis for caching and rate limiting, it follows a standard MVC architecture. The system includes JWT-based authentication for user management and request tracking, alongside a static frontend served via Pug templates. While the API contract is well-documented via OpenAPI and Insomnia, the codebase exhibits significant technical debt, specifically regarding cryptographic security (MD5 password hashing) and outdated core dependencies (Jest v24, Mongoose v5). The architecture is functional and modular but relies on legacy frontend technologies (jQuery/Pug) rather than modern SPA frameworks.
Bull Exporter is a Prometheus metrics exporter for Bull queues running on Redis. It provides an HTTP server (default port 9538) that exposes queue state metrics (waiting, active, delayed, failed, completed counts) and job duration summaries. It supports automatic queue discovery by scanning Redis keys, and can also be run in one-shot mode to print metrics to stdout. The application is built with Express, Bull, ioredis, and prom-client, and is packaged as a Docker image. The codebase is well-structured with TypeScript, strict compiler options, comprehensive unit tests using Jest and real Redis, and CI/CD pipelines (Travis CI and CircleCI). However, the project has been stale since October 2020, uses very outdated dependencies (Node.js 10, TypeScript 3.9, old prom-client), and has no recent maintenance activity. The code quality is solid for its time but suffers from technical drift.
OpenUserJS.org is a Node.js/Express web application that serves as a hosting platform for user scripts (userscripts) and JavaScript libraries. It provides full CRUD operations for scripts, including upload, version management, GitHub import, and metadata parsing via PEG.js grammars. The platform includes community features such as user authentication (OAuth/OpenID via Passport.js), voting, flagging, moderation, discussions, issue tracking per script, and group management. The architecture follows a monolithic Express pattern with MongoDB (Mongoose) for persistence and AWS S3 for script storage. The frontend is server-rendered using Mustache templates with Bootstrap 3 and various client-side libraries (Ace editor, jQuery, highlight.js). The codebase demonstrates a comprehensive implementation of a community-driven script repository with rate limiting, security headers, and role-based access control (admin, moderator, user). Key modules include controllers for scripts, users, discussions, and moderation, along with utility libraries for model parsing, search, pagination, and async task orchestration. While the application is functional and has been in production for years, it exhibits significant technical debt: deprecated dependencies (request, underscore, moment), inconsistent error handling, hardcoded configuration, and a large number of TODO/FIXME comments. The code is not particularly modular or testable, and there are no automated tests visible in the repository. Despite these issues, the repository contains several well-crafted components that could be extracted and reused in other Node.js projects, such as the PEG.js grammar for userscript metadata parsing and the async task helper library. The overall quality is average, with room for improvement in modernisation, testing, and code organisation.