metal-orm 1.0.0

package/src/playground/features/playground/services/QueryExecutionService.ts

@@ -0,0 +1,120 @@
+import { performance } from 'node:perf_hooks';
+import { SelectQueryBuilder } from '../../../../builder/select';
+import { Users } from '../data/schema';
+import { SqliteDialect } from '../../../../dialect/sqlite';
+import { hydrateRows } from '../../../../runtime/hydration';
+import type { IDatabaseClient } from '../common/IDatabaseClient';
+import type { QueryExecutionResult } from '../api/types';
+import type { Scenario } from '../data/scenarios';
+
+/**
+ * Extracts the TypeScript code from a build function
+ */
+function extractTypeScriptCode(buildFn: (builder: SelectQueryBuilder<any>) => SelectQueryBuilder<any>): string {
+    const fnString = buildFn.toString();
+
+    // Remove the function wrapper and return statement
+    const bodyMatch = fnString.match(/=>\s*\{?\s*(.*?)\s*\}?$/s);
+    if (bodyMatch) {
+        let code = bodyMatch[1].trim();
+
+        // Remove trailing semicolon if present
+        code = code.replace(/;$/, '');
+
+        // Clean up indentation (remove common leading spaces)
+        const lines = code.split('\n');
+        if (lines.length > 1) {
+            // Find the minimum indentation of non-empty lines
+            const nonEmptyLines = lines.filter(line => line.trim().length > 0);
+            const minIndent = Math.min(...nonEmptyLines.map(line => {
+                const match = line.match(/^(\s*)/);
+                return match ? match[1].length : 0;
+            }));
+
+            // Remove the common indentation
+            code = lines.map(line => line.slice(minIndent)).join('\n').trim();
+        }
+
+        return code;
+    }
+
+    return fnString;
+}
+
+export class QueryExecutionService {
+  constructor(private dbClient: IDatabaseClient) { }
+
+  async executeScenario(scenario: Scenario): Promise<QueryExecutionResult> {
+    const startTime = performance.now();
+
+    try {
+      if (!this.dbClient.isReady) {
+        return {
+          sql: '',
+          params: [],
+          typescriptCode: scenario.typescriptCode || extractTypeScriptCode(scenario.build),
+          results: [],
+          error: 'Database not ready',
+          executionTime: 0
+        };
+      }
+
+      const queryBuilder = new SelectQueryBuilder(Users);
+      const builtQuery = scenario.build(queryBuilder);
+
+      const dialect = new SqliteDialect();
+      const compiled = builtQuery.compile(dialect);
+
+      const results = await this.dbClient.executeSql(compiled.sql, compiled.params);
+      const executionTime = performance.now() - startTime;
+
+      // Check if hydration is needed
+      const hydrationPlan = builtQuery.getHydrationPlan();
+      let hydratedResults: Record<string, any>[] | undefined;
+
+      if (hydrationPlan && results.length > 0) {
+        // Convert QueryResult[] to Record<string, any>[] for hydration
+        const rows: Record<string, any>[] = [];
+        const { columns, values } = results[0];
+
+        for (const row of values) {
+          const obj: Record<string, any> = {};
+          columns.forEach((col, idx) => {
+            obj[col] = row[idx];
+          });
+          rows.push(obj);
+        }
+
+        hydratedResults = hydrateRows(rows, hydrationPlan);
+      }
+
+      return {
+        sql: compiled.sql,
+        params: compiled.params,
+        typescriptCode: scenario.typescriptCode || extractTypeScriptCode(scenario.build),
+        results,
+        hydratedResults,
+        error: this.dbClient.error,
+        executionTime
+      };
+    } catch (error) {
+      const executionTime = performance.now() - startTime;
+      return {
+        sql: '',
+        params: [],
+        typescriptCode: scenario.typescriptCode || extractTypeScriptCode(scenario.build),
+        results: [],
+        error: error instanceof Error ? error.message : 'Unknown error',
+        executionTime
+      };
+    }
+  }
+
+  isDatabaseReady(): boolean {
+    return this.dbClient.isReady;
+  }
+
+  getLastError(): string | null {
+    return this.dbClient.error;
+  }
+}

package/src/runtime/als.ts

