metal-orm 1.0.8 → 1.0.10

package/tests/complex-exists.test.ts

@@ -1,230 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SelectQueryBuilder } from '../src/builder/select';
-import { SqliteDialect } from '../src/dialect/sqlite';
-import { TableDef, defineTable } from '../src/schema/table';
-import { col } from '../src/schema/column';
-import { eq, exists, and } from '../src/ast/expression';
-
-// Define test schema: Clientes, Pedidos and Fidelidade
-const Clientes = defineTable('clientes', {
-    id: col.primaryKey(col.int()),
-    nome: col.varchar(255),
-    email: col.varchar(255),
-}, {});
-
-const Pedidos = defineTable('pedidos', {
-    id: col.primaryKey(col.int()),
-    cliente_id: col.int(),
-    data_pedido: col.varchar(50), // Usando varchar em vez de date
-    status: col.varchar(50),
-    total: col.int(),
-}, {});
-
-const Fidelidade = defineTable('fidelidade', {
-    id: col.primaryKey(col.int()),
-    cliente_id: col.int(),
-    status: col.varchar(50),
-    data_inicio: col.varchar(50), // Usando varchar em vez de date
-}, {});
-
-// Define relationships
-Clientes.relations = {
-    pedidos: {
-        type: 'HAS_MANY',
-        target: Pedidos,
-        foreignKey: 'cliente_id',
-        localKey: 'id'
-    },
-    fidelidade: {
-        type: 'HAS_MANY',
-        target: Fidelidade,
-        foreignKey: 'cliente_id',
-        localKey: 'id'
-    }
-};
-
-Pedidos.relations = {
-    cliente: {
-        type: 'BELONGS_TO',
-        target: Clientes,
-        foreignKey: 'cliente_id',
-        localKey: 'id'
-    }
-};
-
-Fidelidade.relations = {
-    cliente: {
-        type: 'BELONGS_TO',
-        target: Clientes,
-        foreignKey: 'cliente_id',
-        localKey: 'id'
-    }
-};
-
-const dialect = new SqliteDialect();
-
-describe('Complex EXISTS Query Support', () => {
-    it('should support EXISTS with date range AND another EXISTS', () => {
-        // Construindo a subquery para pedidos em 2024
-        const pedidosEm2024 = new SelectQueryBuilder(Pedidos)
-            .select({ dummy: col.int() }) // SELECT 1 (dummy)
-            .where(and(
-                eq(Pedidos.columns.cliente_id, { type: 'Column', table: 'clientes', name: 'id' }),
-                // BETWEEN não é suportado diretamente, então usamos >= e <=
-                and(
-                    eq(Pedidos.columns.data_pedido, '2024-01-01'),
-                    eq(Pedidos.columns.data_pedido, '2024-12-31')
-                )
-            ));
-
-        // Construindo a subquery para fidelidade ativa
-        const fidelidadeAtiva = new SelectQueryBuilder(Fidelidade)
-            .select({ dummy: col.int() }) // SELECT 1 (dummy)
-            .where(and(
-                eq(Fidelidade.columns.cliente_id, { type: 'Column', table: 'clientes', name: 'id' }),
-                eq(Fidelidade.columns.status, 'Ativo')
-            ));
-
-        // Consulta principal
-        const query = new SelectQueryBuilder(Clientes)
-            .select({ nome: Clientes.columns.nome })
-            .where(and(
-                exists(pedidosEm2024.getAST()),
-                exists(fidelidadeAtiva.getAST())
-            ));
-
-        const compiled = query.compile(dialect);
-        const { sql, params } = compiled;
-
-        console.log('Generated SQL:', sql);
-        console.log('Parameters:', params);
-
-        expect(sql).toContain('EXISTS');
-        expect(sql).toContain('SELECT 1 FROM "pedidos"');
-        expect(sql).toContain('"pedidos"."cliente_id" = "clientes"."id"');
-        expect(sql).toContain('"pedidos"."data_pedido"');
-        expect(sql).toContain('EXISTS');
-        expect(sql).toContain('SELECT 1 FROM "fidelidade"');
-        expect(sql).toContain('"fidelidade"."cliente_id" = "clientes"."id"');
-        expect(sql).toContain('"fidelidade"."status" = ?');
-        expect(params).toContain('Ativo');
-    });
-
-    it('should support whereHas for both conditions', () => {
-        // Usando whereHas para simplificar a construção das subqueries EXISTS
-        const query = new SelectQueryBuilder(Clientes)
-            .select({ nome: Clientes.columns.nome })
-            .whereHas('pedidos', (pedidosQb) =>
-                pedidosQb.where(and(
-                    eq(Pedidos.columns.data_pedido, '2024-01-01'),
-                    eq(Pedidos.columns.data_pedido, '2024-12-31')
-                ))
-            )
-            .whereHas('fidelidade', (fidelidadeQb) =>
-                fidelidadeQb.where(eq(Fidelidade.columns.status, 'Ativo'))
-            );
-
-        const compiled = query.compile(dialect);
-        const { sql, params } = compiled;
-
-        console.log('Generated SQL with whereHas:', sql);
-        console.log('Parameters:', params);
-
-        expect(sql).toContain('EXISTS');
-        expect(sql).toContain('SELECT 1 FROM "pedidos"');
-        expect(sql).toContain('"pedidos"."cliente_id" = "clientes"."id"');
-        expect(sql).toContain('"pedidos"."data_pedido"');
-        expect(sql).toContain('EXISTS');
-        expect(sql).toContain('SELECT 1 FROM "fidelidade"');
-        expect(sql).toContain('"fidelidade"."cliente_id" = "clientes"."id"');
-        expect(sql).toContain('"fidelidade"."status" = ?');
-        expect(params).toContain('Ativo');
-    });
-
-    it('should generate correct SQL structure for complex EXISTS query', () => {
-        // Teste para verificar se o SQL gerado tem a estrutura correta
-        const query = new SelectQueryBuilder(Clientes)
-            .select({ nome: Clientes.columns.nome })
-            .where(and(
-                exists({
-                    type: 'SelectQuery',
-                    from: { type: 'Table', name: 'pedidos' },
-                    columns: [{ type: 'Column', table: 'pedidos', name: 'id' }],
-                    joins: [],
-                    where: {
-                        type: 'LogicalExpression',
-                        operator: 'AND',
-                        operands: [
-                            {
-                                type: 'BinaryExpression',
-                                left: { type: 'Column', table: 'pedidos', name: 'cliente_id' },
-                                operator: '=',
-                                right: { type: 'Column', table: 'clientes', name: 'id' }
-                            },
-                            {
-                                type: 'LogicalExpression',
-                                operator: 'AND',
-                                operands: [
-                                    {
-                                        type: 'BinaryExpression',
-                                        left: { type: 'Column', table: 'pedidos', name: 'data_pedido' },
-                                        operator: '>=',
-                                        right: { type: 'Literal', value: '2024-01-01' }
-                                    },
-                                    {
-                                        type: 'BinaryExpression',
-                                        left: { type: 'Column', table: 'pedidos', name: 'data_pedido' },
-                                        operator: '<=',
-                                        right: { type: 'Literal', value: '2024-12-31' }
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                }),
-                exists({
-                    type: 'SelectQuery',
-                    from: { type: 'Table', name: 'fidelidade' },
-                    columns: [{ type: 'Column', table: 'fidelidade', name: 'id' }],
-                    joins: [],
-                    where: {
-                        type: 'LogicalExpression',
-                        operator: 'AND',
-                        operands: [
-                            {
-                                type: 'BinaryExpression',
-                                left: { type: 'Column', table: 'fidelidade', name: 'cliente_id' },
-                                operator: '=',
-                                right: { type: 'Column', table: 'clientes', name: 'id' }
-                            },
-                            {
-                                type: 'BinaryExpression',
-                                left: { type: 'Column', table: 'fidelidade', name: 'status' },
-                                operator: '=',
-                                right: { type: 'Literal', value: 'Ativo' }
-                            }
-                        ]
-                    }
-                })
-            ));
-
-        const compiled = query.compile(dialect);
-        const { sql, params } = compiled;
-
-        console.log('Generated SQL structure:', sql);
-        console.log('Parameters:', params);
-
-        // Verifica a estrutura geral da consulta
-        expect(sql).toContain('SELECT "clientes"."nome" AS "nome" FROM "clientes" WHERE');
-        expect(sql).toContain('EXISTS');
-        expect(sql).toContain('SELECT 1 FROM "pedidos"');
-        expect(sql).toContain('"pedidos"."cliente_id" = "clientes"."id"');
-        expect(sql).toContain('"pedidos"."data_pedido" >= ?');
-        expect(sql).toContain('"pedidos"."data_pedido" <= ?');
-        expect(sql).toContain('EXISTS');
-        expect(sql).toContain('SELECT 1 FROM "fidelidade"');
-        expect(sql).toContain('"fidelidade"."cliente_id" = "clientes"."id"');
-        expect(sql).toContain('"fidelidade"."status" = ?');
-        expect(params).toEqual(['2024-01-01', '2024-12-31', 'Ativo']);
-    });
-});

package/tests/cte.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SelectQueryBuilder } from '../src/builder/select';
-import { SqliteDialect } from '../src/dialect/sqlite';
-import { MySqlDialect } from '../src/dialect/mysql';
-import { SqlServerDialect } from '../src/dialect/mssql';
-import { TableDef } from '../src/schema/table';
-import { eq } from '../src/ast/expression';
-
-const table = (name: string): TableDef => ({ name, columns: {}, relations: {} });
-const col = (name: string, table?: string) => ({ type: 'Column', name, table: table || 'unknown' } as any);
-const lit = (value: any) => ({ type: 'Literal', value } as any);
-
-describe('CTE Support', () => {
-    const sqlite = new SqliteDialect();
-    const mysql = new MySqlDialect();
-    const mssql = new SqlServerDialect();
-
-    it('should generate a simple CTE', () => {
-        const users = table('users');
-        const cte = new SelectQueryBuilder(users)
-            .selectRaw('id', 'name')
-            .where(eq(col('id', 'users'), lit(1)));
-
-        const query = new SelectQueryBuilder(table('cte_users'))
-            .with('cte_users', cte)
-            .selectRaw('id', 'name');
-
-        expect(query.toSql(sqlite)).toBe('WITH "cte_users" AS (SELECT "users"."id", "users"."name" FROM "users" WHERE "users"."id" = ?) SELECT "cte_users"."id", "cte_users"."name" FROM "cte_users";');
-    });
-
-    it('should generate a recursive CTE', () => {
-        const numbers = table('numbers');
-        const cte = new SelectQueryBuilder(numbers)
-            .selectRaw('n')
-            .where(eq(col('n', 'numbers'), lit(1)));
-
-        // Recursive part usually involves UNION, but our builder might not support UNION yet?
-        // The task didn't mention UNION.
-        // But we can test the RECURSIVE keyword generation at least.
-
-        const query = new SelectQueryBuilder(table('cte_numbers'))
-            .withRecursive('cte_numbers', cte)
-            .selectRaw('n');
-
-        expect(query.toSql(sqlite)).toBe('WITH RECURSIVE "cte_numbers" AS (SELECT "numbers"."n" FROM "numbers" WHERE "numbers"."n" = ?) SELECT "cte_numbers"."n" FROM "cte_numbers";');
-        expect(query.toSql(mysql)).toBe('WITH RECURSIVE `cte_numbers` AS (SELECT `numbers`.`n` FROM `numbers` WHERE `numbers`.`n` = ?) SELECT `cte_numbers`.`n` FROM `cte_numbers`;');
-        // MSSQL should NOT have RECURSIVE
-        expect(query.toSql(mssql)).toBe('WITH [cte_numbers] AS (SELECT [numbers].[n] FROM [numbers] WHERE [numbers].[n] = @p1) SELECT [cte_numbers].[n] FROM [cte_numbers];');
-    });
-
-    it('should generate CTE with column aliases', () => {
-        const users = table('users');
-        const cte = new SelectQueryBuilder(users)
-            .selectRaw('id', 'name');
-
-        const query = new SelectQueryBuilder(table('cte_users'))
-            .with('cte_users', cte, ['user_id', 'user_name'])
-            .selectRaw('user_id');
-
-        expect(query.toSql(sqlite)).toBe('WITH "cte_users"("user_id", "user_name") AS (SELECT "users"."id", "users"."name" FROM "users") SELECT "cte_users"."user_id" FROM "cte_users";');
-    });
-
-    it('should support multiple CTEs', () => {
-        const users = table('users');
-        const orders = table('orders');
-
-        const cte1 = new SelectQueryBuilder(users).selectRaw('id');
-        const cte2 = new SelectQueryBuilder(orders).selectRaw('total');
-
-        const query = new SelectQueryBuilder(table('main'))
-            .with('u', cte1)
-            .with('o', cte2)
-            .selectRaw('u.id', 'o.total');
-
-        expect(query.toSql(sqlite)).toBe('WITH "u" AS (SELECT "users"."id" FROM "users"), "o" AS (SELECT "orders"."total" FROM "orders") SELECT "main"."u.id", "main"."o.total" FROM "main";');
-    });
-
-    it('should handle mixed recursive and non-recursive CTEs', () => {
-        const numbers = table('numbers');
-        const users = table('users');
-
-        const recursiveCte = new SelectQueryBuilder(numbers)
-            .selectRaw('n')
-            .where(eq(col('n', 'numbers'), lit(1)));
-
-        const normalCte = new SelectQueryBuilder(users)
-            .selectRaw('id', 'name');
-
-        const query = new SelectQueryBuilder(table('main'))
-            .withRecursive('recursive_numbers', recursiveCte)
-            .with('normal_users', normalCte)
-            .selectRaw('n', 'id');
-
-        // Should have "WITH RECURSIVE" once at the beginning, not per CTE
-        expect(query.toSql(sqlite)).toBe('WITH RECURSIVE "recursive_numbers" AS (SELECT "numbers"."n" FROM "numbers" WHERE "numbers"."n" = ?), "normal_users" AS (SELECT "users"."id", "users"."name" FROM "users") SELECT "main"."n", "main"."id" FROM "main";');
-        expect(query.toSql(mysql)).toBe('WITH RECURSIVE `recursive_numbers` AS (SELECT `numbers`.`n` FROM `numbers` WHERE `numbers`.`n` = ?), `normal_users` AS (SELECT `users`.`id`, `users`.`name` FROM `users`) SELECT `main`.`n`, `main`.`id` FROM `main`;');
-
-        // MSSQL should NOT have RECURSIVE keyword at all
-        expect(query.toSql(mssql)).toBe('WITH [recursive_numbers] AS (SELECT [numbers].[n] FROM [numbers] WHERE [numbers].[n] = @p1), [normal_users] AS (SELECT [users].[id], [users].[name] FROM [users]) SELECT [main].[n], [main].[id] FROM [main];');
-    });
-
-    it('should handle multiple non-recursive CTEs without RECURSIVE keyword', () => {
-        const users = table('users');
-        const orders = table('orders');
-
-        const cte1 = new SelectQueryBuilder(users).selectRaw('id');
-        const cte2 = new SelectQueryBuilder(orders).selectRaw('total');
-
-        const query = new SelectQueryBuilder(table('main'))
-            .with('u', cte1)
-            .with('o', cte2)
-            .selectRaw('id');
-
-        // Should NOT have RECURSIVE keyword
-        expect(query.toSql(sqlite)).toBe('WITH "u" AS (SELECT "users"."id" FROM "users"), "o" AS (SELECT "orders"."total" FROM "orders") SELECT "main"."id" FROM "main";');
-        expect(query.toSql(mysql)).toBe('WITH `u` AS (SELECT `users`.`id` FROM `users`), `o` AS (SELECT `orders`.`total` FROM `orders`) SELECT `main`.`id` FROM `main`;');
-    });
-});

package/tests/dml.test.ts

@@ -1,206 +0,0 @@
-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]);
-        });
-      }
-    });
-  });
-});
-

