metal-orm 1.1.24 → 1.1.26

package/src/core/dialect/postgres/index.ts

@@ -1,135 +1,96 @@
-import { CompilerContext } from '../abstract.js';
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type { BitwiseExpressionNode, ColumnNode, JsonPathNode } from '../../ast/expression.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  TableNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type { CompiledQuery, Dialect } from '../abstract.js';
 import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
-import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
-import { InsertQueryNode, TableNode } from '../../ast/query.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
+import { composeSqlDialect } from '../base/sql-dialect-composer.js';
 import { PostgresFunctionStrategy } from './functions.js';
 import { PostgresTableFunctionStrategy } from './table-functions.js';
-import { ProcedureCallNode } from '../../ast/procedure.js';
+import { PostgresProcedureCompiler } from './procedure-compiler.js';
+import { PostgresReturningStrategy } from './returning.js';
+import { PostgresUpsertStrategy } from './upsert.js';
+
+const quoteIdentifier = (id: string): string => `"${id}"`;
+
+export type PostgresDialectImplementation = Dialect & ProcedureCompiler;
+
+/** Creates the PostgreSQL dialect entirely from composable compiler components. */
+export const createPostgresDialect = (): PostgresDialectImplementation => {
+  const composition = composeSqlDialect({
+    name: 'postgres',
+    quoteIdentifier,
+    formatPlaceholder: index => `$${index}`,
+    functionStrategy: new PostgresFunctionStrategy(),
+    tableFunctionStrategy: new PostgresTableFunctionStrategy(),
+    returningStrategy: new PostgresReturningStrategy(),
+    upsertStrategy: new PostgresUpsertStrategy(),
+    supportsDmlReturning: true,
+    compileSetTarget: (column: ColumnNode, _table: TableNode) => {
+      void _table;
+      return quoteIdentifier(column.name);
+    },
+    compileJsonPath(node: JsonPathNode): string {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `${column}->>'${node.path}'`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        const operator = node.operator === '^' ? '#' : node.operator;
+        return `${left} ${operator} ${right}`;
+      });
+      api.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        const operator = node.operator === '^' ? '#' : node.operator;
+        return `(${left} ${operator} ${right})`;
+      });
+    }
+  });
 
