metal-orm 1.0.4 → 1.0.5

package/src/dialect/sqlite/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode } from '../../ast/query';
-import { JsonPathNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
+import { JsonPathNode, ColumnNode } from '../../ast/expression';
 
 /**
  * SQLite dialect implementation
@@ -39,7 +39,7 @@ export class SqliteDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns SQLite SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -102,6 +102,45 @@ export class SqliteDialect extends Dialect {
       })()
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning};`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = returning
+      .map(column => {
+        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
+        return `${tablePart}${this.quoteIdentifier(column.name)}`;
+      })
+      .join(', ');
+    return ` RETURNING ${columns}`;
+  }
 }

package/src/index.ts

@@ -1,9 +1,12 @@
 
 export * from './schema/table';
 export * from './schema/column';
-export * from './schema/relation';
-export * from './builder/select';
-export * from './ast/expression';
+export * from './schema/relation';
+export * from './builder/select';
+export * from './builder/insert';
+export * from './builder/update';
+export * from './builder/delete';
+export * from './ast/expression';
 export * from './dialect/mysql';
 export * from './dialect/mssql';
 export * from './dialect/sqlite';

package/src/playground/features/playground/data/scenarios/hydration.ts

@@ -2,14 +2,26 @@ import { eq } from '../../../../../ast/expression';
 import { Users } from '../schema';
 import { createScenario } from './types';
 
-export const HYDRATION_SCENARIOS = [
-    createScenario({
-        id: 'user_with_orders',
-        category: 'Hydration',
-        title: 'Nested User Graph',
-        description: 'Eager-load orders for a single user and hydrate a JSON graph from flat SQL rows.',
-        build: (qb) => qb
-            .include('orders', { columns: ['id', 'total', 'status', 'user_id'] })
-            .where(eq(Users.columns.id, 1))
-    })
-];
+export const HYDRATION_SCENARIOS = [
+    createScenario({
+        id: 'user_with_orders',
+        category: 'Hydration',
+        title: 'Nested User Graph',
+        description: 'Eager-load orders for a single user and hydrate a JSON graph from flat SQL rows.',
+        build: (qb) => qb
+            .include('orders', { columns: ['id', 'total', 'status', 'user_id'] })
+            .where(eq(Users.columns.id, 1))
+    }),
+    createScenario({
+        id: 'user_projects_with_pivot',
+        category: 'Hydration',
+        title: 'Projects with Pivot Data',
+        description: 'Include projects for a user along with pivot metadata stored in `_pivot`.',
+        build: (qb) => qb
+            .include('projects', {
+                columns: ['id', 'name', 'client'],
+                pivot: { columns: ['assigned_at', 'role_id'] }
+            })
+            .where(eq(Users.columns.id, 1))
+    })
+];

package/src/playground/features/playground/data/schema.ts

@@ -1,6 +1,6 @@
 import { defineTable } from '../../../../schema/table';
 import { col } from '../../../../schema/column';
-import { hasMany, belongsTo } from '../../../../schema/relation';
+import { hasMany, belongsTo, belongsToMany } from '../../../../schema/relation';
 
 export const Users = defineTable('users', {
     id: col.primaryKey(col.int()),
@@ -52,11 +52,15 @@ export const ProjectAssignments = defineTable('project_assignments', {
     assigned_at: col.varchar(50)
 });
 
-Users.relations = {
-    orders: hasMany(Orders, 'user_id'),
-    profiles: hasMany(Profiles, 'user_id'),
-    userRoles: hasMany(UserRoles, 'user_id')
-};
+Users.relations = {
+    orders: hasMany(Orders, 'user_id'),
+    profiles: hasMany(Profiles, 'user_id'),
+    userRoles: hasMany(UserRoles, 'user_id'),
+    projects: belongsToMany(Projects, ProjectAssignments, {
+        pivotForeignKeyToRoot: 'user_id',
+        pivotForeignKeyToTarget: 'project_id'
+    })
+};
 
 Orders.relations = {
     user: belongsTo(Users, 'user_id')

package/src/runtime/hydration.ts

@@ -26,20 +26,32 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
 
     const parent = rootMap.get(rootId);
 
-    plan.relations.forEach(rel => {
+    plan.relations.forEach(rel => {
       const childPkKey = makeRelationAlias(rel.aliasPrefix, rel.targetPrimaryKey);
       const childPk = row[childPkKey];
-      if (childPk === null || childPk === undefined) return;
-
+      if (childPk === null || childPk === undefined) return;
+
       const bucket = parent[rel.name] as any[];
       if (bucket.some(item => item[rel.targetPrimaryKey] === childPk)) return;
 
-      const child: Record<string, any> = {};
+      const child: Record<string, any> = {};
       rel.columns.forEach(col => {
         const key = makeRelationAlias(rel.aliasPrefix, col);
         child[col] = row[key];
       });
-
+
+      if (rel.pivot) {
+        const pivot: Record<string, any> = {};
+        rel.pivot.columns.forEach(col => {
+          const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
+          pivot[col] = row[key];
+        });
+
+        if (Object.values(pivot).some(v => v !== null && v !== undefined)) {
+          (child as any)._pivot = pivot;
+        }
+      }
+
       bucket.push(child);
     });
   });

package/src/schema/relation.ts

@@ -8,6 +8,8 @@ export const RelationKinds = {
     HasMany: 'HAS_MANY',
     /** Many-to-one relationship */
     BelongsTo: 'BELONGS_TO',
+    /** Many-to-many relationship with pivot metadata */
+    BelongsToMany: 'BELONGS_TO_MANY'
 } as const;
 
 /**
@@ -16,41 +18,50 @@ export const RelationKinds = {
 export type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
 
 /**
- * Base properties common to all relationship types
+ * One-to-many relationship definition
  */
