metal-orm 1.0.8 → 1.0.10

package/src/builder/operations/filter-manager.ts

@@ -1,68 +0,0 @@
-import { ColumnDef } from '../../schema/column';
-import { ColumnNode, ExpressionNode } from '../../ast/expression';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps';
-import { OrderDirection } from '../../constants/sql';
-
-/**
- * Manages filtering, ordering, and grouping operations for queries
- */
-export class FilterManager {
-  /**
-   * Creates a new FilterManager instance
-   * @param env - Query builder environment
-   */
-  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
-
-  /**
-   * Adds a WHERE clause to the query
-   * @param context - Current query context
-   * @param expr - Expression for the WHERE clause
-   * @returns Updated query context with WHERE clause
-   */
-  where(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withWhere(expr);
-    return { state: nextState, hydration: context.hydration };
-  }
-
-  /**
-   * Adds a GROUP BY clause to the query
-   * @param context - Current query context
-   * @param column - Column to group by
-   * @returns Updated query context with GROUP BY clause
-   */
-  groupBy(context: SelectQueryBuilderContext, column: ColumnDef | ColumnNode): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withGroupBy(column);
-    return { state: nextState, hydration: context.hydration };
-  }
-
-  /**
-   * Adds a HAVING clause to the query
-   * @param context - Current query context
-   * @param expr - Expression for the HAVING clause
-   * @returns Updated query context with HAVING clause
-   */
-  having(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withHaving(expr);
-    return { state: nextState, hydration: context.hydration };
-  }
-
-  /**
-   * Adds an ORDER BY clause to the query
-   * @param context - Current query context
-   * @param column - Column to order by
-   * @param direction - Order direction (ASC/DESC)
-   * @returns Updated query context with ORDER BY clause
-   */
-  orderBy(
-    context: SelectQueryBuilderContext,
-    column: ColumnDef | ColumnNode,
-    direction: OrderDirection
-  ): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withOrderBy(column, direction);
-    return { state: nextState, hydration: context.hydration };
-  }
-}

package/src/builder/operations/join-manager.ts

@@ -1,36 +0,0 @@
-import { BinaryExpressionNode } from '../../ast/expression';
-import { TableDef } from '../../schema/table';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps';
-import { JoinKind } from '../../constants/sql';
-import { createJoinNode } from '../../utils/join-node';
-
-/**
- * Manages JOIN operations for query building
- */
-export class JoinManager {
-  /**
-   * Creates a new JoinManager instance
-   * @param env - Query builder environment
-   */
-  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
-
-  /**
-   * Adds a JOIN clause to the query
-   * @param context - Current query context
-   * @param table - Table to join
-   * @param condition - Join condition expression
-   * @param kind - Type of join (INNER, LEFT, RIGHT, etc.)
-   * @returns Updated query context with JOIN clause
-   */
-  join(
-    context: SelectQueryBuilderContext,
-    table: TableDef,
-    condition: BinaryExpressionNode,
-    kind: JoinKind
-  ): SelectQueryBuilderContext {
-    const joinNode = createJoinNode(kind, table.name, condition);
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withJoin(joinNode);
-    return { state: nextState, hydration: context.hydration };
-  }
-}

package/src/builder/operations/pagination-manager.ts

@@ -1,36 +0,0 @@
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps';
-
-/**
- * Manages pagination operations (LIMIT and OFFSET) for queries
- */
-export class PaginationManager {
-  /**
-   * Creates a new PaginationManager instance
-   * @param env - Query builder environment
-   */
-  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
-
-  /**
-   * Adds a LIMIT clause to the query
-   * @param context - Current query context
-   * @param value - Maximum number of rows to return
-   * @returns Updated query context with LIMIT clause
-   */
-  limit(context: SelectQueryBuilderContext, value: number): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withLimit(value);
-    return { state: nextState, hydration: context.hydration };
-  }
-
-  /**
-   * Adds an OFFSET clause to the query
-   * @param context - Current query context
-   * @param value - Number of rows to skip
-   * @returns Updated query context with OFFSET clause
-   */
-  offset(context: SelectQueryBuilderContext, value: number): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withOffset(value);
-    return { state: nextState, hydration: context.hydration };
-  }
-}

package/src/playground/features/playground/api/types.ts

