Vincit/objection.js

Features

• Object-Relational Mappers - Provides a comprehensive object-relational mapper that links database tables to JavaScript classes and rows to model instances.
• Active-Record ORMs - Implements an ORM based on the Active Record pattern where models encapsulate data access logic.
• Object-Relational Mapping - Maps programming language objects to database records and manages complex relationships between them.
• Transaction Lifecycle Control - Runs groups of operations as an atomic unit that commits or rolls back based on the total outcome.
• Object-to-Row Mapping - Links database table rows directly to object instances to provide an object-oriented data interface.
• Model-Level Integrity Enforcement - Enforces data integrity using JSON schema definitions during instantiation and throws errors for invalid data.
• Atomic Transactions - Provides mechanisms to execute multiple data manipulation operations as a single atomic unit to ensure consistency.
• Database Query Builders - Provides a fluent interface for programmatic SQL construction to perform CRUD operations.
• Eager Loading - Retrieves complex sets of related objects in a single operation to minimize database round-trips.
• Database Record Querying - Implements mechanisms for retrieving data from tables using filters, sorting, and programmatic method chaining.
• Database Transaction Management - Offers programmatic control of transaction boundaries and context-aware database operations to ensure consistency.
• Schema Validators - Uses schema validators to verify that JSON documents adhere to predefined structures before saving to the database.
• Node.js SQL ORMs - Provides a comprehensive object-relational mapper for Node.js that maps database tables to classes.
• Object-Relational Mapping Associations - Provides mechanisms for managing relational associations and foreign key links between database entities.
• Object-Relational Mapping Models - Provides structural definitions for mapping application data models to database table columns and types.
• Query Builders - Wraps a low-level SQL query builder to translate programmatic method chains into executable database queries.
• Relational Data Modeling - Provides techniques for organizing data into structured tables with defined associations for SQL storage.
• Schema Validators - Enforces structural rules and data type constraints on database documents using JSON schema validation.
• Node.js Database Integration - Provides a high-level programmatic interface for connecting Node.js applications to SQL database systems.
• JSON Schema Validation - Enforces data integrity by validating model instances against structured JSON schema definitions before persistence.
• Column Mappings - Implements configurations for mapping application class properties to database columns, including case conversion.
• Raw SQL Execution - Supports direct execution of raw SQL queries with parameter binding for advanced database operations.
• Row Mapping Logic - Converts SQL result set rows into rich model instances to enable custom logic on retrieved data.
• Composite - Identifies unique rows using either a single column or multiple columns to support various schema designs.
• Hybrid Relational-JSON Storage - Saves complex objects as JSON strings within traditional relational database columns and restores them to objects.
• Nested Data Persistence - Provides capabilities for creating or updating complex, deeply nested object graphs in a single operation.
• Relation Graph Upserting - Synchronizes related objects by inserting new records, updating existing ones, and deleting missing entries in one operation.
• Eager Loading - Implements eager loading of related data graphs using joins or batch queries to eliminate N+1 query performance issues.
• Relationship Management - Provides capabilities for creating, modifying, and filtering associations between data entities.
• SQL Query Builders - Provides utilities for programmatically constructing structured SQL query operations.
• Database Model Mixins - Uses mixins to inject shared methods and properties into database-mapped model class prototypes.
• Model Extensions - Allows extending models with custom metadata and lifecycle behavior using reusable logic.
• Case-Conversion Mappings - Automatically translates between database snake_case column names and application camelCase properties during data hydration.
• Databases - Lightweight ORM based on Knex.
• Object Relational Mappers - Lightweight ORM built on Knex.
• Search and Databases - Provides a SQL-friendly ORM built on Knex.

Star history