metal-orm 1.0.0

package/tests/cte.test.ts

@@ -0,0 +1,118 @@
+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/exists.test.ts

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

package/tests/like.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { like, notLike } from '../src/ast/expression';
+import { Users } from '../src/playground/features/playground/data/schema';
+import { SqliteDialect } from '../src/dialect/sqlite';
+import { SelectQueryBuilder } from '../src/builder/select';
+
+describe('like expressions', () => {
+    const dialect = new SqliteDialect();
+
+    it('compiles LIKE with an escape clause', () => {
+        const q = new SelectQueryBuilder(Users)
+            .selectRaw('*')
+            .where(like(Users.columns.name, 'Admin\\_%', '\\'));
+
+        const compiled = q.compile(dialect);
+        expect(compiled.sql).toBe(
+            'SELECT "users"."*" FROM "users" WHERE "users"."name" LIKE ? ESCAPE ?;'
+        );
+        expect(compiled.params).toEqual(['Admin\\_%', '\\']);
+    });
+
+    it('compiles NOT LIKE with an escape clause', () => {
+        const q = new SelectQueryBuilder(Users)
+            .selectRaw('*')
+            .where(notLike(Users.columns.role, 'admin\\_%', '\\'));
+
+        const compiled = q.compile(dialect);
+        expect(compiled.sql).toBe(
+            'SELECT "users"."*" FROM "users" WHERE "users"."role" NOT LIKE ? ESCAPE ?;'
+        );
+        expect(compiled.params).toEqual(['admin\\_%', '\\']);
+    });
+});

package/tests/right-join.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { SelectQueryBuilder } from '../src/builder/select';
+import { TableDef } from '../src/schema/table';
+import { eq } from '../src/ast/expression';
+import { SqliteDialect } from '../src/dialect/sqlite';
+import { MySqlDialect } from '../src/dialect/mysql';
+import { SqlServerDialect } from '../src/dialect/mssql';
+
+const Users: TableDef = {
+    name: 'users',
+    columns: {
+        id: { name: 'id', type: 'integer' },
+        name: { name: 'name', type: 'text' }
+    },
+    relations: {
+        orders: {
+            type: 'HAS_MANY',
+            target: {
+                name: 'orders',
+                columns: {
+                    id: { name: 'id', type: 'integer' },
+                    user_id: { name: 'user_id', type: 'integer' },
+                    total: { name: 'total', type: 'integer' }
+                },
+                relations: {}
+            },
+            foreignKey: 'user_id',
+            localKey: 'id'
+        }
+    }
+};
+
+const Orders = Users.relations.orders.target;
+
+describe('RIGHT JOIN Support', () => {
+    it('should generate correct SQL for manual rightJoin', () => {
+        const qb = new SelectQueryBuilder(Users)
+            .select({
+                user: { ...Users.columns.name, table: 'users' },
+                total: { ...Orders.columns.total, table: 'orders' }
+            })
+            .rightJoin(Orders, eq({ ...Users.columns.id, table: 'users' }, { ...Orders.columns.user_id, table: 'orders' }));
+
+        const sqlite = new SqliteDialect();
+        expect(qb.toSql(sqlite)).toBe('SELECT "users"."name" AS "user", "orders"."total" AS "total" FROM "users" RIGHT JOIN "orders" ON "users"."id" = "orders"."user_id";');
+    });
+
+    it('should generate correct SQL for manual leftJoin', () => {
+        const qb = new SelectQueryBuilder(Users)
+            .select({
+                user: { ...Users.columns.name, table: 'users' },
+                total: { ...Orders.columns.total, table: 'orders' }
+            })
+            .leftJoin(Orders, eq({ ...Users.columns.id, table: 'users' }, { ...Orders.columns.user_id, table: 'orders' }));
+
+        const sqlite = new SqliteDialect();
+        expect(qb.toSql(sqlite)).toBe('SELECT "users"."name" AS "user", "orders"."total" AS "total" FROM "users" LEFT JOIN "orders" ON "users"."id" = "orders"."user_id";');
+    });
+
+    it('should generate correct SQL for joinRelation with RIGHT kind', () => {
+        const qb = new SelectQueryBuilder(Users)
+            .select({
+                user: { ...Users.columns.name, table: 'users' },
+                total: { ...Orders.columns.total, table: 'orders' }
+            })
+            .joinRelation('orders', 'RIGHT');
+
+        const sqlite = new SqliteDialect();
+        expect(qb.toSql(sqlite)).toBe('SELECT "users"."name" AS "user", "orders"."total" AS "total" FROM "users" RIGHT JOIN "orders" ON "orders"."user_id" = "users"."id";');
+    });
+
+    it('should work with MySQL dialect', () => {
+        const qb = new SelectQueryBuilder(Users)
+            .select({ user: { ...Users.columns.name, table: 'users' } })
+            .rightJoin(Orders, eq({ ...Users.columns.id, table: 'users' }, { ...Orders.columns.user_id, table: 'orders' }));
+
+        const mysql = new MySqlDialect();
+        expect(qb.toSql(mysql)).toBe('SELECT `users`.`name` AS `user` FROM `users` RIGHT JOIN `orders` ON `users`.`id` = `orders`.`user_id`;');
+    });
+
+    it('should work with MSSQL dialect', () => {
+        const qb = new SelectQueryBuilder(Users)
+            .select({ user: { ...Users.columns.name, table: 'users' } })
+            .rightJoin(Orders, eq({ ...Users.columns.id, table: 'users' }, { ...Orders.columns.user_id, table: 'orders' }));
+
+        const mssql = new SqlServerDialect();
+        expect(qb.toSql(mssql)).toBe('SELECT [users].[name] AS [user] FROM [users] RIGHT JOIN [orders] ON [users].[id] = [orders].[user_id];');
+    });
+});

