@decaf-ts/for-typeorm 0.0.6

package/lib/esm/query/Paginator.js

@@ -0,0 +1,124 @@
+import { Paginator, PagingError } from "@decaf-ts/core";
+import { ModelKeys } from "@decaf-ts/decorator-validation";
+import { findPrimaryKey } from "@decaf-ts/db-decorators";
+/**
+ * @description Paginator for TypeORM query results.
+ * @summary Implements pagination for TypeORM-built queries using take/skip for efficient navigation through result sets.
+ * @template M The model type that extends Model.
+ * @template R The result type.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter.
+ * @param {TypeORMQuery} query The query container to paginate.
+ * @param {number} size The page size.
+ * @param {Constructor<M>} clazz The model constructor.
+ * @class TypeORMPaginator
+ * @example
+ * // Example of using TypeORMPaginator
+ * const paginator = new TypeORMPaginator(adapter, { query: qb }, 10, User);
+ * const page1 = await paginator.page(1);
+ * const page2 = await paginator.page(2);
+ */
+export class TypeORMPaginator extends Paginator {
+    /**
+     * @description Gets the total number of pages
+     * @summary Returns the total number of pages based on the record count and page size
+     * @return {number} The total number of pages
+     */
+    get total() {
+        return this._totalPages;
+    }
+    /**
+     * @description Gets the total record count
+     * @summary Returns the total number of records matching the query
+     * @return {number} The total record count
+     */
+    get count() {
+        return this._recordCount;
+    }
+    get repo() {
+        if (!this.__repo) {
+            this.__repo = this.adapter.dataSource.getRepository(this.clazz[ModelKeys.ANCHOR]);
+        }
+        return this.__repo;
+    }
+    /**
+     * @description Creates a new TypeORMPaginator instance.
+     * @summary Initializes a paginator for TypeORM query results.
+     * @param {TypeORMAdapter} adapter The TypeORM adapter.
+     * @param {TypeORMQuery} query The TypeORM query container to paginate.
+     * @param {number} size The page size.
+     * @param {Constructor<M>} clazz The model constructor.
+     */
+    constructor(adapter, query, size, clazz) {
+        super(adapter, query, size, clazz);
+    }
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {TypeORMQuery} rawStatement - The original PostgreSQL query
+     * @return {TypeORMQuery} The prepared query with pagination parameters
+     */
+    prepare(rawStatement) {
+        const query = { ...rawStatement };
+        return query;
+    }
+    /**
+     * @description Retrieves a specific page of results.
+     * @summary Executes the query with pagination and processes the results.
+     * @param {number} [page=1] The page number to retrieve.
+     * @return {Promise<R[]>} A promise that resolves to an array of results.
+     * @throws {PagingError} If trying to access an invalid page or if no class is defined.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant Paginator as TypeORMPaginator
+     *   participant Adapter
+     *   participant DB as Database
+     *
+     *   Client->>Paginator: page(pageNumber)
+     *   Note over Paginator: Prepare options (skip/take)
+     *
+     *   alt First time or need count
+     *     Paginator->>Adapter: Get count
+     *     Adapter->>DB: Execute COUNT
+     *     DB-->>Adapter: count
+     *     Adapter-->>Paginator: count
+     *     Paginator->>Paginator: Calculate total pages
+     *   end
+     *
+     *   Paginator->>Adapter: Execute query
+     *   Adapter->>DB: findAndCount(options)
+     *   DB-->>Adapter: rows, count
+     *   Adapter-->>Paginator: rows, count
+     *
+     *   Paginator->>Paginator: Map rows to models
+     *   Paginator-->>Client: results
+     */
+    async page(page = 1) {
+        const statement = { ...this.statement };
+        // Get total count if not already calculated
+        if (!this._recordCount || !this._totalPages) {
+            this._totalPages = this._recordCount = 0;
+        }
+        const opts = Object.assign(statement, {
+            skip: (this.current || 0) * this.size,
+            take: this.size,
+        });
+        // this.validatePage(page);
+        const result = await this.repo.findAndCount(opts);
+        this._recordCount = result[1];
+        this._totalPages = Math.ceil(this._recordCount / this.size);
+        if (!this.clazz)
+            throw new PagingError("No statement target defined");
+        const pkDef = findPrimaryKey(new this.clazz());
+        const rows = result[0] || [];
+        const results = 
+        // statement.columns && statement.columns.length
+        //   ? rows // has columns means it's not full model
+        rows.map((row) => {
+            return this.adapter.revert(row, this.clazz, pkDef.id, row[pkDef.id]);
+        });
+        this._currentPage = page;
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Paginator.js","sourceRoot":"","sources":["../../../src/query/Paginator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAsB,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAG/E,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,gBAAqC,SAAQ,SAIzD;IACC;;;;OAIG;IACH,IAAa,KAAK;QAChB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACH,IAAa,KAAK;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAID,IAAc,IAAI;QAChB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,GAAI,IAAI,CAAC,OAA0B,CAAC,UAAU,CAAC,aAAa,CACrE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAiC,CAAC,CACxD,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;;OAOG;IACH,YACE,OAAuB,EACvB,KAAmB,EACnB,IAAY,EACZ,KAAqB;QAErB,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAED;;;;;OAKG;IACO,OAAO,CAAC,YAA0B;QAC1C,MAAM,KAAK,GAAiB,EAAE,GAAG,YAAY,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IAEH,KAAK,CAAC,IAAI,CAAC,OAAe,CAAC;QACzB,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAExC,4CAA4C;QAC5C,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YAC5C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QAC3C,CAAC;QAED,MAAM,IAAI,GAAuB,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE;YACxD,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI;YACrC,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC,CAAC;QAEH,2BAA2B;QAE3B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAElD,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAE5D,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,WAAW,CAAC,6BAA6B,CAAC,CAAC;QAEtE,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAE7B,MAAM,OAAO;QACX,gDAAgD;QAChD,oDAAoD;QACpD,IAAI,CAAC,GAAG,CAAC,CAAC,GAAQ,EAAE,EAAE;YACpB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,OAAO,OAAyB,CAAC;IACnC,CAAC;CACF","sourcesContent":["import { Paginator, PagingError } from \"@decaf-ts/core\";\nimport { TypeORMQuery } from \"../types\";\nimport { Constructor, Model, ModelKeys } from \"@decaf-ts/decorator-validation\";\nimport { TypeORMAdapter } from \"../TypeORMAdapter\";\nimport { FindManyOptions, Repository as Repo } from \"typeorm\";\nimport { findPrimaryKey } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Paginator for TypeORM query results.\n * @summary Implements pagination for TypeORM-built queries using take/skip for efficient navigation through result sets.\n * @template M The model type that extends Model.\n * @template R The result type.\n * @param {TypeORMAdapter} adapter The TypeORM adapter.\n * @param {TypeORMQuery} query The query container to paginate.\n * @param {number} size The page size.\n * @param {Constructor<M>} clazz The model constructor.\n * @class TypeORMPaginator\n * @example\n * // Example of using TypeORMPaginator\n * const paginator = new TypeORMPaginator(adapter, { query: qb }, 10, User);\n * const page1 = await paginator.page(1);\n * const page2 = await paginator.page(2);\n */\nexport class TypeORMPaginator<M extends Model, R> extends Paginator<\n  M,\n  R,\n  TypeORMQuery\n> {\n  /**\n   * @description Gets the total number of pages\n   * @summary Returns the total number of pages based on the record count and page size\n   * @return {number} The total number of pages\n   */\n  override get total(): number {\n    return this._totalPages;\n  }\n\n  /**\n   * @description Gets the total record count\n   * @summary Returns the total number of records matching the query\n   * @return {number} The total record count\n   */\n  override get count(): number {\n    return this._recordCount;\n  }\n\n  private __repo?: Repo<any>;\n\n  protected get repo() {\n    if (!this.__repo) {\n      this.__repo = (this.adapter as TypeORMAdapter).dataSource.getRepository(\n        this.clazz[ModelKeys.ANCHOR as keyof typeof this.clazz]\n      );\n    }\n    return this.__repo;\n  }\n\n  /**\n   * @description Creates a new TypeORMPaginator instance.\n   * @summary Initializes a paginator for TypeORM query results.\n   * @param {TypeORMAdapter} adapter The TypeORM adapter.\n   * @param {TypeORMQuery} query The TypeORM query container to paginate.\n   * @param {number} size The page size.\n   * @param {Constructor<M>} clazz The model constructor.\n   */\n  constructor(\n    adapter: TypeORMAdapter,\n    query: TypeORMQuery,\n    size: number,\n    clazz: Constructor<M>\n  ) {\n    super(adapter, query, size, clazz);\n  }\n\n  /**\n   * @description Prepares a query for pagination\n   * @summary Modifies the raw query to include pagination parameters\n   * @param {TypeORMQuery} rawStatement - The original PostgreSQL query\n   * @return {TypeORMQuery} The prepared query with pagination parameters\n   */\n  protected prepare(rawStatement: TypeORMQuery): TypeORMQuery {\n    const query: TypeORMQuery = { ...rawStatement };\n    return query;\n  }\n\n  /**\n   * @description Retrieves a specific page of results.\n   * @summary Executes the query with pagination and processes the results.\n   * @param {number} [page=1] The page number to retrieve.\n   * @return {Promise<R[]>} A promise that resolves to an array of results.\n   * @throws {PagingError} If trying to access an invalid page or if no class is defined.\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant Paginator as TypeORMPaginator\n   *   participant Adapter\n   *   participant DB as Database\n   *\n   *   Client->>Paginator: page(pageNumber)\n   *   Note over Paginator: Prepare options (skip/take)\n   *\n   *   alt First time or need count\n   *     Paginator->>Adapter: Get count\n   *     Adapter->>DB: Execute COUNT\n   *     DB-->>Adapter: count\n   *     Adapter-->>Paginator: count\n   *     Paginator->>Paginator: Calculate total pages\n   *   end\n   *\n   *   Paginator->>Adapter: Execute query\n   *   Adapter->>DB: findAndCount(options)\n   *   DB-->>Adapter: rows, count\n   *   Adapter-->>Paginator: rows, count\n   *\n   *   Paginator->>Paginator: Map rows to models\n   *   Paginator-->>Client: results\n   */\n\n  async page(page: number = 1): Promise<R[]> {\n    const statement = { ...this.statement };\n\n    // Get total count if not already calculated\n    if (!this._recordCount || !this._totalPages) {\n      this._totalPages = this._recordCount = 0;\n    }\n\n    const opts: FindManyOptions<M> = Object.assign(statement, {\n      skip: (this.current || 0) * this.size,\n      take: this.size,\n    });\n\n    // this.validatePage(page);\n\n    const result = await this.repo.findAndCount(opts);\n\n    this._recordCount = result[1];\n    this._totalPages = Math.ceil(this._recordCount / this.size);\n\n    if (!this.clazz) throw new PagingError(\"No statement target defined\");\n\n    const pkDef = findPrimaryKey(new this.clazz());\n    const rows = result[0] || [];\n\n    const results =\n      // statement.columns && statement.columns.length\n      //   ? rows // has columns means it's not full model\n      rows.map((row: any) => {\n        return this.adapter.revert(row, this.clazz, pkDef.id, row[pkDef.id]);\n      });\n\n    this._currentPage = page;\n    return results as unknown as R[];\n  }\n}\n"]}

