metal-orm 1.0.13 → 1.0.15

package/README.md

@@ -1,11 +1,9 @@
-# MetalORM ⚙️
+# MetalORM ⚙️ - Type-safe SQL, layered ORM, decorator-based entities – all on the same core.
 
 [![npm version](https://img.shields.io/npm/v/metal-orm.svg)](https://www.npmjs.com/package/metal-orm)
 [![license](https://img.shields.io/npm/l/metal-orm.svg)](https://github.com/celsowm/metal-orm/blob/main/LICENSE)
 [![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%23007ACC.svg)](https://www.typescriptlang.org/)
 
-**Type-safe SQL, layered ORM, decorator-based entities – all on the same core.**
-
 MetalORM is a TypeScript-first, AST-driven SQL toolkit you can dial up or down depending on how “ORM-y” you want to be:
 
 - **Level 1 – Query builder & hydration 🧩**  
@@ -22,10 +20,10 @@ Use only the layer you need in each part of your codebase.
 <a id="table-of-contents"></a>
 ## Table of Contents 🧭
 
-- [Documentation](#documentation)
-- [Features](#features)
-- [Installation](#installation)
-- [Quick start - three levels](#quick-start)
+- [Documentation](#documentation)
+- [Features](#features)
+- [Installation](#installation)
+- [Quick start - three levels](#quick-start)
   - [Level 1 – Query builder & hydration](#level-1)
   - [Level 2 – Entities + Unit of Work](#level-2)
   - [Level 3 – Decorator entities](#level-3)
@@ -41,18 +39,18 @@ Use only the layer you need in each part of your codebase.
 
 Full docs live in the `docs/` folder:
 
-- [Introduction](https://github.com/celsowm/metal-orm/blob/main/docs/index.md)
-- [Getting Started](https://github.com/celsowm/metal-orm/blob/main/docs/getting-started.md)
-- [Level 3 Backend Tutorial](https://github.com/celsowm/metal-orm/blob/main/docs/level-3-backend-tutorial.md)
-- [Schema Definition](https://github.com/celsowm/metal-orm/blob/main/docs/schema-definition.md)
-- [Query Builder](https://github.com/celsowm/metal-orm/blob/main/docs/query-builder.md)
-- [DML Operations](https://github.com/celsowm/metal-orm/blob/main/docs/dml-operations.md)
-- [Hydration & Entities](https://github.com/celsowm/metal-orm/blob/main/docs/hydration.md)
-- [Runtime & Unit of Work](https://github.com/celsowm/metal-orm/blob/main/docs/runtime.md)
-- [Advanced Features](https://github.com/celsowm/metal-orm/blob/main/docs/advanced-features.md)
-- [Multi-Dialect Support](https://github.com/celsowm/metal-orm/blob/main/docs/multi-dialect-support.md)
-- [Schema Generation (DDL)](https://github.com/celsowm/metal-orm/blob/main/docs/schema-generation.md)
-- [API Reference](https://github.com/celsowm/metal-orm/blob/main/docs/api-reference.md)
+- [Introduction](https://github.com/celsowm/metal-orm/blob/main/docs/index.md)
+- [Getting Started](https://github.com/celsowm/metal-orm/blob/main/docs/getting-started.md)
+- [Level 3 Backend Tutorial](https://github.com/celsowm/metal-orm/blob/main/docs/level-3-backend-tutorial.md)
+- [Schema Definition](https://github.com/celsowm/metal-orm/blob/main/docs/schema-definition.md)
+- [Query Builder](https://github.com/celsowm/metal-orm/blob/main/docs/query-builder.md)
+- [DML Operations](https://github.com/celsowm/metal-orm/blob/main/docs/dml-operations.md)
+- [Hydration & Entities](https://github.com/celsowm/metal-orm/blob/main/docs/hydration.md)
+- [Runtime & Unit of Work](https://github.com/celsowm/metal-orm/blob/main/docs/runtime.md)
+- [Advanced Features](https://github.com/celsowm/metal-orm/blob/main/docs/advanced-features.md)
+- [Multi-Dialect Support](https://github.com/celsowm/metal-orm/blob/main/docs/multi-dialect-support.md)
+- [Schema Generation (DDL)](https://github.com/celsowm/metal-orm/blob/main/docs/schema-generation.md)
+- [API Reference](https://github.com/celsowm/metal-orm/blob/main/docs/api-reference.md)
 
 ---
 
@@ -62,16 +60,17 @@ Full docs live in the `docs/` folder:
 ### Level 1 – Query builder & hydration
 
 - **Declarative schema definition** with `defineTable`, `col.*`, and typed relations.
-- **Fluent query builder** over a real SQL AST  
-  (`SelectQueryBuilder`, `InsertQueryBuilder`, `UpdateQueryBuilder`, `DeleteQueryBuilder`).
-- **Advanced SQL**: CTEs, aggregates, window functions, subqueries, JSON, CASE, EXISTS.
-- **Set operations**: `union`, `unionAll`, `intersect`, `except` across all dialects (ORDER/LIMIT apply to the combined result; hydration is disabled for compound queries so rows are returned as-is without collapsing duplicates).
-- **Expression builders**: `eq`, `and`, `or`, `between`, `inList`, `exists`, `jsonPath`, `caseWhen`, window functions like `rowNumber`, `rank`, `lag`, `lead`, etc., all backed by typed AST nodes.
-- **Relation-aware hydration**: turn flat rows into nested objects (`user.posts`, `user.roles`, etc.) using a hydration plan derived from the AST metadata.
-- **Multi-dialect**: compile once, run on MySQL/MariaDB, PostgreSQL, SQLite, or SQL Server via pluggable dialects.
-- **DML**: type-safe INSERT / UPDATE / DELETE with `RETURNING` where supported.
-
-Level 1 is ideal when you:
+- **Fluent query builder** over a real SQL AST  
+  (`SelectQueryBuilder`, `InsertQueryBuilder`, `UpdateQueryBuilder`, `DeleteQueryBuilder`).
+- **Advanced SQL**: CTEs, aggregates, window functions, subqueries, JSON, CASE, EXISTS.
+- **String helpers**: `lower`, `upper`, `trim`, `ltrim/rtrim`, `concat/concatWs`, `substr/left/right`, `position/instr/locate`, `replace`, `repeat`, `lpad/rpad`, `space`, and more with dialect-aware rendering.
+- **Set operations**: `union`, `unionAll`, `intersect`, `except` across all dialects (ORDER/LIMIT apply to the combined result; hydration is disabled for compound queries so rows are returned as-is without collapsing duplicates).
+- **Expression builders**: `eq`, `and`, `or`, `between`, `inList`, `exists`, `jsonPath`, `caseWhen`, window functions like `rowNumber`, `rank`, `lag`, `lead`, etc., all backed by typed AST nodes.
+- **Relation-aware hydration**: turn flat rows into nested objects (`user.posts`, `user.roles`, etc.) using a hydration plan derived from the AST metadata.
+- **Multi-dialect**: compile once, run on MySQL/MariaDB, PostgreSQL, SQLite, or SQL Server via pluggable dialects.
+- **DML**: type-safe INSERT / UPDATE / DELETE with `RETURNING` where supported.
+
+Level 1 is ideal when you:
 
 - Already have a domain model and just want a serious SQL builder.
 - Want deterministic SQL (no magical query generation).
@@ -83,13 +82,13 @@ On top of the query builder, MetalORM ships a focused runtime:
 
 - **Entities inferred from your `TableDef`s** (no separate mapping file).
 - **Lazy, batched relations**: `user.posts.load()`, `user.roles.syncByIds([...])`, etc.
-- **Identity map**: the same row becomes the same entity instance within a context (see the [Identity map pattern](https://en.wikipedia.org/wiki/Identity_map_pattern)).
-- **Unit of Work (`OrmContext`)** tracking New/Dirty/Removed entities and relation changes, inspired by the classic [Unit of Work pattern](https://en.wikipedia.org/wiki/Unit_of_work).
-- **Graph persistence**: mutate a whole object graph and flush once with `ctx.saveChanges()`.
-- **Relation change processor** that knows how to deal with has-many and many-to-many pivot tables.
-- **Interceptors**: `beforeFlush` / `afterFlush` hooks for cross-cutting concerns (auditing, multi-tenant filters, soft delete filters, etc.).
-- **Domain events**: `addDomainEvent` and a DomainEventBus integrated into `saveChanges()`, aligned with domain events from [Domain-driven design](https://en.wikipedia.org/wiki/Domain-driven_design).
-- **JSON-safe entities**: relation wrappers hide internal references and implement `toJSON`, so `JSON.stringify` of hydrated entities works without circular reference errors.
+- **Identity map**: the same row becomes the same entity instance within a context (see the [Identity map pattern](https://en.wikipedia.org/wiki/Identity_map_pattern)).
+- **Unit of Work (`OrmContext`)** tracking New/Dirty/Removed entities and relation changes, inspired by the classic [Unit of Work pattern](https://en.wikipedia.org/wiki/Unit_of_work).
+- **Graph persistence**: mutate a whole object graph and flush once with `ctx.saveChanges()`.
+- **Relation change processor** that knows how to deal with has-many and many-to-many pivot tables.
+- **Interceptors**: `beforeFlush` / `afterFlush` hooks for cross-cutting concerns (auditing, multi-tenant filters, soft delete filters, etc.).
+- **Domain events**: `addDomainEvent` and a DomainEventBus integrated into `saveChanges()`, aligned with domain events from [Domain-driven design](https://en.wikipedia.org/wiki/Domain-driven_design).
+- **JSON-safe entities**: relation wrappers hide internal references and implement `toJSON`, so `JSON.stringify` of hydrated entities works without circular reference errors.
 
 Use this layer where:
 
@@ -104,9 +103,10 @@ If you like explicit model classes, you can add a thin decorator layer on top of
 - `@Column(...)` and `@PrimaryKey(...)` on properties; decorators collect column metadata and later build `TableDef`s from it.
 - Relation decorators:
   - `@HasMany({ target, foreignKey, ... })`
+  - `@HasOne({ target, foreignKey, ... })`
   - `@BelongsTo({ target, foreignKey, ... })`
   - `@BelongsToMany({ target, pivotTable, ... })`
-- `bootstrapEntities()` scans metadata, builds `TableDef`s, wires relations with the same `hasMany` / `belongsTo` / `belongsToMany` helpers you would use manually, and returns the resulting tables.
+- `bootstrapEntities()` scans metadata, builds `TableDef`s, wires relations with the same `hasOne` / `hasMany` / `belongsTo` / `belongsToMany` helpers you would use manually, and returns the resulting tables.
 - `selectFromEntity(MyEntity)` lets you start a `SelectQueryBuilder` directly from the class.
 
 You don’t have to use decorators, but when you do, you’re still on the same AST + dialect + runtime foundation.
@@ -173,10 +173,13 @@ import {
 
 // 1) A very small table
 const todos = defineTable('todos', {
-  id: col.int().primaryKey(),
-  title: col.varchar(255).notNull(),
-  done: col.boolean().default(false),
+  id: col.primaryKey(col.int()),
+  title: col.varchar(255),
+  done: col.boolean(),
 });
+// Add constraints
+todos.columns.title.notNull = true;
+todos.columns.done.default = false;
 
 // 2) Build a simple query
 const listOpenTodos = new SelectQueryBuilder(todos)
@@ -222,20 +225,29 @@ import {
 } from 'metal-orm';
 
 const posts = defineTable('posts', {
-  id: col.int().primaryKey(),
-  title: col.varchar(255).notNull(),
-  userId: col.int().notNull(),
-  createdAt: col.timestamp().default('CURRENT_TIMESTAMP'),
+  id: col.primaryKey(col.int()),
+  title: col.varchar(255),
+  userId: col.int(),
+  createdAt: col.timestamp(),
 });
 
+// Add constraints
+posts.columns.title.notNull = true;
+posts.columns.userId.notNull = true;
+
 const users = defineTable('users', {
-  id: col.int().primaryKey(),
-  name: col.varchar(255).notNull(),
-  email: col.varchar(255).unique(),
-}, {
-  posts: hasMany(posts, 'userId'),
+  id: col.primaryKey(col.int()),
+  name: col.varchar(255),
+  email: col.varchar(255),
 });
 
+// Add relations and constraints
+users.relations = {
+  posts: hasMany(posts, 'userId'),
+};
+users.columns.name.notNull = true;
+users.columns.email.unique = true;
+
 // Build a query with relation & window function
 const builder = new SelectQueryBuilder(users)
   .select({
@@ -289,36 +301,23 @@ When you're ready, you can let MetalORM manage entities and relations for you.
 Instead of “naked objects”, your queries can return entities attached to an `OrmContext`:
 
 ```ts
+import mysql from 'mysql2/promise';
 import {
   OrmContext,
   MySqlDialect,
   SelectQueryBuilder,
   eq,
+  createMysqlExecutor,
 } from 'metal-orm';
 
 // 1) Create an OrmContext for this request
+
+const connection = await mysql.createConnection({ /* ... */ });
+const executor = createMysqlExecutor(connection);
+
 const ctx = new OrmContext({
   dialect: new MySqlDialect(),
-  executor: {
-    async executeSql(sql, params) {
-      const [rows] = await connection.execute(sql, params);
-      // MetalORM expects columns + values; adapt as needed
-      return [{
-        columns: Object.keys(rows[0] ?? {}),
-        values: rows.map(row => Object.values(row)),
-      }];
-    },
-    // Optional: if you want MetalORM to handle transactions around saveChanges()
-    async beginTransaction() {
-      await connection.beginTransaction();
-    },
-    async commitTransaction() {
-      await connection.commit();
-    },
-    async rollbackTransaction() {
-      await connection.rollback();
-    },
-  },
+  executor,
 });
 
 // 2) Load entities with lazy relations
@@ -382,7 +381,7 @@ class User {
   @PrimaryKey(col.int())
   id!: number;
 
-  @Column(col.varchar(255).notNull())
+  @Column(col.varchar(255))
   name!: string;
 
   @Column(col.varchar(255))
@@ -400,10 +399,10 @@ class Post {
   @PrimaryKey(col.int())
   id!: number;
 
-  @Column(col.varchar(255).notNull())
+  @Column(col.varchar(255))
   title!: string;
 
-  @Column(col.int().notNull())
+  @Column(col.int())
   userId!: number;
 
   @BelongsTo({
@@ -419,18 +418,11 @@ const tables = bootstrapEntities();
 
 // 2) Create OrmContext as before
 const connection = await mysql.createConnection({ /* ... */ });
+const executor = createMysqlExecutor(connection);
 
 const ctx = new OrmContext({
   dialect: new MySqlDialect(),
-  executor: {
-    async executeSql(sql, params) {
-      const [rows] = await connection.execute(sql, params);
-      return [{
-        columns: Object.keys(rows[0] ?? {}),
-        values: rows.map(row => Object.values(row)),
-      }];
-    },
-  },
+  executor,
 });
 
 // 3) Query starting from the entity class
@@ -477,6 +469,7 @@ Under the hood, MetalORM leans on well-known patterns:
 
 - **AST + dialect abstraction**: SQL is modeled as typed AST nodes, compiled by dialects that you can extend.
 - **Separation of concerns**: schema, AST, SQL compilation, execution, and ORM runtime are separate layers.
+- **Executor abstraction**: built-in executor creators (`createMysqlExecutor`, `createPostgresExecutor`, etc.) provide a clean separation between database drivers and ORM operations.
 - **Unit of Work + Identity Map**: `OrmContext` coordinates changes and enforces one entity instance per row, following the [Unit of Work](https://en.wikipedia.org/wiki/Unit_of_work) and [Identity map](https://en.wikipedia.org/wiki/Identity_map_pattern) patterns.
 - **Domain events + interceptors**: decouple side-effects from persistence and let cross-cutting concerns hook into flush points, similar in spirit to domain events in [Domain-driven design](https://en.wikipedia.org/wiki/Domain-driven_design).
 
@@ -496,4 +489,4 @@ See the contributing guide for details.
 <a id="license"></a>
 ## License 📄
 
-MetalORM is MIT licensed.
+MetalORM is MIT licensed.