@@ -1,16 +0,0 @@
-import type { QueryResult } from '../common/IDatabaseClient';
-
-export interface QueryExecutionResult {
-  sql: string;
-  params: unknown[];
-  typescriptCode: string;
-  results: QueryResult[];
-  hydratedResults?: Record<string, any>[];
-  error: string | null;
-  executionTime: number;
-}
-
-export interface ApiStatusResponse {
-  ready: boolean;
-  error: string | null;
-}

package/src/playground/features/playground/clients/MockClient.ts

@@ -1,17 +0,0 @@
-import { IDatabaseClient, QueryResult } from "../common/IDatabaseClient";
-import { DialectName } from "../../../../constants/sql";
-
-export type SupportedDialect = DialectName;
-
-export class MockClient implements IDatabaseClient {
-    isReady: boolean = true;
-    error: string | null = null;
-
-    constructor(dialect: SupportedDialect) {
-        this.error = `${dialect} is not supported yet.`;
-    }
-
-    public async executeSql(sql: string, _params: unknown[] = []): Promise<QueryResult[]> {
-        return [];
-    }
-}

package/src/playground/features/playground/clients/SqliteClient.ts

@@ -1,57 +0,0 @@
-import { IDatabaseClient, QueryResult } from "../common/IDatabaseClient";
-import { SEED_SQL } from "../data/seed";
-import sqlite3 from 'sqlite3';
-
-export class SqliteClient implements IDatabaseClient {
-    isReady: boolean = false;
-    error: string | null = null;
-    private db: sqlite3.Database | null = null;
-
-    constructor() {
-        this.initDB();
-    }
-
-    private async initDB() {
-        try {
-            this.db = new sqlite3.Database(':memory:');
-            await new Promise<void>((resolve, reject) => {
-                this.db!.exec(SEED_SQL, (err) => {
-                    if (err) reject(err);
-                    else resolve();
-                });
-            });
-            this.isReady = true;
-        } catch (e) {
-            console.error("Failed to load DB", e);
-            this.error = "Failed to initialize SQLite database.";
-        }
-    }
-
-    public async executeSql(sql: string, params: unknown[] = []): Promise<QueryResult[]> {
-        if (!this.db) {
-            this.error = "Database not ready.";
-            return [];
-        }
-
-        return new Promise((resolve, reject) => {
-            this.db!.all(sql, params, (err, rows) => {
-                if (err) {
-                    this.error = err.message;
-                    resolve([]);
-                } else {
-                    this.error = null;
-                    if (rows.length === 0) {
-                        resolve([]);
-                    } else {
-                        const columns = Object.keys(rows[0]);
-                        const values = rows.map(row => columns.map(col => row[col]));
-                        resolve([{
-                            columns,
-                            values,
-                        }]);
-                    }
-                }
-            });
-        });
-    }
-}

package/src/playground/features/playground/common/IDatabaseClient.ts

@@ -1,10 +0,0 @@
-export type QueryResult = {
-  columns: string[];
-  values: any[][];
-};
-
-export interface IDatabaseClient {
-  isReady: boolean;
-  error: string | null;
-  executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
-}

package/src/playground/features/playground/data/scenarios/aggregation.ts

@@ -1,36 +0,0 @@
-import { eq, count, sum } from '../../../../../ast/expression';
-import { createLiteral } from '../../../../../builder/select';
-import { Users, Orders } from '../schema';
-import { Scenario } from './types';
-
-export const AGGREGATION_SCENARIOS = [
-    {
-        id: 'analytics',
-        category: 'Aggregation',
-        title: 'Sales Analytics',
-        description: 'Aggregating sales data using GROUP BY and sorting with ORDER BY DESC.',
-        build: (qb) => qb
-            .select({
-                user: Users.columns.name,
-                orderCount: count(Orders.columns.id)
-            })
-            .joinRelation('orders')
-            .groupBy(Users.columns.name)
-            .orderBy(Users.columns.name, 'DESC')
-    },
-    {
-        id: 'revenue_by_role',
-        category: 'Aggregation',
-        title: 'Revenue by Role',
-        description: 'Summing completed order totals and grouping the result by user role.',
-        build: (qb) => qb
-            .select({
-                role: Users.columns.role,
-                revenue: sum(Orders.columns.total)
-            })
-            .joinRelation('orders')
-            .where(eq(Orders.columns.status, createLiteral('completed')))
-            .groupBy(Users.columns.role)
-            .orderBy(Users.columns.role, 'ASC')
-    }
-];

package/src/playground/features/playground/data/scenarios/basics.ts

