metal-orm 1.0.42 → 1.0.44

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

@@ -2,6 +2,7 @@ import type { TableDef, IndexDef } from '../../schema/table.js';
 import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
 import type { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
 
+/** The name of a database dialect. */
 export type DialectName =
   | 'postgres'
   | 'mysql'
@@ -9,33 +10,46 @@ export type DialectName =
   | 'mssql'
   | (string & {});
 
+/** Interface for schema dialect implementations that handle database-specific DDL operations. */
 export interface SchemaDialect {
+  /** The name of the dialect. */
   readonly name: DialectName;
 
-  // Minimal quoting surface; reusable for helpers
+  /** Quotes an identifier for use in SQL. */
   quoteIdentifier(id: string): string;
 
-  // Table naming
+  /** Formats the table name for SQL. */
   formatTableName(table: TableDef | DatabaseTable): string;
 
-  // Column rendering
+  /** Renders the column type for SQL. */
   renderColumnType(column: ColumnDef): string;
+  /** Renders the default value for SQL. */
   renderDefault(value: unknown, column: ColumnDef): string;
+  /** Renders the auto-increment clause for SQL. */
   renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
 
-  // Constraints & indexes
+  /** Renders a foreign key reference for SQL. */
   renderReference(ref: ForeignKeyReference, table: TableDef): string;
+  /** Renders an index for SQL. */
   renderIndex(table: TableDef, index: IndexDef): string;
+  /** Renders table options for SQL. */
   renderTableOptions(table: TableDef): string | undefined;
 
-  // Capability flags
+  /** Checks if the dialect supports partial indexes. */
   supportsPartialIndexes(): boolean;
+  /** Checks if the dialect prefers inline primary key auto-increment. */
+  preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean;
 
-  // DDL operations
+  /** Generates SQL to drop a column. */
   dropColumnSql?(table: DatabaseTable, column: string): string[];
+  /** Generates SQL to drop an index. */
   dropIndexSql?(table: DatabaseTable, index: string): string[];
+  /** Generates SQL to drop a table. */
   dropTableSql?(table: DatabaseTable): string[];
+  /** Returns a warning message for dropping a column. */
   warnDropColumn?(table: DatabaseTable, column: string): string | undefined;
+  /** Generates SQL to alter a column. */
   alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[];
+  /** 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

@@ -6,6 +6,7 @@ import { deriveIndexName } from './naming-strategy.js';
 import { generateCreateTableSql, renderColumnDefinition } from './schema-generator.js';
 import { ColumnDiff, DatabaseColumn, DatabaseSchema, DatabaseTable } from './schema-types.js';
 
+/** The kind of schema change. */
 export type SchemaChangeKind =
   | 'createTable'
   | 'dropTable'
@@ -15,6 +16,7 @@ export type SchemaChangeKind =
   | 'addIndex'
   | 'dropIndex';
 
+/** Represents a single schema change. */
 export interface SchemaChange {
   kind: SchemaChangeKind;
   table: string;
@@ -23,11 +25,13 @@ export interface SchemaChange {
   safe: boolean;
 }
 
+/** Represents a plan of schema changes. */
 export interface SchemaPlan {
   changes: SchemaChange[];
   warnings: string[];
 }
 
+/** Options for schema diffing. */
 export interface SchemaDiffOptions {
   /** Allow destructive operations (drops) */
   allowDestructive?: boolean;
@@ -69,6 +73,14 @@ const diffColumn = (expected: ColumnDef, actual: DatabaseColumn, dialect: Schema
   };
 };
 
+/**
+ * Computes the differences between expected and actual database schemas.
+ * @param expectedTables - The expected table definitions.
+ * @param actualSchema - The actual database schema.
+ * @param dialect - The schema dialect.
+ * @param options - Options for the diff.
+ * @returns The schema plan with changes and warnings.
+ */
 export const diffSchema = (
   expectedTables: TableDef[],
   actualSchema: DatabaseSchema,
@@ -191,10 +203,20 @@ export const diffSchema = (
   return plan;
 };
 
+/** Options for schema synchronization. */
 export interface SynchronizeOptions extends SchemaDiffOptions {
   dryRun?: boolean;
 }
 
+/**
+ * Synchronizes the database schema with the expected tables.
+ * @param expectedTables - The expected table definitions.
+ * @param actualSchema - The actual database schema.
+ * @param dialect - The schema dialect.
+ * @param executor - The database executor.
+ * @param options - Options for synchronization.
+ * @returns The schema plan with changes and warnings.
+ */
 export const synchronizeSchema = async (
   expectedTables: TableDef[],
   actualSchema: DatabaseSchema,

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

@@ -1,26 +1,28 @@
-import type { TableDef, IndexDef, IndexColumn } from '../../schema/table.js';
-import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
+import type { TableDef } from '../../schema/table.js';
+import type { ColumnDef } from '../../schema/column.js';
 import type { SchemaDialect } from './schema-dialect.js';
-import { deriveIndexName } from './naming-strategy.js';
-import {
-  formatLiteral,
-  renderIndexColumns,
-  quoteQualified,
-  resolvePrimaryKey,
-  Quoter
-} from './sql-writing.js';
-import { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
+import { resolvePrimaryKey } from './sql-writing.js';
 import { DialectName } from './schema-dialect.js';
 
+/** Result of generating schema SQL. */
 export interface SchemaGenerateResult {
   tableSql: string;
   indexSql: string[];
 }
 
+/** Options for rendering column definitions. */
 export interface RenderColumnOptions {
   includePrimary?: boolean;
 }
 
+/**
+ * Renders a column definition for SQL.
+ * @param table - The table definition.
+ * @param col - The column definition.
+ * @param dialect - The schema dialect.
+ * @param options - Options for rendering.
+ * @returns The rendered SQL and whether primary key is inline.
+ */
 export const renderColumnDefinition = (
   table: TableDef,
   col: ColumnDef,
@@ -52,6 +54,12 @@ export const renderColumnDefinition = (
   return { sql: parts.join(' '), inlinePrimary: !!(options.includePrimary && col.primary) };
 };
 
+/**
+ * Generates SQL to create a table.
+ * @param table - The table definition.
+ * @param dialect - The schema dialect.
+ * @returns The table SQL and index SQL.
+ */
 export const generateCreateTableSql = (
   table: TableDef,
   dialect: SchemaDialect
@@ -60,7 +68,7 @@ export const generateCreateTableSql = (
   const inlinePkColumns = new Set<string>();
 
   const columnLines = Object.values(table.columns).map(col => {
-    const includePk = (dialect as any).preferInlinePkAutoincrement?.(col, table, pk) && pk.includes(col.name);
+    const includePk = dialect.preferInlinePkAutoincrement(col, table, pk) && pk.includes(col.name);
     if (includePk) {
       inlinePkColumns.add(col.name);
     }
@@ -99,6 +107,12 @@ export const generateCreateTableSql = (
   return { tableSql, indexSql };
 };
 
+/**
+ * Generates SQL for creating multiple tables.
+ * @param tables - The table definitions.
+ * @param dialect - The schema dialect.
+ * @returns The SQL statements.
+ */
 export const generateSchemaSql = (
   tables: TableDef[],
   dialect: SchemaDialect

package/src/core/ddl/schema-plan-executor.ts

@@ -1,6 +1,12 @@
 import { DbExecutor } from '../execution/db-executor.js';
 import type { SchemaPlan, SynchronizeOptions } from './schema-diff.js';
 
+/**
+ * Executes a schema plan by running the SQL statements.
+ * @param plan - The schema plan to execute.
+ * @param executor - The database executor.
+ * @param options - Options for synchronization.
+ */
 export const executeSchemaPlan = async (
   plan: SchemaPlan,
   executor: DbExecutor,

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

@@ -1,6 +1,7 @@
 import { ForeignKeyReference } from '../../schema/column.js';
 import { IndexColumn } from '../../schema/table.js';
 
+/** Represents the differences detected in a database column's properties. */
 export interface ColumnDiff {
   typeChanged?: boolean;
   nullabilityChanged?: boolean;
@@ -8,6 +9,7 @@ export interface ColumnDiff {
   autoIncrementChanged?: boolean;
 }
 
+/** Represents a column in the database schema. */
 export interface DatabaseColumn {
   name: string;
   type: string;
@@ -20,6 +22,7 @@ export interface DatabaseColumn {
   check?: string;
 }
 
+/** Represents an index in the database schema. */
 export interface DatabaseIndex {
   name: string;
   columns: IndexColumn[];
@@ -27,11 +30,13 @@ export interface DatabaseIndex {
   where?: string;
 }
 
+/** Represents a check constraint in the database schema. */
 export interface DatabaseCheck {
   name?: string;
   expression: string;
 }
 
+/** Represents a table in the database schema. */
 export interface DatabaseTable {
   name: string;
   schema?: string;
@@ -41,6 +46,7 @@ export interface DatabaseTable {
   checks?: DatabaseCheck[];
 }
 
+/** Represents the overall database schema. */
 export interface DatabaseSchema {
   tables: DatabaseTable[];
 }

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

@@ -1,5 +1,5 @@
 import type { TableDef, IndexColumn } from '../../schema/table.js';
-import type { RawDefaultValue } from '../../schema/column.js';
+import type { ColumnDef, RawDefaultValue } from '../../schema/column.js';
 
 /**
  * Minimal surface for anything that can quote identifiers.
@@ -161,10 +161,10 @@ export const resolvePrimaryKey = (table: TableDef): string[] => {
     return table.primaryKey;
   }
 
-  const columns = Object.values(table.columns ?? {});
+  const columns = Object.values(table.columns ?? {}) as ColumnDef[];
 
   // `primary` / `name` are domain-level properties of ColumnDef.
   return columns
-    .filter((col: any) => col.primary)
-    .map((col: any) => col.name);
+    .filter(col => col.primary)
+    .map(col => col.name);
 };

package/src/core/dialect/abstract.ts

@@ -157,8 +157,9 @@ export abstract class Dialect
 
   protected compileReturning(
     returning: ColumnNode[] | undefined,
-    ctx: CompilerContext
+    _ctx: CompilerContext
   ): string {
+    void _ctx;
     if (!returning || returning.length === 0) return '';
     throw new Error('RETURNING is not supported by this dialect.');
   }
@@ -213,7 +214,8 @@ export abstract class Dialect
    * @param index - Parameter index
    * @returns Formatted placeholder string
    */
-  protected formatPlaceholder(index: number): string {
+  protected formatPlaceholder(_index: number): string {
+    void _index;
     return '?';
   }
 
@@ -221,7 +223,8 @@ export abstract class Dialect
    * Whether the current dialect supports a given set operation.
    * Override in concrete dialects to restrict support.
    */
-  protected supportsSetOperation(kind: SetOperationKind): boolean {
+  protected supportsSetOperation(_kind: SetOperationKind): boolean {
+    void _kind;
     return true;
   }
 
@@ -376,7 +379,8 @@ export abstract class Dialect
     if (isOperandNode(term)) {
       return this.compileOperand(term, ctx);
     }
-    const expr = this.compileExpression(term as any, ctx);
+    // At this point, term must be an ExpressionNode
+    const expr = this.compileExpression(term as ExpressionNode, ctx);
     return `(${expr})`;
   }
 
@@ -438,15 +442,22 @@ export abstract class Dialect
   private registerDefaultOperandCompilers(): void {
     this.registerOperandCompiler('Literal', (literal: LiteralNode, ctx) => ctx.addParameter(literal.value));
 
-    this.registerOperandCompiler('AliasRef', (alias: AliasRefNode, _ctx) => this.quoteIdentifier(alias.name));
+    this.registerOperandCompiler('AliasRef', (alias: AliasRefNode, _ctx) => {
+      void _ctx;
+      return this.quoteIdentifier(alias.name);
+    });
 
     this.registerOperandCompiler('Column', (column: ColumnNode, _ctx) => {
+      void _ctx;
       return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
     });
     this.registerOperandCompiler('Function', (fnNode: FunctionNode, ctx) =>
       this.compileFunctionOperand(fnNode, ctx)
     );
-    this.registerOperandCompiler('JsonPath', (path: JsonPathNode, _ctx) => this.compileJsonPath(path));
+    this.registerOperandCompiler('JsonPath', (path: JsonPathNode, _ctx) => {
+      void _ctx;
+      return this.compileJsonPath(path);
+    });
 
     this.registerOperandCompiler('ScalarSubquery', (node: ScalarSubqueryNode, ctx) => {
       const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, '');
@@ -499,7 +510,8 @@ export abstract class Dialect
   }
 
   // Default fallback, should be overridden by dialects if supported
-  protected compileJsonPath(node: JsonPathNode): string {
+  protected compileJsonPath(_node: JsonPathNode): string {
+    void _node;
     throw new Error("JSON Path not supported by this dialect");
   }
 

package/src/core/dialect/base/function-table-formatter.ts

@@ -1,4 +1,5 @@
 import { CompilerContext } from '../abstract.js';
+import { OperandNode } from '../../ast/expression.js';
 import { SqlDialectBase } from './sql-dialect.js';
 
 export interface FunctionTableNode {
@@ -57,9 +58,9 @@ export class FunctionTableFormatter {
    */
   private static formatArgs(fn: FunctionTableNode, ctx?: CompilerContext, dialect?: SqlDialectBase): string {
     return (fn.args || [])
-      .map((a: any) => {
+      .map((a: OperandNode) => {
         if (ctx && dialect) {
-          return (dialect as any).compileOperand(a, ctx);
+          return (dialect as unknown as { compileOperand(n: OperandNode, c: CompilerContext): string }).compileOperand(a, ctx);
         }
         return String(a);
       })

package/src/core/dialect/base/join-compiler.ts

@@ -1,5 +1,7 @@
 import { CompilerContext } from '../abstract.js';
 import { JoinNode } from '../../ast/join.js';
+import { TableSourceNode } from '../../ast/query.js';
+import { ExpressionNode } from '../../ast/expression.js';
 
 /**
  * Compiler for JOIN clauses in SELECT statements.
@@ -9,12 +11,12 @@ export class JoinCompiler {
   static compileJoins(
     joins: JoinNode[] | undefined,
     ctx: CompilerContext,
-    compileFrom: (from: any, ctx: CompilerContext) => string,
-    compileExpression: (expr: any, ctx: CompilerContext) => string
+    compileFrom: (from: TableSourceNode, ctx: CompilerContext) => string,
+    compileExpression: (expr: ExpressionNode, ctx: CompilerContext) => string
   ): string {
     if (!joins || joins.length === 0) return '';
     const parts = joins.map(j => {
-      const table = compileFrom(j.table as any, ctx);
+      const table = compileFrom(j.table, ctx);
       const cond = compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
     });

package/src/core/dialect/base/returning-strategy.ts

@@ -35,6 +35,7 @@ export class NoReturningStrategy implements ReturningStrategy {
    * @throws Error indicating RETURNING is not supported.
    */
   compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string {
+    void _ctx;
     if (!returning || returning.length === 0) return '';
     throw new Error('RETURNING is not supported by this dialect.');
   }

package/src/core/dialect/base/sql-dialect.ts

@@ -11,7 +11,7 @@ import {
   OrderByNode,
   TableNode
 } from '../../ast/query.js';
-import { ColumnNode } from '../../ast/expression.js';
+import { ColumnNode, OperandNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
 import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
 import { CteCompiler } from './cte-compiler.js';
@@ -134,7 +134,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   private compileUpdateAssignments(
-    assignments: { column: ColumnNode; value: any }[],
+    assignments: { column: ColumnNode; value: OperandNode }[],
     table: TableNode,
     ctx: CompilerContext
   ): string {
@@ -190,7 +190,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
-    const tableSource = ast as any;
+    const tableSource = ast;
     if (tableSource.type === 'FunctionTable') {
       return this.compileFunctionTable(tableSource, ctx);
     }

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

@@ -1,5 +1,4 @@
 import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
 import { LiteralNode } from '../../ast/expression.js';
 
 export class MssqlFunctionStrategy extends StandardFunctionStrategy {
@@ -84,27 +83,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('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}`;
-        });
-    }
-}
+        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/mssql/index.ts

@@ -1,10 +1,7 @@
 import { CompilerContext } from '../abstract.js';
 import {
   SelectQueryNode,
-  DeleteQueryNode,
-  TableSourceNode,
-  DerivedTableNode,
-  OrderByNode
+  DeleteQueryNode
 } from '../../ast/query.js';
 import { JsonPathNode } from '../../ast/expression.js';
 import { MssqlFunctionStrategy } from './functions.js';

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

@@ -1,5 +1,4 @@
 import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
 import { LiteralNode } from '../../ast/expression.js';
 
 export class MysqlFunctionStrategy extends StandardFunctionStrategy {

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

@@ -1,5 +1,4 @@
 import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
 import { LiteralNode } from '../../ast/expression.js';
 
 export class PostgresFunctionStrategy extends StandardFunctionStrategy {
@@ -69,36 +68,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('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})`;
-        });
-    }
-}
+        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/postgres/index.ts

@@ -36,6 +36,7 @@ export class PostgresDialect extends SqlDialectBase {
   }
 
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    void ctx;
     if (!returning || returning.length === 0) return '';
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;

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

@@ -1,12 +1,11 @@
-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 { LiteralNode } from '../../ast/expression.js';
+
+export class SqliteFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
 
     private registerOverrides() {
         // Override Standard/Abstract definitions with SQLite specifics
@@ -110,13 +109,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})`;
-        });
-    }
-}
+        });
+
+        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/dialect/sqlite/index.ts

@@ -37,10 +37,12 @@ export class SqliteDialect extends SqlDialectBase {
   }
 
   protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
+    void _table;
     return this.quoteIdentifier(column.name);
   }
 
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    void ctx;
     if (!returning || returning.length === 0) return '';
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;