@@ -0,0 +1,19 @@
+// In a real Node environment: import { AsyncLocalStorage } from 'node:async_hooks';
+
+// Browser Shim
+export class AsyncLocalStorage<T> {
+  private store: T | undefined;
+
+  run<R>(store: T, callback: () => R): R {
+    this.store = store;
+    try {
+      return callback();
+    } finally {
+      this.store = undefined;
+    }
+  }
+
+  getStore(): T | undefined {
+    return this.store;
+  }
+}

package/src/runtime/hydration.ts

@@ -0,0 +1,43 @@
+import { HydrationPlan } from '../ast/query';
+
+const isRelationKey = (key: string) => key.includes('__');
+
+export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan): Record<string, any>[] => {
+  if (!plan || !rows.length) return rows;
+
+  const rootMap = new Map<any, any>();
+
+  rows.forEach(row => {
+    const rootId = row[plan.rootPrimaryKey];
+    if (rootId === undefined) return;
+
+    if (!rootMap.has(rootId)) {
+      const base: Record<string, any> = {};
+      const baseKeys = plan.rootColumns.length ? plan.rootColumns : Object.keys(row).filter(k => !isRelationKey(k));
+      baseKeys.forEach(key => { base[key] = row[key]; });
+      plan.relations.forEach(rel => { base[rel.name] = []; });
+      rootMap.set(rootId, base);
+    }
+
+    const parent = rootMap.get(rootId);
+
+    plan.relations.forEach(rel => {
+      const childPkKey = `${rel.aliasPrefix}__${rel.targetPrimaryKey}`;
+      const childPk = row[childPkKey];
+      if (childPk === null || childPk === undefined) return;
+
+      const bucket = parent[rel.name] as any[];
+      if (bucket.some(item => item[rel.targetPrimaryKey] === childPk)) return;
+
+      const child: Record<string, any> = {};
+      rel.columns.forEach(col => {
+        const key = `${rel.aliasPrefix}__${col}`;
+        child[col] = row[key];
+      });
+
+      bucket.push(child);
+    });
+  });
+
+  return Array.from(rootMap.values());
+};

package/src/schema/column.ts

@@ -0,0 +1,19 @@
+export type ColumnType = 'INT' | 'VARCHAR' | 'JSON' | 'ENUM' | 'BOOLEAN';
+
+export interface ColumnDef {
+  name: string; // filled at runtime by defineTable
+  type: ColumnType;
+  primary?: boolean;
+  notNull?: boolean;
+  args?: any[]; // for varchar length etc
+  table?: string; // Filled at runtime by defineTable
+}
+
+// Column Factory
+export const col = {
+  int: (): ColumnDef => ({ name: '', type: 'INT' }),
+  varchar: (length: number): ColumnDef => ({ name: '', type: 'VARCHAR', args: [length] }),
+  json: (): ColumnDef => ({ name: '', type: 'JSON' }),
+  boolean: (): ColumnDef => ({ name: '', type: 'BOOLEAN' }),
+  primaryKey: (def: ColumnDef): ColumnDef => ({ ...def, primary: true })
+};

package/src/schema/relation.ts

@@ -0,0 +1,38 @@
+import { TableDef } from './table';
+
+export const RelationKinds = {
+    HasMany: 'HAS_MANY',
+    BelongsTo: 'BELONGS_TO',
+} as const;
+
+export type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
+
+interface BaseRelation {
+    target: TableDef;
+    foreignKey: string; // The column on the child table
+    localKey?: string;  // Usually 'id'
+}
+
+export interface HasManyRelation extends BaseRelation {
+    type: typeof RelationKinds.HasMany;
+}
+
+export interface BelongsToRelation extends BaseRelation {
+    type: typeof RelationKinds.BelongsTo;
+}
+
+export type RelationDef = HasManyRelation | BelongsToRelation;
+
+export const hasMany = (target: TableDef, foreignKey: string, localKey: string = 'id'): HasManyRelation => ({
+    type: RelationKinds.HasMany,
+    target,
+    foreignKey,
+    localKey,
+});
+
+export const belongsTo = (target: TableDef, foreignKey: string, localKey: string = 'id'): BelongsToRelation => ({
+    type: RelationKinds.BelongsTo,
+    target,
+    foreignKey,
+    localKey,
+});

package/src/schema/table.ts

