hayes/pothos

Features

• Type-Safe API Schemas - Constructs type-safe GraphQL schemas using TypeScript definitions to ensure consistency without external code generation.
• Type-Safe Schema Construction - Implements a code-first framework for defining type-safe GraphQL schemas directly in TypeScript.
• Column Selection Optimizations - Optimizes performance by ensuring only the specifically requested columns are fetched from the database.
• Database Record Querying - Provides mechanisms to retrieve database records while merging GraphQL field selections directly into the underlying database query.
• Database Relationship Mappings - Maps relational database associations to GraphQL fields with integrated support for filtering, ordering, and argument-based parameters.
• GraphQL Data Mappers - Implements a dedicated data mapper to connect GraphQL types to relational databases and ORMs with optimized resolution.
• Object-Relational Mapping - Provides a data mapper that connects GraphQL object types to relational database tables and ORM models like Prisma.
• Object-Relational Mapping Models - Maps Prisma database models to GraphQL object types and optimizes relation resolution to prevent performance issues.
• Cursor-Based Pagination - Defines connection and edge types supporting offset, array, and cursor-based pagination for large datasets.
• Query Planning - Replaces standard resolvers with optimized data-fetching plans that merge API selections into database queries.
• Data-Fetching Plan Execution - Replaces standard resolvers with data-fetching plans to improve query performance and eliminate redundant database calls.
• Relational Database Integrations - Integrates with relational query builders to optimize query resolution and eliminate N+1 fetching problems.
• Request Batching - Groups multiple individual field requests into single database operations to prevent N+1 performance issues.
• Object Mappings - Automatically maps database table definitions to type-safe GraphQL object types with customizable field naming.
• Context-Aware Access Control - Calculates required authorization scopes dynamically based on the parent object value or the request context.
• Field-Level Access Controls - Enforces granular read/write authorization at the individual field and type level using dynamic scopes.
• Scope-Based Visibility Controls - Enforces field-level authorization by calculating required permissions based on request context or parent objects.
• Authorization Rule Composition - Combines multiple authorization requirements using logical operators to require specific scopes.
• GraphQL Authorization Frameworks - Provides a granular authorization framework for enforcing field-level access control and scope-based permissions.
• Fine-Grained Permission Checking - Determines access rights at runtime using scope loaders that depend on specific resources or user permissions.
• Authorization Scope Definition - Enforces access control on queries and mutations by requiring requests to possess specific authorization scopes.
• N+1 Query Prevention - Prevents N+1 query issues by batching data requests for nested fields.
• GraphQL Performance Optimizers - Solves N+1 query problems and reduces database roundtrips through request batching and optimized data-fetching plans.
• Relay Global Object Identification - Implements a Relay-compliant system that encodes type and database IDs into single opaque strings for global resolution.
• Code-First Serialization Engines - Defines the GraphQL schema directly on application types using TypeScript, eliminating the need for external schema files.
• Global Object Identifiers - Implements globally unique IDs for types with utilities to encode, decode, and resolve them for direct retrieval.
• Type Definitions - Implements type-safe definitions for the shape and structure of data objects within the GraphQL schema.
• GraphQL Schema Generation - Acts as a code-first framework for defining and generating type-safe GraphQL schemas.
• Relay Mutation Generation - Generates mutation fields along with required input and payload objects, including standard client mutation identifiers.
• Relay Specification Implementations - Defines object types that implement a global interface to fetch single or multiple nodes by their unique identifiers.
• Input Validation - Checks GraphQL field arguments and input objects using schema-based libraries to ensure data conforms to constraints.
• Relationship Aggregators - Calculates derived statistical summaries, such as counts or sums, from data relationships without loading full records.
• API Type Variants - Supports defining multiple distinct object types from a single data source to represent different roles or views.
• Query-to-Stream Adapters - Transforms static GraphQL queries into live data streams using triggers that push updates upon data changes.
• Real-time Data Subscriptions - Transforms static queries into live data streams by registering triggers that push updates when data changes.
• Input Validation Schemas - Verifies the format and constraints of GraphQL input data using schema-based validation before processing.
• Partial List Error Handling - Wraps individual list elements in union types to support partial failures where some items return data and others return errors.
• GraphQL Error Formats - Implements structured error responses using union types to provide type-safe feedback for partial failures.
• Custom Error Type Definitions - Constructs union types containing success and error shapes to provide granular, type-safe control over field return values.
• Error to Value Wrapping - Wraps resolver results in sum types that automatically resolve to error objects when exceptions are thrown.
• Query Complexity Calculators - Calculates the total cost of queries based on multipliers and arguments to reject requests that exceed resource limits.
• API Schema Subset Generation - Generates multiple variations of a single schema to expose different fields and types for public and internal consumers.
• Union Types - Uses GraphQL union types to return structured error objects instead of throwing top-level exceptions.
• GraphQL Sub-Graph Partitioning - Allows splitting a single schema into multiple subsets to share logic between public and internal API endpoints.
• Schema-Integrated Error Types - Incorporates dedicated error types directly into the GraphQL schema and links them to the underlying resolver logic.
• Type Safety and Schema Construction - Plugin based GraphQL schema builder for TypeScript.

Star history