metal-orm 1.0.13 → 1.0.15

package/src/core/dialect/sqlite/functions.ts

@@ -0,0 +1,115 @@
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { FunctionRenderContext } from '../../functions/types.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+export class SqliteFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
+
+    private registerOverrides() {
+        // Override Standard/Abstract definitions with SQLite specifics
+
+        // Date/Time functions
+        this.add('NOW', () => `datetime('now', 'localtime')`);
+        this.add('CURRENT_DATE', () => `date('now', 'localtime')`);
+        this.add('CURRENT_TIME', () => `time('now', 'localtime')`);
+        this.add('UTC_NOW', () => `datetime('now')`);
+
+        this.add('EXTRACT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('EXTRACT expects 2 arguments (part, date)');
+            const [part, date] = compiledArgs;
+            // Map common parts to strftime format
+            const partUpper = part.replace(/['"]/g, '').toUpperCase();
+            const formatMap: Record<string, string> = {
+                'YEAR': '%Y', 'MONTH': '%m', 'DAY': '%d',
+                'HOUR': '%H', 'MINUTE': '%M', 'SECOND': '%S',
+                'DOW': '%w', 'WEEK': '%W'
+            };
+            const format = formatMap[partUpper] || '%Y';
+            return `CAST(strftime('${format}', ${date}) AS INTEGER)`;
+        });
+
+        this.add('YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('YEAR expects 1 argument');
+            return `CAST(strftime('%Y', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('MONTH expects 1 argument');
+            return `CAST(strftime('%m', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('DAY', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY expects 1 argument');
+            return `CAST(strftime('%d', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('DATE_ADD', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_ADD expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `datetime(${date}, '+' || ${interval} || ' ${unitClean}')`;
+        });
+
+        this.add('DATE_SUB', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_SUB expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `datetime(${date}, '-' || ${interval} || ' ${unitClean}')`;
+        });
+
+        this.add('DATE_DIFF', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_DIFF expects 2 arguments');
+            const [date1, date2] = compiledArgs;
+            return `CAST(julianday(${date1}) - julianday(${date2}) AS INTEGER)`;
+        });
+
+        this.add('DATE_FORMAT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_FORMAT expects 2 arguments');
+            const [date, format] = compiledArgs;
+            return `strftime(${format}, ${date})`;
+        });
+
+        this.add('UNIX_TIMESTAMP', () => `CAST(strftime('%s', 'now') AS INTEGER)`);
+
+        this.add('FROM_UNIXTIME', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('FROM_UNIXTIME expects 1 argument');
+            return `datetime(${compiledArgs[0]}, 'unixepoch')`;
+        });
+
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `date(${compiledArgs[0]}, 'start of month', '+1 month', '-1 day')`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `CAST(strftime('%w', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `CAST(strftime('%W', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            // SQLite uses date modifiers
+            if (partClean === 'year') {
+                return `date(${date}, 'start of year')`;
+            } else if (partClean === 'month') {
+                return `date(${date}, 'start of month')`;
+            } else if (partClean === 'day') {
+                return `date(${date})`;
+            }
+            return `date(${date}, 'start of ${partClean}')`;
+        });
+    }
+}

package/src/core/dialect/sqlite/index.ts

@@ -1,16 +1,18 @@
-import { CompilerContext } from '../abstract.js';
-import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-
-/**
- * SQLite dialect implementation
- */
-export class SqliteDialect extends SqlDialectBase {
-  /**
-   * Creates a new SqliteDialect instance
-   */
-  public constructor() {
-    super();
+import { CompilerContext } from '../abstract.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+import { SqliteFunctionStrategy } from './functions.js';
+
+/**
+ * SQLite dialect implementation
+ */
+export class SqliteDialect extends SqlDialectBase {
+  protected readonly dialect = 'sqlite';
+  /**
+   * Creates a new SqliteDialect instance
+   */
+  public constructor() {
+    super(new SqliteFunctionStrategy());
   }
 
   /**
@@ -27,19 +29,19 @@ export class SqliteDialect extends SqlDialectBase {
    * @param node - JSON path node
    * @returns SQLite JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // SQLite uses json_extract(col, '$.path')
-    return `json_extract(${col}, '${node.path}')`;
-  }
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // SQLite uses json_extract(col, '$.path')
+    return `json_extract(${col}, '${node.path}')`;
+  }
 
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-
-  supportsReturning(): boolean {
-    return true;
-  }
-}
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = this.formatReturningColumns(returning);
+    return ` RETURNING ${columns}`;
+  }
+
+  supportsReturning(): boolean {
+    return true;
+  }
+}

package/src/core/driver/database-driver.ts

@@ -0,0 +1,11 @@
+import type { Dialect } from '../dialect/abstract.js';
+import type { SchemaDialect } from '../ddl/schema-dialect.js';
+import type { SchemaIntrospector } from '../ddl/schema-introspect.js';
+
+export interface DatabaseDriver {
+  readonly name: string; // e.g. "postgres"
+
+  createDialect(): Dialect;
+  createSchemaDialect(): SchemaDialect;
+  createIntrospector(): SchemaIntrospector;
+}

package/src/core/driver/mssql-driver.ts

@@ -0,0 +1,20 @@
+import { DatabaseDriver } from './database-driver.js';
+import { SqlServerDialect } from '../dialect/mssql/index.js';
+import { MSSqlSchemaDialect } from '../ddl/dialects/mssql-schema-dialect.js';
+import { mssqlIntrospector } from '../ddl/introspect/mssql.js';
+
+export class MssqlDriver implements DatabaseDriver {
+  readonly name = 'mssql';
+
+  createDialect() {
+    return new SqlServerDialect();
+  }
+
+  createSchemaDialect() {
+    return new MSSqlSchemaDialect();
+  }
+
+  createIntrospector() {
+    return mssqlIntrospector;
+  }
+}

package/src/core/driver/mysql-driver.ts

@@ -0,0 +1,20 @@
+import { DatabaseDriver } from './database-driver.js';
+import { MySqlDialect } from '../dialect/mysql/index.js';
+import { MySqlSchemaDialect } from '../ddl/dialects/mysql-schema-dialect.js';
+import { mysqlIntrospector } from '../ddl/introspect/mysql.js';
+
+export class MySqlDriver implements DatabaseDriver {
+  readonly name = 'mysql';
+
+  createDialect() {
+    return new MySqlDialect();
+  }
+
+  createSchemaDialect() {
+    return new MySqlSchemaDialect();
+  }
+
+  createIntrospector() {
+    return mysqlIntrospector;
+  }
+}

package/src/core/driver/postgres-driver.ts

@@ -0,0 +1,20 @@
+import { DatabaseDriver } from './database-driver.js';
+import { PostgresDialect } from '../dialect/postgres/index.js';
+import { PostgresSchemaDialect } from '../ddl/dialects/postgres-schema-dialect.js';
+import { postgresIntrospector } from '../ddl/introspect/postgres.js';
+
+export class PostgresDriver implements DatabaseDriver {
+  readonly name = 'postgres';
+
+  createDialect() {
+    return new PostgresDialect();
+  }
+
+  createSchemaDialect() {
+    return new PostgresSchemaDialect();
+  }
+
+  createIntrospector() {
+    return postgresIntrospector;
+  }
+}

package/src/core/driver/sqlite-driver.ts

@@ -0,0 +1,20 @@
+import { DatabaseDriver } from './database-driver.js';
+import { SqliteDialect } from '../dialect/sqlite/index.js';
+import { SQLiteSchemaDialect } from '../ddl/dialects/sqlite-schema-dialect.js';
+import { sqliteIntrospector } from '../ddl/introspect/sqlite.js';
+
+export class SqliteDriver implements DatabaseDriver {
+  readonly name = 'sqlite';
+
+  createDialect() {
+    return new SqliteDialect();
+  }
+
+  createSchemaDialect() {
+    return new SQLiteSchemaDialect();
+  }
+
+  createIntrospector() {
+    return sqliteIntrospector;
+  }
+}

package/src/core/execution/db-executor.ts

@@ -0,0 +1,63 @@
+// src/core/execution/db-executor.ts
+
+// low-level canonical shape
+export type QueryResult = {
+  columns: string[];
+  values: unknown[][];
+};
+
+export interface DbExecutor {
+  executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
+
+  beginTransaction?(): Promise<void>;
+  commitTransaction?(): Promise<void>;
+  rollbackTransaction?(): Promise<void>;
+}
+
+// --- helpers ---
+
+/**
+ * Convert an array of row objects into a QueryResult.
+ */
+export function rowsToQueryResult(
+  rows: Array<Record<string, unknown>>
+): QueryResult {
+  if (rows.length === 0) {
+    return { columns: [], values: [] };
+  }
+
+  const columns = Object.keys(rows[0]);
+  const values = rows.map(row => columns.map(c => (row as any)[c]));
+  return { columns, values };
+}
+
+/**
+ * Minimal contract that most SQL clients can implement.
+ */
+export interface SimpleQueryRunner {
+  query(
+    sql: string,
+    params?: unknown[]
+  ): Promise<Array<Record<string, unknown>>>;
+  beginTransaction?(): Promise<void>;
+  commitTransaction?(): Promise<void>;
+  rollbackTransaction?(): Promise<void>;
+}
+
+/**
+ * Generic factory: turn any SimpleQueryRunner into a DbExecutor.
+ */
+export function createExecutorFromQueryRunner(
+  runner: SimpleQueryRunner
+): DbExecutor {
+  return {
+    async executeSql(sql, params) {
+      const rows = await runner.query(sql, params);
+      const result = rowsToQueryResult(rows);
+      return [result];
+    },
+    beginTransaction: runner.beginTransaction?.bind(runner),
+    commitTransaction: runner.commitTransaction?.bind(runner),
+    rollbackTransaction: runner.rollbackTransaction?.bind(runner),
+  };
+}

package/src/core/execution/executors/mssql-executor.ts

@@ -0,0 +1,39 @@
+// src/core/execution/executors/mssql-executor.ts
+import {
+  DbExecutor,
+  rowsToQueryResult
+} from '../db-executor.js';
+
+export interface MssqlClientLike {
+  query(
+    sql: string,
+    params?: unknown[]
+  ): Promise<{ recordset: Array<Record<string, unknown>> }>;
+  beginTransaction?(): Promise<void>;
+  commit?(): Promise<void>;
+  rollback?(): Promise<void>;
+}
+
+export function createMssqlExecutor(
+  client: MssqlClientLike
+): DbExecutor {
+  return {
+    async executeSql(sql, params) {
+      const { recordset } = await client.query(sql, params);
+      const result = rowsToQueryResult(recordset ?? []);
+      return [result];
+    },
+    async beginTransaction() {
+      if (!client.beginTransaction) return;
+      await client.beginTransaction();
+    },
+    async commitTransaction() {
+      if (!client.commit) return;
+      await client.commit();
+    },
+    async rollbackTransaction() {
+      if (!client.rollback) return;
+      await client.rollback();
+    },
+  };
+}

package/src/core/execution/executors/mysql-executor.ts

@@ -0,0 +1,47 @@
+// src/core/execution/executors/mysql-executor.ts
+import {
+  DbExecutor,
+  rowsToQueryResult
+} from '../db-executor.js';
+
+export interface MysqlClientLike {
+  query(
+    sql: string,
+    params?: unknown[]
+  ): Promise<[any, any?]>; // rows, metadata
+  beginTransaction?(): Promise<void>;
+  commit?(): Promise<void>;
+  rollback?(): Promise<void>;
+}
+
+export function createMysqlExecutor(
+  client: MysqlClientLike
+): DbExecutor {
+  return {
+    async executeSql(sql, params) {
+      const [rows] = await client.query(sql, params as any[]);
+
+      if (!Array.isArray(rows)) {
+        // e.g. insert/update returning only headers, treat as no rows
+        return [{ columns: [], values: [] }];
+      }
+
+      const result = rowsToQueryResult(
+        rows as Array<Record<string, unknown>>
+      );
+      return [result];
+    },
+    async beginTransaction() {
+      if (!client.beginTransaction) return;
+      await client.beginTransaction();
+    },
+    async commitTransaction() {
+      if (!client.commit) return;
+      await client.commit();
+    },
+    async rollbackTransaction() {
+      if (!client.rollback) return;
+      await client.rollback();
+    },
+  };
+}

package/src/core/execution/executors/postgres-executor.ts

@@ -0,0 +1,32 @@
+// src/core/execution/executors/postgres-executor.ts
+import {
+  DbExecutor,
+  createExecutorFromQueryRunner
+} from '../db-executor.js';
+
+export interface PostgresClientLike {
+  query(
+    text: string,
+    params?: unknown[]
+  ): Promise<{ rows: Array<Record<string, unknown>> }>;
+}
+
+export function createPostgresExecutor(
+  client: PostgresClientLike
+): DbExecutor {
+  return createExecutorFromQueryRunner({
+    async query(sql, params) {
+      const { rows } = await client.query(sql, params as any[]);
+      return rows;
+    },
+    async beginTransaction() {
+      await client.query('BEGIN');
+    },
+    async commitTransaction() {
+      await client.query('COMMIT');
+    },
+    async rollbackTransaction() {
+      await client.query('ROLLBACK');
+    },
+  });
+}

package/src/core/execution/executors/sqlite-executor.ts

@@ -0,0 +1,31 @@
+// src/core/execution/executors/sqlite-executor.ts
+import {
+  DbExecutor,
+  rowsToQueryResult
+} from '../db-executor.js';
+
+export interface SqliteClientLike {
+  all(
+    sql: string,
+    params?: unknown[]
+  ): Promise<Array<Record<string, unknown>>>;
+  run?(sql: string, params?: unknown[]): Promise<unknown>;
+  beginTransaction?(): Promise<void>;
+  commitTransaction?(): Promise<void>;
+  rollbackTransaction?(): Promise<void>;
+}
+
+export function createSqliteExecutor(
+  client: SqliteClientLike
+): DbExecutor {
+  return {
+    async executeSql(sql, params) {
+      const rows = await client.all(sql, params);
+      const result = rowsToQueryResult(rows);
+      return [result];
+    },
+    beginTransaction: client.beginTransaction?.bind(client),
+    commitTransaction: client.commitTransaction?.bind(client),
+    rollbackTransaction: client.rollbackTransaction?.bind(client),
+  };
+}

package/src/core/functions/datetime.ts

@@ -0,0 +1,132 @@
+// Pure AST Builders - No Dialect Logic Here!
+
+import { ColumnDef } from '../../schema/column.js';
+import { columnOperand, valueToOperand } from '../ast/expression-builders.js';
+import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
+
+type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
+
+const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
+
+const toOperand = (input: OperandInput): OperandNode => {
+    if (isOperandNode(input)) return input;
+    if (isColumnDef(input)) return columnOperand(input);
+    return valueToOperand(input as any);
+};
+
+const fn = (key: string, args: OperandInput[]): FunctionNode => ({
+    type: 'Function',
+    name: key,
+    args: args.map(toOperand)
+});
+
+// ----------------------
+// Helper Functions
+// ----------------------
+
+/**
+ * Helper: NOW() - Returns the current local date and time
+ */
+export const now = (): FunctionNode => fn('NOW', []);
+
+/**
+ * Helper: CURRENT_DATE - Returns only the current date (no time)
+ */
+export const currentDate = (): FunctionNode => fn('CURRENT_DATE', []);
+
+/**
+ * Helper: CURRENT_TIME - Returns only the current time
+ */
+export const currentTime = (): FunctionNode => fn('CURRENT_TIME', []);
+
+/**
+ * Helper: UTC_NOW() - Returns current UTC/GMT date and time
+ */
+export const utcNow = (): FunctionNode => fn('UTC_NOW', []);
+
+/**
+ * Helper: EXTRACT(part FROM date) - Extracts a part (year, month, day, hour, etc.) from a date
+ * @param part - The date part to extract (e.g., 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND')
+ * @param date - The date/datetime value
+ */
+export const extract = (part: OperandInput, date: OperandInput): FunctionNode => fn('EXTRACT', [part, date]);
+
+/**
+ * Helper: YEAR(date) - Extracts the year from a date
+ */
+export const year = (date: OperandInput): FunctionNode => fn('YEAR', [date]);
+
+/**
+ * Helper: MONTH(date) - Extracts the month from a date
+ */
+export const month = (date: OperandInput): FunctionNode => fn('MONTH', [date]);
+
+/**
+ * Helper: DAY(date) - Extracts the day from a date
+ */
+export const day = (date: OperandInput): FunctionNode => fn('DAY', [date]);
+
+/**
+ * Helper: DATE_ADD(date, interval, unit) - Adds a specific time interval to a date
+ * @param date - The date/datetime value
+ * @param interval - The number of units to add
+ * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND')
+ */
+export const dateAdd = (date: OperandInput, interval: OperandInput, unit: OperandInput): FunctionNode =>
+    fn('DATE_ADD', [date, interval, unit]);
+
+/**
+ * Helper: DATE_SUB(date, interval, unit) - Subtracts a specific time interval from a date
+ * @param date - The date/datetime value
+ * @param interval - The number of units to subtract
+ * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND')
+ */
+export const dateSub = (date: OperandInput, interval: OperandInput, unit: OperandInput): FunctionNode =>
+    fn('DATE_SUB', [date, interval, unit]);
+
+/**
+ * Helper: DATE_DIFF(date1, date2) - Returns the difference between two dates in days
+ * @param date1 - The end date
+ * @param date2 - The start date
+ */
+export const dateDiff = (date1: OperandInput, date2: OperandInput): FunctionNode => fn('DATE_DIFF', [date1, date2]);
+
+/**
+ * Helper: DATE_FORMAT(date, format) - Converts a date to a formatted string
+ * @param date - The date/datetime value
+ * @param format - The format string (dialect-specific)
+ */
+export const dateFormat = (date: OperandInput, format: OperandInput): FunctionNode => fn('DATE_FORMAT', [date, format]);
+
+/**
+ * Helper: UNIX_TIMESTAMP() - Returns the current Unix epoch (seconds since 1970)
+ */
+export const unixTimestamp = (): FunctionNode => fn('UNIX_TIMESTAMP', []);
+
+/**
+ * Helper: FROM_UNIXTIME(timestamp) - Converts Unix epoch seconds to a date
+ * @param timestamp - Unix timestamp in seconds
+ */
+export const fromUnixTime = (timestamp: OperandInput): FunctionNode => fn('FROM_UNIXTIME', [timestamp]);
+
+/**
+ * Helper: END_OF_MONTH(date) - Returns the last day of the month for a given date
+ */
+export const endOfMonth = (date: OperandInput): FunctionNode => fn('END_OF_MONTH', [date]);
+
+/**
+ * Helper: DAY_OF_WEEK(date) - Returns the index of the weekday
+ */
+export const dayOfWeek = (date: OperandInput): FunctionNode => fn('DAY_OF_WEEK', [date]);
+
+/**
+ * Helper: WEEK_OF_YEAR(date) - Returns the week number of the year
+ */
+export const weekOfYear = (date: OperandInput): FunctionNode => fn('WEEK_OF_YEAR', [date]);
+
+/**
+ * Helper: DATE_TRUNC(part, date) - Resets date precision (e.g., first day of the month/year)
+ * @param part - The truncation precision (e.g., 'YEAR', 'MONTH', 'DAY')
+ * @param date - The date/datetime value
+ */
+export const dateTrunc = (part: OperandInput, date: OperandInput): FunctionNode => fn('DATE_TRUNC', [part, date]);