@fastify/cookie is a Fastify plugin that adds cookie handling capabilities to Fastify applications. It provides automatic parsing of incoming cookies via Fastify hooks and methods to set, clear, and sign cookies on responses. The plugin integrates with Fastify's lifecycle through decorators and hooks, supporting various hook points for cookie parsing (onRequest, preParsing, etc.). It includes robust security features like cookie signing with HMAC, key rotation support, and protection against timing attacks. The implementation follows Fastify plugin best practices and provides both high-level convenience methods and low-level utilities for direct use.
Apache ShardingSphere ElasticJob is a distributed job scheduling framework providing elastic sharding, failover, misfire handling, and lifecycle management. It is a Java library that can be embedded in applications or used via Spring Boot auto-configuration. The system coordinates jobs across multiple nodes using a registry center (ZooKeeper, etcd, Nacos, or in-memory). It supports multiple job types (simple, dataflow, script, HTTP) and provides RESTful admin APIs, event tracing, and error notification. The architecture is modular with clear SPI-based extensibility for job executors, error handlers, tracing listeners, and registry center providers. The codebase is well-engineered with extensive tests, but retains some legacy integration paths (Spring XML namespace) and tight coupling to ZooKeeper in core modules.
Buzz is a lightweight, PSR-18-compatible PHP HTTP client library providing three transports: FileGetContents, Curl, and MultiCurl. The MultiCurl client supports both asynchronous requests and HTTP/2 server push. Architecture follows a middleware chain pattern through the `Browser` class, which wraps any client and allows request/response modification via pluggable middleware. Built-in middleware covers authentication (Basic, Bearer, Digest, WSSE), cookie management, content-length, content-type auto-detection, request logging, and history recording. The library integrates with Symfony OptionsResolver for configuration validation and supports PSR-7, PSR-17, and php-http/httplug interfaces. It is a mature, stable library primarily in maintenance mode but still receiving compatibility updates and bug fixes.
nanoexpress is a professional backend framework for Node.js built on top of uWebSockets.js for high performance. It provides HTTP server functionality with routing, middleware support, WebSocket capabilities, request validation using AJV, Swagger/OpenAPI documentation generation, and utilities for file serving, compression, and cookie handling. The framework follows a modular architecture with core components including App (application wrapper), Config (configuration handling), and Route (routing system with middleware chain). It emphasizes performance while maintaining Express-like usability patterns.
This repository is a Laravel package that provides middleware for integrating with the IPinfo API to enrich HTTP requests with IP geolocation and related data. It supports multiple API tiers (Core, Plus, Lite, and Residential Proxy) and includes features like caching, IP selection strategies, bot filtering, and exception handling. The package follows Laravel conventions with service providers, facades, and configurable middleware. It is actively maintained with recent commits and supports Laravel versions up to 13. The codebase is well-structured, with clear separation of concerns and reusable components like the caching mechanism and IP selector interface.
This repository is the `pyTelegramBotAPI` Python library, providing both synchronous (`TeleBot`) and asynchronous (`AsyncTeleBot`) implementations for building Telegram bots. It acts as a wrapper around the Telegram Bot API, handling all message types, inline queries, payments, webhooks, polling, and more. The library's architecture is layered: a user-facing bot class that exposes method calls to a core API helper module (`apihelper.py` / `asyncio_helper.py`), which performs HTTP requests to Telegram servers. Bot logic is structured via message handlers (decorator-based), custom filters, middleware hooks, and a state machine with pluggable storage backends (memory, Redis, pickle). Key entry points include `TeleBot` and `AsyncTeleBot` classes, with webhook support via `SyncWebhookListener` and `AsyncWebhookListener` in the `ext` module. The library relies on `requests` (sync) and `aiohttp` (async) for HTTP, with optional dependencies `redis`, `Pillow`, `fastapi`, `uvicorn`, and `watchdog`. It is extensively tested and documented, with over 50 examples covering typical bot patterns. While the codebase is mature and well-maintained, it exhibits some technical drift: duplicated sync/async helper modules, deprecated API parameters maintained for backward compatibility, and incomplete localization files. Overall, it is a solid, production-ready library for Telegram bot development.
This repository provides a reusable, interactive node editor library built on top of Dear ImGui. It is a pure C++ library with a public API that enables embedding a visual node/graph editor into any ImGui-based application. The core implementation handles node and link creation, dragging, selection, zoom/pan, context menus, cut/copy/paste, flow animations, and state serialization via a bundled JSON library. It is not a standalone application but ships with several examples and an application framework (Win32/DirectX11, GLFW/OpenGL) to demonstrate usage. The architecture is modular, with separate components for canvas rendering, bezier math, and JSON serialization, making individual parts reusable in other projects. The repository is well-maintained with active issue triage and recent commits, though it has medium technical drift due to heavy version-conditional code for Dear ImGui compatibility and reliance on some outdated dependencies (DirectX SDK, older stb versions).
This repository is a comprehensive multi-module Maven project that serves as a learning and demonstration resource for the Java ecosystem, specifically focusing on Spring Boot, microservices, middleware, and AI integration. It contains over 20 independent modules, each showcasing a specific technology or pattern: from core Spring features (AOP, events, lifecycle) to advanced distributed systems (Dubbo, gRPC, Netty, RocketMQ, Kafka, Redis, Elasticsearch, ShardingSphere, Sentinel, Nacos, Curator) and modern AI capabilities (LangChain4j-based RAG, agentic workflows, guardrails, MCP client, image generation, TTS). The architecture is a modular monolith where each module is independently runnable via its own Spring Boot application class, sharing a common utility library (whatsmars-common) for serialization, caching, consistent hashing, encryption, and logging. The AI module is particularly notable for implementing advanced patterns such as query compression, smart routing, re-ranking, structured output, and configurable agentic workflows (sequential, parallel, conditional, loop, supervisor). While the repository is not a single deployable product, it provides high-quality, well-documented examples that demonstrate non-obvious craftsmanship in areas like custom gRPC load balancing, consistent hashing with virtual nodes, and programmatic logger creation. The codebase is professionally written with good separation of concerns, though testing coverage is limited to utility classes. Overall, it is a valuable reference for Java developers exploring modern frameworks and AI integration patterns.
pointfreeco/swift-web is a collection of modular Swift libraries for building server-side web applications. It provides a functional approach to routing (ApplicativeRouter using partial isomorphisms and applicative combinators), a type-safe CSS DSL (Css module), an HTTP pipeline middleware system with phantom types for state safety (HttpPipeline), URL form encoding/decoding, HTML rendering integration, and signed cookie support. The architecture is highly modular: each library can be used independently. The codebase demonstrates advanced functional programming patterns from the Point-Free ecosystem, including applicative functors, optics, and monoids. It relies on Apple's SwiftNIO for server I/O and supports both macOS and Linux via Docker. The project is experimental but well-tested with snapshot testing. It is best suited for Swift developers seeking a functional, composable web framework foundation.
Wavefront is an enterprise AI middleware platform, open-source alternative to tools like UnifyApps and n8n. It provides a full-stack system for building, managing, and deploying AI agents, chatbots, voice agents, knowledge bases (RAG), and AI-powered workflows. The monorepo includes a Python FastAPI backend with a modular, domain-driven architecture (agents, tools, knowledge base, voice, triggers, auth, API proxy), a React/TypeScript management console, background workers (Celery, stream processors), and the `flo_ai` Python agent framework (LLM wrappers, Arium graph engine, tool system). The platform supports multi-tenancy, RBAC, cloud storage abstractions (GCP/AWS/Azure), and pluggable datasource and authenticator modules. While primarily an application, it incorporates RAG pipelines, image embedding services, and model inference, giving it a hybrid character with strong data engineering elements.
CakePHP 5.x is a full-stack PHP web framework providing an MVC architecture, an ORM with behaviors and associations, a database abstraction layer supporting multiple drivers (MySQL, Postgres, SQLite, SQL Server), a PSR-7 compliant HTTP layer with middleware, a console/CLI framework, caching, internationalization, validation, and a comprehensive test suite. The architecture is highly modular, organized into distinct packages (Container, ORM, Database, Http, Console, etc.) that communicate via interfaces, events, and dependency injection. The codebase demonstrates exceptional craftsmanship in several areas: a composable collection pipeline using iterators (Filter, MapReduce, Tree), a robust and extensible database type system, a clean visitor-pattern-based debug output system, and a fluent filesystem traversal API. These components are self-contained and highly reusable. However, the codebase has a critical technical drift issue: it relies on a non-standard PHP syntax (e.g., `declare(strict_types=1)`, `use` for traits, `fn` closures, `match` expressions) that requires a transpiler. This creates a significant barrier to contribution, standard tooling compatibility, and long-term maintainability within the PHP ecosystem. Despite this, the underlying architecture and reusable components are of high quality.
This repository is a collection of standalone example applications demonstrating features of the Gin web framework for Go. It includes over 30 examples covering routing, middleware, authentication, file uploads, WebSocket, server-sent events, gRPC integration, OpenTelemetry, and more. Each example is a self-contained Go program with its own main.go and dependencies. The codebase serves as a learning resource and reference for Gin patterns, but is not a cohesive production system. Many examples are simple and straightforward, though some demonstrate non-trivial patterns like rate limiting, struct-level validation, and concurrent room management.
Lavandula is a lightweight C web framework designed for building small web applications quickly. It provides HTTP server functionality with routing, middleware pipeline support, SQLite3 integration, and a built-in JSON library. The framework includes a CLI tool (lavu) for project scaffolding and features a 'hot restart' mechanism for development. The codebase is well-organized with clear separation of concerns between HTTP parsing, routing, middleware, and database operations. However, the README explicitly states it's in early development and not production-ready, with several features still in progress including multithreading, TLS, rate limiting, and the Lavender ORM layer. The framework demonstrates solid C engineering practices with proper memory management, error handling, and a comprehensive test suite covering core components like JSON parsing, authentication, CORS, and HTTP parsing.
socketio-wildcard is a small Node.js library that adds a wildcard event listener ('*') to socket.io, allowing developers to catch all incoming events in a single handler. The core implementation is a middleware that intercepts the `onevent` method of a socket, emitting a wildcard event before delegating to the specific event handler. It supports both server-side and client-side usage, with a single-file module that exports a factory function. The library is deprecated as socket.io 2.0.4+ includes native middleware for packet interception, which supersedes the wildcard pattern. The codebase is clean, well-tested, and follows modern JavaScript standards, but its functionality is largely redundant with current socket.io features. The repository includes comprehensive integration tests using mocha and power-assert, and CI configurations for Travis and CircleCI.
This is the Katana project: Microsoft's implementation of the OWIN (Open Web Interface for .NET) specification for .NET Framework. It provides a middleware pipeline, hosting infrastructure (self-host via HttpListener and IIS integration via System.Web), and a rich set of middleware including static files, diagnostics, CORS, and an extensive authentication/authorization suite covering cookies, OAuth 2.0, OpenID Connect, WS-Federation, JWT, and social providers (Google, Facebook, Twitter, Microsoft Account). The architecture is built around the OWIN environment dictionary flowing through composable middleware. Key entry points include `WebApp.Start()` for programmatic hosting, `OwinHttpHandler`/`OwinHttpModule` for IIS integration, and the `OwinHost.exe` command-line tool. The codebase is well-architected with patterns like `AuthenticationHandler<T>` base class, `IAppBuilder` extensions, and service abstraction interfaces, but it is deprecated in favor of ASP.NET Core. It targets .NET Framework 4.5 exclusively and uses legacy package management (`packages.config`). While the core patterns remain instructive, the library is not directly reusable for modern .NET development without significant porting.
This repository is a Vue Router plugin that provides a fluent, Laravel-inspired API for defining routes. It allows developers to declare routes, redirects, nested groups, and route guards using a chainable syntax. The library is archived and retired in favor of a successor project called Routier. The core functionality includes a factory for managing route state, a route class for defining individual routes, and a guard base class for creating route middleware. Despite being archived, the code demonstrates solid engineering practices, particularly in the reusable Guard base class which implements a promise-based interception pattern.
GraphQL Playground is a full-featured GraphQL IDE (similar to GraphiQL) that provides an interactive development environment for GraphQL APIs. It includes a React-based frontend with query editing, schema exploration, documentation, subscriptions, and history. The repository is a monorepo (Lerna + Yarn workspaces) containing packages for the core React app (`graphql-playground-react`), an Electron desktop app (`graphql-playground-electron`), an HTML embedding page (`graphql-playground-html`), and server middleware for Express, Koa, Hapi, and Lambda. The architecture is a typical React + Redux + Redux-Saga + Immutable.js stack with CodeMirror for editors and Apollo Link for network execution. The project is now archived; future development has moved to GraphiQL. The codebase shows signs of age (outdated dependencies, legacy lifecycle methods, global variable assignments) and has had two documented XSS vulnerabilities. Despite this, some components like the schema fetcher, theming system, and middleware wrappers demonstrate solid engineering patterns.