package/lib/esm/query/Statement.d.ts

@@ -0,0 +1,131 @@
+import { Condition, GroupOperator, Operator, Paginator, Statement } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { TypeORMQuery } from "../types";
+import { TypeORMAdapter } from "../TypeORMAdapter";
+import { SelectQueryBuilder } from "typeorm";
+import { FindOptionsWhere } from "typeorm/find-options/FindOptionsWhere";
+/**
+ * @description Statement builder for TypeORM-backed queries.
+ * @summary Provides a fluent interface for building SQL queries via TypeORM's SelectQueryBuilder with type safety and Decaf.ts abstractions.
+ * @template M The model type that extends Model.
+ * @template R The result type returned from execution.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter.
+ * @class TypeORMStatement
+ * @example
+ * // Example using TypeORMStatement
+ * const statement = new TypeORMStatement<User, User[]>(adapter);
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
+export declare class TypeORMStatement<M extends Model, R> extends Statement<TypeORMQuery<M>, M, R> {
+    protected adapter: TypeORMAdapter;
+    constructor(adapter: TypeORMAdapter);
+    /**
+     * @description Builds a TypeORM SelectQueryBuilder from the statement.
+     * @summary Converts the statement's conditions, selectors, and options into a TypeORM-backed query object.
+     * @return {TypeORMQuery} The built TypeORM query container.
+     * @throws {Error} If there are invalid query conditions.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize query
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add columns to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed conditions
+     *     Statement->>Statement: Add conditions to query
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add orderBy to query
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set offset
+     *   end
+     *
+     *   Statement-->>Statement: Return query
+     */
+    protected build(): TypeORMQuery<M>;
+    /**
+     * @description Creates a paginator for the statement.
+     * @summary Builds the query and returns a TypeORMPaginator for paginated results.
+     * @template R The result type.
+     * @param {number} size The page size.
+     * @return {Promise<Paginator<M, R, TypeORMQuery>>} A promise that resolves to a paginator.
+     * @throws {InternalError} If there's an error building the query.
+     */
+    paginate<R>(size: number): Promise<Paginator<M, R, TypeORMQuery>>;
+    /**
+     * @description Processes a record.
+     * @summary Converts a raw result row to a model instance using the adapter.
+     * @param {any} r The raw record.
+     * @param {keyof M} pkAttr The primary key attribute of the model.
+     * @param {"Number" | "BigInt" | undefined} sequenceType The type of the sequence.
+     * @return {any} The processed record.
+     */
+    private processRecord;
+    /**
+     * @description Executes a raw TypeORM query builder.
+     * @summary Sends the built SelectQueryBuilder to the database via TypeORM and returns the results.
+     * @template R The result type.
+     * @param {TypeORMQuery} rawInput The query container to execute.
+     * @return {Promise<R>} A promise that resolves to the query results.
+     */
+    raw<R>(rawInput: TypeORMQuery<M>): Promise<R>;
+    protected parseConditionForPagination(condition: Condition<M>, tableName: string, counter?: number, conditionalOp?: GroupOperator | Operator): FindOptionsWhere<M>[] | FindOptionsWhere<M>;
+    /**
+     * @description Parses a condition into PostgreSQL conditions
+     * @summary Converts a Condition object into PostgreSQL condition structures
+     * @param {Condition<M>} condition - The condition to parse
+     * @param {string} [tableName] - the positional index of the arguments
+     * @return {TypeORMQuery} The PostgresSQL condition
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return PostgreSQL operator
+     *     Statement->>Statement: Create condition with column, operator, and value
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: Add NOT to conditions
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>Statement: Combine conditions with AND/OR
+     *   end
+     *
+     *   Statement-->>Statement: Return conditions array
+     */
+    protected parseCondition(condition: Condition<M>, tableName: string, qb: SelectQueryBuilder<any>, counter?: number, conditionalOp?: GroupOperator | Operator): TypeORMQuery<M>;
+}