@@ -1,25 +0,0 @@
-import { Users } from '../schema';
-import { createScenario } from './types';
-
-export const BASIC_SCENARIOS = [
-    createScenario({
-        id: 'basic',
-        category: 'Basics',
-        title: 'Hello World',
-        description: 'A basic projection query fetching specific columns from the Users table.',
-        build: (qb) => qb.select({ id: Users.columns.id, name: Users.columns.name }).limit(5)
-    }),
-    createScenario({
-        id: 'aliased_projection',
-        category: 'Basics',
-        title: 'Aliased Projection',
-        description: 'Expose friendly aliases when projecting columns for DTOs.',
-        build: (qb) => qb
-            .select({
-                userId: Users.columns.id,
-                userName: Users.columns.name,
-                userRole: Users.columns.role
-            })
-            .limit(4)
-    })
-];

package/src/playground/features/playground/data/scenarios/edge_cases.ts

@@ -1,57 +0,0 @@
-import { eq, and, or, inList, jsonPath, isNull } from '../../../../../ast/expression';
-import { createLiteral } from '../../../../../builder/select';
-import { Users } from '../schema';
-import { Scenario } from './types';
-
-export const EDGE_CASE_SCENARIOS = [
-    {
-        id: 'empty_in_list',
-        category: 'Edge Cases',
-        title: 'Empty IN List',
-        description: 'Filtering with an empty list in IN clause. Should return no results or handle gracefully.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name })
-            .where(inList(Users.columns.id, []))
-    },
-    {
-        id: 'deep_nested_logic',
-        category: 'Edge Cases',
-        title: 'Deeply Nested Logic',
-        description: 'Complex nested AND/OR logic to test parser/compiler robustness.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name })
-            .where(
-                or(
-                    and(
-                        eq(Users.columns.role, 'admin'),
-                        or(
-                            eq(Users.columns.name, 'Alice'),
-                            eq(Users.columns.name, 'Bob')
-                        )
-                    ),
-                    and(
-                        eq(Users.columns.role, 'user'),
-                        isNull(Users.columns.deleted_at)
-                    )
-                )
-            )
-    },
-    {
-        id: 'json_path_missing',
-        category: 'Edge Cases',
-        title: 'Non-existent JSON Path',
-        description: 'Querying a JSON path that likely does not exist.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name })
-            .where(eq(jsonPath(Users.columns.settings, '$.non_existent_key'), createLiteral('some_value')))
-    },
-    {
-        id: 'zero_limit',
-        category: 'Edge Cases',
-        title: 'Zero Limit',
-        description: 'Limit 0 should return empty result set.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name })
-            .limit(0)
-    }
-];

package/src/playground/features/playground/data/scenarios/filtering.ts

@@ -1,94 +0,0 @@
-import { eq, and, or, gt, like, jsonPath, isNull, isNotNull, inList } from '../../../../../ast/expression';
-import { createLiteral } from '../../../../../builder/select';
-import { Users, Orders } from '../schema';
-import { createScenario } from './types';
-
-export const FILTERING_SCENARIOS = [
-    createScenario({
-        id: 'filter_basic',
-        category: 'Filtering',
-        title: 'Active Admins',
-        description: 'Filtering records using a WHERE clause with type-safe operators.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, role: Users.columns.role })
-            .where(eq(Users.columns.role, createLiteral('admin')))
-    }),
-    createScenario({
-        id: 'search',
-        category: 'Filtering',
-        title: 'Text Search (LIKE)',
-        description: 'Using pattern matching to find users starting with "Alice".',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, role: Users.columns.role })
-            .where(like(Users.columns.name, 'Alice%'))
-    }),
-    createScenario({
-        id: 'json_filter',
-        category: 'Filtering',
-        title: 'JSON Extract',
-        description: 'Extracting values from JSON columns using dialect-specific syntax.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, settings: Users.columns.settings })
-            .where(eq(jsonPath(Users.columns.settings, '$.theme'), createLiteral('dark')))
-    }),
-    createScenario({
-        id: 'advanced_filter',
-        category: 'Filtering',
-        title: 'Nulls & Lists',
-        description: 'Advanced filtering using IN(...) clause and IS NULL checks.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, role: Users.columns.role })
-            .where(
-                and(
-                    inList(Users.columns.role, ['admin', 'manager']),
-                    isNull(Users.columns.deleted_at)
-                )
-            )
-    }),
-    createScenario({
-        id: 'complex_filter',
-        category: 'Filtering',
-        title: 'Logical Groups',
-        description: 'Using Nested AND/OR to filter for Admins OR users with specific ID.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, role: Users.columns.role })
-            .where(
-                or(
-                    eq(Users.columns.role, createLiteral('admin')),
-                    and(
-                        eq(Users.columns.role, createLiteral('user')),
-                        eq(Users.columns.id, createLiteral(2))
-                    )
-                )
-            )
-    }),
-    createScenario({
-        id: 'soft_deleted_users',
-        category: 'Filtering',
-        title: 'Soft Deleted Users',
-        description: 'Reveal users that were soft-deleted via a non-null deleted_at.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, deletedAt: Users.columns.deleted_at })
-            .where(isNotNull(Users.columns.deleted_at))
-    }),
-    createScenario({
-        id: 'high_value_admins',
-        category: 'Filtering',
-        title: 'High Value Admins',
-        description: 'Filter admins with completed orders exceeding 200 via a joined WHERE clause.',
-        build: (qb) => qb
-            .select({
-                name: Users.columns.name,
-                role: Users.columns.role,
-                total: Orders.columns.total
-            })
-            .joinRelation('orders')
-            .where(
-                and(
-                    eq(Users.columns.role, createLiteral('admin')),
-                    gt(Orders.columns.total, createLiteral(200)),
-                    eq(Orders.columns.status, createLiteral('completed'))
-                )
-            )
-    })
-];