-/**
- * PostgreSQL dialect implementation
- */
-export class PostgresDialect extends SqlDialectBase implements ProcedureCompiler {
-  protected readonly dialect = 'postgres';
-  /**
-   * Creates a new PostgresDialect instance
-   */
-  public constructor() {
-    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `${left} ${op} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `(${left} ${op} ${right})`;
-    });
-  }
+  const procedures = new PostgresProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: ast => procedures.compileProcedureCall(ast)
+  };
+};
+
+/** Ergonomic constructor facade over the composed PostgreSQL dialect. */
+export class PostgresDialect implements Dialect, ProcedureCompiler {
+  private readonly impl: PostgresDialectImplementation = createPostgresDialect();
 
-  /**
-   * Quotes an identifier using PostgreSQL double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
   quoteIdentifier(id: string): string {
-    return `"${id}"`;
+    return this.impl.quoteIdentifier(id);
   }
 
-  protected formatPlaceholder(index: number): string {
-    return `$${index}`;
+  supportsDmlReturningClause(): boolean {
+    return this.impl.supportsDmlReturningClause();
   }
 
-  /**
-   * Compiles JSON path expression using PostgreSQL syntax
-   * @param node - JSON path node
-   * @returns PostgreSQL JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // Postgres uses col->>'path' for text extraction
-    return `${col}->>'${node.path}'`;
+  compileSelect(ast: SelectQueryNode): CompiledQuery {
+    return this.impl.compileSelect(ast);
   }
 
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    void ctx;
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
+  compileInsert(ast: InsertQueryNode): CompiledQuery {
+    return this.impl.compileInsert(ast);
   }
 
-  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
-    if (!ast.onConflict) return '';
-
-    const clause = ast.onConflict;
-    const target = clause.target.constraint
-      ? ` ON CONFLICT ON CONSTRAINT ${this.quoteIdentifier(clause.target.constraint)}`
-      : (() => {
-          this.ensureConflictColumns(
-            clause,
-            'PostgreSQL ON CONFLICT requires conflict columns or a constraint name.'
-          );
-          const cols = clause.target.columns.map(col => this.quoteIdentifier(col.name)).join(', ');
-          return ` ON CONFLICT (${cols})`;
-        })();
-
-    if (clause.action.type === 'DoNothing') {
-      return `${target} DO NOTHING`;
-    }
-
-    if (!clause.action.set.length) {
-      throw new Error('PostgreSQL ON CONFLICT DO UPDATE requires at least one assignment.');
-    }
-
-    const assignments = this.compileUpdateAssignments(clause.action.set, ast.into, ctx);
-    const where = clause.action.where
-      ? ` WHERE ${this.compileExpression(clause.action.where, ctx)}`
-      : '';
-    return `${target} DO UPDATE SET ${assignments}${where}`;
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    return this.impl.compileUpdate(ast);
   }
 
-  supportsDmlReturningClause(): boolean {
-    return true;
+  compileDelete(ast: DeleteQueryNode): CompiledQuery {
+    return this.impl.compileDelete(ast);
   }
 
   compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
-    const ctx = this.createCompilerContext();
-    const qualifiedName = ast.ref.schema
-      ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}`
-      : this.quoteIdentifier(ast.ref.name);
-
-    const args: string[] = [];
-    for (const param of ast.params) {
-      if (param.direction === 'out') continue;
-      if (!param.value) {
-        throw new Error(`Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`);
-      }
-      args.push(this.compileOperand(param.value, ctx));
-    }
-
-    const outNames = ast.params
-      .filter(param => param.direction === 'out' || param.direction === 'inout')
-      .map(param => param.name);
-
-    const rawSql = `CALL ${qualifiedName}(${args.join(', ')})`;
-    return {
-      sql: `${rawSql};`,
-      params: [...ctx.params],
-      outParams: {
-        source: outNames.length ? 'firstResultSet' : 'none',
-        names: outNames
-      }
-    };
-  }
-
-  /**
-   * PostgreSQL requires unqualified column names in SET clause
-   */
-  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
-    return this.quoteIdentifier(column.name);
+    return this.impl.compileProcedureCall(ast);
   }
 }

package/src/core/dialect/postgres/procedure-compiler.ts

@@ -0,0 +1,41 @@
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type {
+  CompiledProcedureCall,
+  ProcedureCompiler,
+  ProcedureCompilerServices
+} from '../capabilities/procedure-compiler.js';
+
+export class PostgresProcedureCompiler implements ProcedureCompiler {
+  constructor(private readonly services: ProcedureCompilerServices) {}
+
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
+    const ctx = this.services.createCompilerContext();
+    const qualifiedName = ast.ref.schema
+      ? `${this.services.quoteIdentifier(ast.ref.schema)}.${this.services.quoteIdentifier(ast.ref.name)}`
+      : this.services.quoteIdentifier(ast.ref.name);
+
+    const args: string[] = [];
+    for (const param of ast.params) {
+      if (param.direction === 'out') continue;
+      if (!param.value) {
+        throw new Error(
+          `Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`
+        );
+      }
+      args.push(this.services.compileOperand(param.value, ctx));
+    }
+
+    const outNames = ast.params
+      .filter(param => param.direction === 'out' || param.direction === 'inout')
+      .map(param => param.name);
+
+    return {
+      sql: `CALL ${qualifiedName}(${args.join(', ')});`,
+      params: [...ctx.params],
+      outParams: {
+        source: outNames.length ? 'firstResultSet' : 'none',
+        names: outNames
+      }
+    };
+  }
+}

package/src/core/dialect/postgres/returning.ts

@@ -0,0 +1,4 @@
+import { StandardReturningStrategy } from '../base/returning-strategy.js';
+
+/** PostgreSQL uses standard SQL RETURNING with qualified columns. */
+export class PostgresReturningStrategy extends StandardReturningStrategy {}

package/src/core/dialect/postgres/upsert.ts

