metal-orm 1.0.4 → 1.0.6

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]);
+        });
+      }
+    });
+  });
+});
+

package/tests/orm-runtime.test.ts

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