metal-orm 1.1.21 → 1.1.23

package/dist/index.js

@@ -36,7 +36,7 @@ var init_schema_plan_executor = __esm({
 });
 
 // src/schema/table.ts
-var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
+var defineTable = (name, columns, relations = {}, options = {}) => {
   const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
     const colDef = { ...def, name: key, table: name };
     acc[key] = colDef;
@@ -47,7 +47,6 @@ var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
     schema: options.schema,
     columns: colsWithNames,
     relations,
-    hooks,
     primaryKey: options.primaryKey,
     indexes: options.indexes,
     checks: options.checks,
@@ -1315,268 +1314,40 @@ var StandardTableFunctionStrategy = class {
   }
 };
 
-// src/core/dialect/abstract.ts
-var Dialect = class _Dialect {
-  /**
-   * Compiles a SELECT query AST to SQL
-   * @param ast - Query AST to compile
-   * @returns Compiled query with SQL and parameters
-   */
-  compileSelect(ast) {
-    const ctx = this.createCompilerContext();
-    const normalized = this.normalizeSelectAst(ast);
-    const rawSql = this.compileSelectAst(normalized, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileInsert(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileInsertAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileUpdate(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileUpdateAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileDelete(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileDeleteAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  supportsDmlReturningClause() {
-    return false;
-  }
-  /**
-   * Compiles a WHERE clause
-   * @param where - WHERE expression
-   * @param ctx - Compiler context
-   * @returns SQL WHERE clause or empty string
-   */
-  compileWhere(where, ctx) {
-    if (!where) return "";
-    return ` WHERE ${this.compileExpression(where, ctx)}`;
-  }
-  compileReturning(returning, _ctx) {
-    void _ctx;
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  /**
-   * Generates subquery for EXISTS expressions
-   * Rule: Always forces SELECT 1, ignoring column list
-   * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
-   * Does not add ';' at the end
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL for EXISTS subquery
-   */
-  compileSelectForExists(ast, ctx) {
-    const normalized = this.normalizeSelectAst(ast);
-    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
-    if (normalized.setOps && normalized.setOps.length > 0) {
-      return `SELECT 1 FROM (${full}) AS _exists`;
-    }
-    const upper2 = full.toUpperCase();
-    const fromIndex = upper2.indexOf(" FROM ");
-    if (fromIndex === -1) {
-      return full;
-    }
-    const tail = full.slice(fromIndex);
-    return `SELECT 1${tail}`;
-  }
-  /**
-   * Creates a new compiler context
-   * @returns Compiler context with parameter management
-   */
-  createCompilerContext() {
-    const params = [];
-    let counter = 0;
-    return {
-      params,
-      addParameter: (value) => {
-        counter += 1;
-        params.push(value);
-        return this.formatPlaceholder(counter);
-      }
-    };
-  }
-  /**
-   * Formats a parameter placeholder
-   * @param index - Parameter index
-   * @returns Formatted placeholder string
-   */
-  formatPlaceholder(_index) {
-    void _index;
-    return "?";
-  }
-  /**
-   * Whether the current dialect supports a given set operation.
-   * Override in concrete dialects to restrict support.
-   */
-  supportsSetOperation(_kind) {
-    void _kind;
-    return true;
-  }
-  /**
-   * Validates set-operation semantics:
-   * - Ensures the dialect supports requested operators.
-   * - Enforces that only the outermost compound query may have ORDER/LIMIT/OFFSET.
-   * @param ast - Query to validate
-   * @param isOutermost - Whether this node is the outermost compound query
-   */
-  validateSetOperations(ast, isOutermost = true) {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    if (!isOutermost && (ast.orderBy || ast.limit !== void 0 || ast.offset !== void 0)) {
-      throw new Error("ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.");
-    }
-    if (hasSetOps) {
-      for (const op of ast.setOps) {
-        if (!this.supportsSetOperation(op.operator)) {
-          throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
-        }
-        this.validateSetOperations(op.query, false);
-      }
-    }
-  }
-  /**
-   * Hoists CTEs from set-operation operands to the outermost query so WITH appears once.
-   * @param ast - Query AST
-   * @returns Normalized AST without inner CTEs and a list of hoisted CTEs
-   */
-  hoistCtes(ast) {
-    let hoisted = [];
-    const normalizedSetOps = ast.setOps?.map((op) => {
-      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
-      const childCtes = child.ctes ?? [];
-      if (childCtes.length) {
-        hoisted = hoisted.concat(childCtes);
-      }
-      hoisted = hoisted.concat(childHoisted);
-      const queryWithoutCtes = childCtes.length ? { ...child, ctes: void 0 } : child;
-      return { ...op, query: queryWithoutCtes };
-    });
-    const normalized = normalizedSetOps ? { ...ast, setOps: normalizedSetOps } : ast;
-    return { normalized, hoistedCtes: hoisted };
-  }
-  /**
-   * Normalizes a SELECT AST before compilation (validation + CTE hoisting).
-   * @param ast - Query AST
-   * @returns Normalized query AST
-   */
-  normalizeSelectAst(ast) {
-    this.validateSetOperations(ast, true);
-    const { normalized, hoistedCtes } = this.hoistCtes(ast);
-    const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
-    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
-  }
-  expressionCompilers;
-  operandCompilers;
-  functionStrategy;
-  tableFunctionStrategy;
-  constructor(functionStrategy, tableFunctionStrategy) {
-    this.expressionCompilers = /* @__PURE__ */ new Map();
-    this.operandCompilers = /* @__PURE__ */ new Map();
-    this.functionStrategy = functionStrategy || new StandardFunctionStrategy();
-    this.tableFunctionStrategy = tableFunctionStrategy || new StandardTableFunctionStrategy();
+// src/core/dialect/base/expression-compiler-registry.ts
+var ExpressionCompilerRegistry = class {
+  constructor(host) {
+    this.host = host;
     this.registerDefaultOperandCompilers();
     this.registerDefaultExpressionCompilers();
   }
-  /**
-   * Creates a new Dialect instance (for testing purposes)
-   * @param functionStrategy - Optional function strategy
-   * @returns New Dialect instance
-   */
-  static create(functionStrategy, tableFunctionStrategy) {
-    class TestDialect extends _Dialect {
-      dialect = "sqlite";
-      quoteIdentifier(id) {
-        return `"${id}"`;
-      }
-      compileSelectAst() {
-        throw new Error("Not implemented");
-      }
-      compileInsertAst() {
-        throw new Error("Not implemented");
-      }
-      compileUpdateAst() {
-        throw new Error("Not implemented");
-      }
-      compileDeleteAst() {
-        throw new Error("Not implemented");
-      }
-      compileProcedureCall() {
-        throw new Error("Not implemented");
-      }
-    }
-    return new TestDialect(functionStrategy, tableFunctionStrategy);
-  }
-  /**
-   * Registers an expression compiler for a specific node type
-   * @param type - Expression node type
-   * @param compiler - Compiler function
-   */
+  expressionCompilers = /* @__PURE__ */ new Map();
+  operandCompilers = /* @__PURE__ */ new Map();
   registerExpressionCompiler(type, compiler) {
     this.expressionCompilers.set(type, compiler);
   }
-  /**
-   * Registers an operand compiler for a specific node type
-   * @param type - Operand node type
-   * @param compiler - Compiler function
-   */
   registerOperandCompiler(type, compiler) {
     this.operandCompilers.set(type, compiler);
   }
-  /**
-   * Compiles an expression node
-   * @param node - Expression node to compile
-   * @param ctx - Compiler context
-   * @returns Compiled SQL expression
-   */
   compileExpression(node, ctx) {
     const compiler = this.expressionCompilers.get(node.type);
     if (!compiler) {
-      throw new Error(`Unsupported expression node type "${node.type}" for ${this.constructor.name}`);
+      throw new Error(`Unsupported expression node type "${node.type}" for ${this.host.describe()}`);
     }
     return compiler(node, ctx);
   }
-  /**
-   * Compiles an operand node
-   * @param node - Operand node to compile
-   * @param ctx - Compiler context
-   * @returns Compiled SQL operand
-   */
   compileOperand(node, ctx) {
     const compiler = this.operandCompilers.get(node.type);
     if (!compiler) {
-      throw new Error(`Unsupported operand node type "${node.type}" for ${this.constructor.name}`);
+      throw new Error(`Unsupported operand node type "${node.type}" for ${this.host.describe()}`);
     }
     return compiler(node, ctx);
   }
-  /**
-   * Compiles an ordering term (operand, expression, or alias reference).
-   */
   compileOrderingTerm(term, ctx) {
     if (isOperandNode(term)) {
       return this.compileOperand(term, ctx);
     }
-    const expr = this.compileExpression(term, ctx);
-    return `(${expr})`;
+    return `(${this.compileExpression(term, ctx)})`;
   }
   registerDefaultExpressionCompilers() {
     this.registerExpressionCompiler("BinaryExpression", (binary, ctx) => {
@@ -1611,11 +1382,11 @@ var Dialect = class _Dialect {
         const values = inExpr.right.map((v) => this.compileOperand(v, ctx)).join(", ");
         return `${left2} ${inExpr.operator} (${values})`;
       }
-      const subquerySql = this.compileSelectAst(inExpr.right.query, ctx).trim().replace(/;$/, "");
+      const subquerySql = this.host.compileSelectAst(inExpr.right.query, ctx).trim().replace(/;$/, "");
       return `${left2} ${inExpr.operator} (${subquerySql})`;
     });
     this.registerExpressionCompiler("ExistsExpression", (existsExpr, ctx) => {
-      const subquerySql = this.compileSelectForExists(existsExpr.subquery, ctx);
+      const subquerySql = this.host.compileSelectForExists(existsExpr.subquery, ctx);
       return `${existsExpr.operator} (${subquerySql})`;
     });
     this.registerExpressionCompiler("BetweenExpression", (betweenExpr, ctx) => {
@@ -1641,25 +1412,28 @@ var Dialect = class _Dialect {
     });
   }
   registerDefaultOperandCompilers() {
-    this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
-    this.registerOperandCompiler("AliasRef", (alias, _ctx) => {
-      void _ctx;
-      return this.quoteIdentifier(alias.name);
-    });
-    this.registerOperandCompiler("Column", (column, _ctx) => {
-      void _ctx;
-      return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
-    });
+    this.registerOperandCompiler(
+      "Literal",
+      (literal, ctx) => ctx.addParameter(literal.value)
+    );
+    this.registerOperandCompiler(
+      "AliasRef",
+      (alias) => this.host.quoteIdentifier(alias.name)
+    );
+    this.registerOperandCompiler(
+      "Column",
+      (column) => `${this.host.quoteIdentifier(column.table)}.${this.host.quoteIdentifier(column.name)}`
+    );
     this.registerOperandCompiler(
       "Function",
-      (fnNode, ctx) => this.compileFunctionOperand(fnNode, ctx)
+      (fnNode, ctx) => this.host.compileFunctionOperand(fnNode, ctx)
+    );
+    this.registerOperandCompiler(
+      "JsonPath",
+      (path) => this.host.compileJsonPath(path)
     );
-    this.registerOperandCompiler("JsonPath", (path, _ctx) => {
-      void _ctx;
-      return this.compileJsonPath(path);
-    });
     this.registerOperandCompiler("ScalarSubquery", (node, ctx) => {
-      const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
+      const sql = this.host.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
       return `(${sql})`;
     });
     this.registerOperandCompiler("CaseExpression", (node, ctx) => {
@@ -1686,7 +1460,7 @@ var Dialect = class _Dialect {
       const parts = [];
       if (node.partitionBy && node.partitionBy.length > 0) {
         const partitionClause = "PARTITION BY " + node.partitionBy.map(
-          (col2) => `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`
+          (col2) => `${this.host.quoteIdentifier(col2.table)}.${this.host.quoteIdentifier(col2.name)}`
         ).join(", ");
         parts.push(partitionClause);
       }
@@ -1718,14 +1492,164 @@ var Dialect = class _Dialect {
       return `${expr} COLLATE ${node.collation}`;
     });
   }
-  // Default fallback, should be overridden by dialects if supported
+};
+
+// src/core/dialect/base/select-ast-normalizer.ts
+var SelectAstNormalizer = class {
+  constructor(supportsSetOperation) {
+    this.supportsSetOperation = supportsSetOperation;
+  }
+  normalize(ast) {
+    this.validateSetOperations(ast, true);
+    const { normalized, hoistedCtes } = this.hoistCtes(ast);
+    const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
+    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
+  }
+  validateSetOperations(ast, isOutermost) {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    if (!isOutermost && (ast.orderBy || ast.limit !== void 0 || ast.offset !== void 0)) {
+      throw new Error("ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.");
+    }
+    if (!hasSetOps) return;
+    for (const op of ast.setOps) {
+      if (!this.supportsSetOperation(op.operator)) {
+        throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
+      }
+      this.validateSetOperations(op.query, false);
+    }
+  }
+  hoistCtes(ast) {
+    let hoisted = [];
+    const normalizedSetOps = ast.setOps?.map((op) => {
+      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
+      const childCtes = child.ctes ?? [];
+      if (childCtes.length) hoisted = hoisted.concat(childCtes);
+      hoisted = hoisted.concat(childHoisted);
+      const queryWithoutCtes = childCtes.length ? { ...child, ctes: void 0 } : child;
+      return { ...op, query: queryWithoutCtes };
+    });
+    const normalized = normalizedSetOps ? { ...ast, setOps: normalizedSetOps } : ast;
+    return { normalized, hoistedCtes: hoisted };
+  }
+};
+
+// src/core/dialect/abstract.ts
+var DialectBase = class _DialectBase {
+  expressionCompilerRegistry;
+  selectAstNormalizer;
+  functionStrategy;
+  tableFunctionStrategy;
+  constructor(functionStrategy, tableFunctionStrategy) {
+    this.functionStrategy = functionStrategy ?? new StandardFunctionStrategy();
+    this.tableFunctionStrategy = tableFunctionStrategy ?? new StandardTableFunctionStrategy();
+    this.selectAstNormalizer = new SelectAstNormalizer((kind) => this.supportsSetOperation(kind));
+    this.expressionCompilerRegistry = new ExpressionCompilerRegistry({
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
+      compileSelectForExists: (ast, ctx) => this.compileSelectForExists(ast, ctx),
+      compileJsonPath: (node) => this.compileJsonPath(node),
+      compileFunctionOperand: (node, ctx) => this.compileFunctionOperand(node, ctx),
+      describe: () => this.constructor.name
+    });
+  }
+  compileSelect(ast) {
+    const ctx = this.createCompilerContext();
+    const normalized = this.normalizeSelectAst(ast);
+    const rawSql = this.compileSelectAst(normalized, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  compileInsert(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileInsertAst(ast, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  compileUpdate(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileUpdateAst(ast, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  compileDelete(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileDeleteAst(ast, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  supportsDmlReturningClause() {
+    return false;
+  }
+  compileWhere(where, ctx) {
+    if (!where) return "";
+    return ` WHERE ${this.compileExpression(where, ctx)}`;
+  }
+  compileReturning(returning, _ctx) {
+    void _ctx;
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  compileSelectForExists(ast, ctx) {
+    const normalized = this.normalizeSelectAst(ast);
+    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    if (normalized.setOps && normalized.setOps.length > 0) {
+      return `SELECT 1 FROM (${full}) AS _exists`;
+    }
+    const upper2 = full.toUpperCase();
+    const fromIndex = upper2.indexOf(" FROM ");
+    if (fromIndex === -1) return full;
+    return `SELECT 1${full.slice(fromIndex)}`;
+  }
+  createCompilerContext() {
+    const params = [];
+    let counter = 0;
+    return {
+      params,
+      addParameter: (value) => {
+        counter += 1;
+        params.push(value);
+        return this.formatPlaceholder(counter);
+      }
+    };
+  }
+  formatPlaceholder(_index) {
+    void _index;
+    return "?";
+  }
+  supportsSetOperation(_kind) {
+    void _kind;
+    return true;
+  }
+  normalizeSelectAst(ast) {
+    return this.selectAstNormalizer.normalize(ast);
+  }
+  registerExpressionCompiler(type, compiler) {
+    this.expressionCompilerRegistry.registerExpressionCompiler(type, compiler);
+  }
+  registerOperandCompiler(type, compiler) {
+    this.expressionCompilerRegistry.registerOperandCompiler(type, compiler);
+  }
+  compileExpression(node, ctx) {
+    return this.expressionCompilerRegistry.compileExpression(node, ctx);
+  }
+  compileOperand(node, ctx) {
+    return this.expressionCompilerRegistry.compileOperand(node, ctx);
+  }
+  compileOrderingTerm(term, ctx) {
+    return this.expressionCompilerRegistry.compileOrderingTerm(term, ctx);
+  }
   compileJsonPath(_node) {
     void _node;
     throw new Error("JSON Path not supported by this dialect");
   }
-  /**
-   * Compiles a function operand, using the dialect's function strategy.
-   */
   compileFunctionOperand(fnNode, ctx) {
     const compiledArgs = fnNode.args.map((arg) => this.compileOperand(arg, ctx));
     const renderer = this.functionStrategy.getRenderer(fnNode.name);
@@ -1738,98 +1662,62 @@ var Dialect = class _Dialect {
     }
     return `${fnNode.name}(${compiledArgs.join(", ")})`;
   }
+  /** Creates a minimal dialect implementation for isolated compiler tests. */
+  static create(functionStrategy, tableFunctionStrategy) {
+    class TestDialect extends _DialectBase {
+      dialect = "sqlite";
+      quoteIdentifier(id) {
+        return `"${id}"`;
+      }
+      compileSelectAst() {
+        throw new Error("Not implemented");
+      }
+      compileInsertAst() {
+        throw new Error("Not implemented");
+      }
+      compileUpdateAst() {
+        throw new Error("Not implemented");
+      }
+      compileDeleteAst() {
+        throw new Error("Not implemented");
+      }
+    }
+    return new TestDialect(functionStrategy, tableFunctionStrategy);
+  }
 };
 
 // src/core/dialect/base/function-table-formatter.ts
 var FunctionTableFormatter = class {
-  /**
-   * Formats a function table node into SQL syntax.
-   * @param fn - The function table node containing schema, name, args, and aliases.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns SQL function table expression (e.g., "LATERAL schema.func(args) WITH ORDINALITY AS alias(col1, col2)").
-   */
-  static format(fn9, ctx, dialect) {
-    const schemaPart = this.formatSchema(fn9, dialect);
-    const args = this.formatArgs(fn9, ctx, dialect);
+  static format(fn9, ctx, formatter) {
+    const schemaPart = this.formatSchema(fn9, formatter);
+    const args = this.formatArgs(fn9, ctx, formatter);
     const base = this.formatBase(fn9, schemaPart, args);
     const lateral = this.formatLateral(fn9);
-    const alias = this.formatAlias(fn9, dialect);
-    const colAliases = this.formatColumnAliases(fn9, dialect);
+    const alias = this.formatAlias(fn9, formatter);
+    const colAliases = this.formatColumnAliases(fn9, formatter);
     return `${lateral}${base}${alias}${colAliases}`;
   }
-  /**
-   * Formats the schema prefix for the function name.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Schema prefix (e.g., "schema.") or empty string.
-   * @internal
-   */
-  static formatSchema(fn9, dialect) {
+  static formatSchema(fn9, formatter) {
     if (!fn9.schema) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn9.schema) : fn9.schema;
-    return `${quoted}.`;
+    return `${formatter.quoteIdentifier(fn9.schema)}.`;
   }
-  /**
-   * Formats function arguments into SQL syntax.
-   * @param fn - The function table node containing arguments.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns Comma-separated function arguments.
-   * @internal
-   */
-  static formatArgs(fn9, ctx, dialect) {
-    return (fn9.args || []).map((a) => {
-      if (ctx && dialect) {
-        return dialect.compileOperand(a, ctx);
-      }
-      return String(a);
-    }).join(", ");
+  static formatArgs(fn9, ctx, formatter) {
+    return (fn9.args || []).map((arg) => ctx ? formatter.compileOperand(arg, ctx) : String(arg)).join(", ");
   }
-  /**
-   * Formats the base function call with WITH ORDINALITY if present.
-   * @param fn - The function table node.
-   * @param schemaPart - Formatted schema prefix.
-   * @param args - Formatted function arguments.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Base function call expression (e.g., "schema.func(args) WITH ORDINALITY").
-   * @internal
-   */
   static formatBase(fn9, schemaPart, args) {
     const ordinality = fn9.withOrdinality ? " WITH ORDINALITY" : "";
     return `${schemaPart}${fn9.name}(${args})${ordinality}`;
   }
-  /**
-   * Formats the LATERAL keyword if present.
-   * @param fn - The function table node.
-   * @returns "LATERAL " or empty string.
-   * @internal
-   */
   static formatLateral(fn9) {
     return fn9.lateral ? "LATERAL " : "";
   }
-  /**
-   * Formats the table alias for the function table.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns " AS alias" or empty string.
-   * @internal
-   */
-  static formatAlias(fn9, dialect) {
+  static formatAlias(fn9, formatter) {
     if (!fn9.alias) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn9.alias) : fn9.alias;
-    return ` AS ${quoted}`;
+    return ` AS ${formatter.quoteIdentifier(fn9.alias)}`;
   }
-  /**
-   * Formats column aliases for the function table result columns.
-   * @param fn - The function table node containing column aliases.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns "(col1, col2, ...)" or empty string.
-   * @internal
-   */
-  static formatColumnAliases(fn9, dialect) {
+  static formatColumnAliases(fn9, formatter) {
     if (!fn9.columnAliases || !fn9.columnAliases.length) return "";
-    const aliases = fn9.columnAliases.map((col2) => dialect ? dialect.quoteIdentifier(col2) : col2).join(", ");
+    const aliases = fn9.columnAliases.map((col2) => formatter.quoteIdentifier(col2)).join(", ");
     return `(${aliases})`;
   }
 };
@@ -1955,7 +1843,7 @@ var OrderByCompiler = class {
 };
 
 // src/core/dialect/base/sql-dialect.ts
-var SqlDialectBase = class extends Dialect {
+var SqlDialectBase = class extends DialectBase {
   paginationStrategy = new StandardLimitOffsetPagination();
   returningStrategy = new NoReturningStrategy();
   compileSelectAst(ast, ctx) {
@@ -1965,14 +1853,12 @@ var SqlDialectBase = class extends Dialect {
       ctx,
       this.quoteIdentifier.bind(this),
       this.compileSelectAst.bind(this),
-      this.normalizeSelectAst?.bind(this) ?? ((a) => a),
+      this.normalizeSelectAst.bind(this),
       this.stripTrailingSemicolon.bind(this)
     );
     const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
     const baseSelect = this.compileSelectCore(baseAst, ctx);
-    if (!hasSetOps) {
-      return `${ctes}${baseSelect}`;
-    }
+    if (!hasSetOps) return `${ctes}${baseSelect}`;
     return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
   }
   compileSelectWithSetOps(ast, baseSelect, ctes, ctx) {
@@ -2021,9 +1907,7 @@ var SqlDialectBase = class extends Dialect {
     return columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
   }
   ensureConflictColumns(clause, message) {
-    if (!clause.target.columns.length) {
-      throw new Error(message);
-    }
+    if (!clause.target.columns.length) throw new Error(message);
   }
   compileSelectCore(ast, ctx) {
     const columns = this.compileSelectColumns(ast, ctx);
@@ -2056,8 +1940,7 @@ var SqlDialectBase = class extends Dialect {
   }
   compileUpdateAssignments(assignments, table, ctx) {
     return assignments.map((assignment) => {
-      const col2 = assignment.column;
-      const target = this.compileSetTarget(col2, table);
+      const target = this.compileSetTarget(assignment.column, table);
       const value = this.compileOperand(assignment.value, ctx);
       return `${target} = ${value}`;
     }).join(", ");
@@ -2070,9 +1953,7 @@ var SqlDialectBase = class extends Dialect {
     const alias = table.alias;
     const columnTable = column.table ?? alias ?? baseTableName;
     const tableQualifier = alias && column.table === baseTableName ? alias : columnTable;
-    if (!tableQualifier) {
-      return this.quoteIdentifier(column.name);
-    }
+    if (!tableQualifier) return this.quoteIdentifier(column.name);
     return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
   }
   compileDeleteAst(ast, ctx) {
@@ -2089,27 +1970,20 @@ var SqlDialectBase = class extends Dialect {
     return ast.distinct ? "DISTINCT " : "";
   }
   compileSelectColumns(ast, ctx) {
-    if (!ast.columns || ast.columns.length === 0) {
-      return "*";
-    }
-    return ast.columns.map((c) => {
-      const expr = this.compileOperand(c, ctx);
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+    if (!ast.columns || ast.columns.length === 0) return "*";
+    return ast.columns.map((column) => {
+      const expr = this.compileOperand(column, ctx);
+      if (column.alias) {
+        if (column.alias.includes("(")) return column.alias;
+        return `${expr} AS ${this.quoteIdentifier(column.alias)}`;
       }
       return expr;
     }).join(", ");
   }
   compileFrom(ast, ctx) {
-    const tableSource = ast;
-    if (tableSource.type === "FunctionTable") {
-      return this.compileFunctionTable(tableSource, ctx);
-    }
-    if (tableSource.type === "DerivedTable") {
-      return this.compileDerivedTable(tableSource, ctx);
-    }
-    return this.compileTableSource(tableSource);
+    if (ast.type === "FunctionTable") return this.compileFunctionTable(ast, ctx);
+    if (ast.type === "DerivedTable") return this.compileDerivedTable(ast, ctx);
+    return this.compileTableSource(ast);
   }
   compileFunctionTable(fn9, ctx) {
     const key = fn9.key ?? fn9.name;
@@ -2128,23 +2002,20 @@ var SqlDialectBase = class extends Dialect {
         throw new Error(`Table function "${key}" is not supported by dialect "${this.dialect}".`);
       }
     }
-    return FunctionTableFormatter.format(fn9, ctx, this);
+    return FunctionTableFormatter.format(fn9, ctx, {
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext)
+    });
   }
   compileDerivedTable(table, ctx) {
-    if (!table.alias) {
-      throw new Error("Derived tables must have an alias.");
-    }
+    if (!table.alias) throw new Error("Derived tables must have an alias.");
     const subquery = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
     const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
     return `(${subquery}) AS ${this.quoteIdentifier(table.alias)}${columns}`;
   }
   compileTableSource(table) {
-    if (table.type === "FunctionTable") {
-      return this.compileFunctionTable(table);
-    }
-    if (table.type === "DerivedTable") {
-      return this.compileDerivedTable(table);
-    }
+    if (table.type === "FunctionTable") return this.compileFunctionTable(table);
+    if (table.type === "DerivedTable") return this.compileDerivedTable(table);
     const base = this.compileTableName(table);
     return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
   }
@@ -2160,9 +2031,7 @@ var SqlDialectBase = class extends Dialect {
   }
   compileUpdateFromClause(ast, ctx) {
     if (!ast.from && (!ast.joins || ast.joins.length === 0)) return "";
-    if (!ast.from) {
-      throw new Error("UPDATE with JOINs requires an explicit FROM clause.");
-    }
+    if (!ast.from) throw new Error("UPDATE with JOINs requires an explicit FROM clause.");
     const from = this.compileFrom(ast.from, ctx);
     const joins = JoinCompiler.compileJoins(
       ast.joins,
@@ -2174,9 +2043,7 @@ var SqlDialectBase = class extends Dialect {
   }
   compileDeleteUsingClause(ast, ctx) {
     if (!ast.using && (!ast.joins || ast.joins.length === 0)) return "";
-    if (!ast.using) {
-      throw new Error("DELETE with JOINs requires a USING clause.");
-    }
+    if (!ast.using) throw new Error("DELETE with JOINs requires a USING clause.");
     const usingTable = this.compileFrom(ast.using, ctx);
     const joins = JoinCompiler.compileJoins(
       ast.joins,
@@ -2194,8 +2061,7 @@ var SqlDialectBase = class extends Dialect {
     return sql.trim().replace(/;$/, "");
   }
   wrapSetOperand(sql) {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
+    return `(${this.stripTrailingSemicolon(sql)})`;
   }
   renderOrderByNulls(order) {
     return order.nulls ? ` NULLS ${order.nulls}` : "";
@@ -2904,10 +2770,6 @@ var SqliteDialect = class extends SqlDialectBase {
   supportsDmlReturningClause() {
     return true;
   }
-  compileProcedureCall(_ast) {
-    void _ast;
-    throw new Error("Stored procedures are not supported by the SQLite dialect.");
-  }
 };
 
 // src/core/dialect/mssql/functions.ts
@@ -3342,9 +3204,8 @@ var DialectFactory = class {
   /**
    * Register (or override) a dialect factory for a key.
    *
-   * Examples:
-   *   DialectFactory.register('sqlite', () => new SqliteDialect());
-   *   DialectFactory.register('my-tenant-dialect', () => new CustomDialect());
+   * Implementations are structural: extending DialectBase/SqlDialectBase is
+   * optional. A composed object satisfying Dialect is a valid registration.
    */
   static register(key, factory) {
     this.registry.set(key, factory);
@@ -7963,14 +7824,11 @@ var addTransformerMetadata = (target, propertyKey, transformer) => {
   const meta = ensureEntityMetadata(target);
   meta.transformers[propertyKey] = transformer;
 };
-var setEntityTableName = (target, tableName, hooks, type) => {
+var setEntityTableName = (target, tableName, type) => {
   const meta = ensureEntityMetadata(target);
   if (tableName && tableName.length > 0) {
     meta.tableName = tableName;
   }
-  if (hooks) {
-    meta.hooks = hooks;
-  }
   if (type) {
     meta.type = type;
   }
@@ -7987,7 +7845,7 @@ var buildTableDef = (meta) => {
       table: meta.tableName
     };
   }
-  const table = defineTable(meta.tableName, columns, {}, meta.hooks);
+  const table = defineTable(meta.tableName, columns);
   meta.table = table;
   return table;
 };
@@ -10920,6 +10778,15 @@ var DeleteQueryBuilder = class _DeleteQueryBuilder {
 };
 var isTableSourceNode2 = (source) => typeof source.type === "string";
 
+// src/core/dialect/capabilities/procedure-compiler.ts
+var isProcedureCompiler = (value) => typeof value?.compileProcedureCall === "function";
+var requireProcedureCompiler = (value) => {
+  if (!isProcedureCompiler(value)) {
+    throw new Error("Stored procedures are not supported by this dialect.");
+  }
+  return value;
+};
+
 // src/orm/execute-procedure.ts
 var resolveColumnIndex = (columns, expectedName) => {
   const exact = columns.findIndex((column) => column === expectedName);
@@ -10958,7 +10825,7 @@ var extractOutValues = (compiled, resultSets) => {
 };
 var executeProcedureAst = async (session, ast) => {
   const execCtx = session.getExecutionContext();
-  const compiled = execCtx.dialect.compileProcedureCall(ast);
+  const compiled = requireProcedureCompiler(execCtx.dialect).compileProcedureCall(ast);
   const payload = await execCtx.interceptors.run(
     { sql: compiled.sql, params: compiled.params },
     execCtx.executor
@@ -11031,8 +10898,7 @@ var ProcedureCallBuilder = class _ProcedureCallBuilder {
   }
   compile(dialect) {
     const resolved = resolveDialectInput(dialect);
-    this.validateMssqlOutDbType(resolved);
-    return resolved.compileProcedureCall(this.getAST());
+    return requireProcedureCompiler(resolved).compileProcedureCall(this.getAST());
   }
   toSql(dialect) {
     return this.compile(dialect).sql;
@@ -11045,21 +10911,8 @@ var ProcedureCallBuilder = class _ProcedureCallBuilder {
     };
   }
   async execute(session) {
-    this.validateMssqlOutDbType(session.getExecutionContext().dialect);
     return executeProcedureAst(session, this.getAST());
   }
-  validateMssqlOutDbType(dialect) {
-    const isMssqlDialect = dialect.constructor.name === "SqlServerDialect";
-    if (!isMssqlDialect) return;
-    for (const param of this.ast.params) {
-      const needsDbType = param.direction === "out" || param.direction === "inout";
-      if (needsDbType && !param.dbType) {
-        throw new Error(
-          `MSSQL requires "dbType" for procedure parameter "${param.name}" with direction "${param.direction}".`
-        );
-      }
-    }
-  }
 };
 var callProcedure = (name, options) => new ProcedureCallBuilder(name, options);
 
@@ -11409,7 +11262,6 @@ var PgInformationSchemaColumns = defineTable(
     ordinal_position: col.int()
   },
   {},
-  void 0,
   { schema: "information_schema" }
 );
 var PgClass = defineTable(
@@ -11421,7 +11273,6 @@ var PgClass = defineTable(
     relkind: col.varchar(1)
   },
   {},
-  void 0,
   { schema: "pg_catalog" }
 );
 var PgNamespace = defineTable(
@@ -11431,7 +11282,6 @@ var PgNamespace = defineTable(
     nspname: col.varchar(255)
   },
   {},
-  void 0,
   { schema: "pg_catalog" }
 );
 var PgIndex = defineTable(
@@ -11444,7 +11294,6 @@ var PgIndex = defineTable(
     indpred: col.varchar(1024)
   },
   {},
-  void 0,
   { schema: "pg_catalog" }
 );
 var PgAttribute = defineTable(
@@ -11455,7 +11304,6 @@ var PgAttribute = defineTable(
     attnum: col.int()
   },
   {},
-  void 0,
   { schema: "pg_catalog" }
 );
 var PgTableConstraints = defineTable(
@@ -11470,7 +11318,6 @@ var PgTableConstraints = defineTable(
     constraint_type: col.varchar(255)
   },
   {},
-  void 0,
   { schema: "information_schema" }
 );
 var PgKeyColumnUsage = defineTable(
@@ -11486,7 +11333,6 @@ var PgKeyColumnUsage = defineTable(
     ordinal_position: col.int()
   },
   {},
-  void 0,
   { schema: "information_schema" }
 );
 var PgConstraintColumnUsage = defineTable(
@@ -11501,7 +11347,6 @@ var PgConstraintColumnUsage = defineTable(
     column_name: col.varchar(255)
   },
   {},
-  void 0,
   { schema: "information_schema" }
 );
 var PgReferentialConstraints = defineTable(
@@ -11518,7 +11363,6 @@ var PgReferentialConstraints = defineTable(
     delete_rule: col.varchar(64)
   },
   {},
-  void 0,
   { schema: "information_schema" }
 );
 
@@ -11900,7 +11744,6 @@ var InformationSchemaTables = defineTable(
     table_comment: col.varchar(1024)
   },
   {},
-  void 0,
   { schema: INFORMATION_SCHEMA }
 );
 var InformationSchemaColumns = defineTable(
@@ -11918,7 +11761,6 @@ var InformationSchemaColumns = defineTable(
     ordinal_position: col.int()
   },
   {},
-  void 0,
   { schema: INFORMATION_SCHEMA }
 );
 var InformationSchemaKeyColumnUsage = defineTable(
@@ -11935,7 +11777,6 @@ var InformationSchemaKeyColumnUsage = defineTable(
     referenced_column_name: col.varchar(255)
   },
   {},
-  void 0,
   { schema: INFORMATION_SCHEMA }
 );
 var InformationSchemaReferentialConstraints = defineTable(
@@ -11947,7 +11788,6 @@ var InformationSchemaReferentialConstraints = defineTable(
     update_rule: col.varchar(255)
   },
   {},
-  void 0,
   { schema: INFORMATION_SCHEMA }
 );
 var InformationSchemaStatistics = defineTable(
@@ -11961,7 +11801,6 @@ var InformationSchemaStatistics = defineTable(
     seq_in_index: col.int()
   },
   {},
-  void 0,
   { schema: INFORMATION_SCHEMA }
 );
 
@@ -12582,7 +12421,6 @@ var SysColumns = defineTable(
     user_type_id: col.int()
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysTables = defineTable(
@@ -12594,7 +12432,6 @@ var SysTables = defineTable(
     is_ms_shipped: col.boolean()
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysSchemas = defineTable(
@@ -12604,7 +12441,6 @@ var SysSchemas = defineTable(
     name: col.varchar(255)
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysTypes = defineTable(
@@ -12614,7 +12450,6 @@ var SysTypes = defineTable(
     name: col.varchar(255)
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysIndexes = defineTable(
@@ -12630,7 +12465,6 @@ var SysIndexes = defineTable(
     is_hypothetical: col.boolean()
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysIndexColumns = defineTable(
@@ -12642,7 +12476,6 @@ var SysIndexColumns = defineTable(
     key_ordinal: col.int()
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysForeignKeys = defineTable(
@@ -12654,7 +12487,6 @@ var SysForeignKeys = defineTable(
     update_referential_action_desc: col.varchar(64)
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 var SysForeignKeyColumns = defineTable(
@@ -12668,7 +12500,6 @@ var SysForeignKeyColumns = defineTable(
     constraint_column_id: col.int()
   },
   {},
-  void 0,
   { schema: "sys" }
 );
 
@@ -14093,12 +13924,14 @@ var UnitOfWork = class {
    * @param executor - The database executor
    * @param identityMap - The identity map
    * @param hookContext - Function to get the hook context
+   * @param resolveTableHooks - Session/runtime lifecycle hook resolver
    */
-  constructor(dialect, executor, identityMap, hookContext) {
+  constructor(dialect, executor, identityMap, hookContext, resolveTableHooks = () => void 0) {
     this.dialect = dialect;
     this.executor = executor;
     this.identityMap = identityMap;
     this.hookContext = hookContext;
+    this.resolveTableHooks = resolveTableHooks;
   }
   trackedEntities = /* @__PURE__ */ new Map();
   /**
@@ -14250,7 +14083,8 @@ var UnitOfWork = class {
    * @param tracked - The tracked entity to insert
    */
   async flushInsert(tracked) {
-    await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
+    const hooks = this.resolveTableHooks(tracked.table);
+    await this.runHook(hooks?.beforeInsert, tracked);
     const payload = this.extractColumns(tracked.table, tracked.entity);
     let builder = new InsertQueryBuilder(tracked.table).values(payload);
     if (this.dialect.supportsDmlReturningClause()) {
@@ -14264,7 +14098,7 @@ var UnitOfWork = class {
     tracked.original = this.createSnapshot(tracked.table, tracked.entity);
     tracked.pk = this.getPrimaryKeyValue(tracked);
     this.registerIdentity(tracked);
-    await this.runHook(tracked.table.hooks?.afterInsert, tracked);
+    await this.runHook(hooks?.afterInsert, tracked);
   }
   /**
    * Flushes an update operation for a modified entity.
@@ -14277,7 +14111,8 @@ var UnitOfWork = class {
       tracked.status = "managed" /* Managed */;
       return;
     }
-    await this.runHook(tracked.table.hooks?.beforeUpdate, tracked);
+    const hooks = this.resolveTableHooks(tracked.table);
+    await this.runHook(hooks?.beforeUpdate, tracked);
     const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
     if (!pkColumn) return;
     let builder = new UpdateQueryBuilder(tracked.table).set(changes).where(eq(pkColumn, tracked.pk));
@@ -14290,7 +14125,7 @@ var UnitOfWork = class {
     tracked.status = "managed" /* Managed */;
     tracked.original = this.createSnapshot(tracked.table, tracked.entity);
     this.registerIdentity(tracked);
-    await this.runHook(tracked.table.hooks?.afterUpdate, tracked);
+    await this.runHook(hooks?.afterUpdate, tracked);
   }
   /**
    * Flushes a delete operation for a removed entity.
@@ -14298,7 +14133,8 @@ var UnitOfWork = class {
    */
   async flushDelete(tracked) {
     if (tracked.pk == null) return;
-    await this.runHook(tracked.table.hooks?.beforeDelete, tracked);
+    const hooks = this.resolveTableHooks(tracked.table);
+    await this.runHook(hooks?.beforeDelete, tracked);
     const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
     if (!pkColumn) return;
     const builder = new DeleteQueryBuilder(tracked.table).where(eq(pkColumn, tracked.pk));
@@ -14307,10 +14143,10 @@ var UnitOfWork = class {
     tracked.status = "detached" /* Detached */;
     this.trackedEntities.delete(tracked.entity);
     this.identityMap.remove(tracked);
-    await this.runHook(tracked.table.hooks?.afterDelete, tracked);
+    await this.runHook(hooks?.afterDelete, tracked);
   }
   /**
-   * Runs a table hook if defined.
+   * Runs a lifecycle hook if defined.
    * @param hook - The hook function
    * @param tracked - The tracked entity
    */
@@ -15215,6 +15051,7 @@ var OrmSession = class {
   /** The tenant ID for multi-tenancy support */
   tenantId;
   interceptors;
+  tableHooks = /* @__PURE__ */ new WeakMap();
   saveGraphDefaults;
   transactionDepth = 0;
   savepointCounter = 0;
@@ -15228,7 +15065,13 @@ var OrmSession = class {
     this.executor = createQueryLoggingExecutor(opts.executor, opts.queryLogger);
     this.interceptors = [...opts.interceptors ?? []];
     this.identityMap = new IdentityMap();
-    this.unitOfWork = new UnitOfWork(this.orm.dialect, this.executor, this.identityMap, () => this);
+    this.unitOfWork = new UnitOfWork(
+      this.orm.dialect,
+      this.executor,
+      this.identityMap,
+      () => this,
+      (table) => this.tableHooks.get(table)
+    );
     this.relationChanges = new RelationChangeProcessor(this.unitOfWork, this.orm.dialect, this.executor);
     this.domainEvents = new DomainEventBus(opts.domainEventHandlers);
     this.cacheManager = opts.cacheManager;
@@ -15336,6 +15179,18 @@ var OrmSession = class {
   getEntitiesForTable(table) {
     return this.unitOfWork.getEntitiesForTable(table);
   }
+  /**
+   * Registers INSERT/UPDATE/DELETE lifecycle hooks for this Session only.
+   * The target can be a TableDef or a decorated entity constructor.
+   * Registering again for the same table replaces the previous hook set.
+   */
+  registerTableHooks(target, hooks) {
+    const table = typeof target === "function" ? getTableDefFromEntity(target) : target;
+    if (!table) {
+      throw new Error("Entity metadata has not been bootstrapped");
+    }
+    this.tableHooks.set(table, hooks);
+  }
   /**
    * Registers an interceptor for flush lifecycle hooks.
    * @param interceptor - The interceptor to register
@@ -15346,7 +15201,7 @@ var OrmSession = class {
   /**
    * Registers a domain event handler.
    * @param type - The event type
-   * @param handler - The event handler
+   * @param handler - The domain event handler
    */
   registerDomainEventHandler(type, handler) {
     this.domainEvents.on(type, handler);
@@ -15520,7 +15375,9 @@ var OrmSession = class {
     this.markRemoved(entity);
   }
   /**
-   * Flushes pending changes to the database without session hooks, relation processing, or domain events.
+   * Flushes pending changes to the database without session interceptors,
+   * relation processing, or domain events. Table lifecycle hooks still run
+   * because they are part of the Unit of Work.
    */
   async flush() {
     await this.unitOfWork.flush();
@@ -16415,7 +16272,7 @@ function Entity(options = {}) {
   return function(value, context) {
     const ctor = value;
     const tableName = options.tableName ?? deriveTableNameFromConstructor(ctor);
-    setEntityTableName(ctor, tableName, options.hooks, options.type);
+    setEntityTableName(ctor, tableName, options.type);
     const bag = context ? readMetadataBag(context) : readMetadataBagFromConstructor(ctor);
     if (bag) {
       const meta = ensureEntityMetadata(ctor);
@@ -20635,7 +20492,7 @@ var TreeManager = class _TreeManager {
    * Moves a node to be the last child of a new parent.
    */
   async moveTo(node, newParentId) {
-    NestedSetStrategy.subtreeWidth(node.lft, node.rght);
+    const width = NestedSetStrategy.subtreeWidth(node.lft, node.rght);
     let newPos;
     if (newParentId === null) {
       const maxRght = await this.getMaxRght();
@@ -20650,7 +20507,8 @@ var TreeManager = class _TreeManager {
         newParent.depth ?? await this.getLevel(newParent)
       );
     }
-    await this.moveSubtree(node, newPos.lft, newParentId, newPos.depth);
+    const targetLft = newPos.lft > node.rght ? newPos.lft - width : newPos.lft;
+    await this.moveSubtree(node, targetLft, newParentId, newPos.depth);
   }
   /**
    * Inserts a new node as a child of a parent.
@@ -20689,7 +20547,10 @@ var TreeManager = class _TreeManager {
     if (insertData[this.pkName] !== void 0) {
       return insertData[this.pkName];
     }
-    const findQuery = selectFrom(this.table).where(eq(this.table.columns[this.config.leftKey], insertPos.lft));
+    const scopeExpressions = this.getScopeExpressions();
+    const lftCondition = eq(this.table.columns[this.config.leftKey], insertPos.lft);
+    const findCondition = scopeExpressions.length > 0 ? and(lftCondition, ...scopeExpressions) : lftCondition;
+    const findQuery = selectFrom(this.table).where(findCondition);
     const { sql: findSql, params: findParams } = findQuery.compile(this.dialect);
     const results = await this.executor.executeSql(findSql, findParams);
     const rows = queryResultsToRows(results);
@@ -20699,23 +20560,37 @@ var TreeManager = class _TreeManager {
     return void 0;
   }
   /**
-   * Removes a node and re-parents its children to the node's parent.
+   * Removes a node from its current tree position, promotes its direct children
+   * to the removed node's parent, and retains the removed row as a standalone root.
    */
   async removeFromTree(node) {
     const nodeId = node.data[this.pkName];
+    const originalMaxRght = await this.getMaxRght();
     await this.executeUpdate(
       eq(this.table.columns[this.config.parentKey], nodeId),
       { [this.config.parentKey]: node.parentId }
     );
-    const gap = NestedSetStrategy.calculateDeleteGap(node.lft, node.rght);
+    if (node.rght - node.lft > 1) {
+      let sql = `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} - 1, ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} - 1`;
+      if (this.config.depthKey) {
+        sql += `, ${this.quoteCol(this.config.depthKey)} = ${this.quoteCol(this.config.depthKey)} - 1`;
+      }
+      sql += ` WHERE ${this.quoteCol(this.config.leftKey)} > ? AND ${this.quoteCol(this.config.rightKey)} < ?`;
+      await this.executeRawUpdate(sql, [node.lft, node.rght]);
+    }
     await this.shiftForDelete(node.rght, 2);
-    NestedSetStrategy.calculateShiftForDelete(node.lft + 1, gap.width - 2);
-    if (gap.width > 2) {
-      await this.executeRawUpdate(
-        `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} - 1, ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} - 1 WHERE ${this.quoteCol(this.config.leftKey)} > ? AND ${this.quoteCol(this.config.rightKey)} < ?`,
-        [node.lft, node.rght]
-      );
+    const detachedData = {
+      [this.config.parentKey]: null,
+      [this.config.leftKey]: originalMaxRght - 1,
+      [this.config.rightKey]: originalMaxRght
+    };
+    if (this.config.depthKey) {
+      detachedData[this.config.depthKey] = 0;
     }
+    await this.executeUpdate(
+      eq(this.table.columns[this.pkName], nodeId),
+      detachedData
+    );
   }
   /**
    * Deletes a node and all its descendants.
@@ -20840,22 +20715,32 @@ var TreeManager = class _TreeManager {
     }
     return "id";
   }
+  getScopeEntries() {
+    return Object.entries(buildScopeConditions(this.config.scope, this.scopeValues));
+  }
+  getScopeExpressions() {
+    return this.getScopeEntries().map(
+      ([key, value]) => eq(this.table.columns[key], value)
+    );
+  }
   async getMaxRght() {
     const query = selectFrom(this.table).selectRaw(`MAX(${this.config.rightKey}) as max_rght`);
-    const { sql, params } = query.compile(this.dialect);
+    const scopeExpressions = this.getScopeExpressions();
+    const finalQuery = scopeExpressions.length > 0 ? query.where(and(...scopeExpressions)) : query;
+    const { sql, params } = finalQuery.compile(this.dialect);
     const queryResults = await this.executor.executeSql(sql, params);
     const rows = queryResultsToRows(queryResults);
     const maxRght = rows[0]?.max_rght;
     return typeof maxRght === "number" ? maxRght : 0;
   }
-  async shiftForInsert(insertPoint) {
+  async shiftForInsert(insertPoint, width = 2) {
     await this.executeRawUpdate(
-      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} + 2 WHERE ${this.quoteCol(this.config.rightKey)} >= ?`,
-      [insertPoint]
+      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} + ? WHERE ${this.quoteCol(this.config.rightKey)} >= ?`,
+      [width, insertPoint]
     );
     await this.executeRawUpdate(
-      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} + 2 WHERE ${this.quoteCol(this.config.leftKey)} > ?`,
-      [insertPoint]
+      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} + ? WHERE ${this.quoteCol(this.config.leftKey)} > ?`,
+      [width, insertPoint]
     );
   }
   async shiftForDelete(deletedRght, width) {
@@ -20891,28 +20776,27 @@ var TreeManager = class _TreeManager {
   }
   async moveSubtree(node, newLft, newParentId, newDepth) {
     const width = NestedSetStrategy.subtreeWidth(node.lft, node.rght);
-    const delta = newLft - node.lft;
-    const depthDelta = this.config.depthKey ? newDepth - (node.depth ?? 0) : 0;
+    const oldDepth = this.config.depthKey ? node.depth ?? await this.getLevel(node) : 0;
+    const depthDelta = this.config.depthKey ? newDepth - oldDepth : 0;
     const nodeId = node.data[this.pkName];
-    const tempOffset = 1e7;
-    await this.executeRawUpdate(
-      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} + ? WHERE ${this.quoteCol(this.config.leftKey)} >= ? AND ${this.quoteCol(this.config.rightKey)} <= ?`,
-      [tempOffset, node.lft, node.rght]
-    );
+    const isolateDelta = -1e7 - node.rght;
+    const isolatedLft = node.lft + isolateDelta;
+    const isolatedRght = node.rght + isolateDelta;
     await this.executeRawUpdate(
-      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} + ? WHERE ${this.quoteCol(this.config.leftKey)} >= ? AND ${this.quoteCol(this.config.rightKey)} <= ?`,
-      [tempOffset, node.lft + tempOffset, node.rght]
+      `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} + ?, ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} + ? WHERE ${this.quoteCol(this.config.leftKey)} >= ? AND ${this.quoteCol(this.config.rightKey)} <= ?`,
+      [isolateDelta, isolateDelta, node.lft, node.rght]
     );
     await this.shiftForDelete(node.rght, width);
-    await this.shiftForInsert(newLft);
-    let updateSql = `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} - ? + ?, ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} - ? + ?`;
-    const updateParams = [tempOffset, delta, tempOffset, delta];
+    await this.shiftForInsert(newLft, width);
+    const restoreDelta = newLft - node.lft - isolateDelta;
+    let updateSql = `UPDATE ${this.quoteTable()} SET ${this.quoteCol(this.config.leftKey)} = ${this.quoteCol(this.config.leftKey)} + ?, ${this.quoteCol(this.config.rightKey)} = ${this.quoteCol(this.config.rightKey)} + ?`;
+    const updateParams = [restoreDelta, restoreDelta];
     if (this.config.depthKey && depthDelta !== 0) {
       updateSql += `, ${this.quoteCol(this.config.depthKey)} = ${this.quoteCol(this.config.depthKey)} + ?`;
       updateParams.push(depthDelta);
     }
-    updateSql += ` WHERE ${this.quoteCol(this.config.leftKey)} >= ?`;
-    updateParams.push(node.lft + tempOffset);
+    updateSql += ` WHERE ${this.quoteCol(this.config.leftKey)} >= ? AND ${this.quoteCol(this.config.rightKey)} <= ?`;
+    updateParams.push(isolatedLft, isolatedRght);
     await this.executeRawUpdate(updateSql, updateParams);
     await this.executeUpdate(
       eq(this.table.columns[this.pkName], nodeId),
@@ -20937,12 +20821,23 @@ var TreeManager = class _TreeManager {
     }));
   }
   async executeUpdate(condition, data) {
-    const query = update(this.table).set(data).where(condition);
+    const scopeExpressions = this.getScopeExpressions();
+    const finalCondition = scopeExpressions.length > 0 ? and(condition, ...scopeExpressions) : condition;
+    const query = update(this.table).set(data).where(finalCondition);
     const { sql, params } = query.compile(this.dialect);
     await this.executor.executeSql(sql, params);
   }
   async executeRawUpdate(sql, params) {
-    await this.executor.executeSql(sql, params);
+    let scopedSql = sql;
+    const scopedParams = [...params];
+    let hasWhere = /\bWHERE\b/i.test(scopedSql);
+    for (const [key, value] of this.getScopeEntries()) {
+      scopedSql += hasWhere ? " AND " : " WHERE ";
+      scopedSql += `${this.quoteCol(key)} = ?`;
+      scopedParams.push(value);
+      hasWhere = true;
+    }
+    await this.executor.executeSql(scopedSql, scopedParams);
   }
   quoteTable() {
     const quote = this.getQuoteChar();
@@ -21745,6 +21640,8 @@ export {
   DefaultMorphToReference,
   DefaultTypeStrategy,
   DeleteQueryBuilder,
+  DialectBase,
+  DialectFactory,
   DomainEventBus,
   Email,
   Entity,
@@ -21972,6 +21869,7 @@ export {
   isNull,
   isNullableColumn,
   isOperandNode,
+  isProcedureCompiler,
   isSingleTargetRelation,
   isTableDef2 as isTableDef,
   isTreeConfig,
@@ -22069,6 +21967,8 @@ export {
   repeat,
   replace,
   replaceWithRefs,
+  requireProcedureCompiler,
+  resolveDialectInput,
   resolveTreeConfig,
   resolveValidator,
   responseToRef,