@@ -0,0 +1,43 @@
+import type { CompilerContext } from '../abstract.js';
+import type { InsertQueryNode } from '../../ast/query.js';
+import type {
+  UpsertCompilationServices,
+  UpsertStrategy
+} from '../base/upsert-strategy.js';
+
+export class PostgresUpsertStrategy implements UpsertStrategy {
+  compile(
+    ast: InsertQueryNode,
+    ctx: CompilerContext,
+    services: UpsertCompilationServices
+  ): string {
+    if (!ast.onConflict) return '';
+
+    const clause = ast.onConflict;
+    const target = clause.target.constraint
+      ? ` ON CONFLICT ON CONSTRAINT ${services.quoteIdentifier(clause.target.constraint)}`
+      : (() => {
+          if (!clause.target.columns.length) {
+            throw new Error('PostgreSQL ON CONFLICT requires conflict columns or a constraint name.');
+          }
+          const columns = clause.target.columns
+            .map(column => services.quoteIdentifier(column.name))
+            .join(', ');
+          return ` ON CONFLICT (${columns})`;
+        })();
+
+    if (clause.action.type === 'DoNothing') {
+      return `${target} DO NOTHING`;
+    }
+
+    if (!clause.action.set.length) {
+      throw new Error('PostgreSQL ON CONFLICT DO UPDATE requires at least one assignment.');
+    }
+
+    const assignments = services.compileUpdateAssignments(clause.action.set, ast.into, ctx);
+    const where = clause.action.where
+      ? ` WHERE ${services.compileExpression(clause.action.where, ctx)}`
+      : '';
+    return `${target} DO UPDATE SET ${assignments}${where}`;
+  }
+}

package/src/core/dialect/sqlite/index.ts

@@ -1,106 +1,81 @@
-import { CompilerContext } from '../abstract.js';
-import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
-import { InsertQueryNode, TableNode } from '../../ast/query.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
+import type { BitwiseExpressionNode, ColumnNode, JsonPathNode } from '../../ast/expression.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  TableNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type { CompiledQuery, Dialect } from '../abstract.js';
+import { composeSqlDialect } from '../base/sql-dialect-composer.js';
 import { SqliteFunctionStrategy } from './functions.js';
+import { SqliteReturningStrategy } from './returning.js';
+import { SqliteUpsertStrategy } from './upsert.js';
 
