metal-orm 1.0.66 → 1.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/core/ast/builders.ts

@@ -74,44 +74,44 @@ export const createTableNode = (table: TableRef): TableNode => ({
 /**
  * Creates a FunctionTable node for expressions like `function_name(args...)` used in FROM
  */
-export const fnTable = (
-  name: string,
-  args: OperandNode[] = [],
-  alias?: string,
-  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
-): FunctionTableNode => ({
-  type: 'FunctionTable',
-  name,
-  args,
-  alias,
-  lateral: opts?.lateral,
-  withOrdinality: opts?.withOrdinality,
-  columnAliases: opts?.columnAliases,
-  schema: opts?.schema
-});
-
-// Dialect-aware table function (portable intent key, not a real SQL function name).
-export const tvf = (
-  key: string,
-  args: OperandNode[] = [],
-  alias?: string,
-  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
-): FunctionTableNode => ({
-  type: 'FunctionTable',
-  key,
-  name: key,
-  args,
-  alias,
-  lateral: opts?.lateral,
-  withOrdinality: opts?.withOrdinality,
-  columnAliases: opts?.columnAliases,
-  schema: opts?.schema
-});
-
-/**
- * Creates a derived table node wrapping a subquery.
- */
-export const derivedTable = (
+export const fnTable = (
+  name: string,
+  args: OperandNode[] = [],
+  alias?: string,
+  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+): FunctionTableNode => ({
+  type: 'FunctionTable',
+  name,
+  args,
+  alias,
+  lateral: opts?.lateral,
+  withOrdinality: opts?.withOrdinality,
+  columnAliases: opts?.columnAliases,
+  schema: opts?.schema
+});
+
+// Dialect-aware table function (portable intent key, not a real SQL function name).
+export const tvf = (
+  key: string,
+  args: OperandNode[] = [],
+  alias?: string,
+  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+): FunctionTableNode => ({
+  type: 'FunctionTable',
+  key,
+  name: key,
+  args,
+  alias,
+  lateral: opts?.lateral,
+  withOrdinality: opts?.withOrdinality,
+  columnAliases: opts?.columnAliases,
+  schema: opts?.schema
+});
+
+/**
+ * Creates a derived table node wrapping a subquery.
+ */
+export const derivedTable = (
   query: import('./query.js').SelectQueryNode,
   alias: string,
   columnAliases?: string[]

package/src/core/ast/expression-builders.ts

@@ -32,17 +32,21 @@ export type TypedLike<T> = { tsType?: T } | { __tsType: T };
 /**
  * Type guard to check if a value is a literal value
  */
-const isLiteralValue = (value: unknown): value is LiteralValue =>
-  value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+const isLiteralValue = (value: unknown): value is LiteralValue =>
+  value === null ||
+  typeof value === 'string' ||
+  typeof value === 'number' ||
+  typeof value === 'boolean' ||
+  value instanceof Date;
 
 
 /**
  * Converts a primitive value to a LiteralNode
  */
-const toLiteralNode = (value: string | number | boolean | null): LiteralNode => ({
-  type: 'Literal',
-  value
-});
+const toLiteralNode = (value: LiteralValue): LiteralNode => ({
+  type: 'Literal',
+  value: value instanceof Date ? value.toISOString() : value
+});
 
 /**
  * Converts a ColumnRef to a ColumnNode

package/src/core/ast/expression-nodes.ts

@@ -5,11 +5,11 @@ import { ColumnRef } from './types.js';
 /**
  * AST node representing a literal value
  */
-export interface LiteralNode {
-  type: 'Literal';
-  /** The literal value (string, number, boolean, or null) */
-  value: string | number | boolean | null;
-}
+export interface LiteralNode {
+  type: 'Literal';
+  /** The literal value (string, number, boolean, Date, or null) */
+  value: string | number | boolean | Date | null;
+}
 
 /**
  * AST node representing a reference to a SELECT alias (for ORDER BY / GROUP BY).

package/src/core/ast/join.ts

@@ -1,18 +1,18 @@
-import { TableSourceNode } from './query.js';
-import { ExpressionNode } from './expression.js';
-import { JoinKind } from '../sql/sql.js';
-
-/**
- * AST node representing a JOIN clause
+import { TableSourceNode } from './query.js';
+import { ExpressionNode } from './expression.js';
+import { JoinKind } from '../sql/sql.js';
+
+/**
+ * AST node representing a JOIN clause
  */
 export interface JoinNode {
-  type: 'Join';
-  /** Type of join (INNER, LEFT, RIGHT, etc.) */
-  kind: JoinKind;
-  /** Table to join */
-  table: TableSourceNode;
- /** Join condition expression */
-  condition: ExpressionNode;
-  /** Optional metadata for non-SQL concerns (e.g., relation name) */
-  meta?: Record<string, unknown>;
-}
+  type: 'Join';
+  /** Type of join (INNER, LEFT, RIGHT, etc.) */
+  kind: JoinKind;
+  /** Table to join */
+  table: TableSourceNode;
+ /** Join condition expression */
+  condition: ExpressionNode;
+  /** Optional metadata for non-SQL concerns (e.g., relation name) */
+  meta?: Record<string, unknown>;
+}

package/src/core/ast/query.ts

@@ -1,219 +1,219 @@
-import {
-  AliasRefNode,
-  CaseExpressionNode,
-  CastExpressionNode,
-  ColumnNode,
-  ExpressionNode,
-  FunctionNode,
-  OperandNode,
-  ScalarSubqueryNode,
-  WindowFunctionNode
-} from './expression.js';
-import { JoinNode } from './join.js';
-import { OrderDirection } from '../sql/sql.js';
-
-/**
- * AST node representing a table reference in a query
- */
-export interface TableNode {
-  type: 'Table';
-  /** Table name */
-  name: string;
-  /** Optional schema name */
-  schema?: string;
-  /** Optional table alias */
-  alias?: string;
-}
-
-/**
- * AST node representing a function used as a table source (table-valued function)
- */
-export interface FunctionTableNode {
-  type: 'FunctionTable';
-  // Canonical "intent" for dialect-aware table functions (tvf).
-  // If set, compiler resolves via TableFunctionStrategy and can fail fast.
-  key?: string;
-  /** Function name */
-  name: string;
-  /** Optional schema for the function (some dialects) */
-  schema?: string;
-  /** Function arguments as operand nodes */
-  args?: OperandNode[];
-  /** Optional alias for the function table */
-  alias?: string;
-  /** LATERAL flag */
-  lateral?: boolean;
-  /** WITH ORDINALITY flag */
-  withOrdinality?: boolean;
-  /** Optional column aliases */
-  columnAliases?: string[];
-}
-
-/**
- * AST node representing a derived table (subquery with an alias)
- */
-export interface DerivedTableNode {
-  type: 'DerivedTable';
-  /** Subquery providing the rows */
-  query: SelectQueryNode;
-  /** Required alias for the derived table */
-  alias: string;
-  /** Optional column aliases */
-  columnAliases?: string[];
-}
-
-export type TableSourceNode = TableNode | FunctionTableNode | DerivedTableNode;
-
-/**
- * Any expression that can appear in ORDER BY / GROUP BY terms.
- */
-export type OrderingTerm = OperandNode | ExpressionNode | AliasRefNode;
-
-/**
- * AST node representing an ORDER BY clause
- */
-export interface OrderByNode {
-  type: 'OrderBy';
-  /** Expression/operand/alias to order by */
-  term: OrderingTerm;
-  /** Order direction (ASC or DESC) */
-  direction: OrderDirection;
-  /** Optional nulls ordering (NULLS FIRST/LAST) */
-  nulls?: 'FIRST' | 'LAST';
-  /** Optional collation */
-  collation?: string;
-}
-
-/**
- * AST node representing a Common Table Expression (CTE)
- */
-export interface CommonTableExpressionNode {
-  type: 'CommonTableExpression';
-  /** CTE name */
-  name: string;
-  /** Optional column names */
-  columns?: string[];
-  /** CTE query */
-  query: SelectQueryNode;
-  /** Whether the CTE is recursive */
-  recursive: boolean;
-}
-
-/**
- * Supported set operation kinds for compound SELECT queries
- */
-export type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
-
-/**
- * AST node representing a set operation (UNION, INTERSECT, etc.)
- */
-export interface SetOperationNode {
-  type: 'SetOperation';
-  /** Operator to combine queries */
-  operator: SetOperationKind;
-  /** Right-hand query in the compound expression */
-  query: SelectQueryNode;
-}
-
-/**
- * AST node representing a complete SELECT query
- */
-export interface SelectQueryNode {
-  type: 'SelectQuery';
-  /** Optional CTEs (WITH clauses) */
-  ctes?: CommonTableExpressionNode[];
-  /** FROM clause table (either a Table or a FunctionTable) */
-  from: TableSourceNode;
-  /** SELECT clause columns */
-  columns: (
-    ColumnNode |
-    FunctionNode |
-    ScalarSubqueryNode |
-    CaseExpressionNode |
-    CastExpressionNode |
-    WindowFunctionNode
-  )[];
-  /** JOIN clauses */
-  joins: JoinNode[];
-  /** Optional WHERE clause */
-  where?: ExpressionNode;
-  /** Optional GROUP BY clause */
-  groupBy?: OrderingTerm[];
-  /** Optional HAVING clause */
-  having?: ExpressionNode;
-  /** Optional ORDER BY clause */
-  orderBy?: OrderByNode[];
-  /** Optional LIMIT clause */
-  limit?: number;
-  /** Optional OFFSET clause */
-  offset?: number;
-  /** Optional query metadata */
-  meta?: Record<string, unknown>;
-  /** Optional DISTINCT clause */
-  distinct?: ColumnNode[];
-  /** Optional set operations chaining this query with others */
-  setOps?: SetOperationNode[];
-}
-
-export interface InsertValuesSourceNode {
-  type: 'InsertValues';
-  /** Rows of values for INSERT rows */
-  rows: OperandNode[][];
-}
-
-export interface InsertSelectSourceNode {
-  type: 'InsertSelect';
-  /** SELECT query providing rows */
-  query: SelectQueryNode;
-}
-
-export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
-
-export interface InsertQueryNode {
-  type: 'InsertQuery';
-  /** Target table */
-  into: TableNode;
-  /** Column order for inserted values */
-  columns: ColumnNode[];
-  /** Source of inserted rows (either literal values or a SELECT query) */
-  source: InsertSourceNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
-
-export interface UpdateAssignmentNode {
-  /** Column to update */
-  column: ColumnNode;
-  /** Value to set */
-  value: OperandNode;
-}
-
-export interface UpdateQueryNode {
-  type: 'UpdateQuery';
-  /** Table being updated */
-  table: TableNode;
-  /** Optional FROM clause for multi-table updates */
-  from?: TableSourceNode;
-  /** Optional joins applied to the FROM/USING tables */
-  joins?: JoinNode[];
-  /** Assignments for SET clause */
-  set: UpdateAssignmentNode[];
-  /** Optional WHERE clause */
-  where?: ExpressionNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
-
-export interface DeleteQueryNode {
-  type: 'DeleteQuery';
-  /** Table to delete from */
-  from: TableNode;
-  /** Optional USING clause for multi-table deletes */
-  using?: TableSourceNode;
-  /** Optional joins applied to the USING clause */
-  joins?: JoinNode[];
-  /** Optional WHERE clause */
-  where?: ExpressionNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
+import {
+  AliasRefNode,
+  CaseExpressionNode,
+  CastExpressionNode,
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  OperandNode,
+  ScalarSubqueryNode,
+  WindowFunctionNode
+} from './expression.js';
+import { JoinNode } from './join.js';
+import { OrderDirection } from '../sql/sql.js';
+
+/**
+ * AST node representing a table reference in a query
+ */
+export interface TableNode {
+  type: 'Table';
+  /** Table name */
+  name: string;
+  /** Optional schema name */
+  schema?: string;
+  /** Optional table alias */
+  alias?: string;
+}
+
+/**
+ * AST node representing a function used as a table source (table-valued function)
+ */
+export interface FunctionTableNode {
+  type: 'FunctionTable';
+  // Canonical "intent" for dialect-aware table functions (tvf).
+  // If set, compiler resolves via TableFunctionStrategy and can fail fast.
+  key?: string;
+  /** Function name */
+  name: string;
+  /** Optional schema for the function (some dialects) */
+  schema?: string;
+  /** Function arguments as operand nodes */
+  args?: OperandNode[];
+  /** Optional alias for the function table */
+  alias?: string;
+  /** LATERAL flag */
+  lateral?: boolean;
+  /** WITH ORDINALITY flag */
+  withOrdinality?: boolean;
+  /** Optional column aliases */
+  columnAliases?: string[];
+}
+
+/**
+ * AST node representing a derived table (subquery with an alias)
+ */
+export interface DerivedTableNode {
+  type: 'DerivedTable';
+  /** Subquery providing the rows */
+  query: SelectQueryNode;
+  /** Required alias for the derived table */
+  alias: string;
+  /** Optional column aliases */
+  columnAliases?: string[];
+}
+
+export type TableSourceNode = TableNode | FunctionTableNode | DerivedTableNode;
+
+/**
+ * Any expression that can appear in ORDER BY / GROUP BY terms.
+ */
+export type OrderingTerm = OperandNode | ExpressionNode | AliasRefNode;
+
+/**
+ * AST node representing an ORDER BY clause
+ */
+export interface OrderByNode {
+  type: 'OrderBy';
+  /** Expression/operand/alias to order by */
+  term: OrderingTerm;
+  /** Order direction (ASC or DESC) */
+  direction: OrderDirection;
+  /** Optional nulls ordering (NULLS FIRST/LAST) */
+  nulls?: 'FIRST' | 'LAST';
+  /** Optional collation */
+  collation?: string;
+}
+
+/**
+ * AST node representing a Common Table Expression (CTE)
+ */
+export interface CommonTableExpressionNode {
+  type: 'CommonTableExpression';
+  /** CTE name */
+  name: string;
+  /** Optional column names */
+  columns?: string[];
+  /** CTE query */
+  query: SelectQueryNode;
+  /** Whether the CTE is recursive */
+  recursive: boolean;
+}
+
+/**
+ * Supported set operation kinds for compound SELECT queries
+ */
+export type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
+
+/**
+ * AST node representing a set operation (UNION, INTERSECT, etc.)
+ */
+export interface SetOperationNode {
+  type: 'SetOperation';
+  /** Operator to combine queries */
+  operator: SetOperationKind;
+  /** Right-hand query in the compound expression */
+  query: SelectQueryNode;
+}
+
+/**
+ * AST node representing a complete SELECT query
+ */
+export interface SelectQueryNode {
+  type: 'SelectQuery';
+  /** Optional CTEs (WITH clauses) */
+  ctes?: CommonTableExpressionNode[];
+  /** FROM clause table (either a Table or a FunctionTable) */
+  from: TableSourceNode;
+  /** SELECT clause columns */
+  columns: (
+    ColumnNode |
+    FunctionNode |
+    ScalarSubqueryNode |
+    CaseExpressionNode |
+    CastExpressionNode |
+    WindowFunctionNode
+  )[];
+  /** JOIN clauses */
+  joins: JoinNode[];
+  /** Optional WHERE clause */
+  where?: ExpressionNode;
+  /** Optional GROUP BY clause */
+  groupBy?: OrderingTerm[];
+  /** Optional HAVING clause */
+  having?: ExpressionNode;
+  /** Optional ORDER BY clause */
+  orderBy?: OrderByNode[];
+  /** Optional LIMIT clause */
+  limit?: number;
+  /** Optional OFFSET clause */
+  offset?: number;
+  /** Optional query metadata */
+  meta?: Record<string, unknown>;
+  /** Optional DISTINCT clause */
+  distinct?: ColumnNode[];
+  /** Optional set operations chaining this query with others */
+  setOps?: SetOperationNode[];
+}
+
+export interface InsertValuesSourceNode {
+  type: 'InsertValues';
+  /** Rows of values for INSERT rows */
+  rows: OperandNode[][];
+}
+
+export interface InsertSelectSourceNode {
+  type: 'InsertSelect';
+  /** SELECT query providing rows */
+  query: SelectQueryNode;
+}
+
+export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
+
+export interface InsertQueryNode {
+  type: 'InsertQuery';
+  /** Target table */
+  into: TableNode;
+  /** Column order for inserted values */
+  columns: ColumnNode[];
+  /** Source of inserted rows (either literal values or a SELECT query) */
+  source: InsertSourceNode;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}
+
+export interface UpdateAssignmentNode {
+  /** Column to update */
+  column: ColumnNode;
+  /** Value to set */
+  value: OperandNode;
+}
+
+export interface UpdateQueryNode {
+  type: 'UpdateQuery';
+  /** Table being updated */
+  table: TableNode;
+  /** Optional FROM clause for multi-table updates */
+  from?: TableSourceNode;
+  /** Optional joins applied to the FROM/USING tables */
+  joins?: JoinNode[];
+  /** Assignments for SET clause */
+  set: UpdateAssignmentNode[];
+  /** Optional WHERE clause */
+  where?: ExpressionNode;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}
+
+export interface DeleteQueryNode {
+  type: 'DeleteQuery';
+  /** Table to delete from */
+  from: TableNode;
+  /** Optional USING clause for multi-table deletes */
+  using?: TableSourceNode;
+  /** Optional joins applied to the USING clause */
+  joins?: JoinNode[];
+  /** Optional WHERE clause */
+  where?: ExpressionNode;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}