metal-orm 1.0.8 → 1.0.10

package/tests/like.test.ts

@@ -1,33 +0,0 @@
-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/orm-runtime.test.ts

@@ -1,254 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { SqliteDialect } from '../src/dialect/sqlite';
-import { SelectQueryBuilder } from '../src/builder/select';
-import { OrmContext, DbExecutor, QueryResult } from '../src/runtime/orm-context';
-import { createEntityFromRow } from '../src/runtime/entity';
-import { Users, Orders } from '../src/playground/features/playground/data/schema';
-import { defineTable } from '../src/schema/table';
-import { col } from '../src/schema/column';
-import { hasMany, belongsTo, belongsToMany } from '../src/schema/relation';
-
-const createMockExecutor = (responses: QueryResult[][]): {
-  executor: DbExecutor;
-  executed: Array<{ sql: string; params?: unknown[] }>;
-} => {
-  const executed: Array<{ sql: string; params?: unknown[] }> = [];
-  let callIndex = 0;
-  const executor: DbExecutor = {
-    async executeSql(sql, params) {
-      executed.push({ sql, params });
-      const result = responses[callIndex] ?? [];
-      callIndex += 1;
-      return result;
-    }
-  };
-
-  return { executor, executed };
-};
-
-const TestOrders = defineTable('test_orders', {
-  id: col.primaryKey(col.int()),
-  user_id: col.int(),
-  total: col.int(),
-  status: col.varchar(50)
-});
-
-const TestProjects = defineTable('test_projects', {
-  id: col.primaryKey(col.int()),
-  name: col.varchar(255),
-  client: col.varchar(255)
-});
-
-const TestUserProjects = defineTable('test_user_projects', {
-  id: col.primaryKey(col.int()),
-  user_id: col.int(),
-  project_id: col.int()
-});
-
-const TestUsers = defineTable('test_users', {
-  id: col.primaryKey(col.int()),
-  name: col.varchar(255)
-});
-
-TestUsers.relations = {
-  orders: hasMany(TestOrders, 'user_id', undefined, 'remove'),
-  projects: belongsToMany(TestProjects, TestUserProjects, {
-    pivotForeignKeyToRoot: 'user_id',
-    pivotForeignKeyToTarget: 'project_id',
-    cascade: 'link'
-  })
-};
-
-TestOrders.relations = {
-  user: belongsTo(TestUsers, 'user_id')
-};
-
-TestProjects.relations = {};
-TestUserProjects.relations = {};
-
-describe('OrmContext entity graphs', () => {
-  it('lazy loads has-many relations in batches', async () => {
-    const responses: QueryResult[][] = [
-      [
-        {
-          columns: ['id', 'name'],
-          values: [[1, 'Alice']]
-        }
-      ],
-      [
-        {
-          columns: ['id', 'user_id', 'total', 'status'],
-          values: [
-            [10, 1, 100, 'open'],
-            [11, 1, 200, 'shipped']
-          ]
-        }
-      ]
-    ];
-    const { executor, executed } = createMockExecutor(responses);
-    const ctx = new OrmContext({ dialect: new SqliteDialect(), executor });
-
-    const builder = new SelectQueryBuilder(Users)
-      .select({
-        id: Users.columns.id,
-        name: Users.columns.name
-      })
-      .includeLazy('orders');
-
-    const [user] = await builder.execute(ctx);
-    expect(user).toBeDefined();
-    expect(executed).toHaveLength(1);
-
-    const orders = await user.orders.load();
-    expect(orders).toHaveLength(2);
-    expect(orders.map(order => order.total)).toEqual([100, 200]);
-    expect(executed[1].sql).toContain('"orders"');
-  });
-
-  it('preloads eager hydration data for has-many relations without extra queries', async () => {
-    const { executor, executed } = createMockExecutor([]);
-    const ctx = new OrmContext({ dialect: new SqliteDialect(), executor });
-
-    const row = {
-      id: 1,
-      name: 'Alice',
-      role: 'admin',
-      settings: '{}',
-      deleted_at: null,
-      orders: [
-        { id: 10, user_id: 1, total: 120, status: 'open' },
-        { id: 11, user_id: 1, total: 230, status: 'completed' }
-      ]
-    };
-
-    const user = createEntityFromRow(ctx, Users, row);
-    expect(user.orders.getItems()).toHaveLength(2);
-
-    const orders = await user.orders.load();
-    expect(orders).toHaveLength(2);
-    expect(orders.map(order => order.total)).toEqual([120, 230]);
-    expect(executed).toHaveLength(0);
-  });
-
-  it('reuses eagerly hydrated belongs-to data and lazily loads belongs-to-many', async () => {
-    const rootRow: QueryResult = {
-      columns: [
-        'id',
-        'user_id',
-        'total',
-        'status',
-        'user__id',
-        'user__name',
-        'user__role',
-        'user__settings',
-        'user__deleted_at'
-      ],
-      values: [[42, 1, 15, 'pending', 1, 'Alice', 'admin', '{}', null]]
-    };
-
-    const responses: QueryResult[][] = [
-      [rootRow],
-      [
-        {
-          columns: ['id', 'project_id', 'user_id', 'role_id', 'assigned_at'],
-          values: [[1, 10, 1, 3, '2025-12-03']]
-        }
-      ],
-      [
-        {
-          columns: ['id', 'name', 'client'],
-          values: [[10, 'Apollo', 'Acme Corp']]
-        }
-      ]
-    ];
-
-    const { executor, executed } = createMockExecutor(responses);
-    const ctx = new OrmContext({ dialect: new SqliteDialect(), executor });
-
-    const builder = new SelectQueryBuilder(Orders)
-      .select({
-        id: Orders.columns.id,
-        user_id: Orders.columns.user_id,
-        total: Orders.columns.total,
-        status: Orders.columns.status
-      })
-      .include('user');
-
-    const [order] = await builder.execute(ctx);
-    expect(order).toBeDefined();
-    expect(executed).toHaveLength(1);
-
-    const user = await order.user.load();
-    expect(user).toBeDefined();
-    expect(user?.name).toBe('Alice');
-    expect(executed).toHaveLength(1);
-
-    const projects = await user!.projects.load();
-    expect(executed).toHaveLength(3);
-    expect(projects).toHaveLength(1);
-    expect(projects[0].name).toBe('Apollo');
-    expect((projects[0] as any)._pivot).toMatchObject({
-      project_id: 10,
-      user_id: 1,
-      id: 1
-    });
-    expect(executed[1].sql).toContain('"project_assignments"');
-    expect(executed[2].sql).toContain('"projects"');
-  });
-
-  it('flushes relation mutations through saveChanges with cascading SQL', async () => {
-    const responses: QueryResult[][] = [
-      [
-        {
-          columns: ['id', 'name'],
-          values: [[1, 'Manager']]
-        }
-      ],
-      [
-        {
-          columns: ['id', 'user_id', 'total', 'status'],
-          values: [[10, 1, 180, 'open']]
-        }
-      ],
-      [
-        {
-          columns: ['id', 'project_id', 'user_id'],
-          values: [[1, 100, 1]]
-        }
-      ],
-      [
-        {
-          columns: ['id', 'name', 'client'],
-          values: [[100, 'Apollo', 'Acme Corp']]
-        }
-      ]
-    ];
-
-    const { executor, executed } = createMockExecutor(responses);
-    const ctx = new OrmContext({ dialect: new SqliteDialect(), executor });
-
-    const [user] = await new SelectQueryBuilder(TestUsers)
-      .select({
-        id: TestUsers.columns.id,
-        name: TestUsers.columns.name
-      })
-      .execute(ctx);
-
-    const orders = await user.orders.load();
-    expect(orders).toHaveLength(1);
-
-    const removedOrder = orders[0];
-    user.orders.remove(removedOrder);
-    user.orders.add({ total: 999, status: 'pending' });
-
-    await user.projects.syncByIds([200]);
-
-    await ctx.saveChanges();
-
-    const payload = executed.slice(-4);
-    expect(payload[0].sql).toContain('INSERT INTO "test_orders"');
-    expect(payload[1].sql).toContain('INSERT INTO "test_user_projects"');
-    expect(payload[2].sql).toContain('DELETE FROM "test_user_projects"');
-    expect(payload[3].sql).toContain('DELETE FROM "test_orders"');
-  });
-});