-/**
- * SQLite dialect implementation
- */
-export class SqliteDialect extends SqlDialectBase {
-  protected readonly dialect = 'sqlite';
-  /**
-   * Creates a new SqliteDialect instance
-   */
-  public constructor() {
-    super(new SqliteFunctionStrategy());
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `(${left} | ${right}) & ~(${left} & ${right})`;
-      }
-      return `${left} ${node.operator} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `((${left} | ${right}) & ~(${left} & ${right}))`;
-      }
-      return `(${left} ${node.operator} ${right})`;
-    });
-  }
+const quoteIdentifier = (id: string): string => `"${id}"`;
 
-  /**
-   * Quotes an identifier using SQLite double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id: string): string {
-    return `"${id}"`;
-  }
+/** Creates the SQLite dialect entirely from composable compiler components. */
+export const createSqliteDialect = (): Dialect =>
+  composeSqlDialect({
+    name: 'sqlite',
+    quoteIdentifier,
+    functionStrategy: new SqliteFunctionStrategy(),
+    returningStrategy: new SqliteReturningStrategy(),
+    upsertStrategy: new SqliteUpsertStrategy(),
+    supportsDmlReturning: true,
+    compileSetTarget: (column: ColumnNode, _table: TableNode) => {
+      void _table;
+      return quoteIdentifier(column.name);
+    },
+    compileJsonPath(node: JsonPathNode): string {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `json_extract(${column}, '${node.path}')`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        if (node.operator === '^') {
+          return `(${left} | ${right}) & ~(${left} & ${right})`;
+        }
+        return `${left} ${node.operator} ${right}`;
+      });
+      api.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        if (node.operator === '^') {
+          return `((${left} | ${right}) & ~(${left} & ${right}))`;
+        }
+        return `(${left} ${node.operator} ${right})`;
+      });
+    }
+  }).dialect;
 
-  /**
-   * Compiles JSON path expression using SQLite syntax
-   * @param node - JSON path node
-   * @returns SQLite JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // SQLite uses json_extract(col, '$.path')
-    return `json_extract(${col}, '${node.path}')`;
-  }
+/** Ergonomic constructor facade over the composed SQLite dialect. */
+export class SqliteDialect implements Dialect {
+  private readonly impl: Dialect = createSqliteDialect();
 
-  protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
-    void _table;
-    return this.quoteIdentifier(column.name);
+  quoteIdentifier(id: string): string {
+    return this.impl.quoteIdentifier(id);
   }
 
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    void ctx;
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
+  supportsDmlReturningClause(): boolean {
+    return this.impl.supportsDmlReturningClause();
   }
 
-  protected formatReturningColumns(returning: ColumnNode[]): string {
-    return returning
-      .map(column => {
-        const alias = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : '';
-        return `${this.quoteIdentifier(column.name)}${alias}`;
-      })
-      .join(', ');
+  compileSelect(ast: SelectQueryNode): CompiledQuery {
+    return this.impl.compileSelect(ast);
   }
 
-  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
-    if (!ast.onConflict) return '';
-
-    const clause = ast.onConflict;
-    if (clause.target.constraint) {
-      throw new Error('SQLite ON CONFLICT does not support named constraints.');
-    }
-    this.ensureConflictColumns(clause, 'SQLite ON CONFLICT requires conflict columns.');
-
-    const cols = clause.target.columns.map(col => this.quoteIdentifier(col.name)).join(', ');
-    const target = ` ON CONFLICT (${cols})`;
-
-    if (clause.action.type === 'DoNothing') {
-      return `${target} DO NOTHING`;
-    }
-
-    if (!clause.action.set.length) {
-      throw new Error('SQLite ON CONFLICT DO UPDATE requires at least one assignment.');
-    }
+  compileInsert(ast: InsertQueryNode): CompiledQuery {
+    return this.impl.compileInsert(ast);
+  }
 
-    const assignments = this.compileUpdateAssignments(clause.action.set, ast.into, ctx);
-    const where = clause.action.where
-      ? ` WHERE ${this.compileExpression(clause.action.where, ctx)}`
-      : '';
-    return `${target} DO UPDATE SET ${assignments}${where}`;
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    return this.impl.compileUpdate(ast);
   }
 
-  supportsDmlReturningClause(): boolean {
-    return true;
+  compileDelete(ast: DeleteQueryNode): CompiledQuery {
+    return this.impl.compileDelete(ast);
   }
 }

package/src/core/dialect/sqlite/returning.ts

@@ -0,0 +1,30 @@
+import type { ColumnNode } from '../../ast/expression.js';
+import type { CompilerContext } from '../abstract.js';
+import type {
+  QuoteIdentifier,
+  ReturningStrategy
+} from '../base/returning-strategy.js';
+
+export class SqliteReturningStrategy implements ReturningStrategy {
+  compileReturning(
+    returning: ColumnNode[] | undefined,
+    _ctx: CompilerContext,
+    quoteIdentifier: QuoteIdentifier
+  ): string {
+    void _ctx;
+    if (!returning || returning.length === 0) return '';
+    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier)}`;
+  }
+
+  formatReturningColumns(
+    returning: ColumnNode[],
+    quoteIdentifier: QuoteIdentifier
+  ): string {
+    return returning
+      .map(column => {
+        const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : '';
+        return `${quoteIdentifier(column.name)}${alias}`;
+      })
+      .join(', ');
+  }
+}

package/src/core/dialect/sqlite/upsert.ts

