WIP: query builder

Author: yago-dorea-deel

CHANGELOG.md

@@ -0,0 +1,127 @@
+import type { WhereOptions } from '../abstract-dialect/where-sql-builder-types.js';
+import type { FindAttributeOptions, Model, ModelStatic } from '../model.d.ts';
+import { BaseSqlExpression, SQL_IDENTIFIER } from './base-sql-expression.js';
+
+/**
+ * Do not use me directly. Use Model.select() instead.
+ */
+export class QueryBuilder<M extends Model = Model> extends BaseSqlExpression {
+  declare protected readonly [SQL_IDENTIFIER]: 'queryBuilder';
+
+  private readonly _model: ModelStatic<M>;
+  private _attributes?: FindAttributeOptions;
+  private _where?: WhereOptions;
+  private _isSelect: boolean = false;
+
+  constructor(model: ModelStatic<M>) {
+    super();
+    this._model = model;
+  }
+
+  /**
+   * Initialize a SELECT query
+   *
+   * @returns The query builder instance for chaining
+   */
+  select(): QueryBuilder<M> {
+    const newBuilder = new QueryBuilder(this._model);
+    newBuilder._isSelect = true;
+    if (this._attributes !== undefined) {
+      newBuilder._attributes = this._attributes;
+    }
+
+    if (this._where !== undefined) {
+      newBuilder._where = this._where;
+    }
+
+    return newBuilder;
+  }
+
+  /**
+   * Specify which attributes to select
+   *
+   * @param attributes - Array of attribute names or attribute options
+   * @returns The query builder instance for chaining
+   */
+  attributes(attributes: FindAttributeOptions): QueryBuilder<M> {
+    const newBuilder = new QueryBuilder(this._model);
+    newBuilder._isSelect = this._isSelect;
+    newBuilder._attributes = attributes;
+    newBuilder._where = this._where;
+
+    return newBuilder;
+  }
+
+  /**
+   * Add WHERE conditions to the query
+   *
+   * @param conditions - Where conditions object
+   * @returns The query builder instance for chaining
+   */
+  where(conditions: WhereOptions): QueryBuilder<M> {
+    const newBuilder = new QueryBuilder(this._model);
+    newBuilder._isSelect = this._isSelect;
+    if (this._attributes !== undefined) {
+      newBuilder._attributes = this._attributes;
+    }
+
+    newBuilder._where = conditions;
+
+    return newBuilder;
+  }
+
+  /**
+   * Generate the SQL query string
+   *
+   * @returns The SQL query
+   */
+  getQuery(): string {
+    if (!this._isSelect) {
+      throw new Error('Query builder requires select() to be called first');
+    }
+
+    const queryGenerator = this._model.queryGenerator;
+    const tableName = this._model.tableName;
+
+    // Build the options object that matches Sequelize's FindOptions pattern
+    const options: any = {
+      attributes: this._attributes,
+      where: this._where,
+      raw: true,
+      plain: false,
+    };
+
+    // Generate the SQL using the existing query generator
+    const sql = queryGenerator.selectQuery(tableName, options, this._model);
+
+    return sql;
+  }
+
+  /**
+   * Get the table name for this query
+   *
+   * @returns The table name
+   */
+  get tableName(): string {
+    return this._model.tableName;
+  }
+
+  /**
+   * Get the model class
+   *
+   * @returns The model class
+   */
+  get model(): ModelStatic<M> {
+    return this._model;
+  }
+}
+
+/**
+ * Creates a new QueryBuilder instance for the given model
+ *
+ * @param model - The model class
+ * @returns A new query builder instance
+ */
+export function createQueryBuilder<M extends Model>(model: ModelStatic<M>): QueryBuilder<M> {
+  return new QueryBuilder(model);
+}

packages/core/CHANGELOG.md

@@ -26,6 +26,7 @@ import type { Cast } from './expression-builders/cast.js';
 import type { Col } from './expression-builders/col.js';
 import type { Fn } from './expression-builders/fn.js';
 import type { Literal } from './expression-builders/literal.js';
+import type { QueryBuilder } from './expression-builders/query-builder.js';
 import type { Where } from './expression-builders/where.js';
 import type { Lock, Op, TableHints, Transaction, WhereOptions } from './index';
 import type { IndexHints } from './index-hints';
@@ -2395,6 +2396,22 @@ export abstract class Model<
     options?: AddScopeOptions,
   ): void;
 
+  /**
+   * Creates a new QueryBuilder instance for this model.
+   * This enables functional/chainable query building.
+   *
+   * @returns A new QueryBuilder instance for this model
+   *
+   * @example
+   * ```js
+   * const query = User.select()
+   *   .attributes(['name', 'email'])
+   *   .where({ active: true })
+   *   .getQuery();
+   * ```
+   */
+  static select<M extends Model>(this: ModelStatic<M>): QueryBuilder<M>;
+
   /**
    * Search for multiple instances.
    * See {@link https://sequelize.org/docs/v7/core-concepts/model-querying-basics/} for more information about querying.

packages/core/src/expression-builders/query-builder.ts

@@ -40,6 +40,7 @@ import { AssociationSecret } from './associations/helpers';
 import * as DataTypes from './data-types';
 import * as SequelizeErrors from './errors';
 import { BaseSqlExpression } from './expression-builders/base-sql-expression.js';
+import { QueryBuilder } from './expression-builders/query-builder.js';
 import { InstanceValidator } from './instance-validator';
 import {
   _validateIncludedElements,
@@ -4626,6 +4627,24 @@ Instead of specifying a Model, either:
   static belongsTo(target, options) {
     return BelongsToAssociation.associate(AssociationSecret, this, target, options);
   }
+
+  /**
+   * Creates a new QueryBuilder instance for this model.
+   * This enables functional/chainable query building.
+   *
+   * @returns {QueryBuilder} A new QueryBuilder instance for this model
+   *
+   * @example
+   * ```js
+   * const query = User.select()
+   *   .attributes(['name', 'email'])
+   *   .where({ active: true })
+   *   .getQuery();
+   * ```
+   */
+  static select() {
+    return new QueryBuilder(this).select();
+  }
 }
 
 /**