package/lib/esm/query/Statement.js

@@ -0,0 +1,242 @@
+import { GroupOperator, Operator, OrderDirection, Repository, Statement, } from "@decaf-ts/core";
+import { ModelKeys } from "@decaf-ts/decorator-validation";
+import { translateOperators } from "./translate.js";
+import { TypeORMQueryLimit } from "./constants.js";
+import { TypeORMPaginator } from "./Paginator.js";
+import { findPrimaryKey, InternalError } from "@decaf-ts/db-decorators";
+/**
+ * @description Statement builder for TypeORM-backed queries.
+ * @summary Provides a fluent interface for building SQL queries via TypeORM's SelectQueryBuilder with type safety and Decaf.ts abstractions.
+ * @template M The model type that extends Model.
+ * @template R The result type returned from execution.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter.
+ * @class TypeORMStatement
+ * @example
+ * // Example using TypeORMStatement
+ * const statement = new TypeORMStatement<User, User[]>(adapter);
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
+export class TypeORMStatement extends Statement {
+    constructor(adapter) {
+        super(adapter);
+    }
+    /**
+     * @description Builds a TypeORM SelectQueryBuilder from the statement.
+     * @summary Converts the statement's conditions, selectors, and options into a TypeORM-backed query object.
+     * @return {TypeORMQuery} The built TypeORM query container.
+     * @throws {Error} If there are invalid query conditions.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize query
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add columns to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed conditions
+     *     Statement->>Statement: Add conditions to query
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add orderBy to query
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set offset
+     *   end
+     *
+     *   Statement-->>Statement: Return query
+     */
+    build() {
+        const log = this.log.for(this.build);
+        const tableName = Repository.table(this.fromSelector);
+        const m = new this.fromSelector();
+        const q = {
+            query: this.adapter.dataSource
+                .getRepository(this.fromSelector[ModelKeys.ANCHOR])
+                .createQueryBuilder(tableName),
+        };
+        if (this.selectSelector)
+            q.query = q.query.select(this.selectSelector.map((s) => `${tableName}.${s}`));
+        else
+            q.query = q.query.select();
+        //
+        // q.query = (q.query as SelectQueryBuilder<any>).from(
+        //   this.fromSelector[ModelKeys.ANCHOR as keyof typeof this.fromSelector],
+        //   tableName
+        // );
+        if (this.whereCondition)
+            q.query = this.parseCondition(this.whereCondition, tableName, q.query).query;
+        let orderByArgs;
+        if (!this.orderBySelector)
+            orderByArgs = [
+                `${tableName}.${findPrimaryKey(m).id}`,
+                OrderDirection.ASC.toUpperCase(),
+            ];
+        else
+            orderByArgs = [
+                `${tableName}.${this.orderBySelector[0]}`,
+                this.orderBySelector[1].toUpperCase(),
+            ];
+        q.query = q.query.orderBy(...orderByArgs);
+        if (this.limitSelector) {
+            q.query = q.query.limit(this.limitSelector);
+        }
+        else {
+            log.debug(`No limit selector defined. Using default limit of ${TypeORMQueryLimit}`);
+            q.query = q.query.limit(TypeORMQueryLimit);
+        }
+        // Add offset
+        if (this.offsetSelector)
+            q.query = q.query.skip(this.offsetSelector);
+        return q;
+    }
+    /**
+     * @description Creates a paginator for the statement.
+     * @summary Builds the query and returns a TypeORMPaginator for paginated results.
+     * @template R The result type.
+     * @param {number} size The page size.
+     * @return {Promise<Paginator<M, R, TypeORMQuery>>} A promise that resolves to a paginator.
+     * @throws {InternalError} If there's an error building the query.
+     */
+    async paginate(size) {
+        try {
+            const query = this.build();
+            const transformedQuery = {};
+            const a = query.query;
+            if (this.whereCondition)
+                transformedQuery.where = this.parseConditionForPagination(this.whereCondition, Repository.table(this.fromSelector));
+            if (this.orderBySelector)
+                transformedQuery.order = {
+                    [this.orderBySelector[0]]: this.orderBySelector[1].toString(),
+                };
+            return new TypeORMPaginator(this.adapter, transformedQuery, size, this.fromSelector);
+        }
+        catch (e) {
+            throw new InternalError(e);
+        }
+    }
+    /**
+     * @description Processes a record.
+     * @summary Converts a raw result row to a model instance using the adapter.
+     * @param {any} r The raw record.
+     * @param {keyof M} pkAttr The primary key attribute of the model.
+     * @param {"Number" | "BigInt" | undefined} sequenceType The type of the sequence.
+     * @return {any} The processed record.
+     */
+    processRecord(r, pkAttr) {
+        if (typeof r[pkAttr] !== "undefined") {
+            return this.adapter.revert(r, this.fromSelector, pkAttr, r[pkAttr]);
+        }
+        return r;
+    }
+    /**
+     * @description Executes a raw TypeORM query builder.
+     * @summary Sends the built SelectQueryBuilder to the database via TypeORM and returns the results.
+     * @template R The result type.
+     * @param {TypeORMQuery} rawInput The query container to execute.
+     * @return {Promise<R>} A promise that resolves to the query results.
+     */
+    async raw(rawInput) {
+        const log = this.log.for(this.raw);
+        log.debug(`Executing raw query: ${rawInput.query.getSql()}`);
+        return (await rawInput.query.getMany());
+    }
+    parseConditionForPagination(condition, tableName, counter = 0, conditionalOp) {
+        throw new InternalError("Not implemented");
+    }
+    /**
+     * @description Parses a condition into PostgreSQL conditions
+     * @summary Converts a Condition object into PostgreSQL condition structures
+     * @param {Condition<M>} condition - The condition to parse
+     * @param {string} [tableName] - the positional index of the arguments
+     * @return {TypeORMQuery} The PostgresSQL condition
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return PostgreSQL operator
+     *     Statement->>Statement: Create condition with column, operator, and value
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: Add NOT to conditions
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>Statement: Combine conditions with AND/OR
+     *   end
+     *
+     *   Statement-->>Statement: Return conditions array
+     */
+    parseCondition(condition, tableName, qb, counter = 0, conditionalOp) {
+        const { attr1, operator, comparison } = condition;
+        function parse() {
+            const sqlOperator = translateOperators(operator);
+            const attrRef = `${attr1}${counter}`;
+            const queryStr = `${tableName}.${attr1} ${sqlOperator} :${attrRef}`;
+            const values = {
+                [attrRef]: comparison,
+            };
+            switch (conditionalOp) {
+                case GroupOperator.AND:
+                    return {
+                        query: qb.andWhere(queryStr, values),
+                    };
+                case GroupOperator.OR:
+                    return {
+                        query: qb.orWhere(queryStr, values),
+                    };
+                case Operator.NOT:
+                    throw new Error("NOT operator not implemented");
+                default:
+                    return {
+                        query: qb.where(queryStr, values),
+                    };
+            }
+        }
+        if ([GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(operator) === -1) {
+            return parse();
+        }
+        // For NOT operator
+        else if (operator === Operator.NOT) {
+            throw new Error("NOT operator not implemented");
+        }
+        // For AND/OR operators
+        else {
+            qb = this.parseCondition(attr1, tableName, qb, ++counter)
+                .query;
+            return this.parseCondition(comparison, tableName, qb, ++counter, operator);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Statement.js","sourceRoot":"","sources":["../../../src/query/Statement.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Condition,\n  GroupOperator,\n  Operator,\n  OrderDirection,\n  Paginator,\n  Repository,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { Model, ModelKeys } from \"@decaf-ts/decorator-validation\";\nimport { translateOperators } from \"./translate\";\nimport { TypeORMQueryLimit } from \"./constants\";\nimport { TypeORMPaginator } from \"./Paginator\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { TypeORMQuery } from \"../types\";\nimport { TypeORMAdapter } from \"../TypeORMAdapter\";\nimport { FindManyOptions, SelectQueryBuilder } from \"typeorm\";\nimport { FindOptionsWhere } from \"typeorm/find-options/FindOptionsWhere\";\nimport { FindOptionsOrder } from \"typeorm/find-options/FindOptionsOrder\";\n\n/**\n * @description Statement builder for TypeORM-backed queries.\n * @summary Provides a fluent interface for building SQL queries via TypeORM's SelectQueryBuilder with type safety and Decaf.ts abstractions.\n * @template M The model type that extends Model.\n * @template R The result type returned from execution.\n * @param {TypeORMAdapter} adapter The TypeORM adapter.\n * @class TypeORMStatement\n * @example\n * // Example using TypeORMStatement\n * const statement = new TypeORMStatement<User, User[]>(adapter);\n * const users = await statement\n *   .from(User)\n *   .where(Condition.attribute<User>('age').gt(18))\n *   .orderBy('lastName', 'asc')\n *   .limit(10)\n *   .execute();\n */\nexport class TypeORMStatement<M extends Model, R> extends Statement<\n  TypeORMQuery<M>,\n  M,\n  R\n> {\n  protected override adapter!: TypeORMAdapter;\n\n  constructor(adapter: TypeORMAdapter) {\n    super(adapter);\n  }\n\n  /**\n   * @description Builds a TypeORM SelectQueryBuilder from the statement.\n   * @summary Converts the statement's conditions, selectors, and options into a TypeORM-backed query object.\n   * @return {TypeORMQuery} The built TypeORM query container.\n   * @throws {Error} If there are invalid query conditions.\n   * @mermaid\n   * sequenceDiagram\n   *   participant Statement\n   *   participant Repository\n   *   participant parseCondition\n   *\n   *   Statement->>Statement: build()\n   *   Note over Statement: Initialize query\n   *   Statement->>Repository: Get table name\n   *   Repository-->>Statement: Return table name\n   *   Statement->>Statement: Create base query\n   *\n   *   alt Has selectSelector\n   *     Statement->>Statement: Add columns to query\n   *   end\n   *\n   *   alt Has whereCondition\n   *     Statement->>Statement: Create combined condition with table\n   *     Statement->>parseCondition: Parse condition\n   *     parseCondition-->>Statement: Return parsed conditions\n   *     Statement->>Statement: Add conditions to query\n   *   end\n   *\n   *   alt Has orderBySelector\n   *     Statement->>Statement: Add orderBy to query\n   *   end\n   *\n   *   alt Has limitSelector\n   *     Statement->>Statement: Set limit\n   *   else\n   *     Statement->>Statement: Use default limit\n   *   end\n   *\n   *   alt Has offsetSelector\n   *     Statement->>Statement: Set offset\n   *   end\n   *\n   *   Statement-->>Statement: Return query\n   */\n  protected build(): TypeORMQuery<M> {\n    const log = this.log.for(this.build);\n    const tableName = Repository.table(this.fromSelector);\n    const m = new this.fromSelector();\n\n    const q: TypeORMQuery<M, SelectQueryBuilder<M>> = {\n      query: this.adapter.dataSource\n        .getRepository(\n          this.fromSelector[ModelKeys.ANCHOR as keyof typeof this.fromSelector]\n        )\n        .createQueryBuilder(tableName) as SelectQueryBuilder<M>,\n    };\n\n    if (this.selectSelector)\n      q.query = q.query.select(\n        this.selectSelector.map((s) => `${tableName}.${s as string}`)\n      );\n    else q.query = q.query.select();\n    //\n    // q.query = (q.query as SelectQueryBuilder<any>).from(\n    //   this.fromSelector[ModelKeys.ANCHOR as keyof typeof this.fromSelector],\n    //   tableName\n    // );\n\n    if (this.whereCondition)\n      q.query = this.parseCondition(\n        this.whereCondition,\n        tableName,\n        q.query as SelectQueryBuilder<any>\n      ).query as unknown as SelectQueryBuilder<M>;\n\n    let orderByArgs: [string, \"DESC\" | \"ASC\"];\n    if (!this.orderBySelector)\n      orderByArgs = [\n        `${tableName}.${findPrimaryKey(m).id as string}`,\n        OrderDirection.ASC.toUpperCase() as \"ASC\",\n      ];\n    else\n      orderByArgs = [\n        `${tableName}.${this.orderBySelector[0] as string}`,\n        this.orderBySelector[1].toUpperCase() as \"DESC\" | \"ASC\",\n      ];\n\n    q.query = (q.query as SelectQueryBuilder<any>).orderBy(...orderByArgs);\n    if (this.limitSelector) {\n      q.query = (q.query as SelectQueryBuilder<any>).limit(this.limitSelector);\n    } else {\n      log.debug(\n        `No limit selector defined. Using default limit of ${TypeORMQueryLimit}`\n      );\n      q.query = (q.query as SelectQueryBuilder<any>).limit(TypeORMQueryLimit);\n    }\n\n    // Add offset\n    if (this.offsetSelector)\n      q.query = (q.query as SelectQueryBuilder<any>).skip(this.offsetSelector);\n\n    return q as any;\n  }\n\n  /**\n   * @description Creates a paginator for the statement.\n   * @summary Builds the query and returns a TypeORMPaginator for paginated results.\n   * @template R The result type.\n   * @param {number} size The page size.\n   * @return {Promise<Paginator<M, R, TypeORMQuery>>} A promise that resolves to a paginator.\n   * @throws {InternalError} If there's an error building the query.\n   */\n  async paginate<R>(size: number): Promise<Paginator<M, R, TypeORMQuery>> {\n    try {\n      const query: TypeORMQuery = this.build();\n      const transformedQuery: FindManyOptions<M> = {};\n      const a = query.query as unknown as SelectQueryBuilder<M>;\n      if (this.whereCondition)\n        transformedQuery.where = this.parseConditionForPagination(\n          this.whereCondition,\n          Repository.table(this.fromSelector)\n        );\n\n      if (this.orderBySelector)\n        transformedQuery.order = {\n          [this.orderBySelector[0]]: this.orderBySelector[1].toString(),\n        } as any;\n\n      return new TypeORMPaginator(\n        this.adapter as any,\n        transformedQuery as any,\n        size,\n        this.fromSelector\n      );\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  /**\n   * @description Processes a record.\n   * @summary Converts a raw result row to a model instance using the adapter.\n   * @param {any} r The raw record.\n   * @param {keyof M} pkAttr The primary key attribute of the model.\n   * @param {\"Number\" | \"BigInt\" | undefined} sequenceType The type of the sequence.\n   * @return {any} The processed record.\n   */\n  private processRecord(r: any, pkAttr: keyof M) {\n    if (typeof r[pkAttr] !== \"undefined\") {\n      return this.adapter.revert(r, this.fromSelector, pkAttr, r[pkAttr]);\n    }\n    return r;\n  }\n\n  /**\n   * @description Executes a raw TypeORM query builder.\n   * @summary Sends the built SelectQueryBuilder to the database via TypeORM and returns the results.\n   * @template R The result type.\n   * @param {TypeORMQuery} rawInput The query container to execute.\n   * @return {Promise<R>} A promise that resolves to the query results.\n   */\n  override async raw<R>(rawInput: TypeORMQuery<M>): Promise<R> {\n    const log = this.log.for(this.raw);\n    log.debug(\n      `Executing raw query: ${(rawInput.query as unknown as SelectQueryBuilder<M>).getSql()}`\n    );\n    return (await (\n      rawInput.query as unknown as SelectQueryBuilder<M>\n    ).getMany()) as R;\n  }\n\n  protected parseConditionForPagination(\n    condition: Condition<M>,\n    tableName: string,\n    counter = 0,\n    conditionalOp?: GroupOperator | Operator\n  ): FindOptionsWhere<M>[] | FindOptionsWhere<M> {\n    throw new InternalError(\"Not implemented\");\n  }\n\n  /**\n   * @description Parses a condition into PostgreSQL conditions\n   * @summary Converts a Condition object into PostgreSQL condition structures\n   * @param {Condition<M>} condition - The condition to parse\n   * @param {string} [tableName] - the positional index of the arguments\n   * @return {TypeORMQuery} The PostgresSQL condition\n   * @mermaid\n   * sequenceDiagram\n   *   participant Statement\n   *   participant translateOperators\n   *   participant parseCondition\n   *\n   *   Statement->>Statement: parseCondition(condition)\n   *\n   *   Note over Statement: Extract condition parts\n   *\n   *   alt Simple comparison operator\n   *     Statement->>translateOperators: translateOperators(operator)\n   *     translateOperators-->>Statement: Return PostgreSQL operator\n   *     Statement->>Statement: Create condition with column, operator, and value\n   *   else NOT operator\n   *     Statement->>Statement: parseCondition(attr1)\n   *     Statement->>Statement: Add NOT to conditions\n   *   else AND/OR operator\n   *     Statement->>Statement: parseCondition(attr1)\n   *     Statement->>Statement: parseCondition(comparison)\n   *     Statement->>Statement: Combine conditions with AND/OR\n   *   end\n   *\n   *   Statement-->>Statement: Return conditions array\n   */\n  protected parseCondition(\n    condition: Condition<M>,\n    tableName: string,\n    qb: SelectQueryBuilder<any>,\n    counter = 0,\n    conditionalOp?: GroupOperator | Operator\n  ): TypeORMQuery<M> {\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition<M>;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    function parse(): TypeORMQuery<M> {\n      const sqlOperator = translateOperators(operator);\n      const attrRef = `${attr1}${counter}`;\n      const queryStr = `${tableName}.${attr1} ${sqlOperator} :${attrRef}`;\n      const values = {\n        [attrRef]: comparison,\n      };\n      switch (conditionalOp) {\n        case GroupOperator.AND:\n          return {\n            query: qb.andWhere(queryStr, values) as any,\n          };\n        case GroupOperator.OR:\n          return {\n            query: qb.orWhere(queryStr, values) as any,\n          };\n        case Operator.NOT:\n          throw new Error(\"NOT operator not implemented\");\n        default:\n          return {\n            query: qb.where(queryStr, values) as any,\n          };\n      }\n    }\n\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      return parse();\n    }\n    // For NOT operator\n    else if (operator === Operator.NOT) {\n      throw new Error(\"NOT operator not implemented\");\n    }\n    // For AND/OR operators\n    else {\n      qb = this.parseCondition(attr1 as Condition<M>, tableName, qb, ++counter)\n        .query as unknown as SelectQueryBuilder<M>;\n      return this.parseCondition(\n        comparison,\n        tableName,\n        qb,\n        ++counter,\n        operator\n      );\n    }\n  }\n}\n"]}

package/lib/esm/query/constants.d.ts

@@ -0,0 +1,52 @@
+import { SQLOperator } from "../types";
+/**
+ * @description Default query limit for TypeORM-backed queries.
+ * @summary Maximum number of records to return in a single page when paginating results.
+ * @const TypeORMQueryLimit
+ * @memberOf module:for-typeorm
+ */
+export declare const TypeORMQueryLimit = 250;
+/**
+ * @description Mapping of operator names to SQL operators.
+ * @summary Constants for comparison operators used when translating high-level filters into SQL via TypeORM.
+ * @typedef {Object} PostgreSQLOperatorType
+ * @property {string} EQUAL Equality operator (=)
+ * @property {string} DIFFERENT Inequality operator (<>)
+ * @property {string} BIGGER Greater than operator (>)
+ * @property {string} BIGGER_EQ Greater than or equal operator (>=)
+ * @property {string} SMALLER Less than operator (<)
+ * @property {string} SMALLER_EQ Less than or equal operator (<=)
+ * @property {string} NOT Negation operator (NOT)
+ * @property {string} IN In array operator (IN)
+ * @property {string} REGEXP Regular expression operator (~)
+ * @property {string} IREGEXP Case-insensitive regular expression operator (~*)
+ * @property {string} LIKE Pattern matching operator (LIKE)
+ * @property {string} ILIKE Case-insensitive pattern matching operator (ILIKE)
+ * @property {string} BETWEEN Range operator (BETWEEN)
+ * @property {string} IS_NULL NULL check operator (IS NULL)
+ * @property {string} IS_NOT_NULL NOT NULL check operator (IS NOT NULL)
+ * @const TypeORMOperator
+ * @type {PostgreSQLOperatorType}
+ * @memberOf module:for-typeorm
+ */
+export declare const TypeORMOperator: Record<string, SQLOperator | string>;
+/**
+ * @description Mapping of logical operator names to SQL operators.
+ * @summary Constants for logical operators used when building WHERE clause groups in TypeORM queries.
+ * @typedef {Object} PostgreSQLGroupOperatorType
+ * @property {string} AND Logical AND operator (AND)
+ * @property {string} OR Logical OR operator (OR)
+ * @const TypeORMGroupOperator
+ * @type {PostgreSQLGroupOperatorType}
+ * @memberOf module:for-typeorm
+ */
+export declare const TypeORMGroupOperator: Record<string, string>;
+/**
+ * @description Special constant values used in queries.
+ * @summary String constants representing special values used while composing SQL with TypeORM.
+ * @typedef {Object} PostgreSQLConstType
+ * @property {string} NULL String representation of null value.
+ * @const TypeORMConst
+ * @memberOf module:for-typeorm
+ */
+export declare const TypeORMConst: Record<string, string>;