package/src/playground/features/playground/data/scenarios/hydration.ts

@@ -1,27 +0,0 @@
-import { eq } from '../../../../../ast/expression';
-import { Users } from '../schema';
-import { createScenario } from './types';
-
-export const HYDRATION_SCENARIOS = [
-    createScenario({
-        id: 'user_with_orders',
-        category: 'Hydration',
-        title: 'Nested User Graph',
-        description: 'Eager-load orders for a single user and hydrate a JSON graph from flat SQL rows.',
-        build: (qb) => qb
-            .include('orders', { columns: ['id', 'total', 'status', 'user_id'] })
-            .where(eq(Users.columns.id, 1))
-    }),
-    createScenario({
-        id: 'user_projects_with_pivot',
-        category: 'Hydration',
-        title: 'Projects with Pivot Data',
-        description: 'Include projects for a user along with pivot metadata stored in `_pivot`.',
-        build: (qb) => qb
-            .include('projects', {
-                columns: ['id', 'name', 'client'],
-                pivot: { columns: ['assigned_at', 'role_id'] }
-            })
-            .where(eq(Users.columns.id, 1))
-    })
-];

package/src/playground/features/playground/data/scenarios/index.ts

@@ -1,29 +0,0 @@
-import type { Scenario } from './types';
-import { BASIC_SCENARIOS } from './basics';
-import { FILTERING_SCENARIOS } from './filtering';
-import { RELATIONSHIP_SCENARIOS } from './relationships';
-import { AGGREGATION_SCENARIOS } from './aggregation';
-import { PAGINATION_SCENARIOS } from './pagination';
-import { ORDERING_SCENARIOS } from './ordering';
-import { HYDRATION_SCENARIOS } from './hydration';
-import { EDGE_CASE_SCENARIOS } from './edge_cases';
-
-export * from './types';
-export { BASIC_SCENARIOS };
-export { FILTERING_SCENARIOS };
-export { RELATIONSHIP_SCENARIOS };
-export { AGGREGATION_SCENARIOS };
-export { PAGINATION_SCENARIOS };
-export { ORDERING_SCENARIOS };
-export { HYDRATION_SCENARIOS };
-
-export const SCENARIOS: Scenario[] = [
-    ...BASIC_SCENARIOS,
-    ...FILTERING_SCENARIOS,
-    ...RELATIONSHIP_SCENARIOS,
-    ...AGGREGATION_SCENARIOS,
-    ...ORDERING_SCENARIOS,
-    ...PAGINATION_SCENARIOS,
-    ...HYDRATION_SCENARIOS,
-    ...EDGE_CASE_SCENARIOS
-];

package/src/playground/features/playground/data/scenarios/ordering.ts

@@ -1,25 +0,0 @@
-
-import { eq } from '../../../../../ast/expression';
-import { createLiteral } from '../../../../../builder/select';
-import { Users, Orders } from '../schema';
-import { Scenario } from './types';
-
-export const ORDERING_SCENARIOS: Scenario[] = [
-    {
-        id: 'order_recent_completed',
-        category: 'Ordering',
-        title: 'Order by Completed Total',
-        description: 'Sort completed orders first by total (DESC) then by user name (ASC).',
-        build: (qb) => qb
-            .select({
-                user: Users.columns.name,
-                status: Orders.columns.status,
-                total: Orders.columns.total
-            })
-            .joinRelation('orders')
-            .where(eq(Orders.columns.status, createLiteral('completed')))
-            .orderBy(Orders.columns.total, 'DESC')
-            .orderBy(Users.columns.name, 'ASC')
-            .limit(5)
-    }
-];

