metal-orm 1.0.14 → 1.0.16

package/src/orm/relations/has-one.ts

@@ -0,0 +1,140 @@
+import { HasOneReference } from '../../schema/types.js';
+import { EntityContext } from '../entity-context.js';
+import { RelationKey } from '../runtime-types.js';
+import { HasOneRelation } from '../../schema/relation.js';
+import { TableDef } from '../../schema/table.js';
+import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta.js';
+
+type Row = Record<string, any>;
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+const hideInternal = (obj: any, keys: string[]): void => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+export class DefaultHasOneReference<TChild> implements HasOneReference<TChild> {
+  private loaded = false;
+  private current: TChild | null = null;
+
+  constructor(
+    private readonly ctx: EntityContext,
+    private readonly meta: EntityMeta<any>,
+    private readonly root: any,
+    private readonly relationName: string,
+    private readonly relation: HasOneRelation,
+    private readonly rootTable: TableDef,
+    private readonly loader: () => Promise<Map<string, Row>>,
+    private readonly createEntity: (row: Row) => TChild,
+    private readonly localKey: string
+  ) {
+    hideInternal(this, [
+      'ctx',
+      'meta',
+      'root',
+      'relationName',
+      'relation',
+      'rootTable',
+      'loader',
+      'createEntity',
+      'localKey'
+    ]);
+    this.populateFromHydrationCache();
+  }
+
+  async load(): Promise<TChild | null> {
+    if (this.loaded) return this.current;
+    const map = await this.loader();
+    const keyValue = this.root[this.localKey];
+    if (keyValue === undefined || keyValue === null) {
+      this.loaded = true;
+      return this.current;
+    }
+    const row = map.get(toKey(keyValue));
+    this.current = row ? this.createEntity(row) : null;
+    this.loaded = true;
+    return this.current;
+  }
+
+  get(): TChild | null {
+    return this.current;
+  }
+
+  set(data: Partial<TChild> | TChild | null): TChild | null {
+    if (data === null) {
+      return this.detachCurrent();
+    }
+
+    const entity = hasEntityMeta(data) ? (data as TChild) : this.createEntity(data as Row);
+    if (this.current && this.current !== entity) {
+      this.ctx.registerRelationChange(
+        this.root,
+        this.relationKey,
+        this.rootTable,
+        this.relationName,
+        this.relation,
+        { kind: 'remove', entity: this.current }
+      );
+    }
+
+    this.assignForeignKey(entity);
+    this.current = entity;
+    this.loaded = true;
+
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'attach', entity }
+    );
+
+    return entity;
+  }
+
+  toJSON(): TChild | null {
+    return this.current;
+  }
+
+  private detachCurrent(): TChild | null {
+    const previous = this.current;
+    if (!previous) return null;
+    this.current = null;
+    this.loaded = true;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'remove', entity: previous }
+    );
+    return null;
+  }
+
+  private assignForeignKey(entity: TChild): void {
+    const keyValue = this.root[this.localKey];
+    (entity as Row)[this.relation.foreignKey] = keyValue;
+  }
+
+  private get relationKey(): RelationKey {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+
+  private populateFromHydrationCache(): void {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === undefined || keyValue === null) return;
+    const row = getHydrationRecord(this.meta, this.relationName, keyValue);
+    if (!row) return;
+    this.current = this.createEntity(row);
+    this.loaded = true;
+  }
+}

package/src/orm/relations/many-to-many.ts

@@ -1,46 +1,47 @@
 import { ManyToManyCollection } from '../../schema/types.js';
-import { OrmContext, RelationKey } from '../orm-context.js';
+import { EntityContext } from '../entity-context.js';
+import { RelationKey } from '../runtime-types.js';
 import { BelongsToManyRelation } from '../../schema/relation.js';
 import { TableDef } from '../../schema/table.js';
 import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
 import { EntityMeta, getHydrationRows } from '../entity-meta.js';
 
