metal-orm 1.0.42 → 1.0.44

package/src/orm/save-graph.ts

@@ -1,4 +1,10 @@
-import type { EntityInstance } from '../schema/types.js';
+import type {
+  EntityInstance,
+  HasManyCollection,
+  HasOneReference,
+  BelongsToReference,
+  ManyToManyCollection
+} from '../schema/types.js';
 import {
   RelationKinds,
   type BelongsToManyRelation,
@@ -19,12 +25,12 @@ export interface SaveGraphOptions {
   pruneMissing?: boolean;
 }
 
-type AnyEntity = Record<string, any>;
+type AnyEntity = Record<string, unknown>;
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-const pickColumns = (table: TableDef, payload: AnyEntity): Record<string, any> => {
-  const columns: Record<string, any> = {};
+const pickColumns = (table: TableDef, payload: AnyEntity): Record<string, unknown> => {
+  const columns: Record<string, unknown> = {};
   for (const key of Object.keys(table.columns)) {
     if (payload[key] !== undefined) {
       columns[key] = payload[key];
@@ -71,7 +77,7 @@ const isEntityInCollection = (items: AnyEntity[], pkName: string, entity: AnyEnt
   return items.some(item => toKey(item[pkName]) === toKey(entityPk));
 };
 
-const findInCollectionByPk = (items: AnyEntity[], pkName: string, pkValue: any): AnyEntity | undefined => {
+const findInCollectionByPk = (items: AnyEntity[], pkName: string, pkValue: unknown): AnyEntity | undefined => {
   if (pkValue === undefined || pkValue === null) return undefined;
   return items.find(item => toKey(item[pkName]) === toKey(pkValue));
 };
@@ -85,12 +91,12 @@ const handleHasMany = async (
   options: SaveGraphOptions
 ): Promise<void> => {
   if (!Array.isArray(payload)) return;
-  const collection = root[relationName];
+  const collection = root[relationName] as unknown as HasManyCollection<unknown>;
   await collection.load();
 
   const targetTable = relation.target;
   const targetPk = findPrimaryKey(targetTable);
-  const existing = collection.getItems();
+  const existing = collection.getItems() as unknown as AnyEntity[];
   const seen = new Set<string>();
 
   for (const item of payload) {
@@ -103,10 +109,10 @@ const handleHasMany = async (
       (pkValue !== undefined && pkValue !== null ? session.getEntity(targetTable, pkValue) : undefined);
 
     const entity = current ?? ensureEntity(session, targetTable, asObj);
-    assignColumns(targetTable, entity, asObj);
-    await applyGraphToEntity(session, targetTable, entity, asObj, options);
+    assignColumns(targetTable, entity as AnyEntity, asObj);
+    await applyGraphToEntity(session, targetTable, entity as AnyEntity, asObj, options);
 
-    if (!isEntityInCollection(collection.getItems(), targetPk, entity)) {
+    if (!isEntityInCollection(collection.getItems() as unknown as AnyEntity[], targetPk, entity as unknown as AnyEntity)) {
       collection.attach(entity);
     }
 
@@ -133,7 +139,7 @@ const handleHasOne = async (
   payload: unknown,
   options: SaveGraphOptions
 ): Promise<void> => {
-  const ref = root[relationName];
+  const ref = root[relationName] as unknown as HasOneReference<unknown>;
   if (payload === undefined) return;
   if (payload === null) {
     ref.set(null);
@@ -143,13 +149,13 @@ const handleHasOne = async (
   if (typeof payload === 'number' || typeof payload === 'string') {
     const entity = ref.set({ [pk]: payload });
     if (entity) {
-      await applyGraphToEntity(session, relation.target, entity, { [pk]: payload }, options);
+      await applyGraphToEntity(session, relation.target, entity as AnyEntity, { [pk]: payload }, options);
     }
     return;
   }
   const attached = ref.set(payload as AnyEntity);
   if (attached) {
-    await applyGraphToEntity(session, relation.target, attached, payload as AnyEntity, options);
+    await applyGraphToEntity(session, relation.target, attached as AnyEntity, payload as AnyEntity, options);
   }
 };
 
@@ -161,7 +167,7 @@ const handleBelongsTo = async (
   payload: unknown,
   options: SaveGraphOptions
 ): Promise<void> => {
-  const ref = root[relationName];
+  const ref = root[relationName] as unknown as BelongsToReference<unknown>;
   if (payload === undefined) return;
   if (payload === null) {
     ref.set(null);
@@ -171,13 +177,13 @@ const handleBelongsTo = async (
   if (typeof payload === 'number' || typeof payload === 'string') {
     const entity = ref.set({ [pk]: payload });
     if (entity) {
-      await applyGraphToEntity(session, relation.target, entity, { [pk]: payload }, options);
+      await applyGraphToEntity(session, relation.target, entity as AnyEntity, { [pk]: payload }, options);
     }
     return;
   }
   const attached = ref.set(payload as AnyEntity);
   if (attached) {
-    await applyGraphToEntity(session, relation.target, attached, payload as AnyEntity, options);
+    await applyGraphToEntity(session, relation.target, attached as AnyEntity, payload as AnyEntity, options);
   }
 };
 
@@ -190,7 +196,7 @@ const handleBelongsToMany = async (
   options: SaveGraphOptions
 ): Promise<void> => {
   if (!Array.isArray(payload)) return;
-  const collection = root[relationName];
+  const collection = root[relationName] as unknown as ManyToManyCollection<unknown>;
   await collection.load();
 
   const targetTable = relation.target;
@@ -212,10 +218,10 @@ const handleBelongsToMany = async (
       ? session.getEntity(targetTable, pkValue) ?? ensureEntity(session, targetTable, asObj)
       : ensureEntity(session, targetTable, asObj);
 
-    assignColumns(targetTable, entity, asObj);
-    await applyGraphToEntity(session, targetTable, entity, asObj, options);
+    assignColumns(targetTable, entity as AnyEntity, asObj);
+    await applyGraphToEntity(session, targetTable, entity as AnyEntity, asObj, options);
 
-    if (!isEntityInCollection(collection.getItems(), targetPk, entity)) {
+    if (!isEntityInCollection(collection.getItems() as unknown as AnyEntity[], targetPk, entity as unknown as AnyEntity)) {
       collection.attach(entity);
     }
 
@@ -225,7 +231,7 @@ const handleBelongsToMany = async (
   }
 
   if (options.pruneMissing) {
-    for (const item of [...collection.getItems()]) {
+    for (const item of [...collection.getItems()] as unknown as AnyEntity[]) {
       const pkValue = item[targetPk];
       if (pkValue !== undefined && pkValue !== null && !seen.has(toKey(pkValue))) {
         collection.detach(item);
@@ -272,7 +278,7 @@ const applyGraphToEntity = async (
 
 export const saveGraph = async <TTable extends TableDef>(
   session: OrmSession,
-  entityClass: EntityConstructor<any>,
+  entityClass: EntityConstructor,
   payload: AnyEntity,
   options: SaveGraphOptions = {}
 ): Promise<EntityInstance<TTable>> => {
@@ -282,11 +288,11 @@ export const saveGraph = async <TTable extends TableDef>(
   }
 
   const root = ensureEntity<TTable>(session, table as TTable, payload);
-  await applyGraphToEntity(session, table, root, payload, options);
+  await applyGraphToEntity(session, table, root as AnyEntity, payload, options);
   return root;
 };
 
-export const saveGraphInternal = async <TCtor extends EntityConstructor<any>>(
+export const saveGraphInternal = async <TCtor extends EntityConstructor>(
   session: OrmSession,
   entityClass: TCtor,
   payload: AnyEntity,
@@ -298,6 +304,6 @@ export const saveGraphInternal = async <TCtor extends EntityConstructor<any>>(
   }
 
   const root = ensureEntity(session, table, payload);
-  await applyGraphToEntity(session, table, root, payload, options);
+  await applyGraphToEntity(session, table, root as AnyEntity, payload, options);
   return root as unknown as InstanceType<TCtor>;
 };

package/src/orm/unit-of-work.ts

@@ -14,7 +14,7 @@ import type { TrackedEntity } from './runtime-types.js';
  * Unit of Work pattern implementation for tracking entity changes.
  */
 export class UnitOfWork {
-  private readonly trackedEntities = new Map<any, TrackedEntity>();
+  private readonly trackedEntities = new Map<unknown, TrackedEntity>();
 
   /**
    * Creates a new UnitOfWork instance.
@@ -51,7 +51,7 @@ export class UnitOfWork {
    * @param pk - The primary key value
    * @returns The entity or undefined if not found
    */
-  getEntity(table: TableDef, pk: string | number): any | undefined {
+  getEntity(table: TableDef, pk: string | number): unknown | undefined {
     return this.identityMap.getEntity(table, pk);
   }
 
@@ -69,7 +69,7 @@ export class UnitOfWork {
    * @param entity - The entity to find
    * @returns The tracked entity or undefined if not found
    */
-  findTracked(entity: any): TrackedEntity | undefined {
+  findTracked(entity: unknown): TrackedEntity | undefined {
     return this.trackedEntities.get(entity);
   }
 
@@ -79,7 +79,7 @@ export class UnitOfWork {
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  setEntity(table: TableDef, pk: string | number, entity: any): void {
+  setEntity(table: TableDef, pk: string | number, entity: unknown): void {
     if (pk === null || pk === undefined) return;
     let tracked = this.trackedEntities.get(entity);
     if (!tracked) {
@@ -88,7 +88,7 @@ export class UnitOfWork {
         entity,
         pk,
         status: EntityStatus.Managed,
-        original: this.createSnapshot(table, entity)
+        original: this.createSnapshot(table, entity as Record<string, unknown>)
       };
       this.trackedEntities.set(entity, tracked);
     } else {
@@ -104,7 +104,7 @@ export class UnitOfWork {
    * @param entity - The entity instance
    * @param pk - Optional primary key value
    */
-  trackNew(table: TableDef, entity: any, pk?: string | number): void {
+  trackNew(table: TableDef, entity: unknown, pk?: string | number): void {
     const tracked: TrackedEntity = {
       table,
       entity,
@@ -124,13 +124,13 @@ export class UnitOfWork {
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  trackManaged(table: TableDef, pk: string | number, entity: any): void {
+  trackManaged(table: TableDef, pk: string | number, entity: unknown): void {
     const tracked: TrackedEntity = {
       table,
       entity,
       pk,
       status: EntityStatus.Managed,
-      original: this.createSnapshot(table, entity)
+      original: this.createSnapshot(table, entity as Record<string, unknown>)
     };
     this.trackedEntities.set(entity, tracked);
     this.registerIdentity(tracked);
@@ -140,7 +140,7 @@ export class UnitOfWork {
    * Marks an entity as dirty (modified).
    * @param entity - The entity to mark as dirty
    */
-  markDirty(entity: any): void {
+  markDirty(entity: unknown): void {
     const tracked = this.trackedEntities.get(entity);
     if (!tracked) return;
     if (tracked.status === EntityStatus.New || tracked.status === EntityStatus.Removed) return;
@@ -151,7 +151,7 @@ export class UnitOfWork {
    * Marks an entity as removed.
    * @param entity - The entity to mark as removed
    */
-  markRemoved(entity: any): void {
+  markRemoved(entity: unknown): void {
     const tracked = this.trackedEntities.get(entity);
     if (!tracked) return;
     tracked.status = EntityStatus.Removed;
@@ -194,7 +194,7 @@ export class UnitOfWork {
   private async flushInsert(tracked: TrackedEntity): Promise<void> {
     await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
 
-    const payload = this.extractColumns(tracked.table, tracked.entity);
+    const payload = this.extractColumns(tracked.table, tracked.entity as Record<string, unknown>);
     let builder = new InsertQueryBuilder(tracked.table).values(payload);
     if (this.dialect.supportsReturning()) {
       builder = builder.returning(...this.getReturningColumns(tracked.table));
@@ -204,7 +204,7 @@ export class UnitOfWork {
     this.applyReturningResults(tracked, results);
 
     tracked.status = EntityStatus.Managed;
-    tracked.original = this.createSnapshot(tracked.table, tracked.entity);
+    tracked.original = this.createSnapshot(tracked.table, tracked.entity as Record<string, unknown>);
     tracked.pk = this.getPrimaryKeyValue(tracked);
     this.registerIdentity(tracked);
 
@@ -241,7 +241,7 @@ export class UnitOfWork {
     this.applyReturningResults(tracked, results);
 
     tracked.status = EntityStatus.Managed;
-    tracked.original = this.createSnapshot(tracked.table, tracked.entity);
+    tracked.original = this.createSnapshot(tracked.table, tracked.entity as Record<string, unknown>);
     this.registerIdentity(tracked);
 
     await this.runHook(tracked.table.hooks?.afterUpdate, tracked);
@@ -279,7 +279,7 @@ export class UnitOfWork {
     tracked: TrackedEntity
   ): Promise<void> {
     if (!hook) return;
-    await hook(this.hookContext() as any, tracked.entity);
+    await hook(this.hookContext(), tracked.entity);
   }
 
   /**
@@ -305,7 +305,7 @@ export class UnitOfWork {
    * @param entity - The entity instance
    * @returns Object with column values
    */
-  private extractColumns(table: TableDef, entity: any): Record<string, unknown> {
+  private extractColumns(table: TableDef, entity: Record<string, unknown>): Record<string, unknown> {
     const payload: Record<string, unknown> = {};
     for (const column of Object.keys(table.columns)) {
       if (entity[column] === undefined) continue;
@@ -381,8 +381,8 @@ export class UnitOfWork {
    * @param entity - The entity instance
    * @returns Object with entity state
    */
-  private createSnapshot(table: TableDef, entity: any): Record<string, any> {
-    const snapshot: Record<string, any> = {};
+  private createSnapshot(table: TableDef, entity: Record<string, unknown>): Record<string, unknown> {
+    const snapshot: Record<string, unknown> = {};
     for (const column of Object.keys(table.columns)) {
       snapshot[column] = entity[column];
     }

package/src/query/index.ts

@@ -0,0 +1,74 @@
+import { TableDef } from '../schema/table.js';
+import { SelectQueryBuilder } from '../query-builder/select.js';
+import { InsertQueryBuilder } from '../query-builder/insert.js';
+import { UpdateQueryBuilder } from '../query-builder/update.js';
+import { DeleteQueryBuilder } from '../query-builder/delete.js';
+import { QueryTarget, resolveTable } from './target.js';
+
+/**
+ * Creates a SELECT query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to query from
+ * @returns A new SelectQueryBuilder instance for building SELECT queries
+ *
+ * @example
+ * ```typescript
+ * const query = selectFrom(UserTable).select('id', 'name');
+ * ```
+ */
+export const selectFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): SelectQueryBuilder<unknown, TTable> => {
+    const table = resolveTable(target);
+    return new SelectQueryBuilder(table);
+};
+
+/**
+ * Creates an INSERT query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to insert into
+ * @returns A new InsertQueryBuilder instance for building INSERT queries
+ *
+ * @example
+ * ```typescript
+ * const query = insertInto(UserTable).values({ name: 'John', email: 'john@example.com' });
+ * ```
+ */
+export const insertInto = <TTable extends TableDef>(target: QueryTarget<TTable>): InsertQueryBuilder<unknown> => {
+    const table = resolveTable(target);
+    return new InsertQueryBuilder(table);
+};
+
+/**
+ * Creates an UPDATE query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to update
+ * @returns A new UpdateQueryBuilder instance for building UPDATE queries
+ *
+ * @example
+ * ```typescript
+ * const query = update(UserTable).set({ name: 'Jane' }).where(eq(UserTable.id, 1));
+ * ```
+ */
+export const update = <TTable extends TableDef>(target: QueryTarget<TTable>): UpdateQueryBuilder<unknown> => {
+    const table = resolveTable(target);
+    return new UpdateQueryBuilder(table);
+};
+
+/**
+ * Creates a DELETE query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to delete from
+ * @returns A new DeleteQueryBuilder instance for building DELETE queries
+ *
+ * @example
+ * ```typescript
+ * const query = deleteFrom(UserTable).where(eq(UserTable.id, 1));
+ * ```
+ */
+export const deleteFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): DeleteQueryBuilder<unknown> => {
+    const table = resolveTable(target);
+    return new DeleteQueryBuilder(table);
+};

package/src/query/target.ts

@@ -0,0 +1,46 @@
+import { TableDef } from '../schema/table.js';
+import { isTableDef } from '../schema/table-guards.js';
+import { EntityConstructor } from '../orm/entity-metadata.js';
+import { getTableDefFromEntity } from '../decorators/bootstrap.js';
+
+/**
+ * Represents a target for query operations, which can be either a table definition
+ * or an entity constructor. This type allows flexible targeting of database tables
+ * through either direct table definitions or entity classes decorated with ORM metadata.
+ *
+ * @template TTable - The table definition type, defaults to TableDef
+ */
+export type QueryTarget<TTable extends TableDef = TableDef> = TTable | EntityConstructor;
+
+const resolveEntityTarget = <TTable extends TableDef>(ctor: EntityConstructor): TTable => {
+    const table = getTableDefFromEntity(ctor);
+    if (!table) {
+        throw new Error(`Entity '${ctor.name}' is not registered with decorators`);
+    }
+    return table as TTable;
+};
+
+/**
+ * Resolves a QueryTarget to its corresponding table definition.
+ *
+ * If the target is already a TableDef, it returns it directly.
+ * If the target is an EntityConstructor, it retrieves the associated table definition
+ * from the entity's metadata.
+ *
+ * @template TTable - The table definition type
+ * @param target - The query target to resolve
+ * @returns The resolved table definition
+ * @throws Error if the entity constructor is not registered with decorators
+ *
+ * @example
+ * ```typescript
+ * const table = resolveTable(UserTable); // Returns UserTable directly
+ * const table2 = resolveTable(UserEntity); // Returns table def from UserEntity metadata
+ * ```
+ */
+export const resolveTable = <TTable extends TableDef>(target: QueryTarget<TTable>): TTable => {
+    if (isTableDef(target)) {
+        return target as TTable;
+    }
+    return resolveEntityTarget(target as EntityConstructor);
+};

package/src/query-builder/delete-query-state.ts

@@ -14,6 +14,11 @@ export class DeleteQueryState {
   public readonly table: TableDef;
   public readonly ast: DeleteQueryNode;
 
+  /**
+   * Creates a new DeleteQueryState instance
+   * @param table - The table definition for the DELETE query
+   * @param ast - Optional initial AST node, defaults to a basic DELETE query
+   */
   constructor(table: TableDef, ast?: DeleteQueryNode) {
     this.table = table;
     this.ast = ast ?? {
@@ -27,6 +32,11 @@ export class DeleteQueryState {
     return new DeleteQueryState(this.table, nextAst);
   }
 
+  /**
+   * Adds a WHERE clause to the DELETE query
+   * @param expr - The expression to use as the WHERE condition
+   * @returns A new DeleteQueryState with the WHERE clause added
+   */
   withWhere(expr: ExpressionNode): DeleteQueryState {
     return this.clone({
       ...this.ast,
@@ -34,6 +44,11 @@ export class DeleteQueryState {
     });
   }
 
+  /**
+   * Adds a RETURNING clause to the DELETE query
+   * @param columns - The columns to return after deletion
+   * @returns A new DeleteQueryState with the RETURNING clause added
+   */
   withReturning(columns: ColumnNode[]): DeleteQueryState {
     return this.clone({
       ...this.ast,
@@ -41,6 +56,11 @@ export class DeleteQueryState {
     });
   }
 
+  /**
+   * Adds a USING clause to the DELETE query
+   * @param source - The table source to use in the USING clause
+   * @returns A new DeleteQueryState with the USING clause added
+   */
   withUsing(source: TableSourceNode): DeleteQueryState {
     return this.clone({
       ...this.ast,
@@ -48,6 +68,11 @@ export class DeleteQueryState {
     });
   }
 
+  /**
+   * Adds a JOIN clause to the DELETE query
+   * @param join - The join node to add
+   * @returns A new DeleteQueryState with the JOIN clause added
+   */
   withJoin(join: JoinNode): DeleteQueryState {
     return this.clone({
       ...this.ast,
@@ -55,6 +80,11 @@ export class DeleteQueryState {
     });
   }
 
+  /**
+   * Sets an alias for the table in the DELETE query
+   * @param alias - The alias to assign to the table
+   * @returns A new DeleteQueryState with the table alias set
+   */
   withTableAlias(alias: string): DeleteQueryState {
     return this.clone({
       ...this.ast,

package/src/query-builder/delete.ts

@@ -2,12 +2,14 @@ import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
 import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
 import { JOIN_KINDS, JoinKind } from '../core/sql/sql.js';
-import { CompiledQuery, DeleteCompiler, Dialect } from '../core/dialect/abstract.js';
+import { CompiledQuery, Dialect } from '../core/dialect/abstract.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
 import { TableSourceNode, DeleteQueryNode } from '../core/ast/query.js';
 import { DeleteQueryState } from './delete-query-state.js';
 import { createJoinNode } from '../core/ast/join-node.js';
 import { buildColumnNode } from '../core/ast/builders.js';
+import { OrmSession } from '../orm/orm-session.js';
+import { QueryResult } from '../core/execution/db-executor.js';
 
 type DeleteDialectInput = Dialect | DialectKey;
 
@@ -18,6 +20,11 @@ export class DeleteQueryBuilder<T> {
   private readonly table: TableDef;
   private readonly state: DeleteQueryState;
 
+  /**
+   * Creates a new DeleteQueryBuilder instance
+   * @param table - The table definition for the DELETE query
+   * @param state - Optional initial query state, defaults to a new DeleteQueryState
+   */
   constructor(table: TableDef, state?: DeleteQueryState) {
     this.table = table;
     this.state = state ?? new DeleteQueryState(table);
@@ -27,18 +34,41 @@ export class DeleteQueryBuilder<T> {
     return new DeleteQueryBuilder(this.table, state);
   }
 
+  /**
+   * Adds a WHERE clause to the DELETE query
+   * @param expr - The expression to use as the WHERE condition
+   * @returns A new DeleteQueryBuilder with the WHERE clause added
+   */
   where(expr: ExpressionNode): DeleteQueryBuilder<T> {
     return this.clone(this.state.withWhere(expr));
   }
 
+  /**
+   * Sets an alias for the table in the DELETE query
+   * @param alias - The alias to assign to the table
+   * @returns A new DeleteQueryBuilder with the table alias set
+   */
   as(alias: string): DeleteQueryBuilder<T> {
     return this.clone(this.state.withTableAlias(alias));
   }
 
+  /**
+   * Adds a USING clause to the DELETE query
+   * @param source - The table source to use in the USING clause
+   * @returns A new DeleteQueryBuilder with the USING clause added
+   */
   using(source: TableDef | TableSourceNode): DeleteQueryBuilder<T> {
     return this.clone(this.state.withUsing(this.resolveTableSource(source)));
   }
 
+  /**
+   * Adds a JOIN clause to the DELETE query
+   * @param table - The table to join with
+   * @param condition - The join condition expression
+   * @param kind - The type of join (defaults to INNER)
+   * @param relationName - Optional name for the relation
+   * @returns A new DeleteQueryBuilder with the JOIN clause added
+   */
   join(
     table: TableDef | TableSourceNode | string,
     condition: ExpressionNode,
@@ -50,6 +80,11 @@ export class DeleteQueryBuilder<T> {
     return this.clone(this.state.withJoin(joinNode));
   }
 
+  /**
+   * Adds a RETURNING clause to the DELETE query
+   * @param columns - The columns to return after deletion
+   * @returns A new DeleteQueryBuilder with the RETURNING clause added
+   */
   returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T> {
     if (!columns.length) return this;
     const nodes = columns.map(column => buildColumnNode(this.table, column));
@@ -68,28 +103,39 @@ export class DeleteQueryBuilder<T> {
     return this.resolveTableSource(table);
   }
 
-  // Existing compiler-based compile stays, but we add a new overload.
-
-  // 1) Keep the old behavior (used internally / tests, if any):
-  compile(compiler: DeleteCompiler): CompiledQuery;
-  // 2) New ergonomic overload:
-  compile(dialect: DeleteDialectInput): CompiledQuery;
-
-  compile(arg: DeleteCompiler | DeleteDialectInput): CompiledQuery {
-    if (typeof (arg as any).compileDelete === 'function') {
-      // DeleteCompiler path – old behavior
-      return (arg as DeleteCompiler).compileDelete(this.state.ast);
-    }
+  /**
+   * Compiles the DELETE query for the specified dialect
+   * @param dialect - The SQL dialect to compile for
+   * @returns The compiled query with SQL and parameters
+   */
+  compile(dialect: DeleteDialectInput): CompiledQuery {
+    const resolved = resolveDialectInput(dialect);
+    return resolved.compileDelete(this.state.ast);
+  }
 
-    // Dialect | string path – new behavior
-    const dialect = resolveDialectInput(arg as DeleteDialectInput);
-    return dialect.compileDelete(this.state.ast);
+  /**
+   * Returns the SQL string for the DELETE query
+   * @param dialect - The SQL dialect to generate SQL for
+   * @returns The SQL string representation of the query
+   */
+  toSql(dialect: DeleteDialectInput): string {
+    return this.compile(dialect).sql;
   }
 
-  toSql(arg: DeleteCompiler | DeleteDialectInput): string {
-    return this.compile(arg as any).sql;
+  /**
+   * Executes the DELETE query using the provided session
+   * @param session - The ORM session to execute the query with
+   * @returns A promise that resolves to the query results
+   */
+  async execute(session: OrmSession): Promise<QueryResult[]> {
+    const compiled = this.compile(session.dialect);
+    return session.executor.executeSql(compiled.sql, compiled.params);
   }
 
+  /**
+   * Returns the Abstract Syntax Tree (AST) representation of the query
+   * @returns The AST node for the DELETE query
+   */
   getAST(): DeleteQueryNode {
     return this.state.ast;
   }