package/tests/postgres.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SelectQueryBuilder } from '../src/builder/select';
-import { PostgresDialect } from '../src/dialect/postgres';
-import { Users } from '../src/playground/features/playground/data/schema';
-import { jsonPath, eq } from '../src/ast/expression';
-
-describe('PostgresDialect', () => {
-  it('should compile a simple select', () => {
-    const query = new SelectQueryBuilder(Users).selectRaw('*');
-    const dialect = new PostgresDialect();
-    const compiled = query.compile(dialect);
-    expect(compiled.sql).toBe('SELECT "users"."*" FROM "users";');
-  });
-
-  it('should compile a select with a where clause', () => {
-    const query = new SelectQueryBuilder(Users).selectRaw('*').where(eq(Users.columns.id, 1));
-    const dialect = new PostgresDialect();
-    const compiled = query.compile(dialect);
-    expect(compiled.sql).toBe('SELECT "users"."*" FROM "users" WHERE "users"."id" = ?;');
-    expect(compiled.params).toEqual([1]);
-  });
-
-  it('should compile a select with a json path', () => {
-    const query = new SelectQueryBuilder(Users).selectRaw('*').where(eq(jsonPath(Users.columns.settings, '$.first'), 'John'));
-    const dialect = new PostgresDialect();
-    const compiled = query.compile(dialect);
-    expect(compiled.sql).toBe('SELECT "users"."*" FROM "users" WHERE "users"."settings"->>\'$.first\' = ?;');
-    expect(compiled.params).toEqual(['John']);
-  });
-});

package/tests/right-join.test.ts

@@ -1,89 +0,0 @@
-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

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