@decaf-ts/for-typeorm 0.0.6

package/lib/overrides/PrimaryGeneratedColumn.d.ts

@@ -0,0 +1,24 @@
+import { PrimaryGeneratedColumnNumericOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnNumericOptions";
+import { PrimaryGeneratedColumnUUIDOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnUUIDOptions";
+import { PrimaryGeneratedColumnIdentityOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnIdentityOptions";
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(options: PrimaryGeneratedColumnNumericOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(strategy: "increment", options?: PrimaryGeneratedColumnNumericOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(strategy: "uuid", options?: PrimaryGeneratedColumnUUIDOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(strategy: "rowid", options?: PrimaryGeneratedColumnUUIDOptions): PropertyDecorator;
+export declare function PrimaryGeneratedColumn(strategy: "identity", options?: PrimaryGeneratedColumnIdentityOptions): PropertyDecorator;

package/lib/overrides/UpdateDateColumn.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateDateColumn = UpdateDateColumn;
+const typeorm_1 = require("typeorm");
+const utils_1 = require("./utils.cjs");
+function UpdateDateColumn(options) {
+    return function (object, propertyName) {
+        const columns = (0, typeorm_1.getMetadataArgsStorage)().columns;
+        (0, utils_1.aggregateOrNewColumn)(object.constructor, propertyName, columns, options || {}, "updateDate");
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXBkYXRlRGF0ZUNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vdmVycmlkZXMvVXBkYXRlRGF0ZUNvbHVtbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLDRDQVdDO0FBZEQscUNBQWdFO0FBQ2hFLHVDQUErQztBQUUvQyxTQUFnQixnQkFBZ0IsQ0FBQyxPQUF1QjtJQUN0RCxPQUFPLFVBQVUsTUFBVyxFQUFFLFlBQWlCO1FBQzdDLE1BQU0sT0FBTyxHQUFHLElBQUEsZ0NBQXNCLEdBQUUsQ0FBQyxPQUFPLENBQUM7UUFDakQsSUFBQSw0QkFBb0IsRUFDbEIsTUFBTSxDQUFDLFdBQVcsRUFDbEIsWUFBWSxFQUNaLE9BQU8sRUFDUCxPQUFPLElBQUksRUFBRSxFQUNiLFlBQVksQ0FDYixDQUFDO0lBQ0osQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbHVtbk9wdGlvbnMsIGdldE1ldGFkYXRhQXJnc1N0b3JhZ2UgfSBmcm9tIFwidHlwZW9ybVwiO1xuaW1wb3J0IHsgYWdncmVnYXRlT3JOZXdDb2x1bW4gfSBmcm9tIFwiLi91dGlsc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gVXBkYXRlRGF0ZUNvbHVtbihvcHRpb25zPzogQ29sdW1uT3B0aW9ucyk6IFByb3BlcnR5RGVjb3JhdG9yIHtcbiAgcmV0dXJuIGZ1bmN0aW9uIChvYmplY3Q6IGFueSwgcHJvcGVydHlOYW1lOiBhbnkpIHtcbiAgICBjb25zdCBjb2x1bW5zID0gZ2V0TWV0YWRhdGFBcmdzU3RvcmFnZSgpLmNvbHVtbnM7XG4gICAgYWdncmVnYXRlT3JOZXdDb2x1bW4oXG4gICAgICBvYmplY3QuY29uc3RydWN0b3IsXG4gICAgICBwcm9wZXJ0eU5hbWUsXG4gICAgICBjb2x1bW5zLFxuICAgICAgb3B0aW9ucyB8fCB7fSxcbiAgICAgIFwidXBkYXRlRGF0ZVwiXG4gICAgKTtcbiAgfTtcbn1cbiJdfQ==

package/lib/overrides/UpdateDateColumn.d.ts

@@ -0,0 +1,2 @@
+import { ColumnOptions } from "typeorm";
+export declare function UpdateDateColumn(options?: ColumnOptions): PropertyDecorator;

package/lib/overrides/utils.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateOrNewColumn = aggregateOrNewColumn;
+function aggregateOrNewColumn(target, property, columns, options = {}, mode = "regular") {
+    const cols = columns.filter((c) => c.target === target && c.propertyName === property);
+    if (cols.length > 1)
+        throw new Error(`Multiple columns for ${property} found for given target: ${columns.map((c) => c.propertyName).join(", ")}`);
+    if (cols.length === 0) {
+        columns.push({
+            target: target,
+            propertyName: property,
+            mode: mode,
+            options: options,
+        });
+        return;
+    }
+    const column = cols[0];
+    Object.defineProperty(column, "options", {
+        value: { ...column.options, ...options },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    if (mode !== "regular")
+        Object.defineProperty(column, "mode", {
+            value: mode,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/overrides/utils.d.ts

@@ -0,0 +1,2 @@
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+export declare function aggregateOrNewColumn(target: any, property: string, columns: ColumnMetadataArgs[], options?: any, mode?: string): void;

package/lib/query/Paginator.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMPaginator = void 0;
+const core_1 = require("@decaf-ts/core");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const db_decorators_1 = require("@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);
+ */
+class TypeORMPaginator extends core_1.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[decorator_validation_1.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 core_1.PagingError("No statement target defined");
+        const pkDef = (0, db_decorators_1.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;
+    }
+}
+exports.TypeORMPaginator = TypeORMPaginator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Paginator.js","sourceRoot":"","sources":["../../src/query/Paginator.ts"],"names":[],"mappings":";;;AAAA,yCAAwD;AAExD,yEAA+E;AAG/E,2DAAyD;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,MAAa,gBAAqC,SAAQ,gBAIzD;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,gCAAS,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,kBAAW,CAAC,6BAA6B,CAAC,CAAC;QAEtE,MAAM,KAAK,GAAG,IAAA,8BAAc,EAAC,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;AAlID,4CAkIC","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/query/Paginator.d.ts

@@ -0,0 +1,86 @@
+import { Paginator } from "@decaf-ts/core";
+import { TypeORMQuery } from "../types";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { TypeORMAdapter } from "../TypeORMAdapter";
+import { Repository as Repo } from "typeorm";
+/**
+ * @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 declare class TypeORMPaginator<M extends Model, R> extends Paginator<M, R, TypeORMQuery> {
+    /**
+     * @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(): number;
+    /**
+     * @description Gets the total record count
+     * @summary Returns the total number of records matching the query
+     * @return {number} The total record count
+     */
+    get count(): number;
+    private __repo?;
+    protected get repo(): Repo<any>;
+    /**
+     * @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: TypeORMAdapter, query: TypeORMQuery, size: number, clazz: Constructor<M>);
+    /**
+     * @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
+     */
+    protected prepare(rawStatement: TypeORMQuery): TypeORMQuery;
+    /**
+     * @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
+     */
+    page(page?: number): Promise<R[]>;
+}

package/lib/query/Statement.cjs

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMStatement = void 0;
+const core_1 = require("@decaf-ts/core");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const translate_1 = require("./translate.cjs");
+const constants_1 = require("./constants.cjs");
+const Paginator_1 = require("./Paginator.cjs");
+const db_decorators_1 = require("@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();
+ */
+class TypeORMStatement extends core_1.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 = core_1.Repository.table(this.fromSelector);
+        const m = new this.fromSelector();
+        const q = {
+            query: this.adapter.dataSource
+                .getRepository(this.fromSelector[decorator_validation_1.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}.${(0, db_decorators_1.findPrimaryKey)(m).id}`,
+                core_1.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 ${constants_1.TypeORMQueryLimit}`);
+            q.query = q.query.limit(constants_1.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, core_1.Repository.table(this.fromSelector));
+            if (this.orderBySelector)
+                transformedQuery.order = {
+                    [this.orderBySelector[0]]: this.orderBySelector[1].toString(),
+                };
+            return new Paginator_1.TypeORMPaginator(this.adapter, transformedQuery, size, this.fromSelector);
+        }
+        catch (e) {
+            throw new db_decorators_1.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 db_decorators_1.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 = (0, translate_1.translateOperators)(operator);
+            const attrRef = `${attr1}${counter}`;
+            const queryStr = `${tableName}.${attr1} ${sqlOperator} :${attrRef}`;
+            const values = {
+                [attrRef]: comparison,
+            };
+            switch (conditionalOp) {
+                case core_1.GroupOperator.AND:
+                    return {
+                        query: qb.andWhere(queryStr, values),
+                    };
+                case core_1.GroupOperator.OR:
+                    return {
+                        query: qb.orWhere(queryStr, values),
+                    };
+                case core_1.Operator.NOT:
+                    throw new Error("NOT operator not implemented");
+                default:
+                    return {
+                        query: qb.where(queryStr, values),
+                    };
+            }
+        }
+        if ([core_1.GroupOperator.AND, core_1.GroupOperator.OR, core_1.Operator.NOT].indexOf(operator) === -1) {
+            return parse();
+        }
+        // For NOT operator
+        else if (operator === core_1.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);
+        }
+    }
+}
+exports.TypeORMStatement = TypeORMStatement;
+//# 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"]}