digitallyinduced/ihp

Features

• PostgreSQL Integrations - Integrates PostgreSQL relational data models with an application type system for compile-time query validation.
• Schema Type Synchronization - Automatically generates native language record types and enums directly from the PostgreSQL schema.
• Database Record Querying - Retrieves single or multiple records using type-safe queries and identifiers.
• Relational Record Fetching - Retrieves nested resources for a record and tracks fetched state at the type level.
• SQL Schema Definitions - Maintains a canonical SQL file that serves as the declarative definition of the database state.
• Database Transactions - Wraps multiple database operations in a transaction to ensure atomic commits.
• Type-Safe Query Construction - Provides a programmatic way to construct SQL queries with compile-time type safety and IDE autocompletion.
• Type-Safe - Maps the results of raw SQL statements directly into strongly-typed application records.
• Type-Safe Client Generators - Automatically generates type-safe database clients and record types from the SQL schema.
• Type-Safe Database Clients - Automatically generates record types from SQL schemas to ensure compile-time query validation.
• Type-Safe Record CRUD - Creates, updates, and deletes database records using type-safe functions.
• Infrastructure Provisioning - Automates the setup of web servers, background workers, and database instances using declarative modules.
• NixOS Deployments - Uses NixOS for declarative provisioning of production environments and reproducible system dependency management.
• Real-Time Data Synchronization - Provides real-time synchronization of database state and views to clients using WebSockets.
• Session State Management - Maintains stateful synchronization and session persistence between clients and servers over persistent WebSocket connections.
• Compile-Time Safe Templates - Uses a JSX-like syntax to create HTML templates that are fully type-checked at compile time.
• Database Schema Type Generation - Automatically generates native record types and identifiers from the database schema for compile-time safety.
• API Client Authentications - Secures API endpoints using a combination of API keys, bearer tokens, and session cookies.
• Automatic Template Escaping - Automatically escapes interpolated values in templates to prevent cross-site scripting attacks.
• Session Cookie Security - Manages secure session cookies using encryption keys and environment variables to prevent hijacking.
• Password Hashing Utilities - Uses specialized algorithms to transform user passwords into irreversible hashes for secure storage.
• SQL Injection Prevention - Prevents SQL injection by using parameterized queries to isolate user input from SQL commands.
• Full-Stack Orchestrators - Orchestrates the entire application lifecycle from database schema design to NixOS production deployment.
• Single Page Applications - Implements a single-page application architecture that updates content dynamically via bidirectional server communication.
• Compile-Time Type Validation - Provides compile-time validation of routing, database queries, and templates to prevent runtime crashes.
• SQL Query Validators - Verifies SQL syntax and result types against a live development database during the build process.
• Stateful UI Components - Creates stateful client-side elements that trigger server-side actions and update the view.
• Server-Driven DOM Patching - Patches changed sections of a page using server-side diffing and prefetching for seamless user experiences.
• Parameter Extraction - Retrieves and converts values from query strings and request bodies into supported types.
• URL Route Mapping - Maps RESTful URL patterns to specific controller actions for request handling.
• Type-Safe Expression Embedding - Injects variables and expressions into HTML markup using type-safe instances verified at compile time.
• Hypermedia-Driven Rendering - Generates type-safe HTML views and updates the DOM via server-driven hypermedia and partial page patching.
• Hypermedia Swapping - Updates specific page sections by sending HTML fragments from the server instead of JSON.
• PostgreSQL Web Frameworks - Provides a web development platform with a type-safe query builder and automated migrations based on PostgreSQL schemas.
• Real-Time Communication - Provides real-time web interfaces with bidirectional communication and instant data synchronization via WebSockets.
• Application Route Definitions - Defines mappings between URI paths, HTTP methods, and controller actions using a DSL.
• Server-Side Rendering Frameworks - Generates type-safe HTML views and updates the DOM via server-driven hypermedia and WebSockets.
• WebSocket State Synchronization - Maintains persistent bidirectional connections to push automatic UI updates when database records change.
• Type-Safe Routing - Verifies that URLs, controller actions, and template links are consistent at compile time.
• Type-Safe Web Frameworks - Verifies routing, database queries, and templates at compile time to prevent runtime crashes.
• URL Generators - Programmatically constructs full URLs and relative paths for consistent application linking.
• WebSocket Communication - Establishes bidirectional WebSocket communication for instant application updates.
• Authenticated User Retrieval - Retrieves logged-in user data and redirects unauthenticated users to the login page.
• Form Validation - Displays error messages and invalid CSS classes when record validation fails.
• Visual Schema Editors - Provides a built-in GUI editor for visually managing database tables and constraints.
• Automated Migrations - Automatically executes pending database migrations as a prerequisite before starting the application server.
• Database Integration Testing - Verifies data persistence and retrieval logic by running tests against a live database instance.
• Declarative Database Provisioners - Automatically provisions PostgreSQL databases and users during the initial server boot process.
• File Upload Management - Manages the storage and retrieval of uploaded files across local and cloud backends.
• Raw SQL Execution - Runs dynamic SQL queries where table or column names are computed at runtime.
• Configurable Storage Backends - Supports switching between different storage backends, such as local disk and cloud providers.
• Boilerplate Generators - Automatically generates controllers, views, and migrations from the IDE to accelerate development.
• Compile-Time Parameter Bindings - Binds URL path segments and query parameters directly to typed record fields at compile time.
• Web Application Hot Reloading - Refreshes the running application instantly upon code changes for immediate developer feedback.
• IDE Integrations - Connects editors to language servers to provide syntax highlighting and autocompletion.
• Live Script Execution - Executes script logic or inline code during development via an interactive session.
• Application Containerization - Packages the web server and background workers into portable container images for production.
• Reverse Proxy Configurations - Manages reverse proxy settings to support WebSockets, domain redirects, and SSL termination.
• Background Task Execution - Executes logic outside the web request cycle to handle reminders and queue processing.
• Custom Parameter Types - Implements custom parsing and rendering logic to map complex types to URL segments.
• Type-Safe Translation Keys - Uses sum types to verify that all translatable strings are mapped to localized versions at compile time.
• Secure Client-Side Session Storages - Stores session data in cryptographically signed client-side cookies to prevent tampering.
• Identity-Based Access Restrictions - Enforces access restrictions by redirecting unauthenticated users or blocking access based on assigned roles.
• Email Verification Flows - Implements a workflow requiring users to click a confirmation link before permitting application login.
• Resource-Level Access Controls - Validates permissions against specific resource instances to control access based on roles.
• Row Level Security - Defines database-level policies that restrict data visibility based on the authenticated user's identity.
• Passkey Authentication - Authenticates users without passwords using the WebAuthn standard.
• Passkey Listings and Deletions - Provides tools to register authentication devices and manage passkeys, including renaming and deletion.
• Fine-Grained Permission Checking - Evaluates ownership and permission rules to authorize specific actions on individual resources.
• Third-Party Identity Integrations - Integrates with external identity providers to allow users to sign in using existing accounts.
• WebSocket Authentications - Verifies and identifies the logged-in user within persistent WebSocket connections to restrict interactions.
• User Identity Management - Implements secure user registration, session handling, and passwordless authentication using Passkeys and OAuth.
• Database Schema Migrations - Provides automated versioning and execution of SQL migration files to evolve the database schema.
• Request Interception Middleware - Executes shared logic such as authentication checks and authorization before controller actions run.
• Automatic Form Generation - Automatically generates HTML input fields and validation logic directly from database record schemas.
• Test User Authenticators - Allows tests to execute actions as specific users to verify permission-based logic.
• Integrated Logic Testing - Provides a test suite to verify full application logic and prevent regressions.
• Unit Testing - Executes isolated tests for application logic and view rendering without database dependencies.
• Conditional Rendering - Conditionally renders view components based on the user's authentication status or assigned roles.
• Page Layout Templates - Wraps views in a consistent global structural layout and injects request-scoped data.
• Client-Side Database APIs - Executes database lookups and updates from client-side code using a standardized API.
• Client-Side Scripting - Embeds scripts in HTML attributes to perform DOM manipulations without requiring external files.
• Ajax Form Submissions - Customizes form submission methods and target URLs using AJAX or standard browser behavior.
• Form Renderers - Renders built-in input types pre-filled with database record values.
• Asynchronous Form Submissions - Intercepts form submissions via JavaScript to enable smooth transitions and prevent double-submissions.
• HTTP Redirects - Sends HTTP redirects to internal actions, specific paths, or external URLs.
• Internationalization Support - Implements multi-language support to provide localized experiences for international users.
• JSON APIs - Creates endpoints that serve structured JSON data for use in mobile or single-page applications.
• Middleware - Provides a system for integrating reusable middleware components to extend application functionality.
• Page Transition Controls - Provides lifecycle events that trigger code execution during partial page updates.
• JSON Parsers - Extracts fields from incoming JSON requests and provides validation errors for invalid payloads.
• Request-to-Record Mapping - Maps incoming request data into typed record structures and handles validation failures.
• Request Middleware - Passes HTTP requests through a configurable chain of functions for shared logic like authentication and CORS.
• Content Negotiation - Sends either HTML or JSON from a single action based on the HTTP Accept header.
• JSON Response Formatters - Produces JSON output from views or controller actions for API integration.
• Response Rendering - Sends responses in multiple formats including HTML, JSON, and plain text from a single controller action.
• Convention-Based URL Routers - Resolves URLs to controller actions automatically based on naming conventions and HTTP methods.
• Type-Safe Schema Validations - Provides type-safe validation schemas for user input to ensure data integrity before storage.

Star history