metal-orm 1.0.42 → 1.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -28,7 +28,9 @@
     "gen:entities": "node scripts/generate-entities.mjs",
     "test": "vitest",
     "test:ui": "vitest --ui",
-    "show-sql": "node scripts/show-sql.mjs"
+    "show-sql": "node scripts/show-sql.mjs",
+    "lint": "node scripts/run-eslint.mjs",
+    "lint:fix": "node scripts/run-eslint.mjs --fix"
   },
   "peerDependencies": {
     "mysql2": "^3.9.0",
@@ -52,6 +54,10 @@
   },
   "devDependencies": {
     "@vitest/ui": "^4.0.14",
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-deprecation": "^3.0.0",
     "mysql2": "^3.15.3",
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",

package/scripts/run-eslint.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const [, , ...userArgs] = process.argv;
+
+const TARGETS = {
+    src: ['./src'],
+    all: ['./src', './tests', './scripts', './playground'],
+    playground: ['./playground'],
+    'src/core': ['./src/core'],
+};
+
+const [firstArg, ...restArgs] = userArgs;
+const hasTarget = firstArg && !firstArg.startsWith('-');
+
+const targetKey = hasTarget ? firstArg : 'all';
+const extraArgs = hasTarget ? restArgs : userArgs;
+
+const paths = TARGETS[targetKey] ?? [targetKey];
+
+if (paths.length === 0) {
+    console.error(`Unknown lint target: ${targetKey}`);
+    process.exit(1);
+}
+
+const eslintArgs = [...paths, '--ext', '.ts,.tsx,.mjs', ...extraArgs];
+
+const eslintBinBase = path.join(process.cwd(), 'node_modules', '.bin', 'eslint');
+const executable = process.platform === 'win32' ? `${eslintBinBase}.cmd` : eslintBinBase;
+
+const child = spawn(executable, eslintArgs, { stdio: 'inherit', shell: true });
+
+child.on('exit', (code) => process.exit(code));

package/src/codegen/typescript.ts

@@ -1,4 +1,4 @@
-import { SelectQueryNode } from '../core/ast/query.js';
+import { OrderingTerm, SelectQueryNode } from '../core/ast/query.js';
 import {
   ExpressionNode,
   OperandNode,
@@ -36,8 +36,15 @@ const assertNever = (value: never): never => {
 /**
  * Generates TypeScript code from query AST nodes
  */
+type SelectionColumn =
+  | ColumnNode
+  | FunctionNode
+  | ScalarSubqueryNode
+  | CaseExpressionNode
+  | WindowFunctionNode;
+
 export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
-  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) {}
+  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) { }
 
   /**
    * Generates TypeScript code from a query AST
@@ -62,12 +69,8 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     const hydratedRelations = new Set(hydration?.relations?.map(r => r.name) ?? []);
 
     const selections = ast.columns
-      .filter(col => !(hydration && isRelationAlias((col as any).alias)))
-      .map(col => {
-        const key = (col as any).alias || (col as any).name;
-        const operand = col as OperandNode;
-        return `${key}: ${this.printOperand(operand)}`;
-      });
+      .filter((col): col is SelectionColumn => !(hydration && isRelationAlias(col.alias)))
+      .map((col, index) => `${this.getSelectionKey(col, index)}: ${this.printOperand(col)}`);
 
     lines.push(`db.select({`);
     selections.forEach((sel, index) => {
@@ -168,26 +171,40 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
   /**
    * Prints an ordering term (operand/expression/alias) to TypeScript code.
    */
-  private printOrderingTerm(term: any): string {
-    if (!term || !(term as any).type) {
+  private printOrderingTerm(term: OrderingTerm): string {
+    if (!term || !('type' in term)) {
       throw new Error('Unsupported ordering term');
     }
 
-    switch ((term as any).type) {
+    switch (term.type) {
       case 'Column':
-        return `${this.namingStrategy.tableToSymbol((term as any).table)}.${(term as any).name}`;
+        return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
       case 'AliasRef':
-        return this.visitAliasRef(term as any);
+        return this.visitAliasRef(term);
       case 'Literal':
       case 'Function':
       case 'JsonPath':
       case 'ScalarSubquery':
       case 'CaseExpression':
       case 'WindowFunction':
-        return this.printOperand(term as OperandNode);
+        return this.printOperand(term);
       default:
-        return this.printExpression(term as ExpressionNode);
+        return this.printExpression(term);
+    }
+  }
+
+  private getSelectionKey(selection: SelectionColumn, index: number): string {
+    if (selection.alias) {
+      return selection.alias;
+    }
+    if (this.isNamedSelection(selection)) {
+      return selection.name;
     }
+    return `selection${index + 1}`;
+  }
+
+  private isNamedSelection(selection: SelectionColumn): selection is ColumnNode | FunctionNode | WindowFunctionNode {
+    return 'name' in selection;
   }
 
   public visitBinaryExpression(binary: BinaryExpressionNode): string {

package/src/core/ast/adapters.ts

@@ -2,13 +2,19 @@ import { ColumnDef } from '../../schema/column.js';
 import { TableDef } from '../../schema/table.js';
 import { ColumnRef, TableRef } from './types.js';
 
+/**
+ * Type guard to check if an object has an alias property
+ */
+const hasAlias = (obj: unknown): obj is { alias?: string } =>
+  typeof obj === 'object' && obj !== null && 'alias' in obj;
+
 /**
  * Adapts a schema ColumnDef to an AST-friendly ColumnRef.
  */
 export const toColumnRef = (col: ColumnRef | ColumnDef): ColumnRef => ({
   name: col.name,
   table: col.table,
-  alias: (col as ColumnRef).alias
+  alias: hasAlias(col) ? col.alias : undefined
 });
 
 /**
@@ -17,5 +23,5 @@ export const toColumnRef = (col: ColumnRef | ColumnDef): ColumnRef => ({
 export const toTableRef = (table: TableRef | TableDef): TableRef => ({
   name: table.name,
   schema: table.schema,
-  alias: (table as TableRef).alias
+  alias: hasAlias(table) ? table.alias : undefined
 });

package/src/core/ast/builders.ts

@@ -1,76 +1,105 @@
-import { ColumnNode } from './expression-nodes.js';
-import { TableNode, FunctionTableNode, DerivedTableNode } from './query.js';
-import { ColumnRef, TableRef } from './types.js';
-
-/**
- * Builds or normalizes a column AST node from a column definition or existing node
- * @param table - Table definition providing a default table name
- * @param column - Column definition or existing column node
- */
-export const buildColumnNode = (table: TableRef, column: ColumnRef | ColumnNode): ColumnNode => {
-  if ((column as ColumnNode).type === 'Column') {
-    return column as ColumnNode;
-  }
-
-  const def = column as ColumnRef;
-  const baseTable = def.table
-    ? table.alias && def.table === table.name
-      ? table.alias
-      : def.table
-    : table.alias || table.name;
-
-  return {
-    type: 'Column',
-    table: baseTable,
-    name: def.name
-  };
-};
-
-/**
- * Builds column AST nodes for a list of column names
- * @param table - Table definition providing the table name
- * @param names - Column names
- */
-export const buildColumnNodes = (table: TableRef, names: string[]): ColumnNode[] =>
-  names.map(name => ({
-    type: 'Column',
-    table: table.alias || table.name,
-    name
-  }));
-
-/**
- * Builds a table AST node for the provided table definition
- * @param table - Table definition
- */
-export const createTableNode = (table: TableRef): TableNode => ({
-  type: 'Table',
-  name: table.name
-});
-
-/**
- * Creates a FunctionTable node for expressions like `function_name(args...)` used in FROM
- */
-export const fnTable = (name: string, args: any[] = [], alias?: string, opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }): FunctionTableNode => ({
-  type: 'FunctionTable',
-  name,
-  args,
-  alias,
-  lateral: opts?.lateral,
-  withOrdinality: opts?.withOrdinality,
-  columnAliases: opts?.columnAliases,
-  schema: opts?.schema
-});
-
-/**
- * Creates a derived table node wrapping a subquery.
- */
-export const derivedTable = (
-  query: import('./query.js').SelectQueryNode,
-  alias: string,
-  columnAliases?: string[]
-): DerivedTableNode => ({
-  type: 'DerivedTable',
-  query,
-  alias,
-  columnAliases
-});
+import { ColumnNode, OperandNode } from './expression-nodes.js';
+import { TableNode, FunctionTableNode, DerivedTableNode } from './query.js';
+import { ColumnRef, TableRef } from './types.js';
+
+/**
+ * Type guard to check if a column is already a ColumnNode
+ */
+const isColumnNode = (col: ColumnRef | ColumnNode): col is ColumnNode =>
+  'type' in col && col.type === 'Column';
+
+/**
+ * Resolves the appropriate table name for a column reference
+ * @param def - Column reference definition
+ * @param table - Table reference providing context
+ * @returns The resolved table name to use
+ */
+const resolveTableName = (def: ColumnRef, table: TableRef): string => {
+  // If column doesn't specify a table, use the table's alias or name
+  if (!def.table) {
+    return table.alias || table.name;
+  }
+
+  // If column specifies the base table name and table has an alias, use the alias
+  if (table.alias && def.table === table.name) {
+    return table.alias;
+  }
+
+  // Otherwise use the table specified in the column definition
+  return def.table;
+};
+
+/**
+ * Builds or normalizes a column AST node from a column definition or existing node
+ * @param table - Table definition providing a default table name
+ * @param column - Column definition or existing column node
+ */
+export const buildColumnNode = (table: TableRef, column: ColumnRef | ColumnNode): ColumnNode => {
+  if (isColumnNode(column)) {
+    return column;
+  }
+
+  const def = column as ColumnRef;
+  const baseTable = resolveTableName(def, table);
+
+  return {
+    type: 'Column',
+    table: baseTable,
+    name: def.name
+  };
+};
+
+/**
+ * Builds column AST nodes for a list of column names
+ * @param table - Table definition providing the table name
+ * @param names - Column names
+ */
+export const buildColumnNodes = (table: TableRef, names: string[]): ColumnNode[] =>
+  names.map(name => ({
+    type: 'Column',
+    table: table.alias || table.name,
+    name
+  }));
+
+/**
+ * Builds a table AST node for the provided table definition
+ * @param table - Table definition
+ */
+export const createTableNode = (table: TableRef): TableNode => ({
+  type: 'Table',
+  name: table.name,
+  schema: (table as unknown as { schema?: string }).schema
+});
+
+/**
+ * Creates a FunctionTable node for expressions like `function_name(args...)` used in FROM
+ */
+export const fnTable = (
+  name: string,
+  args: OperandNode[] = [],
+  alias?: string,
+  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+): FunctionTableNode => ({
+  type: 'FunctionTable',
+  name,
+  args,
+  alias,
+  lateral: opts?.lateral,
+  withOrdinality: opts?.withOrdinality,
+  columnAliases: opts?.columnAliases,
+  schema: opts?.schema
+});
+
+/**
+ * Creates a derived table node wrapping a subquery.
+ */
+export const derivedTable = (
+  query: import('./query.js').SelectQueryNode,
+  alias: string,
+  columnAliases?: string[]
+): DerivedTableNode => ({
+  type: 'DerivedTable',
+  query,
+  alias,
+  columnAliases
+});