-type Rows = Record<string, any>[];
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-const hideInternal = (obj: any, keys: string[]): void => {
-  for (const key of keys) {
-    Object.defineProperty(obj, key, {
-      value: obj[key],
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
-  }
-};
-
-export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
-  private loaded = false;
-  private items: TTarget[] = [];
-
-  constructor(
-    private readonly ctx: OrmContext,
+type Rows = Record<string, any>[];
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+const hideInternal = (obj: any, keys: string[]): void => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
+  private loaded = false;
+  private items: TTarget[] = [];
+
+  constructor(
+    private readonly ctx: EntityContext,
     private readonly meta: EntityMeta<any>,
     private readonly root: any,
     private readonly relationName: string,
     private readonly relation: BelongsToManyRelation,
     private readonly rootTable: TableDef,
     private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TTarget,
-    private readonly localKey: string
-  ) {
-    hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'localKey']);
-    this.hydrateFromCache();
-  }
-
-  async load(): Promise<TTarget[]> {
-    if (this.loaded) return this.items;
+    private readonly createEntity: (row: Record<string, any>) => TTarget,
+    private readonly localKey: string
+  ) {
+    hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'localKey']);
+    this.hydrateFromCache();
+  }
+
+  async load(): Promise<TTarget[]> {
+    if (this.loaded) return this.items;
     const map = await this.loader();
     const key = toKey(this.root[this.localKey]);
     const rows = map.get(key) ?? [];
@@ -144,22 +145,22 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
     return this.relation.targetKey || findPrimaryKey(this.relation.target);
   }
 
-  private hydrateFromCache(): void {
-    const keyValue = this.root[this.localKey];
-    if (keyValue === undefined || keyValue === null) return;
-    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
-    if (!rows?.length) return;
+  private hydrateFromCache(): void {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === undefined || keyValue === null) return;
+    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
+    if (!rows?.length) return;
     this.items = rows.map(row => {
       const entity = this.createEntity(row);
       if ((row as any)._pivot) {
         (entity as any)._pivot = (row as any)._pivot;
       }
-      return entity;
-    });
-    this.loaded = true;
-  }
-
-  toJSON(): TTarget[] {
-    return this.items;
-  }
-}
+      return entity;
+    });
+    this.loaded = true;
+  }
+
+  toJSON(): TTarget[] {
+    return this.items;
+  }
+}

package/src/orm/transaction-runner.ts

