This is a Nuxt.js 2 authentication module that provides zero-boilerplate authentication support. It implements various authentication schemes (local, OAuth2, OpenID Connect, refresh tokens) and integrates with popular providers like Auth0, Google, Facebook, and Laravel-based systems. The module handles token storage, automatic refresh, user management, and provides middleware for route protection. It uses a modular architecture with core auth logic, scheme implementations, provider configurations, and utility functions.
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.
axios-hooks is a React library that provides custom hooks for making HTTP requests using axios, with built-in caching, request cancellation, server-side rendering (SSR) support, and configurable defaults. The library exposes a default `useAxios` hook and a `makeUseAxios` factory to create pre-configured instances with custom axios versions, cache implementations, and default options. The hook manages request lifecycle through React's `useReducer`, automatically executes requests on component mount (unless `manual` is true), and supports manual refetch with optional cache usage. It integrates with `lru-cache` for response caching, allowing both client-side caching and SSR hydration via `serializeCache`/`loadCache`. The architecture is a single-component library with a clean API surface. Key entry points are the default export `useAxios` and named exports `configure`, `makeUseAxios`, `loadCache`, `serializeCache`, and `clearCache`. The primary data flow is: component calls `useAxios(config, options)`, which triggers an axios request (with optional cancellation via `AbortController`), stores the response in cache, and updates component state (`loading`, `data`, `error`, `response`). External dependencies are `axios` (peer), `react` (peer), `lru-cache`, and `dequal` for deep equality checks. The library is well-tested with Jest and includes TypeScript type definitions. The code exhibits quality engineering practices: proper use of React hooks (useMemo, useCallback, useRef, useReducer), deep comparison memoization to avoid unnecessary re-renders, abort controller for request cancellation, and a factory pattern (`makeUseAxios`) that enables multiple independent hook instances. The test suite covers edge cases like cancellation, cache behavior, SSR, and option change detection.
Zodios is a TypeScript library that provides a fully typed and validated REST API client built on top of axios and zod, along with a companion server adapter for Express. The core library (`@zodios/core`) offers a centralized API definition format using zod schemas, auto-complete for paths and parameters on the client side, and runtime validation of both request parameters and responses. It includes a sophisticated plugin system for intercepting requests and responses with support for named plugin replacement and per-endpoint registration. The library also provides helper functions for building API definitions (`makeApi`, `apiBuilder`, `parametersBuilder`, `makeCrudApi`, `mergeApis`) and internal plugins for form-data, form-url, and text request formats. The system is designed for end-to-end type safety, allowing developers to share API definitions between client and server code. It has been well-architected with a clean separation of concerns: the client class (`Zodios`) handles HTTP communication through axios and delegates schema validation to the validation plugin, while the API definition helpers provide a builder pattern for composing endpoints. The plugin system is particularly notable for its flexible registration (global, by alias, or by method+path) and its correct reverse-order execution for response interceptors. Overall, the codebase demonstrates strong TypeScript craftsmanship, disciplined use of type inference and utility types (e.g., path parameter extraction at the type level), and a modular design that allows features like CRUD generation and API merging. While not revolutionary, it is a solid, production-quality library that effectively solves the problem of type-safe REST communication.
Formvuelar is a Vue 3 form component library designed for backend-driven form workflows, with first-class support for Laravel-style validation responses. The source defines 19+ Fvl* components (input, textarea, select, search select, tag select, checkboxes, radio, switches, sliders, color/date pickers, file uploads, dropzone) and a root FvlForm component that coordinates submission, error display, dirty-state tracking, and upload progress. The core architecture uses provide/inject plus mixins: FvlForm creates a form context object and child controls inject it via formControl.js to read backend errors, clear errors on input, and expose loading and upload state. Submission is handled by Axios with per-form instances and interceptors; the library expects Laravel's 422 { message, errors } payload by default but can be adapted through global $formvuelar configuration.
This repository is a Vue.js single-page application that demonstrates the use of the Composition API via the @vue/composition-api plugin in a Vue 2 project. It fetches data from the CNode API to display a list of topics, includes a search bar for filtering, and uses WeUI for styling. The application consists of a few components (Header, Search, Panel) and a simple global store for state management. While the code is functional and correctly implements the Composition API patterns, it suffers from tight coupling to the global store, outdated dependencies, and a lack of error handling or loading states, making it suitable for learning but not for production use without significant improvements.