metal-orm 1.0.45 → 1.0.47

package/src/core/ddl/introspect/sqlite.ts

@@ -1,16 +1,20 @@
 import { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { queryRows, shouldIncludeTable } from './utils.js';
+import { shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex } from '../schema-types.js';
-import { ReferentialAction } from '../../../schema/column.js';
-import { DbExecutor } from '../../execution/db-executor.js';
+import type { IntrospectContext } from './context.js';
+import { runSelectNode } from './run-select.js';
+import type { SelectQueryNode, TableNode } from '../../ast/query.js';
+import type { ColumnNode } from '../../ast/expression-nodes.js';
+import { eq, notLike, and, valueToOperand } from '../../ast/expression-builders.js';
+import { fnTable } from '../../ast/builders.js';
+import type { ReferentialAction } from '../../../schema/column-types.js';
 
-/** Row type for SQLite table list from sqlite_master. */
 type SqliteTableRow = {
   name: string;
 };
 
-/** Row type for SQLite table column information from PRAGMA table_info. */
 type SqliteTableInfoRow = {
+  cid: number;
   name: string;
   type: string;
   notnull: number;
@@ -18,31 +22,28 @@ type SqliteTableInfoRow = {
   pk: number;
 };
 
-/** Row type for SQLite foreign key information from PRAGMA foreign_key_list. */
 type SqliteForeignKeyRow = {
+  id: number;
+  seq: number;
   table: string;
   from: string;
   to: string;
-  on_delete: string | null;
   on_update: string | null;
+  on_delete: string | null;
 };
 
-/** Row type for SQLite index list from PRAGMA index_list. */
 type SqliteIndexListRow = {
+  seq: number;
   name: string;
   unique: number;
 };
 
-/** Row type for SQLite index column information from PRAGMA index_info. */
 type SqliteIndexInfoRow = {
+  seqno: number;
+  cid: number;
   name: string;
 };
 
-/**
- * Converts a SQLite referential action string to a ReferentialAction enum value.
- * @param value - The string value from SQLite pragma (e.g., 'CASCADE', 'SET NULL').
- * @returns The corresponding ReferentialAction enum value, or undefined if the value is invalid or null.
- */
 const toReferentialAction = (value: string | null | undefined): ReferentialAction | undefined => {
   if (!value) return undefined;
   const normalized = value.toUpperCase();
@@ -58,53 +59,101 @@ const toReferentialAction = (value: string | null | undefined): ReferentialActio
   return undefined;
 };
 
-/**
- * Escapes single quotes in a string for safe inclusion in SQL queries.
- * @param name - The string to escape.
- * @returns The escaped string with single quotes doubled.
- */
-const escapeSingleQuotes = (name: string) => name.replace(/'/g, "''");
+const columnNode = (table: string, name: string, alias?: string): ColumnNode => ({
+  type: 'Column',
+  table,
+  name,
+  alias
+});
+
+const buildPragmaQuery = (
+  name: string,
+  table: string,
+  alias: string,
+  columnAliases: string[]
+): SelectQueryNode => ({
+  type: 'SelectQuery',
+  from: fnTable(name, [valueToOperand(table)], alias, { columnAliases }),
+  columns: columnAliases.map(column => columnNode(alias, column)),
+  joins: []
+});
+
+const runPragma = async <T>(
+  name: string,
+  table: string,
+  alias: string,
+  columnAliases: string[],
+  ctx: IntrospectContext
+): Promise<T[]> => {
+  const query = buildPragmaQuery(name, table, alias, columnAliases);
+  return (await runSelectNode<T>(query, ctx)) as T[];
+};
 
-/** SQLite schema introspector. */
 export const sqliteIntrospector: SchemaIntrospector = {
-  /**
-   * Introspects the SQLite database schema by querying sqlite_master and various PRAGMAs.
-   * @param ctx - The database execution context containing the DbExecutor.
-   * @param options - Options controlling which tables and schemas to include.
-   * @returns A promise that resolves to the introspected DatabaseSchema.
-   */
-  async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
+  async introspect(ctx: IntrospectContext, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const alias = 'sqlite_master';
+    const tablesQuery: SelectQueryNode = {
+      type: 'SelectQuery',
+      from: { type: 'Table', name: 'sqlite_master' } as TableNode,
+      columns: [columnNode(alias, 'name')],
+      joins: [],
+      where: and(
+        eq(columnNode(alias, 'type'), 'table'),
+        notLike(columnNode(alias, 'name'), 'sqlite_%')
+      )
+    };
+
+    const tableRows = (await runSelectNode<SqliteTableRow>(tablesQuery, ctx)) as SqliteTableRow[];
     const tables: DatabaseTable[] = [];
-    const tableRows = (await queryRows(
-      ctx.executor,
-      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';`
-    )) as SqliteTableRow[];
 
     for (const row of tableRows) {
-      const name = row.name;
-      if (!shouldIncludeTable(name, options)) continue;
-      const table: DatabaseTable = { name, columns: [], primaryKey: [], indexes: [] };
-
-      const cols = (await queryRows(ctx.executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`)) as SqliteTableInfoRow[];
-      cols.forEach(c => {
-        table.columns.push({
-          name: c.name,
-          type: c.type,
-          notNull: c.notnull === 1,
-          default: c.dflt_value ?? undefined,
+      const tableName = row.name;
+      if (!shouldIncludeTable(tableName, options)) continue;
+
+      const tableInfo = await runPragma<SqliteTableInfoRow>(
+        'pragma_table_info',
+        tableName,
+        'ti',
+        ['cid', 'name', 'type', 'notnull', 'dflt_value', 'pk'],
+        ctx
+      );
+
+      const foreignKeys = await runPragma<SqliteForeignKeyRow>(
+        'pragma_foreign_key_list',
+        tableName,
+        'fk',
+        ['id', 'seq', 'table', 'from', 'to', 'on_update', 'on_delete', 'match'],
+        ctx
+      );
+
+      const indexList = await runPragma<SqliteIndexListRow>(
+        'pragma_index_list',
+        tableName,
+        'idx',
+        ['seq', 'name', 'unique'],
+        ctx
+      );
+
+      const tableEntry: DatabaseTable = { name: tableName, columns: [], primaryKey: [], indexes: [] };
+
+      tableInfo.forEach(info => {
+        tableEntry.columns.push({
+          name: info.name,
+          type: info.type,
+          notNull: info.notnull === 1,
+          default: info.dflt_value ?? undefined,
           autoIncrement: false
         });
-        if (c.pk && c.pk > 0) {
-          table.primaryKey = table.primaryKey || [];
-          table.primaryKey.push(c.name);
+        if (info.pk && info.pk > 0) {
+          tableEntry.primaryKey = tableEntry.primaryKey || [];
+          tableEntry.primaryKey.push(info.name);
         }
       });
 
-      const fkRows = (await queryRows(ctx.executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`)) as SqliteForeignKeyRow[];
-      fkRows.forEach(fk => {
-        const col = table.columns.find(c => c.name === fk.from);
-        if (col) {
-          col.references = {
+      foreignKeys.forEach(fk => {
+        const column = tableEntry.columns.find(col => col.name === fk.from);
+        if (column) {
+          column.references = {
             table: fk.table,
             column: fk.to,
             onDelete: toReferentialAction(fk.on_delete),
@@ -113,19 +162,24 @@ export const sqliteIntrospector: SchemaIntrospector = {
         }
       });
 
-      const idxList = (await queryRows(ctx.executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`)) as SqliteIndexListRow[];
-      for (const idx of idxList) {
-        const idxName = idx.name;
-        const columnsInfo = (await queryRows(ctx.executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`)) as SqliteIndexInfoRow[];
+      for (const idx of indexList) {
+        if (!idx.name) continue;
+        const indexColumns = await runPragma<SqliteIndexInfoRow>(
+          'pragma_index_info',
+          idx.name,
+          'info',
+          ['seqno', 'cid', 'name'],
+          ctx
+        );
         const idxEntry: DatabaseIndex = {
-          name: idxName,
-          columns: columnsInfo.map(ci => ({ column: ci.name })),
+          name: idx.name,
+          columns: indexColumns.map(col => ({ column: col.name })),
           unique: idx.unique === 1
         };
-        table.indexes!.push(idxEntry);
+        tableEntry.indexes!.push(idxEntry);
       }
 
-      tables.push(table);
+      tables.push(tableEntry);
     }
 
     return { tables };

package/src/core/ddl/schema-dialect.ts

@@ -1,5 +1,5 @@
 import type { TableDef, IndexDef } from '../../schema/table.js';
-import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
+import type { ColumnDef, ForeignKeyReference } from '../../schema/column-types.js';
 import type { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
 
 /** The name of a database dialect. */
@@ -53,3 +53,4 @@ export interface SchemaDialect {
   /** Returns a warning message for altering a column. */
   warnAlterColumn?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string | undefined;
 }
+

package/src/core/ddl/schema-diff.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../../schema/table.js';
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import type { DbExecutor } from '../execution/db-executor.js';
 import { SchemaDialect } from './schema-dialect.js';
 import { deriveIndexName } from './naming-strategy.js';
@@ -231,3 +231,4 @@ export const synchronizeSchema = async (
   }
   return plan;
 };
+

package/src/core/ddl/schema-generator.ts

@@ -1,5 +1,5 @@
 import type { TableDef } from '../../schema/table.js';
-import type { ColumnDef } from '../../schema/column.js';
+import type { ColumnDef } from '../../schema/column-types.js';
 import type { SchemaDialect } from './schema-dialect.js';
 import { resolvePrimaryKey } from './sql-writing.js';
 import { DialectName } from './schema-dialect.js';
@@ -168,3 +168,4 @@ const orderTablesByDependencies = (tables: TableDef[]): TableDef[] => {
 
 // Re-export DialectName for backward compatibility
 export type { DialectName };
+

package/src/core/ddl/schema-types.ts

@@ -1,4 +1,4 @@
-import { ForeignKeyReference } from '../../schema/column.js';
+import { ForeignKeyReference } from '../../schema/column-types.js';
 import { IndexColumn } from '../../schema/table.js';
 
 /** Represents the differences detected in a database column's properties. */
@@ -19,6 +19,7 @@ export interface DatabaseColumn {
   generated?: 'always' | 'byDefault';
   unique?: boolean | string;
   references?: ForeignKeyReference;
+  comment?: string;
   check?: string;
 }
 
@@ -44,6 +45,7 @@ export interface DatabaseTable {
   primaryKey?: string[];
   indexes?: DatabaseIndex[];
   checks?: DatabaseCheck[];
+  comment?: string;
 }
 
 /** Represents the overall database schema. */

package/src/core/ddl/sql-writing.ts

@@ -1,5 +1,5 @@
 import type { TableDef, IndexColumn } from '../../schema/table.js';
-import type { ColumnDef, RawDefaultValue } from '../../schema/column.js';
+import type { ColumnDef, RawDefaultValue } from '../../schema/column-types.js';
 
 /**
  * Minimal surface for anything that can quote identifiers.
@@ -168,3 +168,4 @@ export const resolvePrimaryKey = (table: TableDef): string[] => {
     .filter(col => col.primary)
     .map(col => col.name);
 };
+

package/src/core/dialect/abstract.ts

@@ -21,10 +21,11 @@ import {
   JsonPathNode,
   ScalarSubqueryNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode,
   BetweenExpressionNode,
-  AliasRefNode,
   ArithmeticExpressionNode,
+  AliasRefNode,
   isOperandNode
 } from '../ast/expression.js';
 import { DialectName } from '../sql/sql.js';
@@ -476,6 +477,11 @@ export abstract class Dialect
       return parts.join(' ');
     });
 
+    this.registerOperandCompiler('Cast', (node: CastExpressionNode, ctx) => {
+      const value = this.compileOperand(node.expression, ctx);
+      return `CAST(${value} AS ${node.castType})`;
+    });
+
     this.registerOperandCompiler('WindowFunction', (node: WindowFunctionNode, ctx) => {
       let result = `${node.name}(`;
       if (node.args.length > 0) {
@@ -507,6 +513,11 @@ export abstract class Dialect
 
       return result;
     });
+    this.registerOperandCompiler('ArithmeticExpression', (node: ArithmeticExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      return `(${left} ${node.operator} ${right})`;
+    });
   }
 
   // Default fallback, should be overridden by dialects if supported

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

@@ -105,16 +105,10 @@ export class SqlServerDialect extends SqlDialectBase {
 
   private compileSelectCoreForMssql(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
-      let expr = '';
-      if (c.type === 'Function') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'Column') {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === 'ScalarSubquery') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        expr = this.compileOperand(c, ctx);
-      }
+      // Default to full operand compilation for all projection node types (Function, Column, Cast, Case, Window, etc)
+      const expr = c.type === 'Column'
+        ? `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`
+        : this.compileOperand(c as unknown as import('../../ast/expression.js').OperandNode, ctx);
 
       if (c.alias) {
         if (c.alias.includes('(')) return c.alias;

package/src/core/functions/datetime.ts

@@ -1,6 +1,6 @@
 // Pure AST Builders - No Dialect Logic Here!
 
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import { columnOperand, valueToOperand } from '../ast/expression-builders.js';
 import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
 
@@ -155,3 +155,4 @@ export const weekOfYear = (date: OperandInput): FunctionNode => fn('WEEK_OF_YEAR
  * @returns A FunctionNode representing the DATE_TRUNC SQL function.
  */
 export const dateTrunc = (part: OperandInput, date: OperandInput): FunctionNode => fn('DATE_TRUNC', [part, date]);
+

package/src/core/functions/numeric.ts

@@ -1,6 +1,6 @@
 // Pure AST Builders - No Dialect Logic Here!
 
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import { columnOperand, valueToOperand } from '../ast/expression-builders.js';
 import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
 
@@ -243,3 +243,4 @@ export const trunc = (value: OperandInput, decimals?: OperandInput): FunctionNod
  */
 export const truncate = (value: OperandInput, decimals: OperandInput): FunctionNode =>
     fn('TRUNCATE', [value, decimals]);
+

package/src/core/functions/text.ts

@@ -1,6 +1,6 @@
 // Pure AST Builders - No Dialect Logic Here!
 
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import { columnOperand, valueToOperand } from '../ast/expression-builders.js';
 import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
 
@@ -207,3 +207,4 @@ export const rpad = (value: OperandInput, len: OperandInput, pad: OperandInput):
  * @returns A FunctionNode representing the SPACE SQL function.
  */
 export const space = (count: OperandInput): FunctionNode => fn('SPACE', [count]);
+

package/src/decorators/{column.ts → column-decorator.ts}

@@ -1,4 +1,4 @@
-import { ColumnDef, ColumnType } from '../schema/column.js';
+import { ColumnDef, ColumnType } from '../schema/column-types.js';
 import {
   addColumnMetadata,
   EntityConstructor,
@@ -18,6 +18,7 @@ import {
 export interface ColumnOptions {
   type: ColumnType;
   args?: ColumnDef['args'];
+  dialectTypes?: ColumnDef['dialectTypes'];
   notNull?: boolean;
   primary?: boolean;
   tsType?: ColumnDef['tsType'];
@@ -34,6 +35,7 @@ const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
   const column: ColumnDefLike = {
     type: asOptions.type ?? asDefinition.type,
     args: asOptions.args ?? asDefinition.args,
+    dialectTypes: asOptions.dialectTypes ?? asDefinition.dialectTypes,
     notNull: asOptions.notNull ?? asDefinition.notNull,
     primary: asOptions.primary ?? asDefinition.primary,
     tsType: asDefinition.tsType ?? asOptions.tsType,
@@ -130,3 +132,4 @@ export function PrimaryKey(definition: ColumnInput) {
   normalized.primary = true;
   return Column(normalized);
 }
+

package/src/decorators/index.ts

@@ -2,6 +2,6 @@
  * Decorators for defining entities, columns, and relations in Metal ORM.
  */
 export * from './entity.js';
-export * from './column.js';
+export * from './column-decorator.js';
 export * from './relations.js';
 export * from './bootstrap.js';

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './schema/table.js';
-export * from './schema/column.js';
+export * from './schema/column-types.js';
 export * from './schema/relation.js';
 export * from './schema/types.js';
 export * from './query-builder/select.js';
@@ -52,3 +52,4 @@ export * from './core/execution/executors/mssql-executor.js';
 
 // NEW: first-class pooling integration
 export * from './orm/pooled-executor-factory.js';
+

package/src/orm/entity-metadata.ts

@@ -1,4 +1,4 @@
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { defineTable, TableDef, TableHooks } from '../schema/table.js';
 import { CascadeMode, RelationKinds } from '../schema/relation.js';
 
@@ -262,3 +262,4 @@ export const buildTableDef = <TColumns extends Record<string, ColumnDefLike>>(me
   meta.table = table;
   return table;
 };
+

package/src/orm/lazy-batch.ts

@@ -4,7 +4,7 @@ import { SelectQueryBuilder } from '../query-builder/select.js';
 import { inList, LiteralNode } from '../core/ast/expression.js';
 import { EntityContext } from './entity-context.js';
 import type { QueryResult } from '../core/execution/db-executor.js';
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 
 /**
@@ -307,3 +307,4 @@ export const loadBelongsToManyRelation = async (
 
   return result;
 };
+

package/src/orm/orm-session.ts

@@ -3,7 +3,7 @@ import { eq } from '../core/ast/expression.js';
 import type { DbExecutor } from '../core/execution/db-executor.js';
 import { SelectQueryBuilder } from '../query-builder/select.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
-import type { ColumnDef } from '../schema/column.js';
+import type { ColumnDef } from '../schema/column-types.js';
 import type { TableDef } from '../schema/table.js';
 import { EntityInstance } from '../schema/types.js';
 import { RelationDef } from '../schema/relation.js';
@@ -464,3 +464,4 @@ const buildRelationChangeEntry = (
   relation,
   change
 });
+

package/src/query-builder/column-selector.ts

@@ -1,4 +1,4 @@
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { CaseExpressionNode, ColumnNode, FunctionNode, WindowFunctionNode } from '../core/ast/expression.js';
 import { SelectQueryNode } from '../core/ast/query.js';
 import { buildColumnNode } from '../core/ast/builders.js';
@@ -78,3 +78,4 @@ export class ColumnSelector {
     return { state: nextState, hydration: context.hydration };
   }
 }
+

package/src/query-builder/delete.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
 import { JOIN_KINDS, JoinKind } from '../core/sql/sql.js';
 import { CompiledQuery, Dialect } from '../core/dialect/abstract.js';
@@ -143,3 +143,4 @@ export class DeleteQueryBuilder<T> {
 
 const isTableSourceNode = (source: TableDef | TableSourceNode): source is TableSourceNode =>
   typeof (source as TableSourceNode).type === 'string';
+

package/src/query-builder/insert.ts

@@ -1,6 +1,6 @@
 import type { SelectQueryBuilder } from './select.js';
 import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { ColumnNode } from '../core/ast/expression.js';
 import { CompiledQuery, InsertCompiler, Dialect } from '../core/dialect/abstract.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
@@ -137,3 +137,4 @@ export class InsertQueryBuilder<T> {
     return this.state.ast;
   }
 }
+

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

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import {
   SelectQueryNode,
   CommonTableExpressionNode,
@@ -15,6 +15,7 @@ import {
   ExpressionNode,
   FunctionNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode,
   ScalarSubqueryNode,
   and,
@@ -57,7 +58,7 @@ export class QueryAstService {
    * @returns Column selection result with updated state and added columns
    */
   select(
-    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>
+    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode>
   ): ColumnSelectionResult {
     const existingAliases = new Set(
       this.state.ast.columns.map(c => (c as ColumnNode).alias || (c as ColumnNode).name)
@@ -69,7 +70,7 @@ export class QueryAstService {
       if (existingAliases.has(alias)) return acc;
 
       if (isExpressionSelectionNode(val)) {
-        acc.push({ ...(val as FunctionNode | CaseExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
+        acc.push({ ...(val as FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
         return acc;
       }
 

package/src/query-builder/relation-projection-helper.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { SelectQueryState } from './select-query-state.js';
 import { HydrationManager } from './hydration-manager.js';
 import { ColumnNode } from '../core/ast/expression.js';
@@ -99,3 +99,4 @@ export class RelationProjectionHelper {
     }, {} as Record<string, ColumnDef>);
   }
 }
+

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

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column-types.js';
 import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
 import { SelectQueryNode } from '../core/ast/query.js';
 import {
@@ -301,3 +301,4 @@ export class RelationService {
 }
 
 export type { RelationResult } from './relation-projection-helper.js';
+

package/src/query-builder/select/predicate-facet.ts

@@ -1,4 +1,4 @@
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import { ExpressionNode } from '../../core/ast/expression.js';
 import { OrderingTerm } from '../../core/ast/query.js';
 import { OrderDirection } from '../../core/sql/sql.js';
@@ -101,3 +101,4 @@ export class SelectPredicateFacet {
         return { state: nextState, hydration: context.hydration };
     }
 }
+

package/src/query-builder/select/projection-facet.ts

@@ -1,4 +1,4 @@
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import { ColumnNode, FunctionNode, CaseExpressionNode, WindowFunctionNode } from '../../core/ast/expression.js';
 import { SelectQueryBuilderContext } from '../select-query-builder-deps.js';
 import { ColumnSelector } from '../column-selector.js';
@@ -67,3 +67,4 @@ export class SelectProjectionFacet {
         return { ...context, state: this.columnSelector.distinct(context, cols).state };
     }
 }
+

package/src/query-builder/select-helpers.ts

@@ -1,5 +1,5 @@
 import type { TableDef } from '../schema/table.js';
-import type { ColumnDef } from '../schema/column.js';
+import type { ColumnDef } from '../schema/column-types.js';
 import { getTableDefFromEntity } from '../decorators/bootstrap.js';
 
 /**
@@ -61,3 +61,4 @@ export function esel<TEntity extends object, K extends keyof TEntity & string>(
 
   return selection;
 }
+

package/src/query-builder/select-query-state.ts

@@ -14,6 +14,7 @@ import {
   FunctionNode,
   ScalarSubqueryNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode
 } from '../core/ast/expression.js';
 import { JoinNode } from '../core/ast/join.js';
@@ -26,6 +27,7 @@ export type ProjectionNode =
   | FunctionNode
   | ScalarSubqueryNode
   | CaseExpressionNode
+  | CastExpressionNode
   | WindowFunctionNode;
 
 /**