For a library for standard data schemas, the strongest matches are vincit/objection.js (Objection), espocrm/espocrm (EspoCRM is a full CRM application and business app) and chartdb/chartdb (ChartDB is a database schema visualization and ER diagramming). sequelize/sequelize and lerocha/chinook-database round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.
Finde die besten Data-Schema-Bibliotheken für Standard-Entitäten. Vergleiche Top-Open-Source-Projekte nach Aktivität und Features, um die richtige Wahl zu treffen.
Objection.js is an object-relational mapper for Node.js that maps SQL database tables to classes and rows to model instances. It functions as a high-level abstraction layer built on top of the Knex.js query builder to provide structured model definitions and relational data mapping. The project distinguishes itself through its ability to manage complex object graphs, allowing for the persistence and eager-loading of deeply nested related data in single operations. It incorporates a data integrity layer that uses JSON schema validation to verify model instances before they are persisted to the
Objection.js is an ORM framework for Node.js that lets you define your own models and map them to SQL tables, but it does not come with a library of predefined entity schemas for common business domains — it’s a tool for building custom data models rather than a source of standard reusable definitions.
EspoCRM is an open-source customer relationship management platform and SQL-based business application. It serves as a centralized web interface for tracking leads, opportunities, and contacts, providing a sales pipeline manager and a customizable business logic engine. The platform is distinguished by its ability to function as a custom business application builder, allowing for the creation of tailored entities and automated workflows. It integrates marketing automation tools for campaign coordination and a structured customer support ticketing system for case management. The system covers
EspoCRM is a full CRM application and business app builder with predefined entities for contacts, leads, and opportunities, but it is a deployable platform rather than a reusable library of data entity schemas you can import into your own application or database project.
ChartDB is a database schema visualizer and entity-relationship diagramming platform designed to help developers understand, design, and document complex data architectures. It functions as a visual workspace where users can create and modify database schemas, define table attributes, and map foreign key relationships. By parsing database metadata or SQL scripts, the tool generates interactive diagrams that provide a clear overview of structural interdependencies and data associations. The platform distinguishes itself through its focus on automated documentation and schema synchronization. I
ChartDB is a database schema visualization and ER diagramming tool rather than a reusable collection of predefined entity definitions for common business domains, making it a design aid for creating schemas but not the ready-made data model library this search seeks.
Sequelize is an object-relational mapping library that provides a unified interface for managing relational data through code. By implementing the Active Record pattern, it maps database tables to application objects, allowing developers to perform standard create, read, update, and delete operations using high-level method calls. The library abstracts complex database interactions by translating these calls into optimized, engine-specific SQL statements, ensuring consistent behavior across different database systems. The project distinguishes itself through a comprehensive suite of tools for
Sequelize is a powerful ORM for mapping database tables to application objects, but it does not ship with reusable, prebuilt entity definitions for common business domains — it is a tool for defining your own models, not a library of standard schemas.
This project is a relational SQL sample database and synthetic testing dataset. It provides a standardized data model of a fictional digital media store, encompassing business entities such as artists, albums, tracks, customers, and invoices. The dataset is designed as a cross-dialect SQL collection, using compatible scripts to ensure consistent data seeding and environment parity across different database server engines. It combines imported metadata with fictitious personal details to create realistic records for software prototyping and demonstrations. The project covers capabilities for
Chinook is a relational sample database for a fictional media store, providing a single-domain data model—not a cross-domain library of reusable entity schemas with ORM/validation support.
Toon is a data serialization library and toolkit designed to convert complex objects into compact, human-readable formats optimized for large language models. By focusing on token efficiency, the library minimizes the context window footprint of structured data through techniques like key folding and tabular layout optimization. It provides a streaming-capable processor that handles the encoding and decoding of hierarchical data while maintaining structural integrity. The project distinguishes itself through its path-aware transformation pipeline and configurable serialization logic, which al
Toon is a data serialization library for compact token-efficient formatting, not a collection of predefined entity schemas for common business domains, so it addresses serialization support but lacks the core domain model definitions this search targets.
Pothos is a code-first GraphQL schema builder and framework designed for type-safe development. It allows developers to construct schemas using typed definitions in TypeScript, eliminating the need for external code generation steps. The framework distinguishes itself through a dedicated data mapper that connects GraphQL types to relational databases and ORMs, such as Prisma, while optimizing query resolution. It provides a full implementation of the Relay specification, including global object identification and cursor-based pagination. The project covers several core capability areas, incl
Pothos is a type-safe GraphQL schema builder and framework with ORM integration, but it does not provide a reusable collection of standard data entity definitions for common business domains—it is a tool for constructing your own GraphQL schemas rather than offering predefined models.
This project provides the JSON Schema Specification, a standard for annotating and validating JSON documents to ensure consistent data structures across different systems. It serves as a data validation standard and an interoperability standard, establishing a common language for exchanging data definitions between different programming languages and platforms. The specification includes a machine-readable framework for defining JSON vocabularies, which describes the expected types, formats, and structures of data objects. It enables the creation of standardized, machine-readable documentatio
JSON Schema is a specification and validation standard for JSON data structures, but it provides a meta-language for defining schemas rather than a reusable library of predefined entity definitions for common business domains.
Entity Framework Core is an object-relational mapper that enables developers to interact with database systems using strongly-typed code. It serves as a comprehensive data access framework, providing a unified interface for mapping application objects to relational and non-relational database schemas while managing the lifecycle of data operations through a central context. The project distinguishes itself through a provider-based architecture that decouples core data access logic from specific database engines, allowing for consistent interaction across diverse storage systems. It features a
Entity Framework Core is an object-relational mapper for building and managing data models in .NET, not a library of predefined entity schemas for common business domains—it provides the tooling to define your own models rather than offering reusable, ready-made definitions.
This project is a client-side rendering engine that transforms declarative, text-based syntax into visual diagrams directly within the browser. By utilizing a domain-specific language, it allows users to define complex structures—such as software architectures, process flows, and system behaviors—without the need for manual layout configuration. The library functions as a browser-based runtime that parses these definitions into intermediate abstract syntax trees, which are then processed by specialized engines to generate high-fidelity, resolution-independent graphics. The system distinguishe
Mermaid is a diagramming engine that generates visual diagrams from text, not a reusable collection of predefined data entity schemas for business domains—it can render entity-relationship or class diagrams, but the visitor would need to supply the definitions themselves.
TypeORM is an object-relational mapper for TypeScript and JavaScript that bridges the gap between object-oriented application code and relational database tables. It provides a comprehensive data persistence layer that allows developers to define database entities using class decorators or configuration objects, enabling seamless interaction with data through object-oriented patterns. The project distinguishes itself through a flexible architecture that supports both the data mapper and repository patterns, alongside a fluent query builder that translates high-level method calls into platform
TypeORM is an ORM framework for defining and mapping your own entities, not a pre-built collection of standard business domain schemas as this search requires.
serverless-express is a Node.js serverless framework adapter that enables standard web frameworks to run on serverless compute. It utilizes a compatibility layer to map cloud gateway events and triggers into standard HTTP request and response objects. The project features a full-stack code generator that produces API endpoints, database schemas, and frontend boilerplate from centralized entity relationship configurations. It includes a serverless event router to translate non-HTTP cloud events into simulated HTTP requests and a tool for provisioning NoSQL databases and cloud resources using d
This repository is a serverless Express adapter with a code generator that produces data models from your entity configurations, but it does not ship predefined standard entity schemas for common business domains as a reusable data model library.
SQLAlchemy is a comprehensive Python SQL toolkit and object-relational mapper that provides a full suite of tools for interacting with relational databases. It serves as a foundational layer for database connectivity, offering both a high-level object-oriented interface for data persistence and a programmatic SQL expression language for constructing complex, dialect-agnostic queries. The project distinguishes itself through its sophisticated unit of work persistence, which coordinates atomic transactions and tracks object state changes to minimize redundant database operations. It provides a
SQLAlchemy is an ORM and SQL toolkit for defining and persisting your own data models in Python, but it does not ship predefined entity schemas for common business domains like customers, products, or orders — so it is the tool you would use to build such a library rather than the reusable model library itself.
Wasp is a declarative full-stack web framework that enables developers to build and deploy applications by defining their architecture in a centralized configuration. By using a high-level specification, the framework automates the orchestration of frontend, backend, and database components, ensuring that infrastructure concerns like routing, authentication, and data modeling are handled consistently across the entire stack. The framework distinguishes itself through its compiler-driven approach, which translates declarative configurations into cohesive, production-ready codebases. It provide
Wasp is a full-stack web framework that automates app architecture rather than providing a reusable library of standard business-domain entity schemas, so it is a neighbouring tool in the data-modeling space but not a match for a collection of predefined definitions.
Protocol Buffers is a language-neutral, platform-agnostic mechanism for serializing structured data. It provides a schema-driven toolchain that compiles declarative data definitions into type-safe source code, enabling consistent communication and strongly typed API contracts across services written in different programming languages. The project distinguishes itself through a highly efficient binary wire format that utilizes tag-based encoding and variable-width integer compression to minimize payload size and processing overhead. It supports robust evolutionary schema management, allowing d
Protocol Buffers is a schema and serialization framework for defining structured data, not a library of predefined business-domain entity schemas — so it provides the tooling to create custom data models but does not deliver the ready-made domain entities the visitor needs.
Vendure is a Node.js e-commerce engine and headless commerce framework built with NestJS and TypeScript. It serves as a multi-channel commerce platform that manages product catalogs, orders, and customers via a strongly typed GraphQL API. The platform is distinguished by its highly extensible architecture, featuring a customizable administrative dashboard where developers can inject custom React components and entity views. It supports multi-channel commerce, allowing the isolation of products, currencies, and regional catalogs from a single unified backend. The engine covers a broad range o
Vendure is a full e-commerce engine and headless commerce framework with its own data models for products, orders, and customers, not a reusable collection of standard data entity definitions designed for cross-application reuse across common business domains.
| Repository | Stars | Sprache | Lizenz | Letzter Push |
|---|---|---|---|---|
| vincit/objection.js | 7.3K | JavaScript | MIT | |
| espocrm/espocrm | 2.8K | PHP | agpl-3.0 | |
| chartdb/chartdb | 21.3K | TypeScript | agpl-3.0 | |
| sequelize/sequelize | 30.3K | TypeScript | MIT | |
| lerocha/chinook-database | 2.5K | TSQL | NOASSERTION | |
| toon-format/toon | 24.6K | TypeScript | MIT | |
| hayes/pothos | 2.6K | TypeScript | isc | |
| json-schema-org/json-schema-spec | 5K | JavaScript | NOASSERTION | |
| dotnet/efcore | 14.6K | C# | mit | |
| mermaid-js/mermaid | 88.7K | TypeScript | MIT |