simolus3/drift

Features

• Type-Safe - Constructs SQL filters and calculations using type-safe operators and build-time validation.
• SQL Query Execution - Executes SQL queries with build-time validation to ensure results match expected type-safe data structures.
• SQLite Database Management - Provides a comprehensive system for managing SQLite schemas and queries across native and web applications.
• Cross-Platform Database Execution - Executes database operations across multiple operating systems by switching the underlying implementation.
• Custom SQL Execution - Allows execution of manual SQL statements using parameter binding or type-safe generated APIs.
• Object-to-Row Mapping - Transforms relational database rows into type-safe native objects to eliminate manual result set parsing.
• Row-to-Struct Mappers - Automatically transforms database result sets into strongly-typed language objects by matching columns to generated classes.
• Schema Versioning - Executes version-specific transformation functions to transition a database schema to the current version.
• PostgreSQL Connectors - Generates compatible SQL from query code to work with PostgreSQL database servers.
• Atomic Transactions - Runs multiple database statements as a single atomic unit to ensure consistency and success.
• Database Schema Migrations - Automates the application of versioned updates to database schemas to maintain structural compatibility.
• Model Table Mappings - Maps database tables to classes using annotations to unify schema declarations and data models.
• Fluent Query Builders - Provides a chainable, functional interface for constructing complex, type-safe database queries without writing raw SQL.
• Migration Generation - Automates the creation of code required to transition a database schema between versions.
• Custom Class Bindings - Provides a mechanism to bind SQL query outputs to specific, predefined data classes.
• Object-Relational Mappers - Maps database records to native objects to eliminate manual result set parsing.
• Raw SQL Execution - Embeds raw SQL snippets to perform database operations not supported by the type-safe query builder.
• Reactive Data Queries - Transforms SQL queries into auto-updating streams that emit new results whenever underlying data changes.
• Reactive SQL Query Execution - Returns reactive streams for manual SQL queries that emit updates when underlying tables change.
• SQL Persistence Frameworks - Provides a type-safe library for mapping database tables to classes and executing validated SQL queries.
• Database Wrappers - Wraps SQLite drivers with high-level management for migrations, encryption, and reactive streams.
• Table Data Retrieval - Retrieves data from tables as either a single result set or an auto-updating reactive stream.
• Table Definitions - Declares table structures using typed columns to automate mapping between language and SQL types.
• Table Update Monitoring - Monitors specific tables for change events to trigger automatic updates of reactive query streams.
• Type-Safe Database Clients - Generates strongly-typed interfaces for database operations to ensure compile-time safety.
• Type-Safe Object-Relational Mappers - Translates relational database rows into language-native objects using generated classes and converters.
• Type-Safe Query Builders - Provides compile-time validation for database queries based on schema definitions.
• Build-Time Code Generators - Produces type-safe APIs and data classes by analyzing SQL queries and schema definitions during the build process.
• Cross-Platform Data Integration - Enables a single database codebase to run across mobile, desktop, and web targets using conditional executors.
• Database Schema Migrations - Tracks database versions and executes sequential transformation functions to evolve the schema.
• Database Change Streams - Transforms SQL queries into auto-updating streams that emit new results whenever underlying table data changes.
• SQL Query Validators - Analyzes raw SQL statements against database versions to ensure column accuracy and dialect compatibility before execution.
• Database API Generation - Creates typed methods from SQL queries during the build process to eliminate manual parsing.
• Browser Data Persistence - Stores database files using browser APIs like the Origin-Private File System or IndexedDB.
• Bulk Data Operations - Executes multiple insert or update statements within a single batch to optimize database performance.
• PostgreSQL Database Clients - Functions as a PostgreSQL client that generates compatible SQL with support for native types and connection pooling.
• PostgreSQL Pool Managers - Establishes connections to PostgreSQL databases using endpoints or integrates with existing connection pools.
• Custom Type Converters - Translates complex types into SQL-compatible formats using global or generic converters.
• Expression-Level Type Converters - Maps database column values to complex language types using custom converter classes.
• Database Metadata Snapshots - Extracts a snapshot of the database structure into a file to track and audit version history.
• Batch Insertion Interfaces - Groups multiple insert statements into a single operation to improve write performance.
• Data Type Mappings - Automatically converts custom objects into database-compatible types during data operations.
• Read-Only Isolate Pooling - Maintains a pool of read-only isolates to enable parallel retrieval without blocking concurrent writes.
• Database Schema Initializations - Executes callbacks after migrations to populate initial data or configure database pragmas.
• Primary Keys - Defines unique identifiers for rows using auto-incrementing integers or custom columns.
• Foreign Key Constraints - Enforces parent-child integrity through relational dependencies and configurable update/delete behaviors.
• Relationship Automation - Automates the generation of relational constraints and simplifies the retrieval of associated entities.
• High-Level Query APIs - Retrieves records using a high-level API with simplified filters for equality and nullability.
• In-Memory Databases - Opens a database instance in memory for fast, isolated tests that do not persist data.
• Isolate-Based Database Sharing - Establishes a centralized database server isolate for synchronized data access across client isolates.
• Joined Result Nesting - Prevents column name collisions by organizing joined table results into nested objects.
• PostgreSQL Integrations - Provides specialized support for PostgreSQL native data types and server connectivity.
• Type Mappings - Maps native PostgreSQL types like UUID and date formats to language-native objects.
• Related Data Prefetching - Retrieves parent records and their associated child records as a single list using specialized functions.
• Relation Prefetching - Retrieves an entity along with its referenced fields using prefetching to avoid inefficient queries.
• Set-Based Operations - Combines results of multiple select statements using union, intersect, and except operators.
• Row Aggregations - Computes summary statistics such as counts, sums, and averages across multiple rows using group-by clauses.
• Companion-Based Insertions - Adds new records using companion objects that enforce required fields while allowing optional columns.
• Upsertions - Provides a mechanism to insert new records or update existing ones when a uniqueness conflict occurs.
• Database Constraints - Enforces data integrity via nullability, default values, check constraints, and uniqueness requirements.
• Schema Migration Validation - Runs tests against schema changes to verify that migrations apply reliably across different database versions.
• Migration Test Generation - Produces test code and snapshots from exported schema files to verify the correctness of migration logic.
• SQL-Based Row Updates - Modifies row values using database-side functions and expressions to avoid loading data into memory.
• Companion-Based Updates - Modifies fields of existing rows using companions to distinguish unchanged fields from modified ones.
• SQL Dialect Adapters - Generates database code compatible with multiple SQL dialects and selects the appropriate one at runtime.
• SQL Static Analyzers - Performs static analysis on SQL queries to detect incompatible features based on the database version.
• Subquery Execution - Allows the use of select statement results as sources for joins or complex nested queries.
• Table Joining Operations - Supports merging rows from multiple tables using various join types to filter results based on referenced table conditions.
• View Definitions - Creates virtual tables via select statements to reuse complex queries as typed data classes.
• Blocking Task Offloaders - Provides mechanisms to delegate long-running database I/O tasks to background isolates to maintain UI responsiveness.
• SQL Schema Generators - Automatically generates SQL schema definitions from language-specific structures and creates corresponding type-safe classes.
• Database Connectivity - Executes queries against a hosted server via a network protocol.
• Dynamic SQL Expressions - Allows the insertion of runtime logic into SQL queries for dynamic filtering and ordering.
• Encrypted Database Managers - Secures stored data using encryption to prevent unauthorized access to the database file.
• Storage Encryption - Uses an encrypted executor on native platforms to ensure database files are encrypted at rest.
• Multiplatform Code Sharing - Uses conditional exports and a customizable executor to run a single codebase on native and web targets.
• Column-Transforming Migrations - Automates copying data from an old table to a new schema using column transformers.
• Database Schema Validations - Compares the active database schema against the expected definition to detect mismatches.
• Execution Abstraction Layers - Abstracts database operations through a customizable executor to support both native and web targets.
• Migration Integrity Verifications - Generates version-specific classes to validate record consistency before and after a migration.
• Database Transition Tests - Generates unit test code to verify that database transitions between versions function correctly.
• Background Processing Workers - Offloads database input and output tasks to separate worker isolates to keep the UI responsive.
• Schema Evolution - Implements a migration API to apply incremental schema changes and evolve the database structure without data loss.
• Web Worker Orchestrators - Shifts database processing to web workers to prevent interface lag and synchronize data across browser tabs.
• Storage and Persistence - Reactive, typesafe persistence library.

Star history