metal-orm 1.0.8 → 1.0.9

package/src/{dialect → core/dialect}/mssql/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
-import { JsonPathNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { JsonPathNode } from '../../ast/expression.js';
 
 /**
  * Microsoft SQL Server dialect implementation
@@ -48,7 +48,7 @@ export class SqlServerDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns SQL Server SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -111,31 +111,31 @@ export class SqlServerDialect extends Dialect {
       }).join(', ') + ' '
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy};`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
 }

package/src/{dialect → core/dialect}/mysql/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
-import { JsonPathNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { JsonPathNode } from '../../ast/expression.js';
 
 /**
  * MySQL dialect implementation
@@ -39,7 +39,7 @@ export class MySqlDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns MySQL SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -98,31 +98,31 @@ export class MySqlDialect extends Dialect {
       })()
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
 }

package/src/{dialect → core/dialect}/postgres/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
-import { JsonPathNode, ColumnNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
 
 /**
  * PostgreSQL dialect implementation
@@ -39,7 +39,7 @@ export class PostgresDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns PostgreSQL SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -98,45 +98,45 @@ export class PostgresDialect extends Dialect {
       })()
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning};`;
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    if (!returning || returning.length === 0) return '';
-    const columns = returning
-      .map(column => {
-        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
-        return `${tablePart}${this.quoteIdentifier(column.name)}`;
-      })
-      .join(', ');
-    return ` RETURNING ${columns}`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning};`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = returning
+      .map(column => {
+        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
+        return `${tablePart}${this.quoteIdentifier(column.name)}`;
+      })
+      .join(', ');
+    return ` RETURNING ${columns}`;
+  }
 }

package/src/{dialect → core/dialect}/sqlite/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
-import { JsonPathNode, ColumnNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
 
 /**
  * SQLite dialect implementation
@@ -39,7 +39,7 @@ export class SqliteDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns SQLite SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -102,45 +102,45 @@ export class SqliteDialect extends Dialect {
       })()
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning};`;
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    if (!returning || returning.length === 0) return '';
-    const columns = returning
-      .map(column => {
-        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
-        return `${tablePart}${this.quoteIdentifier(column.name)}`;
-      })
-      .join(', ');
-    return ` RETURNING ${columns}`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning};`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = returning
+      .map(column => {
+        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
+        return `${tablePart}${this.quoteIdentifier(column.name)}`;
+      })
+      .join(', ');
+    return ` RETURNING ${columns}`;
+  }
 }

package/src/{constants → core/sql}/sql-operator-config.ts

@@ -1,39 +1,39 @@
-import { SQL_OPERATORS, SqlOperator } from './sql';
-
-/**
- * Configuration for how SQL operators map to TypeScript builder helpers
- */
-export interface SqlOperatorConfig {
-  /**
-   * SQL operator literal
-   */
-  sql: SqlOperator;
-  /**
-   * Corresponding TypeScript helper name
-   */
-  tsName: string;
-}
-
-/**
- * Registry of supported SQL operators and their companion helper names
- */
-export const SQL_OPERATOR_REGISTRY: Record<SqlOperator, SqlOperatorConfig> = {
-  [SQL_OPERATORS.EQUALS]: { sql: SQL_OPERATORS.EQUALS, tsName: 'eq' },
-  [SQL_OPERATORS.NOT_EQUALS]: { sql: SQL_OPERATORS.NOT_EQUALS, tsName: 'neq' },
-  [SQL_OPERATORS.GREATER_THAN]: { sql: SQL_OPERATORS.GREATER_THAN, tsName: 'gt' },
-  [SQL_OPERATORS.GREATER_OR_EQUAL]: { sql: SQL_OPERATORS.GREATER_OR_EQUAL, tsName: 'gte' },
-  [SQL_OPERATORS.LESS_THAN]: { sql: SQL_OPERATORS.LESS_THAN, tsName: 'lt' },
-  [SQL_OPERATORS.LESS_OR_EQUAL]: { sql: SQL_OPERATORS.LESS_OR_EQUAL, tsName: 'lte' },
-  [SQL_OPERATORS.LIKE]: { sql: SQL_OPERATORS.LIKE, tsName: 'like' },
-  [SQL_OPERATORS.NOT_LIKE]: { sql: SQL_OPERATORS.NOT_LIKE, tsName: 'notLike' },
-  [SQL_OPERATORS.IN]: { sql: SQL_OPERATORS.IN, tsName: 'inList' },
-  [SQL_OPERATORS.NOT_IN]: { sql: SQL_OPERATORS.NOT_IN, tsName: 'notInList' },
-  [SQL_OPERATORS.IS_NULL]: { sql: SQL_OPERATORS.IS_NULL, tsName: 'isNull' },
-  [SQL_OPERATORS.IS_NOT_NULL]: { sql: SQL_OPERATORS.IS_NOT_NULL, tsName: 'isNotNull' },
-  [SQL_OPERATORS.AND]: { sql: SQL_OPERATORS.AND, tsName: 'and' },
-  [SQL_OPERATORS.OR]: { sql: SQL_OPERATORS.OR, tsName: 'or' },
-  [SQL_OPERATORS.BETWEEN]: { sql: SQL_OPERATORS.BETWEEN, tsName: 'between' },
-  [SQL_OPERATORS.NOT_BETWEEN]: { sql: SQL_OPERATORS.NOT_BETWEEN, tsName: 'notBetween' },
-  [SQL_OPERATORS.EXISTS]: { sql: SQL_OPERATORS.EXISTS, tsName: 'exists' },
-  [SQL_OPERATORS.NOT_EXISTS]: { sql: SQL_OPERATORS.NOT_EXISTS, tsName: 'notExists' }
-};
+import { SQL_OPERATORS, SqlOperator } from './sql.js';
+
+/**
+ * Configuration for how SQL operators map to TypeScript builder helpers
+ */
+export interface SqlOperatorConfig {
+  /**
+   * SQL operator literal
+   */
+  sql: SqlOperator;
+  /**
+   * Corresponding TypeScript helper name
+   */
+  tsName: string;
+}
+
+/**
+ * Registry of supported SQL operators and their companion helper names
+ */
+export const SQL_OPERATOR_REGISTRY: Record<SqlOperator, SqlOperatorConfig> = {
+  [SQL_OPERATORS.EQUALS]: { sql: SQL_OPERATORS.EQUALS, tsName: 'eq' },
+  [SQL_OPERATORS.NOT_EQUALS]: { sql: SQL_OPERATORS.NOT_EQUALS, tsName: 'neq' },
+  [SQL_OPERATORS.GREATER_THAN]: { sql: SQL_OPERATORS.GREATER_THAN, tsName: 'gt' },
+  [SQL_OPERATORS.GREATER_OR_EQUAL]: { sql: SQL_OPERATORS.GREATER_OR_EQUAL, tsName: 'gte' },
+  [SQL_OPERATORS.LESS_THAN]: { sql: SQL_OPERATORS.LESS_THAN, tsName: 'lt' },
+  [SQL_OPERATORS.LESS_OR_EQUAL]: { sql: SQL_OPERATORS.LESS_OR_EQUAL, tsName: 'lte' },
+  [SQL_OPERATORS.LIKE]: { sql: SQL_OPERATORS.LIKE, tsName: 'like' },
+  [SQL_OPERATORS.NOT_LIKE]: { sql: SQL_OPERATORS.NOT_LIKE, tsName: 'notLike' },
+  [SQL_OPERATORS.IN]: { sql: SQL_OPERATORS.IN, tsName: 'inList' },
+  [SQL_OPERATORS.NOT_IN]: { sql: SQL_OPERATORS.NOT_IN, tsName: 'notInList' },
+  [SQL_OPERATORS.IS_NULL]: { sql: SQL_OPERATORS.IS_NULL, tsName: 'isNull' },
+  [SQL_OPERATORS.IS_NOT_NULL]: { sql: SQL_OPERATORS.IS_NOT_NULL, tsName: 'isNotNull' },
+  [SQL_OPERATORS.AND]: { sql: SQL_OPERATORS.AND, tsName: 'and' },
+  [SQL_OPERATORS.OR]: { sql: SQL_OPERATORS.OR, tsName: 'or' },
+  [SQL_OPERATORS.BETWEEN]: { sql: SQL_OPERATORS.BETWEEN, tsName: 'between' },
+  [SQL_OPERATORS.NOT_BETWEEN]: { sql: SQL_OPERATORS.NOT_BETWEEN, tsName: 'notBetween' },
+  [SQL_OPERATORS.EXISTS]: { sql: SQL_OPERATORS.EXISTS, tsName: 'exists' },
+  [SQL_OPERATORS.NOT_EXISTS]: { sql: SQL_OPERATORS.NOT_EXISTS, tsName: 'notExists' }
+};

package/src/decorators/bootstrap.ts

@@ -0,0 +1,126 @@
+import { SelectQueryBuilder } from '../query-builder/select.js';
+import {
+  hasMany,
+  belongsTo,
+  belongsToMany,
+  RelationKinds,
+  type RelationDef
+} from '../schema/relation.js';
+import { TableDef } from '../schema/table.js';
+import {
+  buildTableDef,
+  EntityConstructor,
+  EntityOrTableTarget,
+  EntityOrTableTargetResolver,
+  getAllEntityMetadata,
+  getEntityMetadata,
+  RelationMetadata
+} from '../orm/entity-metadata.js';
+
+const isTableDef = (value: unknown): value is TableDef => {
+  return typeof value === 'object' && value !== null && 'columns' in (value as TableDef);
+};
+
+const unwrapTarget = (target: EntityOrTableTargetResolver): EntityOrTableTarget => {
+  if (typeof target === 'function' && (target as Function).prototype === undefined) {
+    return (target as () => EntityOrTableTarget)();
+  }
+  return target as EntityOrTableTarget;
+};
+
+const resolveTableTarget = (
+  target: EntityOrTableTargetResolver,
+  tableMap: Map<EntityConstructor, TableDef>
+): TableDef => {
+  const resolved = unwrapTarget(target);
+  if (isTableDef(resolved)) {
+    return resolved;
+  }
+  const table = tableMap.get(resolved as EntityConstructor);
+  if (!table) {
+    throw new Error(`Entity '${(resolved as EntityConstructor).name}' is not registered with decorators`);
+  }
+  return table;
+};
+
+const buildRelationDefinitions = (
+  meta: { relations: Record<string, RelationMetadata> },
+  tableMap: Map<EntityConstructor, TableDef>
+): Record<string, RelationDef> => {
+  const relations: Record<string, RelationDef> = {};
+
+  for (const [name, relation] of Object.entries(meta.relations)) {
+    switch (relation.kind) {
+      case RelationKinds.HasMany: {
+        relations[name] = hasMany(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.BelongsTo: {
+        relations[name] = belongsTo(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.BelongsToMany: {
+        relations[name] = belongsToMany(
+          resolveTableTarget(relation.target, tableMap),
+          resolveTableTarget(relation.pivotTable, tableMap),
+          {
+            pivotForeignKeyToRoot: relation.pivotForeignKeyToRoot,
+            pivotForeignKeyToTarget: relation.pivotForeignKeyToTarget,
+            localKey: relation.localKey,
+            targetKey: relation.targetKey,
+            pivotPrimaryKey: relation.pivotPrimaryKey,
+            defaultPivotColumns: relation.defaultPivotColumns,
+            cascade: relation.cascade
+          }
+        );
+        break;
+      }
+    }
+  }
+
+  return relations;
+};
+
+export const bootstrapEntities = (): TableDef[] => {
+  const metas = getAllEntityMetadata();
+  const tableMap = new Map<EntityConstructor, TableDef>();
+
+  for (const meta of metas) {
+    const table = buildTableDef(meta);
+    tableMap.set(meta.target, table);
+  }
+
+  for (const meta of metas) {
+    const table = meta.table!;
+    const relations = buildRelationDefinitions(meta, tableMap);
+    table.relations = relations;
+  }
+
+  return metas.map(meta => meta.table!) as TableDef[];
+};
+
+export const getTableDefFromEntity = (ctor: EntityConstructor): TableDef | undefined => {
+  const meta = getEntityMetadata(ctor);
+  if (!meta) return undefined;
+  return meta.table;
+};
+
+export const selectFromEntity = <TTable extends TableDef>(
+  ctor: EntityConstructor
+): SelectQueryBuilder<any, TTable> => {
+  const table = getTableDefFromEntity(ctor);
+  if (!table) {
+    throw new Error('Entity metadata has not been bootstrapped');
+  }
+  return new SelectQueryBuilder(table as TTable);
+};

package/src/decorators/column.ts

@@ -0,0 +1,78 @@
+import { ColumnDef, ColumnType } from '../schema/column.js';
+import {
+  addColumnMetadata,
+  EntityConstructor,
+  ColumnDefLike,
+  ensureEntityMetadata
+} from '../orm/entity-metadata.js';
+
+export interface ColumnOptions {
+  type: ColumnType;
+  args?: ColumnDef['args'];
+  notNull?: boolean;
+  primary?: boolean;
+}
+
+export type ColumnInput = ColumnOptions | ColumnDef;
+
+const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
+  const column: ColumnDefLike = {
+    type: (input as ColumnOptions).type ?? (input as ColumnDef).type,
+    args: (input as ColumnOptions).args ?? (input as ColumnDef).args,
+    notNull: (input as ColumnOptions).notNull ?? (input as ColumnDef).notNull,
+    primary: (input as ColumnOptions).primary ?? (input as ColumnDef).primary
+  };
+
+  if (!column.type) {
+    throw new Error('Column decorator requires a column type');
+  }
+
+  return column;
+};
+
+const normalizePropertyName = (name: string | symbol): string => {
+  if (typeof name === 'symbol') {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+
+const resolveConstructor = (target: unknown): EntityConstructor | undefined => {
+  if (typeof target === 'function') {
+    return target as EntityConstructor;
+  }
+
+  if (target && typeof (target as any).constructor === 'function') {
+    return (target as any).constructor as EntityConstructor;
+  }
+
+  return undefined;
+};
+
+const registerColumn = (ctor: EntityConstructor, propertyName: string, column: ColumnDefLike): void => {
+  const meta = ensureEntityMetadata(ctor);
+  if (meta.columns[propertyName]) {
+    return;
+  }
+  addColumnMetadata(ctor, propertyName, column);
+};
+
+export function Column(definition: ColumnInput) {
+  const normalized = normalizeColumnInput(definition);
+  const decorator = (target: object, propertyKey: string | symbol) => {
+    const propertyName = normalizePropertyName(propertyKey);
+    const ctor = resolveConstructor(target);
+    if (!ctor) {
+      throw new Error('Unable to resolve constructor when registering column metadata');
+    }
+    registerColumn(ctor, propertyName, { ...normalized });
+  };
+
+  return decorator as PropertyDecorator;
+}
+
+export function PrimaryKey(definition: ColumnInput) {
+  const normalized = normalizeColumnInput(definition);
+  normalized.primary = true;
+  return Column(normalized);
+}