metal-orm 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "type": "module",
   "exports": {
     ".": {
@@ -46,6 +46,7 @@
   },
   "devDependencies": {
     "@vitest/ui": "^4.0.14",
+    "sqlite3": "^5.1.7",
     "tsup": "^8.0.0",
     "typescript": "^5.5.0",
     "vitest": "^4.0.14"

package/src/codegen/naming-strategy.ts

@@ -0,0 +1,64 @@
+import type { TableNode, FunctionTableNode } from '../core/ast/query.js';
+import type { ColumnNode } from '../core/ast/expression.js';
+
+/**
+ * Strategy interface for converting database names to TypeScript identifiers
+ */
+export interface NamingStrategy {
+  /**
+   * Converts a table name to a TypeScript symbol name
+   * @param table - Table node, function table node, or name
+   * @returns Valid TypeScript identifier
+   */
+  tableToSymbol(table: TableNode | FunctionTableNode | string): string;
+
+  /**
+   * Converts a column reference to a property name
+   * @param column - Column node
+   * @returns Valid TypeScript property name
+   */
+  columnToProperty(column: ColumnNode): string;
+}
+
+/**
+ * Default naming strategy that maintains backward compatibility
+ * with the original capitalize() behavior
+ */
+export class DefaultNamingStrategy implements NamingStrategy {
+  /**
+   * Converts table names to TypeScript symbols
+   * @param table - Table node, function table node, or string name
+   * @returns Capitalized table name (handles schema-qualified names)
+   */
+  tableToSymbol(table: TableNode | FunctionTableNode | string): string {
+    const tableName = typeof table === 'string' ? table : table.name;
+
+    // Handle schema-qualified names (e.g., "auth.user" → "AuthUser")
+    if (tableName.includes('.')) {
+      return tableName.split('.')
+        .map(part => this.capitalize(part))
+        .join('');
+    }
+
+    return this.capitalize(tableName);
+  }
+
+  /**
+   * Converts column references to property names
+   * @param column - Column node
+   * @returns Column name as-is (for backward compatibility)
+   */
+  columnToProperty(column: ColumnNode): string {
+    return column.name;
+  }
+
+  /**
+   * Capitalizes the first letter of a string
+   * @param s - String to capitalize
+   * @returns Capitalized string
+   */
+  private capitalize(s: string): string {
+    if (!s) return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  }
+}

package/src/codegen/typescript.ts

@@ -1,7 +1,7 @@
-import { SelectQueryNode } from '../core/ast/query.js';
-import {
-  ExpressionNode,
-  OperandNode,
+import { SelectQueryNode } from '../core/ast/query.js';
+import {
+  ExpressionNode,
+  OperandNode,
   BinaryExpressionNode,
   LogicalExpressionNode,
   InExpressionNode,
@@ -20,18 +20,12 @@ import {
   visitExpression,
   visitOperand
 } from '../core/ast/expression.js';
-import { SQL_OPERATOR_REGISTRY } from '../core/sql/sql-operator-config.js';
-import { SqlOperator } from '../core/sql/sql.js';
-import { isRelationAlias } from '../query-builder/relation-alias.js';
-import { HydrationMetadata } from '../core/hydration/types.js';
-import { getJoinRelationName } from '../core/ast/join-metadata.js';
-
-/**
- * Capitalizes the first letter of a string
- * @param s - String to capitalize
- * @returns Capitalized string
- */
-const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+import { SQL_OPERATOR_REGISTRY } from '../core/sql/sql-operator-config.js';
+import { SqlOperator } from '../core/sql/sql.js';
+import { isRelationAlias } from '../query-builder/relation-alias.js';
+import { HydrationMetadata } from '../core/hydration/types.js';
+import { getJoinRelationName } from '../core/ast/join-metadata.js';
+import { NamingStrategy, DefaultNamingStrategy } from './naming-strategy.js';
 
 const assertNever = (value: never): never => {
   throw new Error(`Unhandled SQL operator: ${value}`);
@@ -41,6 +35,7 @@ const assertNever = (value: never): never => {
  * Generates TypeScript code from query AST nodes
  */
 export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
+  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) {}
 
   /**
    * Generates TypeScript code from a query AST
@@ -54,14 +49,14 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return lines.join('\n');
   }
 
-  /**
-   * Builds TypeScript method chain lines from query AST
-   * @param ast - Query AST
-   * @returns Array of TypeScript method chain lines
-   */
-  private buildSelectLines(ast: SelectQueryNode): string[] {
-    const lines: string[] = [];
-    const hydration = (ast.meta as HydrationMetadata | undefined)?.hydration;
+  /**
+   * Builds TypeScript method chain lines from query AST
+   * @param ast - Query AST
+   * @returns Array of TypeScript method chain lines
+   */
+  private buildSelectLines(ast: SelectQueryNode): string[] {
+    const lines: string[] = [];
+    const hydration = (ast.meta as HydrationMetadata | undefined)?.hydration;
     const hydratedRelations = new Set(hydration?.relations?.map(r => r.name) ?? []);
 
     const selections = ast.columns
@@ -77,29 +72,29 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
       lines.push(`  ${sel}${index < selections.length - 1 ? ',' : ''}`);
     });
     lines.push(`})`);
-    lines.push(`.from(${capitalize(ast.from.name)})`);
-
-    if (ast.distinct && ast.distinct.length) {
-      const cols = ast.distinct.map(c => `${capitalize(c.table)}.${c.name}`).join(', ');
-      lines.push(`.distinct(${cols})`);
-    }
-
-    ast.joins.forEach(join => {
-      const relationName = getJoinRelationName(join);
-      if (relationName && hydratedRelations.has(relationName)) {
-        return;
-      }
-
-      if (relationName) {
-        if (join.kind === 'INNER') {
-          lines.push(`.joinRelation('${relationName}')`);
-        } else {
-          lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
-        }
-      } else {
-        const table = capitalize(join.table.name);
-        const cond = this.printExpression(join.condition);
-        let method = 'innerJoin';
+    lines.push(`.from(${this.namingStrategy.tableToSymbol(ast.from)})`);
+
+    if (ast.distinct && ast.distinct.length) {
+      const cols = ast.distinct.map(c => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(', ');
+      lines.push(`.distinct(${cols})`);
+    }
+
+    ast.joins.forEach(join => {
+      const relationName = getJoinRelationName(join);
+      if (relationName && hydratedRelations.has(relationName)) {
+        return;
+      }
+
+      if (relationName) {
+        if (join.kind === 'INNER') {
+          lines.push(`.joinRelation('${relationName}')`);
+        } else {
+          lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
+        }
+      } else {
+        const table = this.namingStrategy.tableToSymbol(join.table);
+        const cond = this.printExpression(join.condition);
+        let method = 'innerJoin';
         if (join.kind === 'LEFT') method = 'leftJoin';
         if (join.kind === 'RIGHT') method = 'rightJoin';
         lines.push(`.${method}(${table}, ${cond})`);
@@ -121,7 +116,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     }
 
     if (ast.groupBy && ast.groupBy.length) {
-      const cols = ast.groupBy.map(c => `${capitalize(c.table)}.${c.name}`).join(', ');
+      const cols = ast.groupBy.map(c => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(', ');
       lines.push(`.groupBy(${cols})`);
     }
 
@@ -131,7 +126,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
 
     if (ast.orderBy && ast.orderBy.length) {
       ast.orderBy.forEach(o => {
-        lines.push(`.orderBy(${capitalize(o.column.table)}.${o.column.name}, '${o.direction}')`);
+        lines.push(`.orderBy(${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name}, '${o.direction}')`);
       });
     }
 
@@ -292,7 +287,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    * @returns TypeScript code representation
    */
   private printColumnOperand(column: ColumnNode): string {
-    return `${capitalize(column.table)}.${column.name}`;
+    return `${this.namingStrategy.tableToSymbol(column.table)}.${column.name}`;
   }
 
   /**
@@ -321,7 +316,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    * @returns TypeScript code representation
    */
   private printJsonPathOperand(json: JsonPathNode): string {
-    return `jsonPath(${capitalize(json.column.table)}.${json.column.name}, '${json.path}')`;
+    return `jsonPath(${this.namingStrategy.tableToSymbol(json.column.table)}.${json.column.name}, '${json.path}')`;
   }
 
   /**
@@ -364,14 +359,14 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
 
     if (node.partitionBy && node.partitionBy.length > 0) {
       const partitionClause =
-        'PARTITION BY ' + node.partitionBy.map(col => `${capitalize(col.table)}.${col.name}`).join(', ');
+        'PARTITION BY ' + node.partitionBy.map(col => `${this.namingStrategy.tableToSymbol(col.table)}.${col.name}`).join(', ');
       parts.push(partitionClause);
     }
 
     if (node.orderBy && node.orderBy.length > 0) {
       const orderClause =
         'ORDER BY ' +
-        node.orderBy.map(o => `${capitalize(o.column.table)}.${o.column.name} ${o.direction}`).join(', ');
+        node.orderBy.map(o => `${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name} ${o.direction}`).join(', ');
       parts.push(orderClause);
     }
 

package/src/core/ast/aggregate-functions.ts

@@ -1,6 +1,8 @@
 import { ColumnNode, FunctionNode } from './expression-nodes.js';
-import { columnOperand } from './expression-builders.js';
+import { columnOperand, valueToOperand, ValueOperandInput } from './expression-builders.js';
 import { ColumnRef } from './types.js';
+import { OrderByNode } from './query.js';
+import { ORDER_DIRECTIONS, OrderDirection } from '../sql/sql.js';
 
 const buildAggregate = (name: string) => (col: ColumnRef | ColumnNode): FunctionNode => ({
   type: 'Function',
@@ -25,6 +27,50 @@ export const sum = buildAggregate('SUM');
 /**
  * Creates an AVG function expression
  * @param col - Column to average
- * @returns Function node with AVG
- */
-export const avg = buildAggregate('AVG');
+ * @returns Function node with AVG
+ */
+export const avg = buildAggregate('AVG');
+
+/**
+ * Creates a MIN function expression
+ * @param col - Column to take the minimum of
+ * @returns Function node with MIN
+ */
+export const min = buildAggregate('MIN');
+
+/**
+ * Creates a MAX function expression
+ * @param col - Column to take the maximum of
+ * @returns Function node with MAX
+ */
+export const max = buildAggregate('MAX');
+
+type GroupConcatOrderByInput = {
+  column: ColumnRef | ColumnNode;
+  direction?: OrderDirection;
+};
+
+export type GroupConcatOptions = {
+  separator?: ValueOperandInput;
+  orderBy?: GroupConcatOrderByInput[];
+};
+
+const toOrderByNode = (order: GroupConcatOrderByInput): OrderByNode => ({
+  type: 'OrderBy',
+  column: columnOperand(order.column),
+  direction: order.direction ?? ORDER_DIRECTIONS.ASC
+});
+
+/**
+ * Aggregates grouped strings into a single value.
+ */
+export const groupConcat = (
+  col: ColumnRef | ColumnNode,
+  options?: GroupConcatOptions
+): FunctionNode => ({
+  type: 'Function',
+  name: 'GROUP_CONCAT',
+  args: [columnOperand(col)],
+  orderBy: options?.orderBy?.map(toOrderByNode),
+  separator: options?.separator !== undefined ? valueToOperand(options.separator) : undefined
+});

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

@@ -19,22 +19,23 @@ import {
   isOperandNode
 } from './expression-nodes.js';
 
+export type LiteralValue = LiteralNode['value'];
+export type ValueOperandInput = OperandNode | LiteralValue;
+
 /**
  * Converts a primitive or existing operand into an operand node
  * @param value - Value or operand to normalize
  * @returns OperandNode representing the value
  */
-export const valueToOperand = (value: unknown): OperandNode => {
-  if (
-    value === null ||
-    value === undefined ||
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    typeof value === 'boolean'
-  ) {
-    return { type: 'Literal', value: value === undefined ? null : value } as LiteralNode;
+export const valueToOperand = (value: ValueOperandInput): OperandNode => {
+  if (isOperandNode(value)) {
+    return value;
   }
-  return value as OperandNode;
+
+  return {
+    type: 'Literal',
+    value
+  } as LiteralNode;
 };
 
 const toNode = (col: ColumnRef | OperandNode): OperandNode => {
@@ -48,12 +49,18 @@ const toLiteralNode = (value: string | number | boolean | null): LiteralNode =>
   value
 });
 
-const toOperand = (val: OperandNode | ColumnRef | string | number | boolean | null): OperandNode => {
-  if (val === null) return { type: 'Literal', value: null };
-  if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {
-    return { type: 'Literal', value: val };
+const isLiteralValue = (value: unknown): value is LiteralValue =>
+  value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+
+export const isValueOperandInput = (value: unknown): value is ValueOperandInput =>
+  isOperandNode(value) || isLiteralValue(value);
+
+const toOperand = (val: OperandNode | ColumnRef | LiteralValue): OperandNode => {
+  if (isLiteralValue(val)) {
+    return valueToOperand(val);
   }
-  return toNode(val as OperandNode | ColumnRef);
+
+  return toNode(val);
 };
 
 export const columnOperand = (col: ColumnRef | ColumnNode): ColumnNode => toNode(col) as ColumnNode;

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

@@ -37,6 +37,12 @@ export interface FunctionNode {
   args: OperandNode[];
   /** Optional alias for the function result */
   alias?: string;
+  /** Optional ORDER BY clause used by aggregations like GROUP_CONCAT */
+  orderBy?: OrderByNode[];
+  /** Optional separator argument used by GROUP_CONCAT-like functions */
+  separator?: OperandNode;
+  /** Optional DISTINCT modifier */
+  distinct?: boolean;
 }
 
 /**

package/src/core/ddl/introspect/functions/postgres.ts

@@ -1,14 +1,10 @@
 // Small helpers to build Postgres-specific function calls as AST FunctionNodes
-import { columnOperand, valueToOperand } from '../../../ast/expression-builders.js';
+import { valueToOperand } from '../../../ast/expression-builders.js';
 import type { OperandNode, FunctionNode } from '../../../ast/expression.js';
 
 type OperandInput = OperandNode | string | number | boolean | null;
 
-const toOperand = (v: OperandInput) => {
-  if (v === null) return valueToOperand(null);
-  if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') return valueToOperand(v);
-  return v as OperandNode;
-};
+const toOperand = (v: OperandInput): OperandNode => valueToOperand(v);
 
 const fn = (name: string, args: OperandInput[]): FunctionNode => ({
   type: 'Function',

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

@@ -1,6 +1,6 @@
 import type { TableDef, IndexDef, IndexColumn } from '../../schema/table.js';
 import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
-import type { SchemaDialect, DialectName } from './schema-dialect.js';
+import type { SchemaDialect } from './schema-dialect.js';
 import { deriveIndexName } from './naming-strategy.js';
 import {
   formatLiteral,
@@ -10,6 +10,7 @@ import {
   Quoter
 } from './sql-writing.js';
 import { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
+import { DialectName } from './schema-dialect.js';
 
 export interface SchemaGenerateResult {
   tableSql: string;
@@ -152,4 +153,4 @@ const orderTablesByDependencies = (tables: TableDef[]): TableDef[] => {
 };
 
 // Re-export DialectName for backward compatibility
-export { DialectName };
+export type { DialectName };

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

@@ -1,4 +1,4 @@
-import { DialectName } from './schema-generator.js';
+import type { DialectName } from './schema-generator.js';
 import { DatabaseSchema } from './schema-types.js';
 import { DbExecutor } from '../execution/db-executor.js';
 import type { IntrospectOptions, SchemaIntrospector, IntrospectContext } from './introspect/types.js';

package/src/core/dialect/abstract.ts

@@ -291,6 +291,34 @@ export abstract class Dialect
     this.registerDefaultExpressionCompilers();
   }
 
+  /**
+   * Creates a new Dialect instance (for testing purposes)
+   * @param functionStrategy - Optional function strategy
+   * @returns New Dialect instance
+   */
+  static create(functionStrategy?: FunctionStrategy): Dialect {
+    // Create a minimal concrete implementation for testing
+    class TestDialect extends Dialect {
+      protected readonly dialect: DialectName = 'sqlite';
+      quoteIdentifier(id: string): string {
+        return `"${id}"`;
+      }
+      protected compileSelectAst(): never {
+        throw new Error('Not implemented');
+      }
+      protected compileInsertAst(): never {
+        throw new Error('Not implemented');
+      }
+      protected compileUpdateAst(): never {
+        throw new Error('Not implemented');
+      }
+      protected compileDeleteAst(): never {
+        throw new Error('Not implemented');
+      }
+    }
+    return new TestDialect(functionStrategy);
+  }
+
   /**
    * Registers an expression compiler for a specific node type
    * @param type - Expression node type
@@ -448,12 +476,16 @@ export abstract class Dialect
   /**
    * Compiles a function operand, using the dialect's function strategy.
    */
-  protected compileFunctionOperand(fnNode: FunctionNode, ctx: CompilerContext): string {
-    const compiledArgs = fnNode.args.map(arg => this.compileOperand(arg, ctx));
-    const renderer = this.functionStrategy.getRenderer(fnNode.name);
-    if (renderer) {
-      return renderer({ node: fnNode, compiledArgs });
-    }
-    return `${fnNode.name}(${compiledArgs.join(', ')})`;
-  }
+  protected compileFunctionOperand(fnNode: FunctionNode, ctx: CompilerContext): string {
+    const compiledArgs = fnNode.args.map(arg => this.compileOperand(arg, ctx));
+    const renderer = this.functionStrategy.getRenderer(fnNode.name);
+    if (renderer) {
+      return renderer({
+        node: fnNode,
+        compiledArgs,
+        compileOperand: operand => this.compileOperand(operand, ctx)
+      });
+    }
+    return `${fnNode.name}(${compiledArgs.join(', ')})`;
+  }
 }

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

@@ -84,18 +84,27 @@ export class MssqlFunctionStrategy extends StandardFunctionStrategy {
             return `DATEPART(dw, ${compiledArgs[0]})`;
         });
 
-        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
-            return `DATEPART(wk, ${compiledArgs[0]})`;
-        });
-
-        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
-            const [, date] = compiledArgs;
-            const partArg = node.args[0] as LiteralNode;
-            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
-            // SQL Server 2022+ has DATETRUNC
-            return `DATETRUNC(${partClean}, ${date})`;
-        });
-    }
-}
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `DATEPART(wk, ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            // SQL Server 2022+ has DATETRUNC
+            return `DATETRUNC(${partClean}, ${date})`;
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            const orderClause = this.buildOrderByExpression(ctx);
+            const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : '';
+            return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
+        });
+    }
+}

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

@@ -69,27 +69,36 @@ export class PostgresFunctionStrategy extends StandardFunctionStrategy {
             return `TO_CHAR(${date}, ${format})`;
         });
 
-        this.add('END_OF_MONTH', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
-            return `(date_trunc('month', ${compiledArgs[0]}) + interval '1 month' - interval '1 day')::DATE`;
-        });
-
-        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
-            return `EXTRACT(DOW FROM ${compiledArgs[0]})`;
-        });
-
-        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
-            return `EXTRACT(WEEK FROM ${compiledArgs[0]})`;
-        });
-
-        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
-            const [, date] = compiledArgs;
-            const partArg = node.args[0] as LiteralNode;
-            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
-            return `DATE_TRUNC('${partClean}', ${date})`;
-        });
-    }
-}
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `(date_trunc('month', ${compiledArgs[0]}) + interval '1 month' - interval '1 day')::DATE`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `EXTRACT(DOW FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `EXTRACT(WEEK FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            return `DATE_TRUNC('${partClean}', ${date})`;
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const orderClause = this.buildOrderByExpression(ctx);
+            const orderSegment = orderClause ? ` ${orderClause}` : '';
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
+        });
+    }
+}

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

@@ -1,12 +1,12 @@
-import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
-import { LiteralNode } from '../../ast/expression.js';
-
-export class SqliteFunctionStrategy extends StandardFunctionStrategy {
-    constructor() {
-        super();
-        this.registerOverrides();
-    }
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { FunctionRenderContext } from '../../functions/types.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+export class SqliteFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
 
     private registerOverrides() {
         // Override Standard/Abstract definitions with SQLite specifics
@@ -110,6 +110,13 @@ export class SqliteFunctionStrategy extends StandardFunctionStrategy {
                 return `date(${date})`;
             }
             return `date(${date}, 'start of ${partClean}')`;
-        });
-    }
-}
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            return `GROUP_CONCAT(${arg}, ${separator})`;
+        });
+    }
+}

package/src/core/functions/datetime.ts

@@ -11,7 +11,8 @@ const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'obj
 const toOperand = (input: OperandInput): OperandNode => {
     if (isOperandNode(input)) return input;
     if (isColumnDef(input)) return columnOperand(input);
-    return valueToOperand(input as any);
+
+    return valueToOperand(input);
 };
 
 const fn = (key: string, args: OperandInput[]): FunctionNode => ({

package/src/core/functions/numeric.ts

@@ -11,7 +11,8 @@ const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'obj
 const toOperand = (input: OperandInput): OperandNode => {
     if (isOperandNode(input)) return input;
     if (isColumnDef(input)) return columnOperand(input);
-    return valueToOperand(input as any);
+
+    return valueToOperand(input);
 };
 
 const fn = (key: string, args: OperandInput[]): FunctionNode => ({