-interface BaseRelation {
-    /** Target table of the relationship */
+export interface HasManyRelation {
+    type: typeof RelationKinds.HasMany;
     target: TableDef;
-    /** Foreign key column name on the child table */
     foreignKey: string;
-    /** Local key column name (usually 'id') */
     localKey?: string;
 }
 
 /**
- * One-to-many relationship definition
+ * Many-to-one relationship definition
  */
-export interface HasManyRelation extends BaseRelation {
-    type: typeof RelationKinds.HasMany;
+export interface BelongsToRelation {
+    type: typeof RelationKinds.BelongsTo;
+    target: TableDef;
+    foreignKey: string;
+    localKey?: string;
 }
 
 /**
- * Many-to-one relationship definition
+ * Many-to-many relationship definition with rich pivot metadata
  */
-export interface BelongsToRelation extends BaseRelation {
-    type: typeof RelationKinds.BelongsTo;
+export interface BelongsToManyRelation {
+    type: typeof RelationKinds.BelongsToMany;
+    target: TableDef;
+    pivotTable: TableDef;
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
 }
 
 /**
  * Union type representing any supported relationship definition
  */
-export type RelationDef = HasManyRelation | BelongsToRelation;
+export type RelationDef = HasManyRelation | BelongsToRelation | BelongsToManyRelation;
 
 /**
  * Creates a one-to-many relationship definition
  * @param target - Target table of the relationship
  * @param foreignKey - Foreign key column name on the child table
- * @param localKey - Local key column name (defaults to 'id')
+ * @param localKey - Local key column name (optional)
  * @returns HasManyRelation definition
  *
  * @example
@@ -58,18 +69,18 @@ export type RelationDef = HasManyRelation | BelongsToRelation;
  * hasMany(usersTable, 'user_id')
  * ```
  */
-export const hasMany = (target: TableDef, foreignKey: string, localKey: string = 'id'): HasManyRelation => ({
+export const hasMany = (target: TableDef, foreignKey: string, localKey?: string): HasManyRelation => ({
     type: RelationKinds.HasMany,
     target,
     foreignKey,
-    localKey,
+    localKey
 });
 
 /**
  * Creates a many-to-one relationship definition
  * @param target - Target table of the relationship
  * @param foreignKey - Foreign key column name on the child table
- * @param localKey - Local key column name (defaults to 'id')
+ * @param localKey - Local key column name (optional)
  * @returns BelongsToRelation definition
  *
  * @example
@@ -77,9 +88,39 @@ export const hasMany = (target: TableDef, foreignKey: string, localKey: string =
  * belongsTo(usersTable, 'user_id')
  * ```
  */
-export const belongsTo = (target: TableDef, foreignKey: string, localKey: string = 'id'): BelongsToRelation => ({
+export const belongsTo = (target: TableDef, foreignKey: string, localKey?: string): BelongsToRelation => ({
     type: RelationKinds.BelongsTo,
     target,
     foreignKey,
-    localKey,
+    localKey
+});
+
+/**
+ * Creates a many-to-many relationship definition with pivot metadata
+ * @param target - Target table
+ * @param pivotTable - Intermediate pivot table definition
+ * @param options - Pivot metadata configuration
+ * @returns BelongsToManyRelation definition
+ */
+export const belongsToMany = (
+    target: TableDef,
+    pivotTable: TableDef,
+    options: {
+        pivotForeignKeyToRoot: string;
+        pivotForeignKeyToTarget: string;
+        localKey?: string;
+        targetKey?: string;
+        pivotPrimaryKey?: string;
+        defaultPivotColumns?: string[];
+    }
+): BelongsToManyRelation => ({
+    type: RelationKinds.BelongsToMany,
+    target,
+    pivotTable,
+    pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
+    pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
+    localKey: options.localKey,
+    targetKey: options.targetKey,
+    pivotPrimaryKey: options.pivotPrimaryKey,
+    defaultPivotColumns: options.defaultPivotColumns
 });

package/tests/belongs-to-many.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { hydrateRows } from '../src/runtime/hydration';
+import { SelectQueryBuilder } from '../src/builder/select';
+import { SqliteDialect } from '../src/dialect/sqlite';
+import { makeRelationAlias } from '../src/utils/relation-alias';
+import { Users } from '../src/playground/features/playground/data/schema';
+
+describe('BelongsToMany hydration', () => {
+  it('includes pivot metadata for a projects include', () => {
+    const builder = new SelectQueryBuilder(Users).include('projects', {
+      columns: ['id', 'name', 'client'],
+      pivot: { columns: ['assigned_at', 'role_id'] }
+    });
+
+    const compiled = builder.compile(new SqliteDialect());
+    expect(compiled.sql).toContain('JOIN "project_assignments"');
+    expect(compiled.sql).toContain('JOIN "projects"');
+
+    const plan = builder.getHydrationPlan();
+    expect(plan).toBeDefined();
+
+    const relationPlan = plan!.relations.find(rel => rel.name === 'projects');
+    expect(relationPlan).toBeDefined();
+    expect(relationPlan!.pivot).toBeDefined();
+    expect(relationPlan!.pivot!.columns).toEqual(['assigned_at', 'role_id']);
+    expect(relationPlan!.pivot!.aliasPrefix).toBe('projects_pivot');
+
+    const row: Record<string, any> = {};
+    plan!.rootColumns.forEach(col => {
+      row[col] = col === plan!.rootPrimaryKey ? 1 : `root-${col}`;
+    });
+
+    row[makeRelationAlias(relationPlan!.aliasPrefix, relationPlan!.targetPrimaryKey)] = 42;
+    relationPlan!.columns.forEach(col => {
+      const alias = makeRelationAlias(relationPlan!.aliasPrefix, col);
+      row[alias] = col === relationPlan!.targetPrimaryKey ? 42 : `project-${col}`;
+    });
+
+    relationPlan!.pivot!.columns.forEach((col, idx) => {
+      const alias = makeRelationAlias(relationPlan!.pivot!.aliasPrefix, col);
+      row[alias] = `pivot-${col}-${idx}`;
+    });
+
+    const hydrated = hydrateRows([row], plan);
+    expect(hydrated).toHaveLength(1);
+    expect(hydrated[0].projects).toHaveLength(1);
+    expect(hydrated[0].projects[0]).toEqual({
+      id: 42,
+      name: 'project-name',
+      client: 'project-client',
+      _pivot: {
+        assigned_at: 'pivot-assigned_at-0',
+        role_id: 'pivot-role_id-1'
+      }
+    });
+  });
+});

package/tests/dml.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, expect } from 'vitest';
+import { InsertQueryBuilder, UpdateQueryBuilder, DeleteQueryBuilder } from '../src';
+import { Dialect } from '../src/dialect/abstract';
+import { MySqlDialect } from '../src/dialect/mysql';
+import { PostgresDialect } from '../src/dialect/postgres';
+import { SqliteDialect } from '../src/dialect/sqlite';
+import { SqlServerDialect } from '../src/dialect/mssql';
+import { Users } from '../src/playground/features/playground/data/schema';
+import { eq } from '../src/ast/expression';
+import type { ColumnDef } from '../src/schema/column';
+
+type Row = {
+  name: string;
+  role: string;
+};
+
+interface DialectCase {
+  name: string;
+  dialect: Dialect;
+  placeholder: (index: number) => string;
+  supportsReturning: boolean;
+}
+
+const rowOrder: (keyof Row)[] = ['name', 'role'];
+const insertRows: Row[] = [
+  { name: 'alice', role: 'admin' },
+  { name: 'bob', role: 'user' }
+];
+
+const returningColumns: ColumnDef[] = [Users.columns.id, Users.columns.name];
+const columnColumns: ColumnDef[] = [Users.columns.name, Users.columns.role];
+
+const dialectCases: DialectCase[] = [
+  {
+    name: 'MySQL',
+    dialect: new MySqlDialect(),
+    placeholder: () => '?',
+    supportsReturning: false
+  },
+  {
+    name: 'Postgres',
+    dialect: new PostgresDialect(),
+    placeholder: () => '?',
+    supportsReturning: true
+  },
+  {
+    name: 'SQLite',
+    dialect: new SqliteDialect(),
+    placeholder: () => '?',
+    supportsReturning: true
+  },
+  {
+    name: 'SQL Server',
+    dialect: new SqlServerDialect(),
+    placeholder: index => `@p${index}`,
+    supportsReturning: false
+  }
+];
+
+const qualifyColumn = (dialect: Dialect, column: ColumnDef): string =>
+  `${dialect.quoteIdentifier(column.table || Users.name)}.${dialect.quoteIdentifier(column.name)}`;
+
+const buildColumnList = (dialect: Dialect, columns: ColumnDef[]): string =>
+  columns.map(column => qualifyColumn(dialect, column)).join(', ');
+
+const buildReturningClause = (dialect: Dialect, columns: ColumnDef[]): string =>
+  columns.length === 0 ? '' : ` RETURNING ${buildColumnList(dialect, columns)}`;
+
+const buildValuesClause = (dialectCase: DialectCase, columnCount: number, rowCount: number): string => {
+  let index = 1;
+  const segments: string[] = [];
+  for (let row = 0; row < rowCount; row += 1) {
+    const placeholders: string[] = [];
+    for (let col = 0; col < columnCount; col += 1) {
+      placeholders.push(dialectCase.placeholder(index));
+      index += 1;
+    }
+    segments.push(`(${placeholders.join(', ')})`);
+  }
+  return segments.join(', ');
+};
+
+const buildPlaceholderSequence = (dialectCase: DialectCase, count: number, startIndex = 1): string[] =>
+  Array.from({ length: count }, (_, idx) => dialectCase.placeholder(startIndex + idx));
+
+const flattenRowValues = (rows: Row[], order: (keyof Row)[]): unknown[] =>
+  rows.flatMap(row => order.map(key => row[key]));
+
+describe('DML builders', () => {
+  dialectCases.forEach(dialectCase => {
+    describe(dialectCase.name, () => {
+      const dialect = dialectCase.dialect;
+      const tableName = Users.name;
+      const qualifiedColumns = buildColumnList(dialect, columnColumns);
+      const returningSql = buildReturningClause(dialect, returningColumns);
+
+      it('compiles single-row insert', () => {
+        const query = new InsertQueryBuilder(Users).values(insertRows[0]);
+        const compiled = query.compile(dialect);
+        const valueClause = `(${dialectCase.placeholder(1)}, ${dialectCase.placeholder(2)})`;
+        const expectedSql = `INSERT INTO ${dialect.quoteIdentifier(tableName)} (${qualifiedColumns}) VALUES ${valueClause};`;
+        expect(compiled.sql).toBe(expectedSql);
+        expect(compiled.params).toEqual([insertRows[0].name, insertRows[0].role]);
+      });
+
+      it('compiles multi-row insert with consistent parameter order', () => {
+        const query = new InsertQueryBuilder(Users).values(insertRows);
+        const compiled = query.compile(dialect);
+        const valuesClause = buildValuesClause(dialectCase, columnColumns.length, insertRows.length);
+        const expectedSql = `INSERT INTO ${dialect.quoteIdentifier(tableName)} (${qualifiedColumns}) VALUES ${valuesClause};`;
+        expect(compiled.sql).toBe(expectedSql);
+        expect(compiled.params).toEqual(flattenRowValues(insertRows, rowOrder));
+      });
+
+      if (dialectCase.supportsReturning) {
+        it('appends RETURNING for insert when requested', () => {
+          const query = new InsertQueryBuilder(Users)
+            .values(insertRows[0])
+            .returning(Users.columns.id, Users.columns.name);
+          const compiled = query.compile(dialect);
+          const valueClause = `(${dialectCase.placeholder(1)}, ${dialectCase.placeholder(2)})`;
+          const expectedSql = `INSERT INTO ${dialect.quoteIdentifier(tableName)} (${qualifiedColumns}) VALUES ${valueClause}${returningSql};`;
+          expect(compiled.sql).toBe(expectedSql);
+          expect(compiled.params).toEqual([insertRows[0].name, insertRows[0].role]);
+        });
+      }
+
+      it('compiles update with SET values', () => {
+        const updateValues = { name: 'ali', role: 'builder' };
+        const query = new UpdateQueryBuilder(Users).set(updateValues);
+        const compiled = query.compile(dialect);
+        const placeholderSeq = buildPlaceholderSequence(dialectCase, columnColumns.length);
+        const assignments = columnColumns
+          .map((column, idx) => `${qualifyColumn(dialect, column)} = ${placeholderSeq[idx]}`)
+          .join(', ');
+        const expectedSql = `UPDATE ${dialect.quoteIdentifier(tableName)} SET ${assignments};`;
+        expect(compiled.sql).toBe(expectedSql);
+        expect(compiled.params).toEqual([updateValues.name, updateValues.role]);
+      });
+
+      it('compiles update with WHERE clause', () => {
+        const updateValues = { name: 'gold', role: 'star' };
+        const query = new UpdateQueryBuilder(Users)
+          .set(updateValues)
+          .where(eq(Users.columns.id, 1));
+        const compiled = query.compile(dialect);
+        const assignmentPlaceholders = buildPlaceholderSequence(dialectCase, columnColumns.length);
+        const assignments = columnColumns
+          .map((column, idx) => `${qualifyColumn(dialect, column)} = ${assignmentPlaceholders[idx]}`)
+          .join(', ');
+        const wherePlaceholder = dialectCase.placeholder(columnColumns.length + 1);
+        const whereClause = ` WHERE ${qualifyColumn(dialect, Users.columns.id)} = ${wherePlaceholder}`;
+        const expectedSql = `UPDATE ${dialect.quoteIdentifier(tableName)} SET ${assignments}${whereClause};`;
+        expect(compiled.sql).toBe(expectedSql);
+        expect(compiled.params).toEqual([updateValues.name, updateValues.role, 1]);
+      });
+
+      if (dialectCase.supportsReturning) {
+        it('appends RETURNING for update when requested', () => {
+          const query = new UpdateQueryBuilder(Users)
+            .set({ name: 'return' })
+            .returning(Users.columns.id, Users.columns.name);
+          const compiled = query.compile(dialect);
+          const placeholder = dialectCase.placeholder(1);
+          const assignment = `${qualifyColumn(dialect, Users.columns.name)} = ${placeholder}`;
+          const expectedSql = `UPDATE ${dialect.quoteIdentifier(tableName)} SET ${assignment}${returningSql};`;
+          expect(compiled.sql).toBe(expectedSql);
+          expect(compiled.params).toEqual(['return']);
+        });
+      }
+
+      it('compiles DELETE without WHERE', () => {
+        const query = new DeleteQueryBuilder(Users);
+        const compiled = query.compile(dialect);
+        const expectedSql = `DELETE FROM ${dialect.quoteIdentifier(tableName)};`;
+        expect(compiled.sql).toBe(expectedSql);
+        expect(compiled.params).toEqual([]);
+      });
+
+      it('compiles DELETE with WHERE clause', () => {
+        const query = new DeleteQueryBuilder(Users).where(eq(Users.columns.id, 7));
+        const compiled = query.compile(dialect);
+        const wherePlaceholder = dialectCase.placeholder(1);
+        const whereClause = ` WHERE ${qualifyColumn(dialect, Users.columns.id)} = ${wherePlaceholder}`;
+        const expectedSql = `DELETE FROM ${dialect.quoteIdentifier(tableName)}${whereClause};`;
+        expect(compiled.sql).toBe(expectedSql);
+        expect(compiled.params).toEqual([7]);
+      });
+
+      if (dialectCase.supportsReturning) {
+        it('appends RETURNING for delete when requested', () => {
+          const query = new DeleteQueryBuilder(Users)
+            .where(eq(Users.columns.id, 11))
+            .returning(Users.columns.id, Users.columns.name);
+          const compiled = query.compile(dialect);
+          const wherePlaceholder = dialectCase.placeholder(1);
+          const whereClause = ` WHERE ${qualifyColumn(dialect, Users.columns.id)} = ${wherePlaceholder}`;
+          const expectedSql = `DELETE FROM ${dialect.quoteIdentifier(tableName)}${whereClause}${returningSql};`;
+          expect(compiled.sql).toBe(expectedSql);
+          expect(compiled.params).toEqual([11]);
+        });
+      }
+    });
+  });
+});
+