@@ -0,0 +1,22 @@
+import { ColumnDef } from './column';
+import { RelationDef } from './relation';
+
+export interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
+  name: string;
+  columns: T;
+  relations: Record<string, RelationDef>;
+}
+
+export const defineTable = <T extends Record<string, ColumnDef>>(
+    name: string, 
+    columns: T,
+    relations: Record<string, RelationDef> = {}
+): TableDef<T> => {
+  // Runtime mutability to assign names to column definitions for convenience
+  const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
+    (acc as any)[key] = { ...def, name: key, table: name };
+    return acc;
+  }, {} as T);
+  
+  return { name, columns: colsWithNames, relations };
+};

package/tests/between.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { between, notBetween, eq } from '../src/ast/expression';
+import { Users, Orders } from '../src/playground/features/playground/data/schema';
+import { SqliteDialect } from '../src/dialect/sqlite';
+import { SelectQueryBuilder } from '../src/builder/select';
+
+describe('between', () => {
+    const dialect = new SqliteDialect();
+
+    it('should handle a basic BETWEEN condition', () => {
+        const q = new SelectQueryBuilder(Users)
+            .selectRaw('*')
+            .where(between(Users.columns.id, 1, 10));
+        const compiled = q.compile(dialect);
+        expect(compiled.sql).toBe(
+            'SELECT "users"."*" FROM "users" WHERE "users"."id" BETWEEN ? AND ?;'
+        );
+        expect(compiled.params).toEqual([1, 10]);
+    });
+
+    it('should handle a NOT BETWEEN condition', () => {
+        const q = new SelectQueryBuilder(Users)
+            .selectRaw('*')
+            .where(notBetween(Users.columns.id, 1, 10));
+        const compiled = q.compile(dialect);
+        expect(compiled.sql).toBe(
+            'SELECT "users"."*" FROM "users" WHERE "users"."id" NOT BETWEEN ? AND ?;'
+        );
+        expect(compiled.params).toEqual([1, 10]);
+    });
+
+    it('should handle multiple conditions', () => {
+        const q = new SelectQueryBuilder(Orders)
+            .selectRaw('*')
+            .where(between(Orders.columns.total, 100, 200))
+            .where(eq(Orders.columns.user_id, 1));
+        const compiled = q.compile(dialect);
+        expect(compiled.sql).toBe(
+            'SELECT "orders"."*" FROM "orders" WHERE "orders"."total" BETWEEN ? AND ? AND "orders"."user_id" = ?;'
+        );
+        expect(compiled.params).toEqual([100, 200, 1]);
+    });
+});

package/tests/case-expression.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { Users } from '../src/playground/features/playground/data/schema';
+import { caseWhen, gt, eq } from '../src/ast/expression';
+import { SqliteDialect } from '../src/dialect/sqlite';
+import { SelectQueryBuilder } from '../src/builder/select';
+
+describe('CASE Expressions', () => {
+    const dialect = new SqliteDialect();
+
+    it('should compile simple CASE WHEN ... THEN ... ELSE ... END', () => {
+        const query = new SelectQueryBuilder(Users)
+            .select({
+                status: caseWhen([
+                    { when: gt(Users.columns.id, 10), then: 'High' },
+                    { when: gt(Users.columns.id, 5), then: 'Medium' }
+                ], 'Low')
+            });
+
+        const compiled = query.compile(dialect);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('CASE WHEN "users"."id" > ? THEN ? WHEN "users"."id" > ? THEN ? ELSE ? END');
+        expect(params).toEqual([10, 'High', 5, 'Medium', 'Low']);
+    });
+
+    it('should compile CASE without ELSE', () => {
+        const query = new SelectQueryBuilder(Users)
+            .select({
+                status: caseWhen([
+                    { when: eq(Users.columns.name, 'Alice'), then: 'Admin' }
+                ])
+            });
+
+        const compiled = query.compile(dialect);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('CASE WHEN "users"."name" = ? THEN ? END');
+        expect(params).toEqual(['Alice', 'Admin']);
+    });
+
+    it('should work in WHERE clause', () => {
+        const query = new SelectQueryBuilder(Users)
+            .where(
+                eq(
+                    caseWhen([
+                        { when: gt(Users.columns.id, 10), then: 'High' }
+                    ], 'Low'),
+                    'High'
+                )
+            );
+
+        const compiled = query.compile(dialect);
+        const { sql, params } = compiled;
+
+        expect(sql).toContain('WHERE CASE WHEN "users"."id" > ? THEN ? ELSE ? END = ?');
+        expect(params).toEqual([10, 'High', 'Low', 'High']);
+    });
+});

package/tests/complex-exists.test.ts

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