metal-orm 1.0.42 → 1.0.43

package/src/query-builder/update.ts

@@ -81,9 +81,10 @@ export class UpdateQueryBuilder<T> {
   compile(dialect: UpdateDialectInput): CompiledQuery;
 
   compile(arg: UpdateCompiler | UpdateDialectInput): CompiledQuery {
-    if (typeof (arg as any).compileUpdate === 'function') {
+    const candidate = arg as { compileUpdate?: (ast: UpdateQueryNode) => CompiledQuery };
+    if (typeof candidate.compileUpdate === 'function') {
       // UpdateCompiler path – old behavior
-      return (arg as UpdateCompiler).compileUpdate(this.state.ast);
+      return candidate.compileUpdate(this.state.ast);
     }
 
     // Dialect | string path – new behavior
@@ -92,7 +93,7 @@ export class UpdateQueryBuilder<T> {
   }
 
   toSql(arg: UpdateCompiler | UpdateDialectInput): string {
-    return this.compile(arg as any).sql;
+    return this.compile(arg as UpdateCompiler).sql;
   }
 
   getAST(): UpdateQueryNode {

package/src/schema/column.ts

@@ -100,7 +100,7 @@ export interface ColumnDef<T extends ColumnType = ColumnType, TRuntime = unknown
   /** Column comment/description */
   comment?: string;
   /** Additional arguments for the column type (e.g., VARCHAR length) */
-  args?: any[];
+  args?: unknown[];
   /** Table name this column belongs to (filled at runtime by defineTable) */
   table?: string;
 }
@@ -234,28 +234,28 @@ export const col = {
    * Marks a column as UNIQUE
    */
   unique: <T extends ColumnType>(def: ColumnDef<T>, name?: string): ColumnDef<T> =>
-    ({
-      ...def,
-      unique: name ?? true
-    }),
+  ({
+    ...def,
+    unique: name ?? true
+  }),
 
   /**
    * Sets a default value for the column
    */
   default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown): ColumnDef<T> =>
-    ({
-      ...def,
-      default: value
-    }),
+  ({
+    ...def,
+    default: value
+  }),
 
   /**
    * Sets a raw SQL default value for the column
    */
   defaultRaw: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
-    ({
-      ...def,
-      default: { raw: expression }
-    }),
+  ({
+    ...def,
+    default: { raw: expression }
+  }),
 
   /**
    * Marks a column as auto-increment / identity
@@ -264,27 +264,27 @@ export const col = {
     def: ColumnDef<T>,
     strategy: ColumnDef['generated'] = 'byDefault'
   ): ColumnDef<T> =>
-    ({
-      ...def,
-      autoIncrement: true,
-      generated: strategy
-    }),
+  ({
+    ...def,
+    autoIncrement: true,
+    generated: strategy
+  }),
 
   /**
    * Adds a foreign key reference
    */
   references: <T extends ColumnType>(def: ColumnDef<T>, ref: ForeignKeyReference): ColumnDef<T> =>
-    ({
-      ...def,
-      references: ref
-    }),
+  ({
+    ...def,
+    references: ref
+  }),
 
   /**
    * Adds a check constraint to the column
    */
   check: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
-    ({
-      ...def,
-      check: expression
-    })
+  ({
+    ...def,
+    check: expression
+  })
 };

package/src/schema/table.ts

@@ -31,12 +31,12 @@ export interface TableOptions {
 }
 
 export interface TableHooks {
-  beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
-  afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
-  beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-  afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-  beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
-  afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
+  beforeInsert?(ctx: unknown, entity: unknown): Promise<void> | void;
+  afterInsert?(ctx: unknown, entity: unknown): Promise<void> | void;
+  beforeUpdate?(ctx: unknown, entity: unknown): Promise<void> | void;
+  afterUpdate?(ctx: unknown, entity: unknown): Promise<void> | void;
+  beforeDelete?(ctx: unknown, entity: unknown): Promise<void> | void;
+  afterDelete?(ctx: unknown, entity: unknown): Promise<void> | void;
 }
 
 /**
@@ -94,7 +94,8 @@ export const defineTable = <T extends Record<string, ColumnDef>>(
 ): 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 };
+    const colDef = { ...def, name: key, table: name };
+    (acc as Record<string, unknown>)[key] = colDef;
     return acc;
   }, {} as T);
 
@@ -128,36 +129,39 @@ export type TableRef<T extends TableDef> =
     $: T["columns"];
   };
 
-const TABLE_REF_CACHE: WeakMap<object, any> = new WeakMap();
+const TABLE_REF_CACHE: WeakMap<object, unknown> = new WeakMap();
 
 const withColumnProps = <T extends TableDef>(table: T): TableRef<T> => {
-  const cached = TABLE_REF_CACHE.get(table as any);
+  const cached = TABLE_REF_CACHE.get(table);
   if (cached) return cached as TableRef<T>;
 
-  const proxy = new Proxy(table as any, {
+  const proxy = new Proxy(table as object, {
     get(target, prop, receiver) {
-      if (prop === "$") return target.columns;
+      const t = target as TableDef;
+      if (prop === "$") return t.columns;
 
       // Prefer real table fields first (prevents collision surprises)
       if (Reflect.has(target, prop)) return Reflect.get(target, prop, receiver);
 
       // Fall back to columns bag
-      if (typeof prop === "string" && prop in target.columns) return target.columns[prop];
+      if (typeof prop === "string" && prop in t.columns) return t.columns[prop];
 
       return undefined;
     },
 
     has(target, prop) {
+      const t = target as TableDef;
       return (
         prop === "$" ||
         Reflect.has(target, prop) ||
-        (typeof prop === "string" && prop in target.columns)
+        (typeof prop === "string" && prop in t.columns)
       );
     },
 
     ownKeys(target) {
+      const t = target as TableDef;
       const base = Reflect.ownKeys(target);
-      const cols = Object.keys(target.columns);
+      const cols = Object.keys(t.columns);
 
       for (const k of cols) {
         if (!base.includes(k)) base.push(k);
@@ -172,20 +176,20 @@ const withColumnProps = <T extends TableDef>(table: T): TableRef<T> => {
           configurable: true,
           enumerable: false,
           get() {
-            return target.columns;
+            return (target as TableDef).columns;
           },
         };
       }
 
       if (
         typeof prop === "string" &&
-        prop in target.columns &&
+        prop in (target as TableDef).columns &&
         !Reflect.has(target, prop)
       ) {
         return {
           configurable: true,
           enumerable: true,
-          value: target.columns[prop],
+          value: (target as TableDef).columns[prop],
           writable: false,
         };
       }
@@ -194,7 +198,7 @@ const withColumnProps = <T extends TableDef>(table: T): TableRef<T> => {
     },
   }) as TableRef<T>;
 
-  TABLE_REF_CACHE.set(table as any, proxy);
+  TABLE_REF_CACHE.set(table, proxy);
   return proxy;
 };
 
@@ -208,3 +212,28 @@ const withColumnProps = <T extends TableDef>(table: T): TableRef<T> => {
  *   t.$.name is the "name" column (escape hatch)
  */
 export const tableRef = <T extends TableDef>(table: T): TableRef<T> => withColumnProps(table);
+
+/**
+ * Public API: dynamic column lookup by string key.
+ *
+ * Useful when the column name is only known at runtime, or when a column name
+ * collides with a real table field (e.g. "name").
+ *
+ * @example
+ * ```ts
+ * const t = tableRef(todos);
+ * const key = runtimeKey();
+ * where(eq(getColumn(t, key), 123));
+ * // or: t.$.name (escape hatch)
+ * ```
+ */
+export function getColumn<T extends TableDef, K extends keyof T['columns'] & string>(table: T, key: K): T['columns'][K];
+export function getColumn<T extends TableDef>(table: T, key: string): ColumnDef;
+export function getColumn<T extends TableDef>(table: T, key: string): ColumnDef {
+  const col = table.columns[key] as ColumnDef | undefined;
+  if (!col) {
+    const tableName = table.name || '<unknown>';
+    throw new Error(`Column '${key}' does not exist on table '${tableName}'`);
+  }
+  return col;
+}

package/src/schema/types.ts

@@ -23,15 +23,15 @@ export type RelationTargetTable<TRel extends RelationDef> =
  */
 export type ColumnToTs<T extends ColumnDef> =
   [unknown] extends [T['tsType']]
-    ? T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
-      T['type'] extends 'BIGINT' | 'bigint' ? number | bigint :
-      T['type'] extends 'DECIMAL' | 'decimal' | 'FLOAT' | 'float' | 'DOUBLE' | 'double' ? number :
-      T['type'] extends 'BOOLEAN' | 'boolean' ? boolean :
-      T['type'] extends 'JSON' | 'json' ? unknown :
-      T['type'] extends 'BLOB' | 'blob' | 'BINARY' | 'binary' | 'VARBINARY' | 'varbinary' | 'BYTEA' | 'bytea' ? Buffer :
-      T['type'] extends 'DATE' | 'date' | 'DATETIME' | 'datetime' | 'TIMESTAMP' | 'timestamp' | 'TIMESTAMPTZ' | 'timestamptz' ? string :
-      string
-    : Exclude<T['tsType'], undefined>;
+  ? T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
+  T['type'] extends 'BIGINT' | 'bigint' ? number | bigint :
+  T['type'] extends 'DECIMAL' | 'decimal' | 'FLOAT' | 'float' | 'DOUBLE' | 'double' ? number :
+  T['type'] extends 'BOOLEAN' | 'boolean' ? boolean :
+  T['type'] extends 'JSON' | 'json' ? unknown :
+  T['type'] extends 'BLOB' | 'blob' | 'BINARY' | 'binary' | 'VARBINARY' | 'varbinary' | 'BYTEA' | 'bytea' ? Buffer :
+  T['type'] extends 'DATE' | 'date' | 'DATETIME' | 'datetime' | 'TIMESTAMP' | 'timestamp' | 'TIMESTAMPTZ' | 'timestamptz' ? string :
+  string
+  : Exclude<T['tsType'], undefined>;
 
 /**
  * Infers a row shape from a table definition
@@ -41,10 +41,10 @@ export type InferRow<TTable extends TableDef> = {
 };
 
 type RelationResult<T extends RelationDef> =
-  T extends HasManyRelation<infer TTarget>        ? InferRow<TTarget>[] :
-  T extends HasOneRelation<infer TTarget>         ? InferRow<TTarget> | null :
-  T extends BelongsToRelation<infer TTarget>      ? InferRow<TTarget> | null :
-  T extends BelongsToManyRelation<infer TTarget>  ? (InferRow<TTarget> & { _pivot?: any })[] :
+  T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] :
+  T extends HasOneRelation<infer TTarget> ? InferRow<TTarget> | null :
+  T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null :
+  T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & { _pivot?: unknown })[] :
   never;
 
 /**
@@ -88,15 +88,15 @@ export type EntityInstance<
   TRow = InferRow<TTable>
 > = TRow & {
   [K in keyof RelationMap<TTable>]:
-    TTable['relations'][K] extends HasManyRelation<infer TTarget>
-      ? HasManyCollection<EntityInstance<TTarget>>
-      : TTable['relations'][K] extends HasOneRelation<infer TTarget>
-        ? HasOneReference<EntityInstance<TTarget>>
-        : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget>
-          ? ManyToManyCollection<EntityInstance<TTarget>>
-          : TTable['relations'][K] extends BelongsToRelation<infer TTarget>
-            ? BelongsToReference<EntityInstance<TTarget>>
-            : never;
+  TTable['relations'][K] extends HasManyRelation<infer TTarget>
+  ? HasManyCollection<EntityInstance<TTarget>>
+  : TTable['relations'][K] extends HasOneRelation<infer TTarget>
+  ? HasOneReference<EntityInstance<TTarget>>
+  : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget>
+  ? ManyToManyCollection<EntityInstance<TTarget>>
+  : TTable['relations'][K] extends BelongsToRelation<infer TTarget>
+  ? BelongsToReference<EntityInstance<TTarget>>
+  : never;
 } & {
   $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
 };