@@ -1,4 +1,4 @@
-import type { DbExecutor } from './db-executor.js';
+import type { DbExecutor } from '../core/execution/db-executor.js';
 
 export const runInTransaction = async (executor: DbExecutor, action: () => Promise<void>): Promise<void> => {
   if (!executor.beginTransaction) {

package/src/orm/unit-of-work.ts

@@ -1,11 +1,11 @@
-import { ColumnNode, eq } from '../core/ast/expression.js';
-import type { Dialect, CompiledQuery } from '../core/dialect/abstract.js';
+import { ColumnNode, eq } from '../core/ast/expression.js';
+import type { Dialect, CompiledQuery } from '../core/dialect/abstract.js';
 import { InsertQueryBuilder } from '../query-builder/insert.js';
 import { UpdateQueryBuilder } from '../query-builder/update.js';
 import { DeleteQueryBuilder } from '../query-builder/delete.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 import type { TableDef, TableHooks } from '../schema/table.js';
-import type { DbExecutor, QueryResult } from './db-executor.js';
+import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
 import { IdentityMap } from './identity-map.js';
 import { EntityStatus } from './runtime-types.js';
 import type { TrackedEntity } from './runtime-types.js';
@@ -18,7 +18,7 @@ export class UnitOfWork {
     private readonly executor: DbExecutor,
     private readonly identityMap: IdentityMap,
     private readonly hookContext: () => unknown
-  ) {}
+  ) { }
 
   get identityBuckets(): Map<string, Map<string, TrackedEntity>> {
     return this.identityMap.bucketsMap;
@@ -117,17 +117,22 @@ export class UnitOfWork {
     }
   }
 
+  reset(): void {
+    this.trackedEntities.clear();
+    this.identityMap.clear();
+  }
+
   private async flushInsert(tracked: TrackedEntity): Promise<void> {
     await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
 
-    const payload = this.extractColumns(tracked.table, tracked.entity);
-    let builder = new InsertQueryBuilder(tracked.table).values(payload);
-    if (this.dialect.supportsReturning()) {
-      builder = builder.returning(...this.getReturningColumns(tracked.table));
-    }
-    const compiled = builder.compile(this.dialect);
-    const results = await this.executeCompiled(compiled);
-    this.applyReturningResults(tracked, results);
+    const payload = this.extractColumns(tracked.table, tracked.entity);
+    let builder = new InsertQueryBuilder(tracked.table).values(payload);
+    if (this.dialect.supportsReturning()) {
+      builder = builder.returning(...this.getReturningColumns(tracked.table));
+    }
+    const compiled = builder.compile(this.dialect);
+    const results = await this.executeCompiled(compiled);
+    this.applyReturningResults(tracked, results);
 
     tracked.status = EntityStatus.Managed;
     tracked.original = this.createSnapshot(tracked.table, tracked.entity);
@@ -150,17 +155,17 @@ export class UnitOfWork {
     const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
     if (!pkColumn) return;
 
-    let builder = new UpdateQueryBuilder(tracked.table)
-      .set(changes)
-      .where(eq(pkColumn, tracked.pk));
-
-    if (this.dialect.supportsReturning()) {
-      builder = builder.returning(...this.getReturningColumns(tracked.table));
-    }
-
-    const compiled = builder.compile(this.dialect);
-    const results = await this.executeCompiled(compiled);
-    this.applyReturningResults(tracked, results);
+    let builder = new UpdateQueryBuilder(tracked.table)
+      .set(changes)
+      .where(eq(pkColumn, tracked.pk));
+
+    if (this.dialect.supportsReturning()) {
+      builder = builder.returning(...this.getReturningColumns(tracked.table));
+    }
+
+    const compiled = builder.compile(this.dialect);
+    const results = await this.executeCompiled(compiled);
+    this.applyReturningResults(tracked, results);
 
     tracked.status = EntityStatus.Managed;
     tracked.original = this.createSnapshot(tracked.table, tracked.entity);
@@ -215,44 +220,44 @@ export class UnitOfWork {
     return payload;
   }
 
-  private async executeCompiled(compiled: CompiledQuery): Promise<QueryResult[]> {
-    return this.executor.executeSql(compiled.sql, compiled.params);
-  }
-
-  private getReturningColumns(table: TableDef): ColumnNode[] {
-    return Object.values(table.columns).map(column => ({
-      type: 'Column',
-      table: table.name,
-      name: column.name,
-      alias: column.name
-    }));
-  }
-
-  private applyReturningResults(tracked: TrackedEntity, results: QueryResult[]): void {
-    if (!this.dialect.supportsReturning()) return;
-    const first = results[0];
-    if (!first || first.values.length === 0) return;
-
-    const row = first.values[0];
-    for (let i = 0; i < first.columns.length; i++) {
-      const columnName = this.normalizeColumnName(first.columns[i]);
-      if (!(columnName in tracked.table.columns)) continue;
-      tracked.entity[columnName] = row[i];
-    }
-  }
-
-  private normalizeColumnName(column: string): string {
-    const parts = column.split('.');
-    const candidate = parts[parts.length - 1];
-    return candidate.replace(/^["`[\]]+|["`[\]]+$/g, '');
-  }
-
-  private registerIdentity(tracked: TrackedEntity): void {
-    if (tracked.pk == null) return;
-    this.identityMap.register(tracked);
-  }
-
-  private createSnapshot(table: TableDef, entity: any): Record<string, any> {
+  private async executeCompiled(compiled: CompiledQuery): Promise<QueryResult[]> {
+    return this.executor.executeSql(compiled.sql, compiled.params);
+  }
+
+  private getReturningColumns(table: TableDef): ColumnNode[] {
+    return Object.values(table.columns).map(column => ({
+      type: 'Column',
+      table: table.name,
+      name: column.name,
+      alias: column.name
+    }));
+  }
+
+  private applyReturningResults(tracked: TrackedEntity, results: QueryResult[]): void {
+    if (!this.dialect.supportsReturning()) return;
+    const first = results[0];
+    if (!first || first.values.length === 0) return;
+
+    const row = first.values[0];
+    for (let i = 0; i < first.columns.length; i++) {
+      const columnName = this.normalizeColumnName(first.columns[i]);
+      if (!(columnName in tracked.table.columns)) continue;
+      tracked.entity[columnName] = row[i];
+    }
+  }
+
+  private normalizeColumnName(column: string): string {
+    const parts = column.split('.');
+    const candidate = parts[parts.length - 1];
+    return candidate.replace(/^["`[\]]+|["`[\]]+$/g, '');
+  }
+
+  private registerIdentity(tracked: TrackedEntity): void {
+    if (tracked.pk == null) return;
+    this.identityMap.register(tracked);
+  }
+
+  private createSnapshot(table: TableDef, entity: any): Record<string, any> {
     const snapshot: Record<string, any> = {};
     for (const column of Object.keys(table.columns)) {
       snapshot[column] = entity[column];

package/src/query-builder/delete.ts

@@ -1,11 +1,14 @@
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
 import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
-import { CompiledQuery, DeleteCompiler } from '../core/dialect/abstract.js';
+import { CompiledQuery, DeleteCompiler, Dialect } from '../core/dialect/abstract.js';
+import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
 import { DeleteQueryNode } from '../core/ast/query.js';
 import { DeleteQueryState } from './delete-query-state.js';
 import { buildColumnNode } from '../core/ast/builders.js';
 
+type DeleteDialectInput = Dialect | DialectKey;
+
 /**
  * Builder for DELETE queries
  */
@@ -32,12 +35,26 @@ export class DeleteQueryBuilder<T> {
     return this.clone(this.state.withReturning(nodes));
   }
 
-  compile(compiler: DeleteCompiler): CompiledQuery {
-    return compiler.compileDelete(this.state.ast);
+  // Existing compiler-based compile stays, but we add a new overload.
+
+  // 1) Keep the old behavior (used internally / tests, if any):
+  compile(compiler: DeleteCompiler): CompiledQuery;
+  // 2) New ergonomic overload:
+  compile(dialect: DeleteDialectInput): CompiledQuery;
+
+  compile(arg: DeleteCompiler | DeleteDialectInput): CompiledQuery {
+    if (typeof (arg as any).compileDelete === 'function') {
+      // DeleteCompiler path – old behavior
+      return (arg as DeleteCompiler).compileDelete(this.state.ast);
+    }
+
+    // Dialect | string path – new behavior
+    const dialect = resolveDialectInput(arg as DeleteDialectInput);
+    return dialect.compileDelete(this.state.ast);
   }
 
-  toSql(compiler: DeleteCompiler): string {
-    return this.compile(compiler).sql;
+  toSql(arg: DeleteCompiler | DeleteDialectInput): string {
+    return this.compile(arg as any).sql;
   }
 
   getAST(): DeleteQueryNode {

package/src/query-builder/hydration-manager.ts

@@ -1,6 +1,7 @@
 import { TableDef } from '../schema/table.js';
 import { RelationDef, RelationKinds } from '../schema/relation.js';
-import { CommonTableExpressionNode, HydrationPlan, OrderByNode, SelectQueryNode } from '../core/ast/query.js';
+import { CommonTableExpressionNode, OrderByNode, SelectQueryNode } from '../core/ast/query.js';
+import { HydrationPlan } from '../core/hydration/types.js';
 import { HydrationPlanner } from './hydration-planner.js';
 import { ProjectionNode, SelectQueryState } from './select-query-state.js';
 import { ColumnNode, eq } from '../core/ast/expression.js';

package/src/query-builder/hydration-planner.ts

@@ -1,7 +1,7 @@
 import { TableDef } from '../schema/table.js';
 import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
 import { ProjectionNode } from './select-query-state.js';
-import { HydrationPlan, HydrationRelationPlan } from '../core/ast/query.js';
+import { HydrationPlan, HydrationRelationPlan } from '../core/hydration/types.js';
 import { isRelationAlias } from './relation-alias.js';
 import { buildDefaultPivotColumns } from './relation-utils.js';
 
@@ -111,12 +111,13 @@ export class HydrationPlanner {
     pivot?: { aliasPrefix: string; columns: string[] }
   ): HydrationRelationPlan {
     switch (rel.type) {
-      case RelationKinds.HasMany: {
-        const localKey = rel.localKey || findPrimaryKey(this.table);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
+      case RelationKinds.HasMany:
+      case RelationKinds.HasOne: {
+        const localKey = rel.localKey || findPrimaryKey(this.table);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
           targetTable: rel.target.name,
           targetPrimaryKey: findPrimaryKey(rel.target),
           foreignKey: rel.foreignKey,

package/src/query-builder/insert.ts

@@ -1,11 +1,14 @@
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
 import { ColumnNode } from '../core/ast/expression.js';
-import { CompiledQuery, InsertCompiler } from '../core/dialect/abstract.js';
+import { CompiledQuery, InsertCompiler, Dialect } from '../core/dialect/abstract.js';
+import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
 import { InsertQueryNode } from '../core/ast/query.js';
 import { InsertQueryState } from './insert-query-state.js';
 import { buildColumnNode } from '../core/ast/builders.js';
 
+type InsertDialectInput = Dialect | DialectKey;
+
 /**
  * Builder for INSERT queries
  */
@@ -34,12 +37,26 @@ export class InsertQueryBuilder<T> {
     return this.clone(this.state.withReturning(nodes));
   }
 
-  compile(compiler: InsertCompiler): CompiledQuery {
-    return compiler.compileInsert(this.state.ast);
+  // Existing compiler-based compile stays, but we add a new overload.
+
+  // 1) Keep the old behavior (used internally / tests, if any):
+  compile(compiler: InsertCompiler): CompiledQuery;
+  // 2) New ergonomic overload:
+  compile(dialect: InsertDialectInput): CompiledQuery;
+
+  compile(arg: InsertCompiler | InsertDialectInput): CompiledQuery {
+    if (typeof (arg as any).compileInsert === 'function') {
+      // InsertCompiler path – old behavior
+      return (arg as InsertCompiler).compileInsert(this.state.ast);
+    }
+
+    // Dialect | string path – new behavior
+    const dialect = resolveDialectInput(arg as InsertDialectInput);
+    return dialect.compileInsert(this.state.ast);
   }
 
-  toSql(compiler: InsertCompiler): string {
-    return this.compile(compiler).sql;
+  toSql(arg: InsertCompiler | InsertDialectInput): string {
+    return this.compile(arg as any).sql;
   }
 
   getAST(): InsertQueryNode {

package/src/query-builder/relation-conditions.ts

@@ -23,17 +23,18 @@ const assertNever = (value: never): never => {
  */
 const baseRelationCondition = (root: TableDef, relation: RelationDef): ExpressionNode => {
   const defaultLocalKey =
-    relation.type === RelationKinds.HasMany
-      ? findPrimaryKey(root)
-      : findPrimaryKey(relation.target);
+  relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
+    ? findPrimaryKey(root)
+    : findPrimaryKey(relation.target);
   const localKey = relation.localKey || defaultLocalKey;
 
   switch (relation.type) {
-    case RelationKinds.HasMany:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
-        { type: 'Column', table: root.name, name: localKey }
-      );
+    case RelationKinds.HasMany:
+    case RelationKinds.HasOne:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
+        { type: 'Column', table: root.name, name: localKey }
+      );
     case RelationKinds.BelongsTo:
       return eq(
         { type: 'Column', table: relation.target.name, name: localKey },

package/src/query-builder/relation-service.ts

@@ -20,7 +20,8 @@ import {
 } from './relation-conditions.js';
 import { JoinKind, JOIN_KINDS } from '../core/sql/sql.js';
 import { RelationIncludeOptions } from './relation-types.js';
-import { createJoinNode } from '../core/ast/join-node.js';
+import { createJoinNode } from '../core/ast/join-node.js';
+import { getJoinRelationName } from '../core/ast/join-metadata.js';
 import { makeRelationAlias } from './relation-alias.js';
 import { buildDefaultPivotColumns } from './relation-utils.js';
 
@@ -93,7 +94,7 @@ export class RelationService {
 
     const relation = this.getRelation(relationName);
     const aliasPrefix = options?.aliasPrefix ?? relationName;
-    const alreadyJoined = state.ast.joins.some(j => j.relationName === relationName);
+    const alreadyJoined = state.ast.joins.some(j => getJoinRelationName(j) === relationName);
 
     if (!alreadyJoined) {
       const joined = this.joinRelation(relationName, options?.joinKind ?? JOIN_KINDS.LEFT, options?.filter);