package/src/playground/features/playground/data/scenarios/pagination.ts

@@ -1,16 +0,0 @@
-import { Users } from '../schema';
-import { Scenario } from './types';
-
-export const PAGINATION_SCENARIOS: Scenario[] = [
-    {
-        id: 'pagination',
-        category: 'Pagination',
-        title: 'Basic Pagination',
-        description: 'Implement basic pagination with LIMIT and OFFSET.',
-        build: (qb) => qb
-            .select({ name: Users.columns.name, role: Users.columns.role })
-            .orderBy(Users.columns.name, 'ASC')
-            .limit(2)
-            .offset(1)
-    }
-];

package/src/playground/features/playground/data/scenarios/relationships.ts

@@ -1,75 +0,0 @@
-import { eq, gt, like, inList } from '../../../../../ast/expression';
-import { Users, Orders, Profiles, Roles, UserRoles } from '../schema';
-import { Scenario } from './types';
-
-export const RELATIONSHIP_SCENARIOS: Scenario[] = [
-    {
-        id: 'smart_join',
-        category: 'Relationships',
-        title: 'Smart Join (1:N)',
-        description: 'Using defined schema relationships to join tables automatically without manual ON clauses.',
-        build: (qb) => qb
-            .select({ user: Users.columns.name, total: Orders.columns.total })
-            .joinRelation('orders')
-            .where(gt(Orders.columns.total, 100))
-    },
-    {
-        id: 'join',
-        category: 'Relationships',
-        title: 'Manual Join',
-        description: 'Performing a manual INNER JOIN with explicit conditions.',
-        build: (qb) => qb
-            .select({ user: Users.columns.name, amount: Orders.columns.total, status: Orders.columns.status })
-            .innerJoin(Orders, eq(Users.columns.id, Orders.columns.user_id))
-            .where(eq(Orders.columns.status, 'completed'))
-    },
-    {
-        id: 'profile_inspection',
-        category: 'Relationships',
-        title: 'Profile Inspection (1:1)',
-        description: 'Join every user with their profile and filter by bio keywords.',
-        build: (qb) => qb
-            .select({
-                user: Users.columns.name,
-                bio: Profiles.columns.bio,
-                twitter: Profiles.columns.twitter
-            })
-            .joinRelation('profiles')
-            .where(like(Profiles.columns.bio, '%Engineer%'))
-    },
-    {
-        id: 'role_filter',
-        category: 'Relationships',
-        title: 'Role-Based Filter (N:N)',
-        description: 'Traverse the pivot table to surface admins and managers.',
-        build: (qb) => qb
-            .select({
-                user: Users.columns.name,
-                role: Roles.columns.name
-            })
-            .innerJoin(UserRoles, eq(UserRoles.columns.user_id, Users.columns.id))
-            .innerJoin(Roles, eq(Roles.columns.id, UserRoles.columns.role_id))
-            .where(inList(Roles.columns.name, ['admin', 'manager']))
-            .orderBy(Users.columns.name, 'ASC')
-    },
-    {
-        id: 'contain_orders',
-        category: 'Relationships',
-        title: 'Contain Orders (LEFT JOIN + filter)',
-        description: 'Fetch users and hydrate only completed orders without dropping users that have none.',
-        build: (qb) => qb
-            .include('orders', { columns: ['id', 'total', 'status', 'user_id'], filter: eq(Orders.columns.status, 'completed') })
-            .select({ id: Users.columns.id, name: Users.columns.name, role: Users.columns.role })
-            .orderBy(Users.columns.id, 'ASC')
-    },
-    {
-        id: 'match_orders',
-        category: 'Relationships',
-        title: 'Match Orders (INNER JOIN + DISTINCT)',
-        description: 'Return only users that match a relation predicate, similar to CakePHP matching().',
-        build: (qb) => qb
-            .match('orders', eq(Orders.columns.status, 'completed'))
-            .select({ id: Users.columns.id, name: Users.columns.name })
-            .orderBy(Users.columns.id, 'ASC')
-    }
-];