package/tests/exists.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SelectQueryBuilder } from '../src/builder/select';
-import { SqliteDialect } from '../src/dialect/sqlite';
-import { TableDef, defineTable } from '../src/schema/table';
-import { col } from '../src/schema/column';
-import { eq, gt, and } from '../src/ast/expression';
-
-// Define test schema: Users and Orders
-const Users = defineTable('users', {
-    id: col.primaryKey(col.int()),
-    name: col.varchar(255),
-    email: col.varchar(255),
-}, {});
-
-const Orders = defineTable('orders', {
-    id: col.primaryKey(col.int()),
-    user_id: col.int(),
-    status: col.varchar(50),
-    total: col.int(),
-}, {});
-
-// Define relationships
-Users.relations = {
-    orders: {
-        type: 'HAS_MANY',
-        target: Orders,
-        foreignKey: 'user_id',
-        localKey: 'id'
-    }
-};
-
-Orders.relations = {
-    user: {
-        type: 'BELONGS_TO',
-        target: Users,
-        foreignKey: 'user_id',
-        localKey: 'id'
-    }
-};
-
-const dialect = new SqliteDialect();
-
-describe('EXISTS Support', () => {
-    describe('whereHas - basic functionality', () => {
-        it('should generate EXISTS with simple correlation', () => {
-            const query = new SelectQueryBuilder(Users)
-                .select({ id: Users.columns.id, name: Users.columns.name })
-                .whereHas('orders');
-
-            const compiled = query.compile(dialect);
-            const { sql, params } = compiled;
-
-            expect(sql).toContain('EXISTS');
-            expect(sql).toContain('SELECT 1 FROM');
-            expect(sql).toContain('"orders"."user_id" = "users"."id"');
-            expect(params).toEqual([]);
-        });
-
-        it('should support whereHas with filter callback', () => {
-            const query = new SelectQueryBuilder(Users)
-                .select({ id: Users.columns.id, name: Users.columns.name })
-                .whereHas('orders', (ordersQb) =>
-                    ordersQb.where(eq(Orders.columns.status, 'completed'))
-                );
-
-            const compiled = query.compile(dialect);
-            const { sql, params } = compiled;
-
-            expect(sql).toContain('EXISTS');
-            expect(sql).toContain('"orders"."status" = ?');
-            expect(sql).toContain('"orders"."user_id" = "users"."id"');
-            expect(params).toEqual(['completed']);
-        });
-
-        it('should support whereHas with multiple filters', () => {
-            const query = new SelectQueryBuilder(Users)
-                .select({ id: Users.columns.id, name: Users.columns.name })
-                .whereHas('orders', (ordersQb) =>
-                    ordersQb.where(and(
-                        eq(Orders.columns.status, 'completed'),
-                        gt(Orders.columns.total, 200)
-                    ))
-                );
-
-            const compiled = query.compile(dialect);
-            const { sql, params } = compiled;
-
-            expect(sql).toContain('EXISTS');
-            expect(sql).toContain('"orders"."status" = ?');
-            expect(sql).toContain('"orders"."total" > ?');
-            expect(sql).toContain('"orders"."user_id" = "users"."id"');
-            expect(params).toEqual(['completed', 200]);
-        });
-    });
-
-    describe('whereHasNot - basic functionality', () => {
-        it('should generate NOT EXISTS with simple correlation', () => {
-            const query = new SelectQueryBuilder(Users)
-                .select({ id: Users.columns.id, name: Users.columns.name })
-                .whereHasNot('orders');
-
-            const compiled = query.compile(dialect);
-            const { sql, params } = compiled;
-
-            expect(sql).toContain('NOT EXISTS');
-            expect(sql).toContain('SELECT 1 FROM');
-            expect(sql).toContain('"orders"."user_id" = "users"."id"');
-            expect(params).toEqual([]);
-        });
-
-        it('should support whereHasNot with filter callback', () => {
-            const query = new SelectQueryBuilder(Users)
-                .select({ id: Users.columns.id, name: Users.columns.name })
-                .whereHasNot('orders', (ordersQb) =>
-                    ordersQb.where(eq(Orders.columns.status, 'pending'))
-                );
-
-            const compiled = query.compile(dialect);
-            const { sql, params } = compiled;
-
-            expect(sql).toContain('NOT EXISTS');
-            expect(sql).toContain('"orders"."status" = ?');
-            expect(sql).toContain('"orders"."user_id" = "users"."id"');
-            expect(params).toEqual(['pending']);
-        });
-    });
-});