package/tests/subquery-having.test.ts

@@ -0,0 +1,193 @@
+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, defineTable } from '../src/schema/table';
+import { col } from '../src/schema/column';
+import { eq, gt, lt, avg, count, sum } from '../src/ast/expression';
+
+// Define test schema
+const Users = defineTable('users', {
+    id: col.primaryKey(col.int()),
+    name: col.varchar(255),
+    age: col.int(),
+}, {});
+
+const Orders = defineTable('orders', {
+    id: col.primaryKey(col.int()),
+    user_id: col.int(),
+    status: col.varchar(50),
+    total: col.int(),
+}, {});
+
+const Profiles = defineTable('profiles', {
+    id: col.primaryKey(col.int()),
+    user_id: col.int(),
+    display_name: col.varchar(255),
+}, {});
+
+const Contributions = defineTable('contributions', {
+    id: col.primaryKey(col.int()),
+    project_id: col.int(),
+    hours: col.int(),
+}, {});
+
+const sqlite = new SqliteDialect();
+const mysql = new MySqlDialect();
+const sqlserver = new SqlServerDialect();
+
+describe('Scalar Subqueries', () => {
+    describe('selectSubquery in SELECT projection', () => {
+        it('should add scalar subquery to SELECT (SQLite)', () => {
+            const profileSubquery = new SelectQueryBuilder(Profiles)
+                .select({ display_name: Profiles.columns.display_name })
+                .where(eq(Profiles.columns.user_id, Users.columns.id));
+
+            const query = new SelectQueryBuilder(Users)
+                .select({ id: Users.columns.id })
+                .selectSubquery('profile_name', profileSubquery);
+
+            const sql = query.toSql(sqlite);
+
+            expect(sql).toContain('(SELECT');
+            expect(sql).toContain('"profiles"."display_name"');
+            expect(sql).toContain('AS "profile_name"');
+        });
+
+        it('should support multiple scalar subqueries', () => {
+            const orderCountSub = new SelectQueryBuilder(Orders)
+                .select({ cnt: count(Orders.columns.id) })
+                .where(eq(Orders.columns.user_id, Users.columns.id));
+
+            const totalSpentSub = new SelectQueryBuilder(Orders)
+                .select({ total: sum(Orders.columns.total) })
+                .where(eq(Orders.columns.user_id, Users.columns.id));
+
+            const query = new SelectQueryBuilder(Users)
+                .select({ id: Users.columns.id })
+                .selectSubquery('order_count', orderCountSub)
+                .selectSubquery('total_spent', totalSpentSub);
+
+            const sql = query.toSql(sqlite);
+            expect(sql).toContain('AS "order_count"');
+            expect(sql).toContain('AS "total_spent"');
+        });
+    });
+
+    describe('Scalar subquery in WHERE clause', () => {
+        it('should support scalar subquery with gt operator', () => {
+            const avgAgeSub = new SelectQueryBuilder(Users)
+                .select({ avg_age: avg(Users.columns.age) });
+
+            const query = new SelectQueryBuilder(Users)
+                .select({ id: Users.columns.id, age: Users.columns.age })
+                .where(gt(Users.columns.age, {
+                    type: 'ScalarSubquery',
+                    query: avgAgeSub.getAST()
+                }));
+
+            const sql = query.toSql(sqlite);
+            expect(sql).toContain('"users"."age" >');
+            expect(sql).toContain('(SELECT');
+            expect(sql).toContain('AVG("users"."age")');
+        });
+    });
+});
+
+describe('HAVING Clause', () => {
+    describe('Basic HAVING with aggregates', () => {
+        it('should add HAVING clause with COUNT (SQLite)', () => {
+        const query = new SelectQueryBuilder(Contributions)
+            .select({ project_id: Contributions.columns.project_id, cnt: count(Contributions.columns.id) })
+            .groupBy(Contributions.columns.project_id)
+            .having(gt(count(Contributions.columns.id), 10));
+
+        const compiled = query.compile(sqlite);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('GROUP BY');
+        expect(sql).toContain('HAVING');
+        expect(sql).toContain('COUNT("contributions"."id") > ?');
+        expect(params).toEqual([10]);
+
+        const groupByIndex = sql.indexOf('GROUP BY');
+        const havingIndex = sql.indexOf('HAVING');
+        expect(havingIndex).toBeGreaterThan(groupByIndex);
+        });
+
+        it('should add HAVING clause with SUM (MySQL)', () => {
+        const query = new SelectQueryBuilder(Contributions)
+            .select({ project_id: Contributions.columns.project_id, hours: sum(Contributions.columns.hours) })
+            .groupBy(Contributions.columns.project_id)
+            .having(gt(sum(Contributions.columns.hours), 100));
+
+        const compiled = query.compile(mysql);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('GROUP BY');
+        expect(sql).toContain('HAVING');
+        expect(sql).toContain('SUM(`contributions`.`hours`) > ?');
+        expect(params).toEqual([100]);
+        });
+
+        it('should add HAVING clause with AVG (SQL Server)', () => {
+        const query = new SelectQueryBuilder(Orders)
+            .select({ user_id: Orders.columns.user_id, avg_total: avg(Orders.columns.total) })
+            .groupBy(Orders.columns.user_id)
+            .having(gt(avg(Orders.columns.total), 500));
+
+        const compiled = query.compile(sqlserver);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('GROUP BY');
+        expect(sql).toContain('HAVING');
+        expect(sql).toContain('AVG([orders].[total]) > @p1');
+        expect(params).toEqual([500]);
+        });
+    });
+
+    describe('Multiple HAVING conditions', () => {
+        it('should combine multiple HAVING calls with AND', () => {
+        const query = new SelectQueryBuilder(Contributions)
+            .select({ project_id: Contributions.columns.project_id, cnt: count(Contributions.columns.id) })
+            .groupBy(Contributions.columns.project_id)
+            .having(gt(count(Contributions.columns.id), 5))
+            .having(lt(sum(Contributions.columns.hours), 200));
+
+        const compiled = query.compile(sqlite);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('HAVING');
+        expect(sql).toContain('AND');
+        expect(sql).toContain('COUNT("contributions"."id") > ?');
+        expect(sql).toContain('SUM("contributions"."hours") < ?');
+        expect(params).toEqual([5, 200]);
+        });
+    });
+
+    describe('SQL clause ordering', () => {
+        it('should maintain correct clause order: WHERE > GROUP BY > HAVING > ORDER BY', () => {
+            const query = new SelectQueryBuilder(Orders)
+                .select({ status: Orders.columns.status, cnt: count(Orders.columns.id) })
+                .where(gt(Orders.columns.total, 0))
+                .groupBy(Orders.columns.status)
+                .having(gt(count(Orders.columns.id), 10))
+                .orderBy(Orders.columns.status, 'ASC');
+
+        const compiled = query.compile(sqlite);
+        const { sql, params } = compiled;
+
+        const whereIdx = sql.indexOf('WHERE');
+        const groupByIdx = sql.indexOf('GROUP BY');
+        const havingIdx = sql.indexOf('HAVING');
+        const orderByIdx = sql.indexOf('ORDER BY');
+
+        expect(whereIdx).toBeGreaterThan(-1);
+        expect(groupByIdx).toBeGreaterThan(whereIdx);
+        expect(havingIdx).toBeGreaterThan(groupByIdx);
+        expect(orderByIdx).toBeGreaterThan(havingIdx);
+        expect(params).toEqual([0, 10]);
+        });
+    });
+});