@@ -0,0 +1,43 @@
+import type { CompilerContext } from '../abstract.js';
+import type { InsertQueryNode } from '../../ast/query.js';
+import type {
+  UpsertCompilationServices,
+  UpsertStrategy
+} from '../base/upsert-strategy.js';
+
+export class SqliteUpsertStrategy implements UpsertStrategy {
+  compile(
+    ast: InsertQueryNode,
+    ctx: CompilerContext,
+    services: UpsertCompilationServices
+  ): string {
+    if (!ast.onConflict) return '';
+
+    const clause = ast.onConflict;
+    if (clause.target.constraint) {
+      throw new Error('SQLite ON CONFLICT does not support named constraints.');
+    }
+    if (!clause.target.columns.length) {
+      throw new Error('SQLite ON CONFLICT requires conflict columns.');
+    }
+
+    const columns = clause.target.columns
+      .map(column => services.quoteIdentifier(column.name))
+      .join(', ');
+    const target = ` ON CONFLICT (${columns})`;
+
+    if (clause.action.type === 'DoNothing') {
+      return `${target} DO NOTHING`;
+    }
+
+    if (!clause.action.set.length) {
+      throw new Error('SQLite ON CONFLICT DO UPDATE requires at least one assignment.');
+    }
+
+    const assignments = services.compileUpdateAssignments(clause.action.set, ast.into, ctx);
+    const where = clause.action.where
+      ? ` WHERE ${services.compileExpression(clause.action.where, ctx)}`
+      : '';
+    return `${target} DO UPDATE SET ${assignments}${where}`;
+  }
+}

package/src/index.ts

@@ -20,16 +20,37 @@ export * from './core/hydration/types.js';
 export * from './core/dialect/abstract.js';
 export * from './core/dialect/dialect-factory.js';
 export * from './core/dialect/capabilities/procedure-compiler.js';
+export * from './core/dialect/base/sql-dialect-composer.js';
+export * from './core/dialect/base/sql-compiler-set.js';
+export * from './core/dialect/base/upsert-strategy.js';
+export * from './core/dialect/base/returning-strategy.js';
+export * from './core/dialect/base/pagination-strategy.js';
 export * from './core/dialect/base/standard-sql-services.js';
 export * from './core/dialect/base/standard-sql-source-compiler.js';
 export * from './core/dialect/base/standard-select-compiler.js';
 export * from './core/dialect/base/standard-insert-compiler.js';
 export * from './core/dialect/base/standard-update-compiler.js';
 export * from './core/dialect/base/standard-delete-compiler.js';
+export * from './core/functions/table-types.js';
+export * from './core/functions/standard-table-strategy.js';
 export * from './core/dialect/mysql/index.js';
+export * from './core/dialect/mysql/upsert.js';
+export * from './core/dialect/mysql/procedure-compiler.js';
 export * from './core/dialect/mssql/index.js';
+export * from './core/dialect/mssql/compiler-factory.js';
+export * from './core/dialect/mssql/select-compiler.js';
+export * from './core/dialect/mssql/insert-compiler.js';
+export * from './core/dialect/mssql/update-compiler.js';
+export * from './core/dialect/mssql/delete-compiler.js';
+export * from './core/dialect/mssql/output.js';
+export * from './core/dialect/mssql/procedure-compiler.js';
 export * from './core/dialect/sqlite/index.js';
+export * from './core/dialect/sqlite/upsert.js';
+export * from './core/dialect/sqlite/returning.js';
 export * from './core/dialect/postgres/index.js';
+export * from './core/dialect/postgres/upsert.js';
+export * from './core/dialect/postgres/returning.js';
+export * from './core/dialect/postgres/procedure-compiler.js';
 export * from './core/ddl/schema-generator.js';
 export * from './core/ddl/schema-types.js';
 export * from './core/ddl/schema-diff.js';
@@ -71,7 +92,7 @@ export * from './orm/jsonify.js';
 export * from './orm/save-graph-types.js';
 export * from './decorators/index.js';
 
-// NEW: execution abstraction + helpers
+// Execution abstraction + helpers
 export * from './core/execution/db-executor.js';
 export * from './core/execution/pooling/pool-types.js';
 export * from './core/execution/pooling/pool.js';
@@ -81,17 +102,8 @@ export * from './core/execution/executors/sqlite-executor.js';
 export * from './core/execution/executors/better-sqlite3-executor.js';
 export * from './core/execution/executors/mssql-executor.js';
 
-// NEW: first-class pooling integration
 export * from './orm/pooled-executor-factory.js';
-
-// DTO module for REST API integration
 export * from './dto/index.js';
-
-// Tree behavior (Nested Set / MPTT)
 export * from './tree/index.js';
-
-// Cache module
 export * from './cache/index.js';
-
-// Bulk operations module
 export * from './bulk/index.js';