@decaf-ts/for-typeorm 0.0.6

package/dist/for-typeorm.cjs

@@ -0,0 +1,2553 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('tslib'), require('@decaf-ts/core'), require('@decaf-ts/db-decorators'), require('reflect-metadata'), require('@decaf-ts/decorator-validation'), require('@decaf-ts/reflection'), require('@decaf-ts/logging'), require('typeorm'), require('typeorm/util/ObjectUtils')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'tslib', '@decaf-ts/core', '@decaf-ts/db-decorators', 'reflect-metadata', '@decaf-ts/decorator-validation', '@decaf-ts/reflection', '@decaf-ts/logging', 'typeorm', 'typeorm/util/ObjectUtils'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["for-typeorm"] = {}, global.tslib, global.core, global.dbDecorators, null, global.decoratorValidation, global.reflection, global.logging, global.typeorm, global.ObjectUtils));
+})(this, (function (exports, tslib, core, dbDecorators, reflectMetadata, decoratorValidation, reflection, logging, typeorm, ObjectUtils) { 'use strict';
+
+    /**
+     * @description Regular expression to identify reserved attributes for SQL contexts.
+     * @summary Matches attribute names that conflict with SQL reserved keywords to prevent invalid schema or query generation.
+     * @const reservedAttributes
+     * @memberOf module:for-typeorm
+     */
+    const reservedAttributes = /^(select|from|where|and|or|insert|update|delete|drop|create|table|index|primary|key|foreign|references|constraint|unique|check|default|null|not|as|order|by|group|having|limit|offset|join|inner|outer|left|right|full|on|using|values|returning|set|into|case|when|then|else|end|cast|coalesce|exists|any|all|some|in|between|like|ilike|similar|to|is|true|false|asc|desc|distinct|union|intersect|except|natural|lateral|window|over|partition|range|rows|unbounded|preceding|following|current|row|with|recursive|materialized|view|function|trigger|procedure|language|returns|return|declare|begin|commit|rollback|savepoint|transaction|temporary|temp|if|loop|while|for|continue|exit|raise|exception|notice|info|log|debug|assert|execute|perform|get|diagnostics|call|do|alias|comment|vacuum|analyze|explain|copy|grant|revoke|privileges|public|usage|schema|sequence|owned|owner|tablespace|storage|inherits|type|operator|collate|collation|cascade|restrict|add|alter|column|rename|to|enable|disable|force|no|instead|of|before|after|each|statement|row|execute|also|only|exclude|nulls|others|ordinality|ties|nothing|cache|cycle|increment|minvalue|maxvalue|start|restart|by|called|returns|language|immutable|stable|volatile|strict|security|definer|invoker|cost|rows|support|handler|inline|validator|options|storage|inheritance|oids|without|data|dictionary|encoding|lc_collate|lc_ctype|connection|limit|password|valid|until|superuser|nosuperuser|createdb|nocreatedb|createrole|nocreaterole|inherit|noinherit|login|nologin|replication|noreplication|bypassrls|nobypassrls|encrypted|unencrypted|new|old|session_user|current_user|current_role|current_schema|current_catalog|current_date|current_time|current_timestamp|localtime|localtimestamp|current_database|inet|cidr|macaddr|macaddr8|bit|varbit|tsvector|tsquery|uuid|xml|json|jsonb|int|integer|smallint|bigint|decimal|numeric|real|double|precision|float|boolean|bool|char|character|varchar|text|bytea|date|time|timestamp|interval|point|line|lseg|box|path|polygon|circle|money|void)$/i;
+    const TypeORMFlavour = "type-orm";
+    /**
+     * @description Shape of the TypeORMKeys constant.
+     * @summary Describes the keys and their meanings used by the TypeORM adapter.
+     * @typedef TypeORMKeysDef
+     * @property {string} SEPARATOR Separator used to join table and column identifiers.
+     * @property {string} ID Default primary key field name.
+     * @property {string} VERSION Version field used for optimistic locking.
+     * @property {string} DELETED Soft-delete timestamp field.
+     * @property {string} TABLE Database table identifier key.
+     * @property {string} SCHEMA Database schema identifier key.
+     * @property {string} SEQUENCE Database sequence name key.
+     * @property {string} INDEX Index identifier key.
+     * @memberOf module:for-typeorm
+     */
+    /**
+     * @description Key constants used by the TypeORM adapter.
+     * @summary Collection of string constants that identify common database properties and adapter-specific keys.
+     * @const TypeORMKeys
+     * @type {TypeORMKeysDef}
+     * @memberOf module:for-typeorm
+     */
+    const TypeORMKeys = {
+        SEPARATOR: ".",
+        ID: "id",
+        VERSION: "version",
+        DELETED: "deleted_at",
+        TABLE: "table_name",
+        SCHEMA: "schema_name",
+        SEQUENCE: "sequence_name",
+        INDEX: "index",
+    };
+
+    /**
+     * @description Error thrown when there is an issue with TypeORM indexes.
+     * @summary Represents an error related to index generation or handling within the TypeORM adapter.
+     * @param {string|Error} msg The error message or Error object.
+     * @class
+     * @category Errors
+     * @example
+     * // Example of using IndexError
+     * try {
+     *   // Some code that might throw an index error
+     *   throw new IndexError("Index not found");
+     * } catch (error) {
+     *   if (error instanceof IndexError) {
+     *     console.error("Index error occurred:", error.message);
+     *   }
+     * }
+     */
+    class IndexError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(IndexError.name, msg, 404);
+        }
+    }
+
+    /**
+     * @description SQL operators available for building TypeORM queries.
+     * @summary Enumeration of common SQL operators intended for use within TypeORM query construction and translation layers.
+     * @enum {string}
+     * @memberOf module:for-typeorm
+     */
+    exports.SQLOperator = void 0;
+    (function (SQLOperator) {
+        SQLOperator["EQUAL"] = "=";
+        SQLOperator["NOT_EQUAL"] = "<>";
+        SQLOperator["LESS_THAN"] = "<";
+        SQLOperator["LESS_THAN_OR_EQUAL"] = "<=";
+        SQLOperator["GREATER_THAN"] = ">";
+        SQLOperator["GREATER_THAN_OR_EQUAL"] = ">=";
+        SQLOperator["IN"] = "IN";
+        SQLOperator["NOT_IN"] = "NOT IN";
+        SQLOperator["LIKE"] = "LIKE";
+        SQLOperator["ILIKE"] = "ILIKE";
+        SQLOperator["BETWEEN"] = "BETWEEN";
+        SQLOperator["IS_NULL"] = "IS NULL";
+        SQLOperator["IS_NOT_NULL"] = "IS NOT NULL";
+        SQLOperator["EXISTS"] = "EXISTS";
+        SQLOperator["NOT_EXISTS"] = "NOT EXISTS";
+        SQLOperator["ANY"] = "ANY";
+        SQLOperator["ALL"] = "ALL";
+        SQLOperator["SOME"] = "SOME";
+    })(exports.SQLOperator || (exports.SQLOperator = {}));
+
+    /**
+     * @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
+     */
+    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
+     */
+    const TypeORMOperator = {
+        EQUAL: exports.SQLOperator.EQUAL,
+        DIFFERENT: exports.SQLOperator.NOT_EQUAL,
+        BIGGER: exports.SQLOperator.GREATER_THAN,
+        BIGGER_EQ: exports.SQLOperator.GREATER_THAN_OR_EQUAL,
+        SMALLER: exports.SQLOperator.LESS_THAN,
+        SMALLER_EQ: exports.SQLOperator.LESS_THAN_OR_EQUAL,
+        BETWEEN: exports.SQLOperator.BETWEEN,
+        NOT: "NOT",
+        IN: exports.SQLOperator.IN,
+        IS_NULL: exports.SQLOperator.IS_NULL,
+        IS_NOT_NULL: exports.SQLOperator.IS_NOT_NULL,
+        REGEXP: "~",
+        IREGEXP: "~*",
+        LIKE: exports.SQLOperator.LIKE,
+        ILIKE: exports.SQLOperator.ILIKE,
+    };
+    /**
+     * @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
+     */
+    const TypeORMGroupOperator = {
+        AND: "AND",
+        OR: "OR",
+    };
+    /**
+     * @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
+     */
+    const TypeORMConst = {
+        NULL: "NULL",
+    };
+
+    /**
+     * @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.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[decoratorValidation.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.PagingError("No statement target defined");
+            const pkDef = dbDecorators.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;
+        }
+    }
+
+    /**
+     * @description Translates core operators to TypeORM SQL operators.
+     * @summary Converts Decaf.ts core operators to their equivalent SQL operators used by the TypeORM adapter.
+     * @param {GroupOperator | Operator} operator The core operator to translate.
+     * @return {SQLOperator | string} The equivalent SQL operator.
+     * @throws {QueryError} If no translation exists for the given operator.
+     * @function translateOperators
+     * @memberOf module:for-typeorm
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant translateOperators
+     *   participant PostgreSQLOperator
+     *   participant PostgreSQLGroupOperator
+     *
+     *   Caller->>translateOperators: operator
+     *
+     *   translateOperators->>PostgreSQLOperator: Check for match
+     *   alt Found in PostgreSQLOperator
+     *     PostgreSQLOperator-->>translateOperators: Return matching operator
+     *     translateOperators-->>Caller: Return SQLOperator
+     *   else Not found
+     *     translateOperators->>PostgreSQLGroupOperator: Check for match
+     *     alt Found in PostgreSQLGroupOperator
+     *       PostgreSQLGroupOperator-->>translateOperators: Return matching operator
+     *       translateOperators-->>Caller: Return string
+     *     else Not found
+     *       translateOperators-->>Caller: Throw QueryError
+     *     end
+     *   end
+     */
+    function translateOperators(operator) {
+        for (const operators of [TypeORMOperator, TypeORMGroupOperator]) {
+            const el = Object.keys(operators).find((k) => k === operator);
+            if (el)
+                return operators[el];
+        }
+        throw new core.QueryError(`Could not find adapter translation for operator ${operator}`);
+    }
+
+    /**
+     * @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.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.Repository.table(this.fromSelector);
+            const m = new this.fromSelector();
+            const q = {
+                query: this.adapter.dataSource
+                    .getRepository(this.fromSelector[decoratorValidation.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}.${dbDecorators.findPrimaryKey(m).id}`,
+                    core.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, core.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 dbDecorators.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 dbDecorators.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 core.GroupOperator.AND:
+                        return {
+                            query: qb.andWhere(queryStr, values),
+                        };
+                    case core.GroupOperator.OR:
+                        return {
+                            query: qb.orWhere(queryStr, values),
+                        };
+                    case core.Operator.NOT:
+                        throw new Error("NOT operator not implemented");
+                    default:
+                        return {
+                            query: qb.where(queryStr, values),
+                        };
+                }
+            }
+            if ([core.GroupOperator.AND, core.GroupOperator.OR, core.Operator.NOT].indexOf(operator) === -1) {
+                return parse();
+            }
+            // For NOT operator
+            else if (operator === core.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);
+            }
+        }
+    }
+
+    /**
+     * @description Abstract implementation of a database sequence for TypeORM.
+     * @summary Provides the basic functionality for {@link Sequence}s, delegating to the {@link TypeORMAdapter} to fetch and increment values while handling type parsing and error translation.
+     * @param {SequenceOptions} options The sequence configuration options (name, type, startWith, incrementBy, etc.).
+     * @param {TypeORMAdapter} adapter The TypeORM adapter used to execute sequence operations.
+     * @class TypeORMSequence
+     * @implements Sequence
+     * @example
+     * // Create and use a TypeORM-backed sequence
+     * const seq = new TypeORMSequence({ name: "user_id_seq", type: "Number", startWith: 1, incrementBy: 1 }, adapter);
+     * const nextId = await seq.next();
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant App
+     *   participant Seq as TypeORMSequence
+     *   participant Adapter as TypeORMAdapter
+     *   participant DB as Database
+     *   App->>Seq: next()
+     *   Seq->>Seq: current()
+     *   Seq->>Adapter: raw(SELECT current_value ...)
+     *   Adapter->>DB: Query current value
+     *   DB-->>Adapter: current_value
+     *   Adapter-->>Seq: value
+     *   Seq->>Seq: increment(current)
+     *   Seq->>Adapter: raw(nextval(name))
+     *   Adapter->>DB: nextval()
+     *   DB-->>Adapter: next value
+     *   Adapter-->>Seq: value
+     *   Seq-->>App: parsed next value
+     */
+    class TypeORMSequence extends core.Sequence {
+        constructor(options, adapter) {
+            super(options);
+            this.adapter = adapter;
+        }
+        /**
+         * @summary Retrieves the current value for the sequence
+         * @protected
+         */
+        async current() {
+            const { name } = this.options;
+            try {
+                const seq = await this.adapter.raw({
+                    query: `SELECT current_value FROM information_schema.sequences WHERE sequence_name = $1`,
+                    values: [name],
+                });
+                return this.parse(seq.current_value);
+            }
+            catch (e) {
+                throw this.adapter.parseError(e);
+            }
+        }
+        /**
+         * @summary Parses the {@link Sequence} value
+         *
+         * @protected
+         * @param value
+         */
+        parse(value) {
+            return core.Sequence.parseValue(this.options.type, value);
+        }
+        /**
+         * @summary increments the sequence
+         * @description Sequence specific implementation
+         *
+         * @param {string | number | bigint} current
+         * @param count
+         * @protected
+         */
+        async increment(current, count) {
+            const { type, incrementBy, name, startWith } = this.options;
+            if (type !== "Number" && type !== "BigInt")
+                throw new dbDecorators.InternalError(`Cannot increment sequence of type ${type} with ${count}`);
+            let next;
+            try {
+                next = await this.adapter.raw({
+                    query: `SELECT nextval($1);`,
+                    values: [name],
+                });
+            }
+            catch (e) {
+                if (!(e instanceof dbDecorators.NotFoundError))
+                    throw e;
+                next = await this.adapter.raw({
+                    query: `CREATE SEQUENCE IF NOT EXISTS $1 START WITH $2 INCREMENT BY $3 NO CYCLE;`,
+                    values: [name, startWith, incrementBy],
+                });
+            }
+            return next;
+        }
+        /**
+         * @summary Generates the next value in th sequence
+         * @description calls {@link Sequence#parse} on the current value
+         * followed by {@link Sequence#increment}
+         *
+         */
+        async next() {
+            const current = await this.current();
+            return this.increment(current);
+        }
+        async range(count) {
+            const current = (await this.current());
+            const incrementBy = this.parse(this.options.incrementBy);
+            const next = await this.increment(current, this.parse(count) * incrementBy);
+            const range = [];
+            for (let i = 1; i <= count; i++) {
+                range.push(current + incrementBy * this.parse(i));
+            }
+            if (range[range.length - 1] !== next)
+                throw new dbDecorators.InternalError("Miscalculation of range");
+            return range;
+        }
+    }
+
+    /**
+     * @description Generates a name for a CouchDB index
+     * @summary Creates a standardized name for a CouchDB index by combining name parts, compositions, and direction
+     * @param {string[]} name - Array of name parts for the index
+     * @param {OrderDirection} [direction] - Optional sort direction for the index
+     * @param {string[]} [compositions] - Optional additional attributes to include in the index name
+     * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+     * @return {string} The generated index name
+     * @memberOf module:for-couchdb
+     */
+    function generateIndexName(name, direction, compositions, separator = dbDecorators.DefaultSeparator) {
+        return [
+            ...name.map((n) => (n === TypeORMKeys.TABLE ? "table" : n)),
+            ...([]),
+            ...([]),
+            TypeORMKeys.INDEX,
+        ].join(separator);
+    }
+    /**
+     * @description Generates CouchDB index configurations for models
+     * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models
+     * @template M - The model type that extends Model
+     * @param models - Array of model constructors to generate indexes for
+     * @return {TypeORMQuery} Array of CouchDB index configurations
+     * @function generateIndexes
+     * @memberOf module:for-couchdb
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant generateIndexes
+     *   participant generateIndexName
+     *   participant Repository
+     *
+     *   Caller->>generateIndexes: models
+     *
+     *   Note over generateIndexes: Create base table index
+     *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]
+     *   generateIndexName-->>generateIndexes: tableName
+     *   generateIndexes->>generateIndexes: Create table index config
+     *
+     *   loop For each model
+     *     generateIndexes->>Repository: Get indexes metadata
+     *     Repository-->>generateIndexes: index metadata
+     *
+     *     loop For each index in metadata
+     *       Note over generateIndexes: Extract index properties
+     *       generateIndexes->>Repository: Get table name
+     *       Repository-->>generateIndexes: tableName
+     *
+     *       Note over generateIndexes: Define nested generate function
+     *
+     *       generateIndexes->>generateIndexes: Call generate() for default order
+     *       Note over generateIndexes: Create index name and config
+     *
+     *       alt Has directions
+     *         loop For each direction
+     *           generateIndexes->>generateIndexes: Call generate(direction)
+     *           Note over generateIndexes: Create ordered index config
+     *         end
+     *       end
+     *     end
+     *   end
+     *
+     *   generateIndexes-->>Caller: Array of index configurations
+     */
+    function generateIndexes(models) {
+        const tableName = generateIndexName([TypeORMKeys.TABLE]);
+        const indexes = {};
+        indexes[tableName] = {
+            query: ``,
+            values: [],
+        };
+        models.forEach((m) => {
+            const ind = core.Repository.indexes(m);
+            Object.entries(ind).forEach(([key, value]) => {
+                const k = Object.keys(value)[0];
+                let { compositions } = value[k];
+                const tableName = core.Repository.table(m);
+                compositions = compositions || [];
+                function generate() {
+                    const name = [key, ...compositions, core.PersistenceKeys.INDEX].join(dbDecorators.DefaultSeparator);
+                    indexes[name] = {
+                        query: `CREATE INDEX $1 ON $2 ($3);`,
+                        values: [name, tableName, key],
+                    };
+                }
+                generate();
+            });
+        });
+        return Object.values(indexes);
+    }
+
+    /**
+     * @description Repository implementation backed by TypeORM.
+     * @summary Provides CRUD operations for a given Model using the {@link TypeORMAdapter}, including bulk operations and query builder access while preserving Decaf.ts repository semantics.
+     * @template M Type extending Model that this repository will manage.
+     * @param {TypeORMAdapter} adapter The adapter used to execute persistence operations.
+     * @param {Constructor<M>} model The Model constructor associated with this repository.
+     * @param {...any[]} args Optional arguments forwarded to the base Repository.
+     * @class TypeORMRepository
+     * @example
+     * // Creating a repository
+     * const repo = new TypeORMRepository<User>(adapter, User);
+     * const created = await repo.create(new User({ name: "Alice" }));
+     * const read = await repo.read(created.id);
+     *
+     * // Bulk create
+     * await repo.createAll([new User({ name: "A" }), new User({ name: "B" })]);
+     *
+     * // Using the query builder
+     * const qb = repo.queryBuilder();
+     * const rows = await qb.where("name = :name", { name: "Alice" }).getMany();
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant App
+     *   participant Repo as TypeORMRepository
+     *   participant Adapter as TypeORMAdapter
+     *   participant DB as TypeORM/DataSource
+     *
+     *   App->>Repo: create(model)
+     *   Repo->>Adapter: prepare(model, pk)
+     *   Adapter-->>Repo: { record, id, transient }
+     *   Repo->>Adapter: create(table, id, model, ...args)
+     *   Adapter->>DB: INSERT ...
+     *   DB-->>Adapter: row
+     *   Adapter-->>Repo: row
+     *   Repo->>Adapter: revert(row, clazz, pk, id)
+     *   Adapter-->>Repo: model
+     *   Repo-->>App: model
+     */
+    exports.TypeORMRepository = class TypeORMRepository extends core.Repository {
+        constructor(adapter, model, ...args) {
+            super(adapter, model, ...args);
+        }
+        /**
+         * @description Creates a TypeORM query builder for the repository entity.
+         * @summary Returns a SelectQueryBuilder bound to this repository's entity for advanced querying.
+         * @return {import("typeorm").SelectQueryBuilder<any>} A TypeORM SelectQueryBuilder instance.
+         */
+        queryBuilder() {
+            const repo = this.adapter.dataSource.getRepository(this.class[decoratorValidation.ModelKeys.ANCHOR]);
+            return repo.createQueryBuilder();
+        }
+        /**
+         * @description Creates and persists a model instance.
+         * @summary Prepares the model, delegates insertion to the adapter, and rehydrates the persisted state back into a Model instance.
+         * @param {M} model The model to create.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<M>} The created model instance.
+         */
+        async create(model, ...args) {
+            // eslint-disable-next-line prefer-const
+            let { record, id, transient } = this.adapter.prepare(model, this.pk);
+            record = await this.adapter.create(this.class[decoratorValidation.ModelKeys.ANCHOR], id, model, ...args);
+            let c = undefined;
+            if (args.length)
+                c = args[args.length - 1];
+            return this.adapter.revert(record, this.class, this.pk, id, c && c.get("rebuildWithTransient") ? transient : undefined);
+        }
+        /**
+         * @description Reads a model from the database by ID.
+         * @summary Retrieves a model instance from the database using its primary key.
+         * @param {string|number|bigint} id - The primary key of the model to read.
+         * @param {...any[]} args - Additional arguments.
+         * @return {Promise<M>} The retrieved model instance.
+         */
+        async read(id, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            const m = await this.adapter.read(this.class[decoratorValidation.ModelKeys.ANCHOR], id, this.pk);
+            return this.adapter.revert(m, this.class, this.pk, id);
+        }
+        /**
+         * @description Updates and persists a model instance.
+         * @summary Prepares the model, delegates update to the adapter, and rehydrates the persisted state back into a Model instance.
+         * @param {M} model The model to update.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<M>} The updated model instance.
+         */
+        async update(model, ...args) {
+            // eslint-disable-next-line prefer-const
+            let { record, id, transient } = this.adapter.prepare(model, this.pk);
+            record = await this.adapter.update(this.class[decoratorValidation.ModelKeys.ANCHOR], id, model, ...args);
+            return this.adapter.revert(record, this.class, this.pk, id, transient);
+        }
+        /**
+         * @description Deletes a model from the database by ID.
+         * @summary Removes a model instance from the database using its primary key.
+         * @param {string|number|bigint} id - The primary key of the model to delete.
+         * @param {...any[]} args - Additional arguments.
+         * @return {Promise<M>} The deleted model instance.
+         */
+        async delete(id, ...args) {
+            const m = await this.adapter.delete(this.class[decoratorValidation.ModelKeys.ANCHOR], id, this.pk, ...args);
+            return this.adapter.revert(m, this.class, this.pk, id);
+        }
+        /**
+         * @description Validates and prepares models for bulk creation.
+         * @summary Applies decorator-based validations and returns transformed models with context args for createAll.
+         * @param {M[]} models The models to be created.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<[M[], ...any[]]>} The prepared models and forwarded args tuple.
+         */
+        async createAllPrefix(models, ...args) {
+            const contextArgs = await dbDecorators.Context.args(dbDecorators.OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
+            if (!models.length)
+                return [models, ...contextArgs.args];
+            models = await Promise.all(models.map(async (m) => {
+                m = new this.class(m);
+                await dbDecorators.enforceDBDecorators(this, contextArgs.context, m, dbDecorators.OperationKeys.CREATE, dbDecorators.OperationKeys.ON);
+                return m;
+            }));
+            const errors = models
+                .map((m) => m.hasErrors(...(contextArgs.context.get("ignoredValidationProperties") || [])))
+                .reduce((accum, e, i) => {
+                if (e)
+                    accum =
+                        typeof accum === "string"
+                            ? accum + `\n - ${i}: ${e.toString()}`
+                            : ` - ${i}: ${e.toString()}`;
+                return accum;
+            }, undefined);
+            if (errors)
+                throw new dbDecorators.ValidationError(errors);
+            return [models, ...contextArgs.args];
+        }
+        /**
+         * @description Creates multiple models at once.
+         * @summary Prepares, persists, and rehydrates a batch of models.
+         * @param {M[]} models The models to create.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<M[]>} The created models.
+         */
+        async createAll(models, ...args) {
+            if (!models.length)
+                return models;
+            const prepared = models.map((m) => this.adapter.prepare(m, this.pk));
+            const ids = prepared.map((p) => p.id);
+            let records = prepared.map((p) => p.record);
+            records = await this.adapter.createAll(this.class[decoratorValidation.ModelKeys.ANCHOR], ids, models, ...args);
+            return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, ids[i]));
+        }
+        /**
+         * @description Reads multiple models by their primary keys.
+         * @summary Retrieves a list of models corresponding to the provided keys.
+         * @param {(string[]|number[])} keys The primary keys to read.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<M[]>} The retrieved models.
+         */
+        async readAll(keys, ...args) {
+            const records = await this.adapter.readAll(this.class[decoratorValidation.ModelKeys.ANCHOR], keys, this.pk, ...args);
+            return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+        }
+        /**
+         * @description Updates multiple models at once.
+         * @summary Persists a batch of model updates and returns their rehydrated instances.
+         * @param {M[]} models The models to update.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<M[]>} The updated models.
+         */
+        async updateAll(models, ...args) {
+            const records = models.map((m) => this.adapter.prepare(m, this.pk));
+            const updated = await this.adapter.updateAll(this.class[decoratorValidation.ModelKeys.ANCHOR], records.map((r) => r.id), models, this.pk, ...args);
+            return updated.map((u, i) => this.adapter.revert(u, this.class, this.pk, records[i].id));
+        }
+        /**
+         * @description Deletes multiple models at once.
+         * @summary Removes a list of models by their primary keys and returns their last persisted states.
+         * @param {(string[]|number[])} keys The primary keys to delete.
+         * @param {...any[]} args Optional arguments/context.
+         * @return {Promise<M[]>} The deleted models.
+         */
+        async deleteAll(keys, ...args) {
+            const results = await this.adapter.deleteAll(this.class[decoratorValidation.ModelKeys.ANCHOR], keys, this.pk, ...args);
+            return results.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+        }
+    };
+    exports.TypeORMRepository = tslib.__decorate([
+        core.uses(TypeORMFlavour),
+        tslib.__metadata("design:paramtypes", [TypeORMAdapter, Object, Object])
+    ], exports.TypeORMRepository);
+
+    /**
+     * @description TypeORM event subscriber that forwards entity lifecycle events to the adapter.
+     * @summary Listens for insert, update, and remove events emitted by TypeORM and notifies the Decaf.ts adapter so that observers can be updated accordingly.
+     * @param {TypeORMAdapter} adapter The TypeORM adapter used to propagate events and look up metadata.
+     * @class
+     * @example
+     * // Registering the subscriber when creating a DataSource
+     * // dataSourceOptions.subscribers = [new TypeORMEventSubscriber(adapter)];
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant TypeORM
+     *   participant Subscriber as TypeORMEventSubscriber
+     *   participant Adapter as TypeORMAdapter
+     *   participant Observers
+     *
+     *   TypeORM->>Subscriber: afterInsert(entity)
+     *   Subscriber->>Adapter: updateObservers(table, CREATE, [id])
+     *   Adapter->>Observers: notify(table, CREATE, [id])
+     *
+     *   TypeORM->>Subscriber: afterUpdate(event)
+     *   Subscriber->>Adapter: updateObservers(table, UPDATE, [id])
+     *   Adapter->>Observers: notify(table, UPDATE, [id])
+     *
+     *   TypeORM->>Subscriber: afterRemove(event)
+     *   Subscriber->>Adapter: updateObservers(table, DELETE, [id])
+     *   Adapter->>Observers: notify(table, DELETE, [id])
+     */
+    let TypeORMEventSubscriber = class TypeORMEventSubscriber {
+        constructor(handler) {
+            this.handler = handler;
+        }
+        /**
+         * @description Handles post-insert events.
+         * @summary Notifies observers about a create operation for the inserted entity.
+         * @param {InsertEvent<any>} event The TypeORM insert event.
+         * @return {Promise<any>|void} A promise when async or void otherwise.
+         */
+        afterInsert(event) {
+            const constructor = decoratorValidation.Model.get(event.entity.constructor.name);
+            if (!constructor)
+                throw new dbDecorators.InternalError(`No registered model found for ${event.entity.constructor.name}`);
+            const tableName = core.Repository.table(constructor);
+            this.handler(tableName, dbDecorators.OperationKeys.CREATE, [event.entityId]);
+        }
+        /**
+         * @description Handles post-remove events.
+         * @summary Notifies observers about a delete operation for the removed entity.
+         * @param {RemoveEvent<any>} event The TypeORM remove event.
+         * @return {Promise<any>|void} A promise when async or void otherwise.
+         */
+        afterRemove(event) {
+            const constructor = decoratorValidation.Model.get(event.entity.constructor.name);
+            if (!constructor)
+                throw new dbDecorators.InternalError(`No registered model found for ${event.entity.constructor.name}`);
+            const tableName = core.Repository.table(constructor);
+            this.handler(tableName, dbDecorators.OperationKeys.DELETE, [event.entityId]);
+        }
+        /**
+         * @description Handles post-update events.
+         * @summary Notifies observers about an update operation for the modified entity.
+         * @param {UpdateEvent<any>} event The TypeORM update event.
+         * @return {Promise<any>|void} A promise when async or void otherwise.
+         */
+        afterUpdate(event) {
+            const constructor = decoratorValidation.Model.get(event.databaseEntity.constructor.name);
+            if (!constructor)
+                throw new dbDecorators.InternalError(`No registered model found for ${event.databaseEntity.constructor.name}`);
+            const tableName = core.Repository.table(constructor);
+            return this.handler(tableName, dbDecorators.OperationKeys.UPDATE, [
+                event.entity["id"],
+            ]);
+        }
+    };
+    TypeORMEventSubscriber = tslib.__decorate([
+        typeorm.EventSubscriber(),
+        tslib.__metadata("design:paramtypes", [Function])
+    ], TypeORMEventSubscriber);
+
+    /**
+     * @description Dispatcher for TypeORM-driven change events.
+     * @summary Subscribes a TypeORM DataSource with a custom EntitySubscriber to notify observers when records are created, updated, or deleted.
+     * @param {number} [timeout=5000] Timeout in milliseconds for initialization retries.
+     * @class TypeORMDispatch
+     * @example
+     * // Create a dispatcher for a TypeORM DataSource
+     * const dispatch = new TypeORMDispatch();
+     * await dispatch.observe(adapter, adapter.dataSource.options);
+     *
+     * // The dispatcher registers a TypeORMEventSubscriber and notifies observers when entities change.
+     * @mermaid
+     * classDiagram
+     *   class Dispatch {
+     *     +initialize()
+     *     +updateObservers()
+     *   }
+     *   class TypeORMDispatch {
+     *     -observerLastUpdate?: string
+     *     -attemptCounter: number
+     *     -timeout: number
+     *     +constructor(timeout)
+     *     #notificationHandler()
+     *     #initialize()
+     *   }
+     *   Dispatch <|-- TypeORMDispatch
+     */
+    class TypeORMDispatch extends core.Dispatch {
+        constructor(timeout = 5000) {
+            super();
+            this.timeout = timeout;
+            this.attemptCounter = 0;
+        }
+        /**
+         * @description Processes TypeORM notification events.
+         * @summary Handles change notifications (translated from TypeORM events) and notifies observers about record changes.
+         * @param {string} table The notification payload.
+         * @param {OperationKeys} operation The notification payload.
+         * @param {EventIds} ids The notification payload.
+         * @return {Promise<void>} A promise that resolves when all notifications have been processed.
+         * @mermaid
+         * sequenceDiagram
+         *   participant D as PostgreSQLDispatch
+         *   participant L as Logger
+         *   participant O as Observers
+         *   Note over D: Receive notification from PostgreSQL
+         *   D->>D: Parse notification payload
+         *   D->>D: Extract table, operation, and ids
+         *   D->>O: updateObservers(table, operation, ids)
+         *   D->>D: Update observerLastUpdate
+         *   D->>L: Log successful dispatch
+         */
+        async notificationHandler(table, operation, ids) {
+            const log = this.log.for(this.notificationHandler);
+            try {
+                // Notify observers
+                await this.updateObservers(table, operation, ids);
+                this.observerLastUpdate = new Date().toISOString();
+                log.verbose(`Observer refresh dispatched by ${operation} for ${table}`);
+                log.debug(`pks: ${ids}`);
+            }
+            catch (e) {
+                log.error(`Failed to process notification: ${e}`);
+            }
+        }
+        /**
+         * @description Initializes the dispatcher and subscribes to TypeORM notifications.
+         * @summary Registers the TypeORMEventSubscriber on the DataSource and logs the subscription lifecycle.
+         * @return {Promise<void>} A promise that resolves when the subscription is established.
+         * @mermaid
+         * sequenceDiagram
+         *   participant D as TypeORMDispatch
+         *   participant S as subscribeToTypeORM
+         *   participant DS as TypeORM DataSource
+         *   participant L as Logger
+         *   D->>S: Call subscribeToTypeORM
+         *   S->>S: Check adapter and native
+         *   alt No adapter or native
+         *     S-->>S: throw InternalError
+         *   end
+         *   S->>DS: initialize()
+         *   S->>DS: subscribers.push(TypeORMEventSubscriber)
+         *   alt Success
+         *     DS-->>S: Subscription established
+         *     S-->>D: Promise resolves
+         *     D->>L: Log successful subscription
+         *   else Error
+         *     DS-->>S: Error
+         *     S-->>D: Promise rejects
+         *   end
+         */
+        async initialize() {
+            async function subscribeToTypeORM() {
+                if (!this.adapter || !this.native) {
+                    throw new dbDecorators.InternalError(`No adapter/native observed for dispatch`);
+                }
+                const adapter = this.adapter;
+                try {
+                    if (!adapter.dataSource.isInitialized)
+                        await adapter.dataSource.initialize();
+                    adapter.dataSource.subscribers.push(new TypeORMEventSubscriber(this.notificationHandler.bind(this)));
+                }
+                catch (e) {
+                    throw new dbDecorators.InternalError(e);
+                }
+            }
+            subscribeToTypeORM
+                .call(this)
+                .then(() => {
+                this.log.info(`Subscribed to TypeORM notifications`);
+            })
+                .catch((e) => {
+                throw new dbDecorators.InternalError(`Failed to subscribe to TypeORM notifications: ${e}`);
+            });
+        }
+        /**
+         * Cleanup method to release resources when the dispatcher is no longer needed
+         */
+        cleanup() {
+            // if (this.adapter) {
+            //
+            //   const adapter = this.adapter as TypeORMAdapter;
+            //   await adapter.dataSource.destroy();
+            // }
+        }
+    }
+
+    /**
+     * @description Converts a JavaScript RegExp pattern to a PostgreSQL POSIX pattern string.
+     * @summary Accepts either a RegExp object or a string representation (/pattern/flags) and returns the raw pattern compatible with PostgreSQL's ~ and ~* operators.
+     * @param {RegExp|string} jsRegex JavaScript RegExp object or pattern string.
+     * @return {string} PostgreSQL-compatible regex pattern string.
+     * @function convertJsRegexToPostgres
+     * @mermaid
+     * sequenceDiagram
+     *   participant App
+     *   participant Utils as convertJsRegexToPostgres
+     *   App->>Utils: convertJsRegexToPostgres(RegExp("foo.*","i"))
+     *   Utils->>Utils: Parse string or use RegExp.source
+     *   Utils-->>App: "foo.*"
+     * @memberOf module:for-typeorm
+     */
+    function convertJsRegexToPostgres(jsRegex) {
+        const rxp = new RegExp(/^\/(.+)\/(\w+)$/g);
+        if (typeof jsRegex === "string") {
+            const match = rxp.exec(jsRegex);
+            if (match) {
+                const [, p] = match;
+                jsRegex = p;
+            }
+        }
+        const regex = typeof jsRegex === "string" ? new RegExp(jsRegex) : jsRegex;
+        const pattern = regex.source;
+        return pattern;
+    }
+
+    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,
+            });
+    }
+
+    /**
+     * Column decorator is used to mark a specific class property as a table column.
+     * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+     */
+    function Column(typeOrOptions, options) {
+        return function (object, propertyName) {
+            // normalize parameters
+            let type;
+            if (typeof typeOrOptions === "string" ||
+                typeof typeOrOptions === "function") {
+                type = typeOrOptions;
+            }
+            else if (typeOrOptions) {
+                options = typeOrOptions;
+                type = typeOrOptions.type;
+            }
+            if (!options)
+                options = {};
+            // if type is not given explicitly then try to guess it
+            const reflectMetadataType = Reflect && Reflect.getMetadata
+                ? Reflect.getMetadata("design:type", object, propertyName)
+                : undefined;
+            if (!type && reflectMetadataType)
+                // if type is not given explicitly then try to guess it
+                type = reflectMetadataType;
+            // check if there is no type in column options then set type from first function argument, or guessed one
+            if (!options.type && type)
+                options.type = type;
+            // specify HSTORE type if column is HSTORE
+            if (options.type === "hstore" && !options.hstoreType)
+                options.hstoreType = reflectMetadataType === Object ? "object" : "string";
+            if (typeof typeOrOptions === "function") {
+                // register an embedded
+                typeorm.getMetadataArgsStorage().embeddeds.push({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    isArray: reflectMetadataType === Array || options.array === true,
+                    prefix: options.prefix !== undefined ? options.prefix : undefined,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+                    type: typeOrOptions,
+                });
+            }
+            else {
+                // register a regular column
+                // if we still don't have a type then we need to give error to user that type is required
+                if (!options.type)
+                    throw new typeorm.ColumnTypeUndefinedError(object, propertyName);
+                // create unique
+                if (options.unique === true)
+                    typeorm.getMetadataArgsStorage().uniques.push({
+                        target: object.constructor,
+                        columns: [propertyName],
+                    });
+                const columns = typeorm.getMetadataArgsStorage().columns;
+                aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+                if (options.generated) {
+                    typeorm.getMetadataArgsStorage().generations.push({
+                        target: object.constructor,
+                        propertyName: propertyName,
+                        strategy: typeof options.generated === "string"
+                            ? options.generated
+                            : "increment",
+                    });
+                }
+            }
+        };
+    }
+
+    function UpdateDateColumn(options) {
+        return function (object, propertyName) {
+            const columns = typeorm.getMetadataArgsStorage().columns;
+            aggregateOrNewColumn(object.constructor, propertyName, columns, {}, "updateDate");
+        };
+    }
+
+    function CreateDateColumn(options) {
+        return function (object, propertyName) {
+            const columns = typeorm.getMetadataArgsStorage().columns;
+            aggregateOrNewColumn(object.constructor, propertyName, columns, {}, "createDate");
+        };
+    }
+
+    /**
+     * Column decorator is used to mark a specific class property as a table column.
+     * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+     * This column creates an integer PRIMARY COLUMN with generated set to true.
+     */
+    function PrimaryGeneratedColumn(strategyOrOptions, maybeOptions) {
+        // normalize parameters
+        const options = {};
+        let strategy;
+        {
+            strategy = "increment";
+        }
+        if (ObjectUtils.ObjectUtils.isObject(maybeOptions))
+            Object.assign(options, maybeOptions);
+        return function (object, propertyName) {
+            // if column type is not explicitly set then determine it based on generation strategy
+            if (!options.type) {
+                if (strategy === "increment" || strategy === "identity") {
+                    options.type = Number;
+                }
+                else if (strategy === "uuid") {
+                    options.type = "uuid";
+                }
+                else if (strategy === "rowid") {
+                    options.type = "int";
+                }
+            }
+            // explicitly set a primary and generated to column options
+            options.primary = true;
+            const columns = typeorm.getMetadataArgsStorage().columns;
+            aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+            // register generated metadata args
+            typeorm.getMetadataArgsStorage().generations.push({
+                target: object.constructor,
+                propertyName: propertyName,
+                strategy: strategy,
+            });
+        };
+    }
+
+    /**
+     * Column decorator is used to mark a specific class property as a table column.
+     * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+     * Primary columns also creates a PRIMARY KEY for this column in a db.
+     */
+    function PrimaryColumn(typeOrOptions, options) {
+        return function (object, propertyName) {
+            // normalize parameters
+            let type;
+            if (typeof typeOrOptions === "string" ||
+                typeOrOptions === String ||
+                typeOrOptions === Boolean ||
+                typeOrOptions === Number) {
+                type = typeOrOptions;
+            }
+            else {
+                options = Object.assign({}, typeOrOptions);
+            }
+            if (!options)
+                options = {};
+            // if type is not given explicitly then try to guess it
+            const reflectMetadataType = Reflect && Reflect.getMetadata
+                ? Reflect.getMetadata("design:type", object, propertyName)
+                : undefined;
+            if (!type && reflectMetadataType)
+                type = reflectMetadataType;
+            // check if there is no type in column options then set type from first function argument, or guessed one
+            if (!options.type && type)
+                options.type = type;
+            // if we still don't have a type then we need to give error to user that type is required
+            if (!options.type)
+                throw new typeorm.ColumnTypeUndefinedError(object, propertyName);
+            // check if column is not nullable, because we cannot allow a primary key to be nullable
+            if (options.nullable)
+                throw new typeorm.PrimaryColumnCannotBeNullableError(object, propertyName);
+            // explicitly set a primary to column options
+            options.primary = true;
+            const columns = typeorm.getMetadataArgsStorage().columns;
+            aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+            if (options.generated) {
+                typeorm.getMetadataArgsStorage().generations.push({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    strategy: typeof options.generated === "string"
+                        ? options.generated
+                        : "increment",
+                });
+            }
+        };
+    }
+
+    /**
+     * This decorator is used to mark classes that will be an entity (table or document depend on database type).
+     * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
+     */
+    function Entity(nameOrOptions, maybeOptions) {
+        const options = (ObjectUtils.ObjectUtils.isObject(nameOrOptions)
+            ? nameOrOptions
+            : maybeOptions) || {};
+        const name = options.name;
+        return function (target) {
+            const tables = typeorm.getMetadataArgsStorage().tables;
+            tables.push({
+                target: target,
+                name: name,
+                type: "regular",
+                orderBy: options.orderBy ? options.orderBy : undefined,
+                engine: options.engine ? options.engine : undefined,
+                database: options.database ? options.database : undefined,
+                schema: options.schema ? options.schema : undefined,
+                synchronize: options.synchronize,
+                withoutRowid: options.withoutRowid,
+                comment: options.comment ? options.comment : undefined,
+            });
+        };
+    }
+
+    async function createdByOnPostgresCreateUpdate(context, data, key, model) {
+        try {
+            const user = context.get("user");
+            model[key] = user;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            throw new dbDecorators.InternalError("No User found in context. Please provide a user in the context");
+        }
+    }
+    /**
+     * @description Adapter for TypeORM-backed persistence operations.
+     * @summary Implements the Decaf.ts Adapter over a TypeORM DataSource, providing CRUD operations, query/statement factories, sequence management, error parsing, and decoration helpers.
+     * @template Y The native configuration type (TypeORM DataSourceOptions).
+     * @template F The repository flags type.
+     * @template C The context type.
+     * @param {DataSourceOptions} scope The DataSource options for the adapter.
+     * @param {string} flavour The flavour of the adapter.
+     * @param {string} [alias] Optional alias for the adapter.
+     * @class TypeORMAdapter
+     * @example
+     * const adapter = new TypeORMAdapter({ type: 'postgres', /* ... *\/ });
+     * await adapter.initialize();
+     * const repo = new (adapter.repository<User>())(adapter, User);
+     * const created = await repo.create(new User({ name: 'Alice' }));
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant App
+     *   participant Adapter as TypeORMAdapter
+     *   participant Repo as TypeORMRepository
+     *   participant DS as TypeORM DataSource
+     *
+     *   App->>Adapter: new TypeORMAdapter(opts)
+     *   Adapter->>DS: initialize()
+     *   App->>Adapter: repository()
+     *   Adapter-->>App: TypeORMRepository
+     *   App->>Repo: create(model)
+     *   Repo->>Adapter: prepare/create/revert
+     *   Adapter-->>Repo: Model
+     *   Repo-->>App: Model
+     */
+    class TypeORMAdapter extends core.Adapter {
+        get dataSource() {
+            if (!this._dataSource) {
+                const models = core.Adapter.models(this.flavour);
+                this._dataSource = new typeorm.DataSource(Object.assign(this.native, {
+                    entities: models.map((c) => c[decoratorValidation.ModelKeys.ANCHOR]),
+                }));
+            }
+            return this._dataSource;
+        }
+        // protected dataSou
+        constructor(options, alias) {
+            super(options, TypeORMFlavour, alias);
+        }
+        async flags(operation, model, flags) {
+            const f = await super.flags(operation, model, flags);
+            const newObj = {
+                user: (await TypeORMAdapter.getCurrentUser(this.dataSource)),
+            };
+            const m = new model();
+            const exceptions = [];
+            if (operation === dbDecorators.OperationKeys.CREATE) {
+                const pk = dbDecorators.findPrimaryKey(m).id;
+                exceptions.push(pk);
+            }
+            if (operation === dbDecorators.OperationKeys.CREATE ||
+                operation === dbDecorators.OperationKeys.UPDATE) {
+                const decs = Object.keys(m).reduce((accum, key) => {
+                    const decs = reflection.Reflection.getPropertyDecorators(decoratorValidation.ValidationKeys.REFLECT, m, key, true);
+                    const dec = decs.decorators.find((dec) => dec.key === dbDecorators.DBKeys.TIMESTAMP &&
+                        dec.props.operation.indexOf(operation) !== -1);
+                    if (dec) {
+                        accum[key] = dec.props;
+                    }
+                    return accum;
+                }, {});
+                exceptions.push(...Object.keys(decs));
+            }
+            newObj.ignoredValidationProperties = (f.ignoredValidationProperties ? f.ignoredValidationProperties : []).concat(...exceptions);
+            return Object.assign(f, newObj);
+        }
+        Dispatch() {
+            return new TypeORMDispatch();
+        }
+        repository() {
+            return exports.TypeORMRepository;
+        }
+        /**
+         * @description Creates a new Postgres statement for querying
+         * @summary Factory method that creates a new PostgresStatement instance for building queries
+         * @template M - The model type
+         * @return {TypeORMStatement<M, any>} A new PostgresStatement instance
+         */
+        Statement() {
+            return new TypeORMStatement(this);
+        }
+        /**
+         * @description Creates a new PostgreSQL sequence
+         * @summary Factory method that creates a new PostgreSQLSequence instance for managing sequences
+         * @param {SequenceOptions} options - The options for the sequence
+         * @return {Promise<Sequence>} A promise that resolves to a new Sequence instance
+         */
+        async Sequence(options) {
+            return new TypeORMSequence(options, this);
+        }
+        /**
+         * @description Initializes the adapter by creating indexes for all managed models
+         * @summary Sets up the necessary database indexes for all models managed by this adapter
+         * @return {Promise<void>} A promise that resolves when initialization is complete
+         */
+        async initialize() {
+            const ds = this.dataSource;
+            try {
+                await ds.initialize();
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            const log = this.log.for(this.initialize);
+            log.verbose(`${this.flavour} adapter initialized`);
+        }
+        /**
+         * @description Creates indexes for the given models
+         * @summary Abstract method that must be implemented to create database indexes for the specified models
+         * @template M - The model type
+         * @param {...Constructor<M>} models - The model constructors to create indexes for
+         * @return {Promise<void>} A promise that resolves when all indexes are created
+         */
+        async index(...models) {
+            const indexes = generateIndexes(models);
+            try {
+                await this.dataSource.query("BEGIN");
+                for (const index of indexes) {
+                    await this.dataSource.query(index.query, index.values);
+                }
+                await this.dataSource.query("COMMIT");
+            }
+            catch (e) {
+                await this.dataSource.query("ROLLBACK");
+                throw this.parseError(e);
+            }
+        }
+        /**
+         * @description Executes a raw SQL query against the database
+         * @summary Abstract method that must be implemented to execute raw SQL queries
+         * @template R - The result type
+         * @param {TypeORMQuery} q - The query to execute
+         * @return {Promise<R>} A promise that resolves to the query result
+         */
+        async raw(q) {
+            const log = this.log.for(this.raw);
+            try {
+                if (!this.dataSource.isInitialized)
+                    await this.dataSource.initialize();
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            try {
+                const { query, values } = q;
+                log.debug(`executing query: ${query.getSql()}`);
+                const response = await this.dataSource.query(query, values);
+                return response;
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        prepare(model, pk, child = false) {
+            const prepared = super.prepare(model, pk);
+            prepared.record = Object.entries(prepared.record).reduce((accum, [key, value]) => {
+                if (key === core.PersistenceKeys.METADATA || this.isReserved(key))
+                    return accum;
+                if (value === undefined) {
+                    return accum;
+                }
+                if (value instanceof Date) {
+                    value = new Date(value.getTime());
+                }
+                else if (decoratorValidation.Model.isModel(value)) {
+                    value = this.prepare(value, dbDecorators.findPrimaryKey(value).id, true).record;
+                }
+                else {
+                    switch (typeof value) {
+                        case "string":
+                            value = `${value}`;
+                            break;
+                        //do nothing;
+                    }
+                }
+                accum[key] = value;
+                return accum;
+            }, {});
+            const constr = decoratorValidation.Model.get(model.constructor.name);
+            if (!constr)
+                throw new dbDecorators.InternalError(`Model ${model.constructor.name} not found in registry`);
+            const result = child
+                ? new constr[decoratorValidation.ModelKeys.ANCHOR]()
+                : new constr();
+            if (child)
+                Object.defineProperty(result, "constructor", {
+                    configurable: false,
+                    enumerable: false,
+                    value: constr[decoratorValidation.ModelKeys.ANCHOR],
+                    writable: false,
+                });
+            Object.entries(prepared.record).forEach(([key, val]) => (result[key] = val));
+            prepared.record = result;
+            return prepared;
+        }
+        revert(obj, clazz, pk, id, transient) {
+            const log = this.log.for(this.revert);
+            if (transient) {
+                log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
+                Object.entries(transient).forEach(([key, val]) => {
+                    if (key in obj)
+                        throw new dbDecorators.InternalError(`Transient property ${key} already exists on model ${typeof clazz === "string" ? clazz : clazz.name}. should be impossible`);
+                    obj[key] = val;
+                });
+            }
+            return new clazz(obj);
+        }
+        /**
+         * @description Creates a new record in the database
+         * @summary Abstract method that must be implemented to create a new record
+         * @param {string} tableName - The name of the table
+         * @param {string|number} id - The ID of the record
+         * @param {Record<string, any>} model - The model to create
+         * @param {...any[]} args - Additional arguments
+         * @return {Promise<Record<string, any>>} A promise that resolves to the created record
+         */
+        async create(tableName, id, model, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            const m = tableName;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                return await repo.save(model);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        /**
+         * @description Reads a record from the database
+         * @summary Abstract method that must be implemented to read a record
+         * @param {string} tableName - The name of the table
+         * @param {string|number} id - The ID of the record
+         * @param {string} pk - primary key colum
+         * @return {Promise<Record<string, any>>} A promise that resolves to the read record
+         */
+        async read(tableName, id, pk) {
+            const m = tableName;
+            let result;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                const q = {
+                    where: {
+                        [pk]: id,
+                    },
+                };
+                result = (await repo.findOne(q));
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            if (!result)
+                throw new dbDecorators.NotFoundError(`Record with id: ${id} not found in table ${typeof tableName === "string" ? tableName : core.Repository.table(tableName)}`);
+            return result;
+        }
+        /**
+         * @description Updates a record in the database
+         * @summary Abstract method that must be implemented to update a record
+         * @param {string} tableName - The name of the table
+         * @param {string|number} id - The ID of the record
+         * @param {Record<string, any>} model - The model to update
+         * @param {string} pk - Additional arguments
+         * @return A promise that resolves to the updated record
+         */
+        async update(tableName, id, model, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            const m = tableName;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                return repo.save(model);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        /**
+         * @description Deletes a record from the database
+         * @summary Abstract method that must be implemented to delete a record
+         * @param {string} tableName - The name of the table
+         * @param {string|number} id - The ID of the record
+         * @param {string} pk - Additional arguments
+         * @return A promise that resolves to the deleted record
+         */
+        async delete(tableName, id, pk, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            const m = tableName;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                const model = await this.read(tableName, id, pk);
+                const res = await repo.delete(id);
+                return model;
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        async createAll(tableName, id, model, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            const m = tableName;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                const result = await repo.insert(model);
+                return this.readAll(tableName, result.identifiers.map((id) => id.id), "id");
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        async readAll(tableName, id, pk, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            if (!id.length)
+                return [];
+            const m = tableName;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                return repo.findBy({ [pk]: typeorm.In(id) });
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        async updateAll(tableName, ids, model, pk, ...args) {
+            const result = [];
+            for (const m of model) {
+                result.push(await this.update(tableName, m[pk], m, ...args));
+            }
+            return result;
+        }
+        async deleteAll(tableName, ids, pk, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ...args) {
+            if (!ids.length)
+                return [];
+            const m = tableName;
+            try {
+                const repo = this.dataSource.getRepository(m);
+                const models = await this.readAll(tableName, ids, pk);
+                await repo.delete(ids);
+                return models;
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        /**
+         * @description Parses an error and converts it to a BaseError
+         * @summary Converts various error types to appropriate BaseError subtypes
+         * @param {Error|string} err - The error to parse
+         * @param {string} [reason] - Optional reason for the error
+         * @return {BaseError} The parsed error as a BaseError
+         */
+        parseError(err, reason) {
+            return TypeORMAdapter.parseError(err, reason);
+        }
+        /**
+         * @description Checks if an attribute is reserved
+         * @summary Determines if an attribute name is reserved in PostgreSQL
+         * @param {string} attr - The attribute name to check
+         * @return {boolean} True if the attribute is reserved, false otherwise
+         */
+        isReserved(attr) {
+            return !!attr.match(reservedAttributes);
+        }
+        /**
+         * @description Static method to parse an error and convert it to a BaseError
+         * @summary Converts various error types to appropriate BaseError subtypes based on PostgreSQL error codes and messages
+         * @param {Error|string} err - The error to parse
+         * @param {string} [reason] - Optional reason for the error
+         * @return {BaseError} The parsed error as a BaseError
+         * @mermaid
+         * sequenceDiagram
+         *   participant Caller
+         *   participant parseError
+         *   participant ErrorTypes
+         *
+         *   Caller->>parseError: err, reason
+         *   Note over parseError: Check if err is already a BaseError
+         *   alt err is BaseError
+         *     parseError-->>Caller: return err
+         *   else err is string
+         *     Note over parseError: Extract code from string
+         *     alt code matches "duplicate key|already exists"
+         *       parseError->>ErrorTypes: new ConflictError(code)
+         *       ErrorTypes-->>Caller: ConflictError
+         *     else code matches "does not exist|not found"
+         *       parseError->>ErrorTypes: new NotFoundError(code)
+         *       ErrorTypes-->>Caller: NotFoundError
+         *     end
+         *   else err has code property
+         *     Note over parseError: Extract code and reason
+         *   else
+         *     Note over parseError: Use err.message as code
+         *   end
+         *
+         *   Note over parseError: Switch on PostgreSQL error code
+         *   alt code is 23505 (unique_violation)
+         *     parseError->>ErrorTypes: new ConflictError(reason)
+         *     ErrorTypes-->>Caller: ConflictError
+         *   else code is 23503 (foreign_key_violation)
+         *     parseError->>ErrorTypes: new ConflictError(reason)
+         *     ErrorTypes-->>Caller: ConflictError
+         *   else code is 42P01 (undefined_table)
+         *     parseError->>ErrorTypes: new NotFoundError(reason)
+         *     ErrorTypes-->>Caller: NotFoundError
+         *   else code is 42703 (undefined_column)
+         *     parseError->>ErrorTypes: new NotFoundError(reason)
+         *     ErrorTypes-->>Caller: NotFoundError
+         *   else code is 42P07 (duplicate_table)
+         *     parseError->>ErrorTypes: new ConflictError(reason)
+         *     ErrorTypes-->>Caller: ConflictError
+         *   else code is 42P16 (invalid_table_definition)
+         *     parseError->>ErrorTypes: new IndexError(err)
+         *     ErrorTypes-->>Caller: IndexError
+         *   else code matches "ECONNREFUSED"
+         *     parseError->>ErrorTypes: new ConnectionError(err)
+         *     ErrorTypes-->>Caller: ConnectionError
+         *   else
+         *     parseError->>ErrorTypes: new InternalError(err)
+         *     ErrorTypes-->>Caller: InternalError
+         *   end
+         */
+        static parseError(err, reason) {
+            if (err instanceof dbDecorators.BaseError)
+                return err;
+            const code = typeof err === "string" ? err : err.message;
+            if (code.match(/duplicate key|already exists/g))
+                return new dbDecorators.ConflictError(code);
+            if (code.match(/does not exist|not found/g))
+                return new dbDecorators.NotFoundError(code);
+            // PostgreSQL error codes: https://www.postgresql.org/docs/current/errcodes-appendix.html
+            switch (code.toString()) {
+                // Integrity constraint violations
+                case "23505": // unique_violation
+                case "23503": // foreign_key_violation
+                case "42P07": // duplicate_table
+                    return new dbDecorators.ConflictError(reason);
+                // Object not found errors
+                case "42P01": // undefined_table
+                case "42703": // undefined_column
+                    return new dbDecorators.NotFoundError(reason);
+                // Invalid object definition
+                case "42P16": // invalid_table_definition
+                    return new IndexError(err);
+                // Connection errors
+                default:
+                    if (code.toString().match(/ECONNREFUSED/g))
+                        return new core.ConnectionError(err);
+                    return new dbDecorators.InternalError(err);
+            }
+        }
+        static async connect(config) {
+            const con = new typeorm.DataSource(config);
+            if (!con.isInitialized)
+                await con.initialize();
+            return con;
+        }
+        static async createDatabase(dataSource, dbName) {
+            const log = logging.Logging.for(this.createDatabase);
+            log.verbose(`Creating database ${dbName}`);
+            try {
+                await dataSource.query(`CREATE DATABASE ${dbName}`);
+                log.info(`Created database ${dbName}`);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        static async createNotifyFunction(dataSource, user) {
+            const log = logging.Logging.for(this.createNotifyFunction);
+            log.verbose(`Creating notify function`);
+            try {
+                await dataSource.query(`CREATE OR REPLACE FUNCTION notify_table_changes()
+RETURNS trigger AS $$
+BEGIN
+    PERFORM pg_notify(
+        'table_changes',
+        json_build_object(
+            'table', TG_TABLE_NAME,
+            'action', TG_OP,
+            'data', row_to_json(NEW),
+            'old_data', row_to_json(OLD)
+        )::text
+    );
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER
+;`);
+                await dataSource.query(`ALTER FUNCTION notify_table_changes() OWNER TO ${user};`);
+                await dataSource.query(`
+            GRANT EXECUTE ON FUNCTION notify_table_changes() TO public;
+        `);
+                log.info(`Created notify function`);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        static async deleteDatabase(dataSource, dbName, user) {
+            try {
+                if (user)
+                    await dataSource.query(`DROP OWNED BY ${user} CASCADE;`);
+                await dataSource.query(`DROP DATABASE ${dbName}`);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        static async createUser(dataSource, dbName, user, password) {
+            try {
+                await dataSource.query(`CREATE USER ${user} WITH PASSWORD '${password}'`);
+                await dataSource.query(`GRANT CONNECT ON DATABASE ${dbName} TO ${user}`);
+                await dataSource.query(`GRANT USAGE ON SCHEMA public TO ${user}`);
+                await dataSource.query(`GRANT CREATE ON SCHEMA public TO ${user}`);
+                await dataSource.query(`GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ${user}`);
+                await dataSource.query(`GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ${user}`);
+                await dataSource.query(`GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public TO ${user}`);
+                await dataSource.query(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO ${user}`);
+                await dataSource.query(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO ${user}`);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        static async deleteUser(client, user, admin) {
+            try {
+                await client.query(`REASSIGN OWNED BY ${user} TO ${admin}`);
+                await client.query(`REVOKE ALL ON ALL TABLES IN SCHEMA public FROM ${user}`);
+                await client.query(`REVOKE ALL ON SCHEMA public FROM ${user}`);
+                await client.query(`REVOKE ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public FROM ${user}`);
+                await client.query(`REVOKE ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public FROM ${user}`);
+                await client.query(`ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON TABLES FROM ${user}`);
+                await client.query(`ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON SEQUENCES FROM ${user};`);
+                await client.query(`ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON FUNCTIONS FROM ${user}`);
+                await client.query(`DROP OWNED BY ${user} CASCADE`);
+                await client.query(`DROP USER IF EXISTS "${user}"`);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        static parseTypeToPostgres(type, isPk, isFk = false) {
+            switch (type.toLowerCase()) {
+                case "string":
+                    return isPk ? "TEXT PRIMARY KEY" : isFk ? "TEXT" : "VARCHAR";
+                case "number":
+                    return isPk ? "SERIAL PRIMARY KEY" : "INTEGER";
+                case "boolean":
+                    return "BOOLEAN";
+                case "date":
+                    return "TIMESTAMP";
+                case "bigint":
+                    return isPk ? "BIGINT PRIMARY KEY" : "BIGINT";
+                default: {
+                    const m = decoratorValidation.Model.get(type);
+                    if (m) {
+                        const mm = new m();
+                        const type = reflection.Reflection.getTypeFromDecorator(mm, dbDecorators.findPrimaryKey(mm).id);
+                        return {
+                            model: m,
+                            pkType: type,
+                        };
+                    }
+                    throw new dbDecorators.InternalError(`Unsupported type: ${type}`);
+                }
+            }
+        }
+        static parseValidationToPostgres(prop, type, isPk, key, options) {
+            switch (key) {
+                case decoratorValidation.ValidationKeys.REQUIRED:
+                    return "NOT NULL";
+                case decoratorValidation.ValidationKeys.MAX_LENGTH:
+                    if (isPk || !options || type.toLowerCase() !== "string") {
+                        return "";
+                    }
+                    return `(${options[decoratorValidation.ValidationKeys.MAX_LENGTH]})`;
+                case decoratorValidation.ValidationKeys.MIN_LENGTH:
+                    return `CONSTRAINT ${prop}_min_length_check CHECK (LENGTH(${prop}) >= ${options[decoratorValidation.ValidationKeys.MIN_LENGTH]})`;
+                case decoratorValidation.ValidationKeys.PATTERN:
+                case decoratorValidation.ValidationKeys.URL:
+                case decoratorValidation.ValidationKeys.EMAIL:
+                    return `CONSTRAINT ${prop}_pattern_check CHECK (${prop} ~ '${convertJsRegexToPostgres(options[decoratorValidation.ValidationKeys.PATTERN])}')`;
+                case decoratorValidation.ValidationKeys.TYPE:
+                case decoratorValidation.ValidationKeys.DATE:
+                    return "";
+                case decoratorValidation.ValidationKeys.MIN:
+                    return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} >= ${options[decoratorValidation.ValidationKeys.MIN]})`;
+                case decoratorValidation.ValidationKeys.MAX:
+                    return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} <= ${options[decoratorValidation.ValidationKeys.MAX]})`;
+                case decoratorValidation.ValidationKeys.PASSWORD:
+                default:
+                    throw new dbDecorators.InternalError(`Unsupported type: ${key}`);
+            }
+        }
+        static parseRelationsToPostgres(prop, clazz, pk, key, options) {
+            const tableName = core.Repository.table(clazz);
+            const { cascade } = options;
+            const cascadeStr = `${cascade.update ? " ON UPDATE CASCADE" : ""}${cascade.delete ? " ON DELETE CASCADE" : ""}`;
+            switch (`relations${key}`) {
+                case core.PersistenceKeys.ONE_TO_ONE:
+                    return `FOREIGN KEY (${prop}) REFERENCES ${tableName}(${pk})${cascadeStr}`;
+                default:
+                    throw new dbDecorators.InternalError(`Unsupported operation: ${key}`);
+            }
+        }
+        static async createTable(client, model) {
+            const result = {};
+            const m = new model({});
+            const tableName = core.Repository.table(model);
+            const { id } = dbDecorators.findPrimaryKey(m);
+            let isPk, column;
+            const properties = Object.getOwnPropertyNames(m);
+            for (const prop of properties) {
+                if (typeof this[prop] === "function" ||
+                    prop.toString().startsWith("_") ||
+                    prop === "constructor") {
+                    continue;
+                }
+                isPk = prop === id;
+                column = core.Repository.column(m, prop.toString());
+                const allDecs = reflection.Reflection.getPropertyDecorators(decoratorValidation.ValidationKeys.REFLECT, m, prop.toString(), false, true);
+                const decoratorData = allDecs.decorators.reduce((accum, el) => {
+                    const { key, props } = el;
+                    if (key === decoratorValidation.ModelKeys.TYPE && !accum[decoratorValidation.ValidationKeys.TYPE]) {
+                        accum[decoratorValidation.ValidationKeys.TYPE] = {
+                            customTypes: [props.name],
+                            message: decoratorValidation.DEFAULT_ERROR_MESSAGES.TYPE,
+                            description: "defines the accepted types for the attribute",
+                        };
+                    }
+                    else if (key !== decoratorValidation.ValidationKeys.TYPE) {
+                        // do nothing. we can only support basis ctypes at this time
+                        accum[key] = props;
+                    }
+                    return accum;
+                }, {});
+                const dbDecs = reflection.Reflection.getPropertyDecorators(core.Repository.key("relations"), m, prop.toString(), true, true);
+                const query = [];
+                const constraints = [];
+                const foreignKeys = [];
+                let typeData = undefined;
+                let childClass = undefined;
+                let childPk;
+                if (Object.keys(decoratorData).length) {
+                    typeData = decoratorData[decoratorValidation.ValidationKeys.TYPE];
+                    if (!typeData) {
+                        throw new Error(`Missing type information`);
+                    }
+                    let parsedType = this.parseTypeToPostgres(typeof typeData.customTypes[0] === "function"
+                        ? typeData.customTypes[0]()
+                        : typeData.customTypes[0], isPk);
+                    if (typeof parsedType === "string") {
+                        parsedType = { model: parsedType };
+                    }
+                    let typeStr = parsedType.model;
+                    if (typeof typeStr !== "string") {
+                        if (Array.isArray(typeStr)) {
+                            console.log(typeStr);
+                        }
+                        // continue;
+                        // const res: Record<string, PostgresTableSpec> = await this.createTable(pool, typeStr);
+                        try {
+                            childClass = parsedType.model;
+                            const m = new childClass();
+                            childPk = dbDecorators.findPrimaryKey(m);
+                            typeStr = this.parseTypeToPostgres(parsedType.pkType, false, true);
+                            await this.createTable(client, childClass);
+                        }
+                        catch (e) {
+                            if (!(e instanceof dbDecorators.ConflictError))
+                                throw e;
+                        }
+                    }
+                    let tp = Array.isArray(typeData.customTypes)
+                        ? typeData.customTypes[0]
+                        : typeData.customTypes;
+                    tp = typeof tp === "function" && !tp.name ? tp() : tp;
+                    const validationStr = this.parseValidationToPostgres(column, tp, isPk, decoratorValidation.ValidationKeys.MAX_LENGTH, decoratorData[decoratorValidation.ValidationKeys.MAX_LENGTH] || {
+                        [decoratorValidation.ValidationKeys.MAX_LENGTH]: 255,
+                    });
+                    const q = `${column} ${typeStr}${validationStr}`;
+                    if (isPk) {
+                        query.unshift(q);
+                    }
+                    else {
+                        query.push(q);
+                    }
+                    for (const [key, props] of Object.entries(decoratorData).filter(([k]) => ![decoratorValidation.ValidationKeys.TYPE, decoratorValidation.ValidationKeys.MAX_LENGTH].includes(k))) {
+                        const validation = this.parseValidationToPostgres(column, tp, isPk, key, props);
+                        if (validation.startsWith("CONSTRAINT")) {
+                            constraints.push(validation);
+                        }
+                        else {
+                            if (validation) {
+                                query.push(validation);
+                            }
+                        }
+                    }
+                }
+                // TODO ignore for now. this leaves foreign keys out
+                // eslint-disable-next-line no-constant-binary-expression
+                if ((dbDecs && dbDecs.decorators.length)) {
+                    if (!typeData)
+                        throw new Error(`Missing type information`);
+                    for (const decorator of dbDecs.decorators) {
+                        const { key, props } = decorator;
+                        const validation = this.parseRelationsToPostgres(column, childClass, childPk.id, key, props);
+                        if (validation.startsWith("FOREIGN")) {
+                            foreignKeys.push(validation);
+                        }
+                        else {
+                            throw new dbDecorators.InternalError(`Unsupported relation: ${key}`);
+                        }
+                    }
+                }
+                result[prop.toString()] = {
+                    query: query.join(" "),
+                    values: [],
+                    primaryKey: isPk,
+                    constraints: constraints,
+                    foreignKeys: foreignKeys,
+                };
+            }
+            const values = Object.values(result);
+            const query = values.map((r) => r.query).join(",\n");
+            const constraints = values
+                .filter((c) => !!c.constraints.length)
+                .map((r) => r.constraints)
+                .join(",\n");
+            const foreignKeys = values
+                .filter((c) => !!c.foreignKeys.length)
+                .map((r) => r.foreignKeys)
+                .join(",\n");
+            const vals = [query, constraints];
+            if (foreignKeys) {
+                vals.push(foreignKeys);
+            }
+            const queryString = `CREATE TABLE ${tableName} (${vals.filter((v) => !!v).join(",\n")})`;
+            try {
+                await client.query(queryString);
+                await client.query(`CREATE TRIGGER notify_changes_${tableName}
+AFTER INSERT OR UPDATE OR DELETE ON ${tableName}
+    FOR EACH ROW
+    EXECUTE FUNCTION notify_table_changes();`);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            return result;
+        }
+        static async getCurrentUser(client) {
+            const queryString = `SELECT CURRENT_USER;`;
+            try {
+                const result = await client.query(queryString);
+                return result[0].current_user;
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+        }
+        static decoration() {
+            // @table() => @Entity()
+            const tableKey = core.Adapter.key(core.PersistenceKeys.TABLE);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(tableKey)
+                .extend((original) => Entity()(original[decoratorValidation.ModelKeys.ANCHOR] || original))
+                .apply();
+            // @pk() => @PrimaryGeneratedColumn() | @PrimaryColumn()
+            const pkKey = core.Repository.key(dbDecorators.DBKeys.ID);
+            function pkDec(options) {
+                const decorators = [
+                    decoratorValidation.required(),
+                    dbDecorators.readonly(),
+                    decoratorValidation.propMetadata(pkKey, options),
+                ];
+                if (options.type)
+                    decorators.push(PrimaryGeneratedColumn());
+                else
+                    decorators.push(PrimaryColumn({ unique: true }));
+                return reflection.apply(...decorators);
+            }
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(pkKey)
+                .define({
+                decorator: pkDec,
+            })
+                .apply();
+            // @column("columnName") => @Column({name: "columnName"})
+            const columnKey = core.Adapter.key(core.PersistenceKeys.COLUMN);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(columnKey)
+                .extend({
+                decorator: function columm(name) {
+                    return function column(obj, prop) {
+                        return Column({
+                            name: name || prop,
+                            nullable: true,
+                        })(obj, prop);
+                    };
+                },
+                transform: (args) => {
+                    const columnName = args[1];
+                    return [columnName];
+                },
+            })
+                .apply();
+            // @unique => @Column({unique: true})
+            const uniqueKey = core.Adapter.key(core.PersistenceKeys.UNIQUE);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(uniqueKey)
+                .define(decoratorValidation.propMetadata(uniqueKey, {}))
+                .extend(Column({ unique: true }))
+                .apply();
+            // @required => @Column({ nullable: false })
+            const requiredKey = decoratorValidation.Validation.key(decoratorValidation.ValidationKeys.REQUIRED);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(requiredKey)
+                .extend(Column({ nullable: false }))
+                .apply();
+            // @version => @VersionColumn()
+            const versionKey = core.Repository.key(dbDecorators.DBKeys.VERSION);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(versionKey)
+                .define(decoratorValidation.type(Number.name), typeorm.VersionColumn())
+                .apply();
+            function ValidationUpdateKey(key) {
+                return dbDecorators.UpdateValidationKeys.REFLECT + key;
+            }
+            // @timestamp(op) => @CreateDateColumn() || @UpdateDateColumn()
+            const timestampKey = ValidationUpdateKey(dbDecorators.DBKeys.TIMESTAMP);
+            function ts(operation, format) {
+                const decorators = [
+                    decoratorValidation.date(format, dbDecorators.DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),
+                    decoratorValidation.required(dbDecorators.DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),
+                    decoratorValidation.propMetadata(decoratorValidation.Validation.key(dbDecorators.DBKeys.TIMESTAMP), {
+                        operation: operation,
+                        format: format,
+                    }),
+                ];
+                if (operation.indexOf(dbDecorators.OperationKeys.UPDATE) !== -1)
+                    decorators.push(decoratorValidation.propMetadata(timestampKey, {
+                        message: dbDecorators.DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID,
+                    }));
+                else
+                    decorators.push(dbDecorators.readonly());
+                return reflection.apply(...decorators);
+            }
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(timestampKey)
+                .define({
+                decorator: ts,
+            })
+                .extend({
+                decorator: function timestamp(...ops) {
+                    return function timestamp(obj, prop) {
+                        if (ops.indexOf(dbDecorators.OperationKeys.UPDATE) !== -1)
+                            return UpdateDateColumn()(obj, prop);
+                        return CreateDateColumn()(obj, prop);
+                    };
+                },
+                transform: (args) => {
+                    return args[0];
+                },
+            })
+                .apply();
+            // @oneToOne(clazz) => @OneToOne(() => clazz)
+            const oneToOneKey = core.Repository.key(core.PersistenceKeys.ONE_TO_ONE);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(oneToOneKey)
+                .define({
+                decorator: function oneToOne(clazz, cascade, populate) {
+                    const metadata = {
+                        class: (clazz.name ? clazz.name : clazz),
+                        cascade: cascade,
+                        populate: populate,
+                    };
+                    const ormMeta = {
+                        cascade: cascade.update === core.Cascade.CASCADE ||
+                            cascade.delete === core.Cascade.CASCADE,
+                        onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                        onUpdate: cascade.update ? "CASCADE" : "DEFAULT",
+                        nullable: true,
+                        eager: populate,
+                    };
+                    return reflection.apply(decoratorValidation.prop(core.PersistenceKeys.RELATIONS), decoratorValidation.type([
+                        (typeof clazz === "function" && !clazz.name
+                            ? clazz
+                            : clazz.name),
+                        String.name,
+                        Number.name,
+                        BigInt.name,
+                    ]), decoratorValidation.propMetadata(oneToOneKey, metadata), typeorm.OneToOne(() => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        if (!clazz[decoratorValidation.ModelKeys.ANCHOR])
+                            throw new dbDecorators.InternalError("Original Model not found in constructor");
+                        return clazz[decoratorValidation.ModelKeys.ANCHOR];
+                    }, (model) => {
+                        const pk = dbDecorators.findPrimaryKey(new clazz()).id;
+                        return model[pk];
+                    }, ormMeta), typeorm.JoinColumn());
+                },
+            })
+                .apply();
+            // @oneToMany(clazz) => @OneToMany(() => clazz)
+            const oneToManyKey = core.Repository.key(core.PersistenceKeys.ONE_TO_MANY);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(oneToManyKey)
+                .define({
+                decorator: function oneToMany(clazz, cascade, populate) {
+                    const metadata = {
+                        class: (clazz.name ? clazz.name : clazz),
+                        cascade: cascade,
+                        populate: populate,
+                    };
+                    return reflection.apply(decoratorValidation.prop(core.PersistenceKeys.RELATIONS), decoratorValidation.list(clazz), decoratorValidation.propMetadata(oneToManyKey, metadata), function OneToManyWrapper(obj, prop) {
+                        const ormMeta = {
+                            cascade: cascade.update === core.Cascade.CASCADE ||
+                                cascade.delete === core.Cascade.CASCADE,
+                            onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                            onUpdate: cascade.update ? "CASCADE" : "DEFAULT",
+                            nullable: true,
+                            eager: populate,
+                        };
+                        return typeorm.OneToMany(() => {
+                            if (!clazz.name)
+                                clazz = clazz();
+                            if (!clazz[decoratorValidation.ModelKeys.ANCHOR])
+                                throw new dbDecorators.InternalError("Original Model not found in constructor");
+                            return clazz[decoratorValidation.ModelKeys.ANCHOR];
+                        }, (model) => {
+                            if (!clazz.name)
+                                clazz = clazz();
+                            const m = new clazz();
+                            const crossRelationKey = Object.keys(m).find((k) => {
+                                const decs = reflection.Reflection.getPropertyDecorators(core.Repository.key(core.PersistenceKeys.MANY_TO_ONE), m, k, true);
+                                if (!decs || !decs.decorators || !decs.decorators.length)
+                                    return false;
+                                const designType = Reflect.getMetadata(decoratorValidation.ModelKeys.TYPE, m, k);
+                                if (!designType)
+                                    throw new dbDecorators.InternalError(`No Type Definition found for ${k} in ${m.constructor.name}`);
+                                return designType.name === obj.constructor.name;
+                            });
+                            if (!crossRelationKey)
+                                throw new dbDecorators.InternalError(`Cross relation not found. Did you use @manyToOne on the ${clazz.name}?`);
+                            return model[crossRelationKey];
+                        }, ormMeta)(obj, prop);
+                    });
+                },
+            })
+                .apply();
+            // @manyToOne(clazz) => @ManyToOne(() => clazz)
+            const manyToOneKey = core.Repository.key(core.PersistenceKeys.MANY_TO_ONE);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(manyToOneKey)
+                .define({
+                decorator: function manyToOne(clazz, cascade, populate) {
+                    const metadata = {
+                        class: (clazz.name ? clazz.name : clazz),
+                        cascade: cascade,
+                        populate: populate,
+                    };
+                    ({
+                        cascade: cascade.update === core.Cascade.CASCADE ||
+                            cascade.delete === core.Cascade.CASCADE,
+                        onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                        onUpdate: cascade.update ? "CASCADE" : "DEFAULT"});
+                    return reflection.apply(decoratorValidation.prop(core.PersistenceKeys.RELATIONS), decoratorValidation.type([
+                        (typeof clazz === "function" && !clazz.name
+                            ? clazz
+                            : clazz.name),
+                        String.name,
+                        Number.name,
+                        BigInt.name,
+                    ]), decoratorValidation.propMetadata(manyToOneKey, metadata), function ManyToOneWrapper(obj, prop) {
+                        return typeorm.ManyToOne(() => {
+                            if (!clazz.name)
+                                clazz = clazz();
+                            if (!clazz[decoratorValidation.ModelKeys.ANCHOR])
+                                throw new dbDecorators.InternalError("Original Model not found in constructor");
+                            return clazz[decoratorValidation.ModelKeys.ANCHOR];
+                        }, (model) => {
+                            if (!clazz.name)
+                                clazz = clazz();
+                            const m = new clazz();
+                            const crossRelationKey = Object.keys(m).find((k) => {
+                                const decs = reflection.Reflection.getPropertyDecorators(core.Repository.key(core.PersistenceKeys.ONE_TO_MANY), m, k, true);
+                                if (!decs || !decs.decorators || !decs.decorators.length)
+                                    return false;
+                                const listDec = Reflect.getMetadata(decoratorValidation.Validation.key(decoratorValidation.ValidationKeys.LIST), m, k);
+                                if (!listDec)
+                                    throw new dbDecorators.InternalError(`No Type Definition found for ${k} in ${m.constructor.name}`);
+                                const name = listDec.clazz[0]().name;
+                                return name === obj.constructor.name;
+                            });
+                            if (!crossRelationKey)
+                                throw new dbDecorators.InternalError(`Cross relation not found. Did you use @manyToOne on the ${clazz.name}?`);
+                            return model[crossRelationKey];
+                        })(obj, prop);
+                    });
+                },
+            })
+                .apply();
+            // @manyToMany(clazz) => @ManyToMany(() => clazz)
+            const manyToManyKey = core.Repository.key(core.PersistenceKeys.MANY_TO_MANY);
+            decoratorValidation.Decoration.flavouredAs(TypeORMFlavour)
+                .for(manyToManyKey)
+                .define({
+                decorator: function manyToMany(clazz, cascade, populate) {
+                    const metadata = {
+                        class: clazz.name,
+                        cascade: cascade,
+                        populate: populate,
+                    };
+                    const ormMeta = {
+                        cascade: cascade.update === core.Cascade.CASCADE ||
+                            cascade.delete === core.Cascade.CASCADE,
+                        onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                        onUpdate: cascade.update ? "CASCADE" : "DEFAULT",
+                        nullable: true,
+                        eager: populate,
+                    };
+                    return reflection.apply(decoratorValidation.prop(core.PersistenceKeys.RELATIONS), decoratorValidation.list(clazz), decoratorValidation.propMetadata(manyToManyKey, metadata), typeorm.ManyToMany(() => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        if (!clazz[decoratorValidation.ModelKeys.ANCHOR])
+                            throw new dbDecorators.InternalError("Original Model not found in constructor");
+                        return clazz[decoratorValidation.ModelKeys.ANCHOR];
+                    }, (model) => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        const pk = dbDecorators.findPrimaryKey(new clazz()).id;
+                        return model[pk];
+                    }, ormMeta), typeorm.JoinTable());
+                },
+            })
+                .apply();
+        }
+    }
+    tslib.__decorate([
+        core.final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", []),
+        tslib.__metadata("design:returntype", TypeORMDispatch)
+    ], TypeORMAdapter.prototype, "Dispatch", null);
+    tslib.__decorate([
+        core.final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", []),
+        tslib.__metadata("design:returntype", Object)
+    ], TypeORMAdapter.prototype, "repository", null);
+    tslib.__decorate([
+        core.final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", []),
+        tslib.__metadata("design:returntype", TypeORMStatement)
+    ], TypeORMAdapter.prototype, "Statement", null);
+    tslib.__decorate([
+        core.final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", [Object]),
+        tslib.__metadata("design:returntype", Promise)
+    ], TypeORMAdapter.prototype, "Sequence", null);
+    tslib.__decorate([
+        core.final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", [Object]),
+        tslib.__metadata("design:returntype", Promise)
+    ], TypeORMAdapter.prototype, "index", null);
+
+    TypeORMAdapter.decoration();
+    /**
+     * @description TypeORM integration for Decaf.ts.
+     * @summary Provides the TypeORM-backed implementation of the Decaf.ts data access abstractions, including the adapter, repository, statement builder, pagination utilities, index helpers, and type definitions. Key exports include {@link TypeORMAdapter}, {@link TypeORMRepository}, {@link TypeORMStatement}, {@link TypeORMPaginator}, and index generation utilities.
+     * @module for-typeorm
+     */
+    /**
+     * @description Stores the current package version.
+     * @summary The version string of the for-typeorm package.
+     * @const VERSION
+     * @memberOf module:for-typeorm
+     */
+    const VERSION = "0.0.6";
+
+    exports.IndexError = IndexError;
+    exports.TypeORMAdapter = TypeORMAdapter;
+    exports.TypeORMConst = TypeORMConst;
+    exports.TypeORMDispatch = TypeORMDispatch;
+    exports.TypeORMFlavour = TypeORMFlavour;
+    exports.TypeORMGroupOperator = TypeORMGroupOperator;
+    exports.TypeORMKeys = TypeORMKeys;
+    exports.TypeORMOperator = TypeORMOperator;
+    exports.TypeORMPaginator = TypeORMPaginator;
+    exports.TypeORMQueryLimit = TypeORMQueryLimit;
+    exports.TypeORMSequence = TypeORMSequence;
+    exports.TypeORMStatement = TypeORMStatement;
+    exports.VERSION = VERSION;
+    exports.convertJsRegexToPostgres = convertJsRegexToPostgres;
+    exports.createdByOnPostgresCreateUpdate = createdByOnPostgresCreateUpdate;
+    exports.generateIndexes = generateIndexes;
+    exports.reservedAttributes = reservedAttributes;
+    exports.translateOperators = translateOperators;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-typeorm.cjs","sources":["../src/constants.ts","../src/errors.ts","../src/types.ts","../src/query/constants.ts","../src/query/Paginator.ts","../src/query/translate.ts","../src/query/Statement.ts","../src/sequences/Sequence.ts","../src/indexes/generator.ts","../src/TypeORMRepository.ts","../src/TypeORMEventSubscriber.ts","../src/TypeORMDispatch.ts","../src/utils.ts","../src/overrides/utils.ts","../src/overrides/Column.ts","../src/overrides/UpdateDateColumn.ts","../src/overrides/CreateDateColumn.ts","../src/overrides/PrimaryGeneratedColumn.ts","../src/overrides/PrimaryColumn.ts","../src/overrides/Entity.ts","../src/TypeORMAdapter.ts","../src/index.ts"],"sourcesContent":["/**\n * @description Regular expression to identify reserved attributes for SQL contexts.\n * @summary Matches attribute names that conflict with SQL reserved keywords to prevent invalid schema or query generation.\n * @const reservedAttributes\n * @memberOf module:for-typeorm\n */\nexport const reservedAttributes =\n  /^(select|from|where|and|or|insert|update|delete|drop|create|table|index|primary|key|foreign|references|constraint|unique|check|default|null|not|as|order|by|group|having|limit|offset|join|inner|outer|left|right|full|on|using|values|returning|set|into|case|when|then|else|end|cast|coalesce|exists|any|all|some|in|between|like|ilike|similar|to|is|true|false|asc|desc|distinct|union|intersect|except|natural|lateral|window|over|partition|range|rows|unbounded|preceding|following|current|row|with|recursive|materialized|view|function|trigger|procedure|language|returns|return|declare|begin|commit|rollback|savepoint|transaction|temporary|temp|if|loop|while|for|continue|exit|raise|exception|notice|info|log|debug|assert|execute|perform|get|diagnostics|call|do|alias|comment|vacuum|analyze|explain|copy|grant|revoke|privileges|public|usage|schema|sequence|owned|owner|tablespace|storage|inherits|type|operator|collate|collation|cascade|restrict|add|alter|column|rename|to|enable|disable|force|no|instead|of|before|after|each|statement|row|execute|also|only|exclude|nulls|others|ordinality|ties|nothing|cache|cycle|increment|minvalue|maxvalue|start|restart|by|called|returns|language|immutable|stable|volatile|strict|security|definer|invoker|cost|rows|support|handler|inline|validator|options|storage|inheritance|oids|without|data|dictionary|encoding|lc_collate|lc_ctype|connection|limit|password|valid|until|superuser|nosuperuser|createdb|nocreatedb|createrole|nocreaterole|inherit|noinherit|login|nologin|replication|noreplication|bypassrls|nobypassrls|encrypted|unencrypted|new|old|session_user|current_user|current_role|current_schema|current_catalog|current_date|current_time|current_timestamp|localtime|localtimestamp|current_database|inet|cidr|macaddr|macaddr8|bit|varbit|tsvector|tsquery|uuid|xml|json|jsonb|int|integer|smallint|bigint|decimal|numeric|real|double|precision|float|boolean|bool|char|character|varchar|text|bytea|date|time|timestamp|interval|point|line|lseg|box|path|polygon|circle|money|void)$/i;\n\nexport const TypeORMFlavour = \"type-orm\";\n\n/**\n * @description Shape of the TypeORMKeys constant.\n * @summary Describes the keys and their meanings used by the TypeORM adapter.\n * @typedef TypeORMKeysDef\n * @property {string} SEPARATOR Separator used to join table and column identifiers.\n * @property {string} ID Default primary key field name.\n * @property {string} VERSION Version field used for optimistic locking.\n * @property {string} DELETED Soft-delete timestamp field.\n * @property {string} TABLE Database table identifier key.\n * @property {string} SCHEMA Database schema identifier key.\n * @property {string} SEQUENCE Database sequence name key.\n * @property {string} INDEX Index identifier key.\n * @memberOf module:for-typeorm\n */\n/**\n * @description Key constants used by the TypeORM adapter.\n * @summary Collection of string constants that identify common database properties and adapter-specific keys.\n * @const TypeORMKeys\n * @type {TypeORMKeysDef}\n * @memberOf module:for-typeorm\n */\nexport const TypeORMKeys = {\n  SEPARATOR: \".\",\n  ID: \"id\",\n  VERSION: \"version\",\n  DELETED: \"deleted_at\",\n  TABLE: \"table_name\",\n  SCHEMA: \"schema_name\",\n  SEQUENCE: \"sequence_name\",\n  INDEX: \"index\",\n};\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown when there is an issue with TypeORM indexes.\n * @summary Represents an error related to index generation or handling within the TypeORM adapter.\n * @param {string|Error} msg The error message or Error object.\n * @class\n * @category Errors\n * @example\n * // Example of using IndexError\n * try {\n *   // Some code that might throw an index error\n *   throw new IndexError(\"Index not found\");\n * } catch (error) {\n *   if (error instanceof IndexError) {\n *     console.error(\"Index error occurred:\", error.message);\n *   }\n * }\n */\nexport class IndexError extends BaseError {\n  constructor(msg: string | Error) {\n    super(IndexError.name, msg, 404);\n  }\n}\n","import { RepositoryFlags } from \"@decaf-ts/db-decorators\";\nimport { SelectQueryBuilder } from \"typeorm\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description SQL operators available for building TypeORM queries.\n * @summary Enumeration of common SQL operators intended for use within TypeORM query construction and translation layers.\n * @enum {string}\n * @memberOf module:for-typeorm\n */\nexport enum SQLOperator {\n  EQUAL = \"=\",\n  NOT_EQUAL = \"<>\",\n  LESS_THAN = \"<\",\n  LESS_THAN_OR_EQUAL = \"<=\",\n  GREATER_THAN = \">\",\n  GREATER_THAN_OR_EQUAL = \">=\",\n  IN = \"IN\",\n  NOT_IN = \"NOT IN\",\n  LIKE = \"LIKE\",\n  ILIKE = \"ILIKE\",\n  BETWEEN = \"BETWEEN\",\n  IS_NULL = \"IS NULL\",\n  IS_NOT_NULL = \"IS NOT NULL\",\n  EXISTS = \"EXISTS\",\n  NOT_EXISTS = \"NOT EXISTS\",\n  ANY = \"ANY\",\n  ALL = \"ALL\",\n  SOME = \"SOME\",\n}\n\n/**\n * @description Query container used by the TypeORM adapter.\n * @summary Represents either a raw SQL string or a TypeORM SelectQueryBuilder along with optional bound values to be executed by the adapter.\n * @template M The Model type for which the SelectQueryBuilder is parameterized.\n * @template T The underlying query type, either a string or a SelectQueryBuilder<M>.\n * @interface TypeORMQuery\n * @memberOf module:for-typeorm\n */\nexport interface TypeORMQuery<\n  M extends Model = Model,\n  T extends string | SelectQueryBuilder<M> = string,\n> {\n  query: T;\n  values?: any[];\n}\n\n/**\n * @description Configuration flags for TypeORM operations.\n * @summary Extended repository flags including connection/user context that can be leveraged by the TypeORM adapter.\n * @interface TypeORMFlags\n * @memberOf module:for-typeorm\n */\nexport interface TypeORMFlags extends RepositoryFlags {\n  /**\n   * @description User authentication information for Postgres database connections\n   */\n  user: string;\n}\n\n/**\n * @description Specification for a table creation/change statement used by the TypeORM adapter.\n * @summary Extends a TypeORMQuery with table metadata such as primary key flag, constraints, and foreign keys.\n * @typedef TypeORMTableSpec\n * @property {boolean} primaryKey Indicates if the target column is part of the primary key.\n * @property {string[]} constraints A list of raw SQL constraints to apply to the table/column.\n * @property {string[]} foreignKeys A list of foreign key constraint definitions.\n * @memberOf module:for-typeorm\n */\nexport type TypeORMTableSpec = TypeORMQuery & {\n  primaryKey: boolean;\n  constraints: string[];\n  foreignKeys: string[];\n};\n","import { SQLOperator } from \"../types\";\n\n/**\n * @description Default query limit for TypeORM-backed queries.\n * @summary Maximum number of records to return in a single page when paginating results.\n * @const TypeORMQueryLimit\n * @memberOf module:for-typeorm\n */\nexport const TypeORMQueryLimit = 250;\n\n/**\n * @description Mapping of operator names to SQL operators.\n * @summary Constants for comparison operators used when translating high-level filters into SQL via TypeORM.\n * @typedef {Object} PostgreSQLOperatorType\n * @property {string} EQUAL Equality operator (=)\n * @property {string} DIFFERENT Inequality operator (<>)\n * @property {string} BIGGER Greater than operator (>)\n * @property {string} BIGGER_EQ Greater than or equal operator (>=)\n * @property {string} SMALLER Less than operator (<)\n * @property {string} SMALLER_EQ Less than or equal operator (<=)\n * @property {string} NOT Negation operator (NOT)\n * @property {string} IN In array operator (IN)\n * @property {string} REGEXP Regular expression operator (~)\n * @property {string} IREGEXP Case-insensitive regular expression operator (~*)\n * @property {string} LIKE Pattern matching operator (LIKE)\n * @property {string} ILIKE Case-insensitive pattern matching operator (ILIKE)\n * @property {string} BETWEEN Range operator (BETWEEN)\n * @property {string} IS_NULL NULL check operator (IS NULL)\n * @property {string} IS_NOT_NULL NOT NULL check operator (IS NOT NULL)\n * @const TypeORMOperator\n * @type {PostgreSQLOperatorType}\n * @memberOf module:for-typeorm\n */\nexport const TypeORMOperator: Record<string, SQLOperator | string> = {\n  EQUAL: SQLOperator.EQUAL,\n  DIFFERENT: SQLOperator.NOT_EQUAL,\n  BIGGER: SQLOperator.GREATER_THAN,\n  BIGGER_EQ: SQLOperator.GREATER_THAN_OR_EQUAL,\n  SMALLER: SQLOperator.LESS_THAN,\n  SMALLER_EQ: SQLOperator.LESS_THAN_OR_EQUAL,\n  BETWEEN: SQLOperator.BETWEEN,\n  NOT: \"NOT\",\n  IN: SQLOperator.IN,\n  IS_NULL: SQLOperator.IS_NULL,\n  IS_NOT_NULL: SQLOperator.IS_NOT_NULL,\n  REGEXP: \"~\",\n  IREGEXP: \"~*\",\n  LIKE: SQLOperator.LIKE,\n  ILIKE: SQLOperator.ILIKE,\n};\n\n/**\n * @description Mapping of logical operator names to SQL operators.\n * @summary Constants for logical operators used when building WHERE clause groups in TypeORM queries.\n * @typedef {Object} PostgreSQLGroupOperatorType\n * @property {string} AND Logical AND operator (AND)\n * @property {string} OR Logical OR operator (OR)\n * @const TypeORMGroupOperator\n * @type {PostgreSQLGroupOperatorType}\n * @memberOf module:for-typeorm\n */\nexport const TypeORMGroupOperator: Record<string, string> = {\n  AND: \"AND\",\n  OR: \"OR\",\n};\n\n/**\n * @description Special constant values used in queries.\n * @summary String constants representing special values used while composing SQL with TypeORM.\n * @typedef {Object} PostgreSQLConstType\n * @property {string} NULL String representation of null value.\n * @const TypeORMConst\n * @memberOf module:for-typeorm\n */\nexport const TypeORMConst: Record<string, string> = {\n  NULL: \"NULL\",\n};\n","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","import { GroupOperator, Operator } from \"@decaf-ts/core\";\nimport { TypeORMGroupOperator, TypeORMOperator } from \"./constants\";\nimport { QueryError } from \"@decaf-ts/core\";\nimport { SQLOperator } from \"../types\";\n\n/**\n * @description Translates core operators to TypeORM SQL operators.\n * @summary Converts Decaf.ts core operators to their equivalent SQL operators used by the TypeORM adapter.\n * @param {GroupOperator | Operator} operator The core operator to translate.\n * @return {SQLOperator | string} The equivalent SQL operator.\n * @throws {QueryError} If no translation exists for the given operator.\n * @function translateOperators\n * @memberOf module:for-typeorm\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant translateOperators\n *   participant PostgreSQLOperator\n *   participant PostgreSQLGroupOperator\n *\n *   Caller->>translateOperators: operator\n *\n *   translateOperators->>PostgreSQLOperator: Check for match\n *   alt Found in PostgreSQLOperator\n *     PostgreSQLOperator-->>translateOperators: Return matching operator\n *     translateOperators-->>Caller: Return SQLOperator\n *   else Not found\n *     translateOperators->>PostgreSQLGroupOperator: Check for match\n *     alt Found in PostgreSQLGroupOperator\n *       PostgreSQLGroupOperator-->>translateOperators: Return matching operator\n *       translateOperators-->>Caller: Return string\n *     else Not found\n *       translateOperators-->>Caller: Throw QueryError\n *     end\n *   end\n */\nexport function translateOperators(\n  operator: GroupOperator | Operator\n): SQLOperator | string {\n  for (const operators of [TypeORMOperator, TypeORMGroupOperator]) {\n    const el = Object.keys(operators).find((k) => k === operator);\n    if (el) return operators[el];\n  }\n  throw new QueryError(\n    `Could not find adapter translation for operator ${operator}`\n  );\n}\n","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","import { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { TypeORMAdapter } from \"../TypeORMAdapter\";\n\n/**\n * @description Abstract implementation of a database sequence for TypeORM.\n * @summary Provides the basic functionality for {@link Sequence}s, delegating to the {@link TypeORMAdapter} to fetch and increment values while handling type parsing and error translation.\n * @param {SequenceOptions} options The sequence configuration options (name, type, startWith, incrementBy, etc.).\n * @param {TypeORMAdapter} adapter The TypeORM adapter used to execute sequence operations.\n * @class TypeORMSequence\n * @implements Sequence\n * @example\n * // Create and use a TypeORM-backed sequence\n * const seq = new TypeORMSequence({ name: \"user_id_seq\", type: \"Number\", startWith: 1, incrementBy: 1 }, adapter);\n * const nextId = await seq.next();\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Seq as TypeORMSequence\n *   participant Adapter as TypeORMAdapter\n *   participant DB as Database\n *   App->>Seq: next()\n *   Seq->>Seq: current()\n *   Seq->>Adapter: raw(SELECT current_value ...)\n *   Adapter->>DB: Query current value\n *   DB-->>Adapter: current_value\n *   Adapter-->>Seq: value\n *   Seq->>Seq: increment(current)\n *   Seq->>Adapter: raw(nextval(name))\n *   Adapter->>DB: nextval()\n *   DB-->>Adapter: next value\n *   Adapter-->>Seq: value\n *   Seq-->>App: parsed next value\n */\nexport class TypeORMSequence extends Sequence {\n  constructor(\n    options: SequenceOptions,\n    protected adapter: TypeORMAdapter\n  ) {\n    super(options);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name } = this.options;\n    try {\n      const seq: any = await this.adapter.raw({\n        query: `SELECT current_value FROM information_schema.sequences WHERE sequence_name = $1`,\n        values: [name],\n      });\n      return this.parse(seq.current_value as string | number);\n    } catch (e: unknown) {\n      throw this.adapter.parseError(e as Error);\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return Sequence.parseValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name, startWith } = this.options;\n    if (type !== \"Number\" && type !== \"BigInt\")\n      throw new InternalError(\n        `Cannot increment sequence of type ${type} with ${count}`\n      );\n    let next: string | number | bigint;\n    try {\n      next = await this.adapter.raw({\n        query: `SELECT nextval($1);`,\n        values: [name],\n      });\n    } catch (e: unknown) {\n      if (!(e instanceof NotFoundError)) throw e;\n      next = await this.adapter.raw({\n        query: `CREATE SEQUENCE IF NOT EXISTS $1 START WITH $2 INCREMENT BY $3 NO CYCLE;`,\n        values: [name, startWith, incrementBy],\n      });\n    }\n\n    return next as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n","import {\n  IndexMetadata,\n  OrderDirection,\n  PersistenceKeys,\n  Repository,\n} from \"@decaf-ts/core\";\nimport { TypeORMKeys } from \"../constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { TypeORMQuery } from \"../types\";\n\n/**\n * @description Generates a name for a CouchDB index\n * @summary Creates a standardized name for a CouchDB index by combining name parts, compositions, and direction\n * @param {string[]} name - Array of name parts for the index\n * @param {OrderDirection} [direction] - Optional sort direction for the index\n * @param {string[]} [compositions] - Optional additional attributes to include in the index name\n * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name\n * @return {string} The generated index name\n * @memberOf module:for-couchdb\n */\nfunction generateIndexName(\n  name: string[],\n  direction?: OrderDirection,\n  compositions?: string[],\n  separator = DefaultSeparator\n) {\n  return [\n    ...name.map((n) => (n === TypeORMKeys.TABLE ? \"table\" : n)),\n    ...(compositions || []),\n    ...(direction ? [direction] : []),\n    TypeORMKeys.INDEX,\n  ].join(separator);\n}\n\n/**\n * @description Generates CouchDB index configurations for models\n * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models\n * @template M - The model type that extends Model\n * @param models - Array of model constructors to generate indexes for\n * @return {TypeORMQuery} Array of CouchDB index configurations\n * @function generateIndexes\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant generateIndexes\n *   participant generateIndexName\n *   participant Repository\n *\n *   Caller->>generateIndexes: models\n *\n *   Note over generateIndexes: Create base table index\n *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]\n *   generateIndexName-->>generateIndexes: tableName\n *   generateIndexes->>generateIndexes: Create table index config\n *\n *   loop For each model\n *     generateIndexes->>Repository: Get indexes metadata\n *     Repository-->>generateIndexes: index metadata\n *\n *     loop For each index in metadata\n *       Note over generateIndexes: Extract index properties\n *       generateIndexes->>Repository: Get table name\n *       Repository-->>generateIndexes: tableName\n *\n *       Note over generateIndexes: Define nested generate function\n *\n *       generateIndexes->>generateIndexes: Call generate() for default order\n *       Note over generateIndexes: Create index name and config\n *\n *       alt Has directions\n *         loop For each direction\n *           generateIndexes->>generateIndexes: Call generate(direction)\n *           Note over generateIndexes: Create ordered index config\n *         end\n *       end\n *     end\n *   end\n *\n *   generateIndexes-->>Caller: Array of index configurations\n */\nexport function generateIndexes<M extends Model>(\n  models: Constructor<M>[]\n): TypeORMQuery[] {\n  const tableName = generateIndexName([TypeORMKeys.TABLE]);\n  const indexes: Record<string, TypeORMQuery> = {};\n  indexes[tableName] = {\n    query: ``,\n    values: [],\n  };\n\n  models.forEach((m) => {\n    const ind: Record<string, IndexMetadata> = Repository.indexes(m);\n    Object.entries(ind).forEach(([key, value]) => {\n      const k = Object.keys(value)[0];\n\n      let { compositions } = (value as any)[k];\n      const tableName = Repository.table(m);\n      compositions = compositions || [];\n\n      function generate() {\n        const name = [key, ...(compositions as []), PersistenceKeys.INDEX].join(\n          DefaultSeparator\n        );\n\n        indexes[name] = {\n          query: `CREATE INDEX $1 ON $2 ($3);`,\n          values: [name, tableName, key],\n        };\n      }\n\n      generate();\n    });\n  });\n  return Object.values(indexes);\n}\n","import {\n  type Constructor,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Repository, uses } from \"@decaf-ts/core\";\nimport {\n  Context,\n  enforceDBDecorators,\n  OperationKeys,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { TypeORMFlags, TypeORMQuery } from \"./types\";\nimport { TypeORMAdapter } from \"./TypeORMAdapter\";\nimport { TypeORMFlavour } from \"./constants\";\n\n/**\n * @description Repository implementation backed by TypeORM.\n * @summary Provides CRUD operations for a given Model using the {@link TypeORMAdapter}, including bulk operations and query builder access while preserving Decaf.ts repository semantics.\n * @template M Type extending Model that this repository will manage.\n * @param {TypeORMAdapter} adapter The adapter used to execute persistence operations.\n * @param {Constructor<M>} model The Model constructor associated with this repository.\n * @param {...any[]} args Optional arguments forwarded to the base Repository.\n * @class TypeORMRepository\n * @example\n * // Creating a repository\n * const repo = new TypeORMRepository<User>(adapter, User);\n * const created = await repo.create(new User({ name: \"Alice\" }));\n * const read = await repo.read(created.id);\n *\n * // Bulk create\n * await repo.createAll([new User({ name: \"A\" }), new User({ name: \"B\" })]);\n *\n * // Using the query builder\n * const qb = repo.queryBuilder();\n * const rows = await qb.where(\"name = :name\", { name: \"Alice\" }).getMany();\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo as TypeORMRepository\n *   participant Adapter as TypeORMAdapter\n *   participant DB as TypeORM/DataSource\n *\n *   App->>Repo: create(model)\n *   Repo->>Adapter: prepare(model, pk)\n *   Adapter-->>Repo: { record, id, transient }\n *   Repo->>Adapter: create(table, id, model, ...args)\n *   Adapter->>DB: INSERT ...\n *   DB-->>Adapter: row\n *   Adapter-->>Repo: row\n *   Repo->>Adapter: revert(row, clazz, pk, id)\n *   Adapter-->>Repo: model\n *   Repo-->>App: model\n */\n@uses(TypeORMFlavour)\nexport class TypeORMRepository<M extends Model> extends Repository<\n  M,\n  TypeORMQuery<M, any>,\n  TypeORMAdapter,\n  TypeORMFlags,\n  Context<TypeORMFlags>\n> {\n  constructor(adapter: TypeORMAdapter, model: Constructor<M>, ...args: any[]) {\n    super(adapter, model, ...args);\n  }\n\n  /**\n   * @description Creates a TypeORM query builder for the repository entity.\n   * @summary Returns a SelectQueryBuilder bound to this repository's entity for advanced querying.\n   * @return {import(\"typeorm\").SelectQueryBuilder<any>} A TypeORM SelectQueryBuilder instance.\n   */\n  queryBuilder() {\n    const repo = this.adapter.dataSource.getRepository(\n      this.class[ModelKeys.ANCHOR as keyof typeof this.class]\n    );\n    return repo.createQueryBuilder();\n  }\n\n  /**\n   * @description Creates and persists a model instance.\n   * @summary Prepares the model, delegates insertion to the adapter, and rehydrates the persisted state back into a Model instance.\n   * @param {M} model The model to create.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M>} The created model instance.\n   */\n  override async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id,\n      model as any,\n      ...args\n    );\n    let c: Context<TypeORMFlags> | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as Context<TypeORMFlags>;\n    return this.adapter.revert<M>(\n      record,\n      this.class,\n      this.pk,\n      id,\n      c && c.get(\"rebuildWithTransient\") ? transient : undefined\n    );\n  }\n\n  /**\n   * @description Reads a model from the database by ID.\n   * @summary Retrieves a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to read.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The retrieved model instance.\n   */\n  override async read(\n    id: string | number | bigint,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<M> {\n    const m = await this.adapter.read(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id as string,\n      this.pk as string\n    );\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Updates and persists a model instance.\n   * @summary Prepares the model, delegates update to the adapter, and rehydrates the persisted state back into a Model instance.\n   * @param {M} model The model to update.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M>} The updated model instance.\n   */\n  override async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id,\n      model,\n      ...args\n    );\n    return this.adapter.revert<M>(record, this.class, this.pk, id, transient);\n  }\n\n  /**\n   * @description Deletes a model from the database by ID.\n   * @summary Removes a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The deleted model instance.\n   */\n  override async delete(\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<M> {\n    const m = await this.adapter.delete(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id as string,\n      this.pk as string,\n      ...args\n    );\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Validates and prepares models for bulk creation.\n   * @summary Applies decorator-based validations and returns transformed models with context args for createAll.\n   * @param {M[]} models The models to be created.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<[M[], ...any[]]>} The prepared models and forwarded args tuple.\n   */\n  protected override async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    if (!models.length) return [models, ...contextArgs.args];\n\n    models = await Promise.all(\n      models.map(async (m) => {\n        m = new this.class(m);\n        await enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) =>\n        m.hasErrors(\n          ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n        )\n      )\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Creates multiple models at once.\n   * @summary Prepares, persists, and rehydrates a batch of models.\n   * @param {M[]} models The models to create.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The created models.\n   */\n  override async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      ids as (string | number)[],\n      models,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  /**\n   * @description Reads multiple models by their primary keys.\n   * @summary Retrieves a list of models corresponding to the provided keys.\n   * @param {(string[]|number[])} keys The primary keys to read.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The retrieved models.\n   */\n  override async readAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const records = await this.adapter.readAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      keys,\n      this.pk as string,\n      ...args\n    );\n    return records.map((r: Record<string, any>, i: number) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  /**\n   * @description Updates multiple models at once.\n   * @summary Persists a batch of model updates and returns their rehydrated instances.\n   * @param {M[]} models The models to update.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The updated models.\n   */\n  override async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      records.map((r) => r.id),\n      models,\n      this.pk as string,\n      ...args\n    );\n    return updated.map((u: Record<string, any>, i: number) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  /**\n   * @description Deletes multiple models at once.\n   * @summary Removes a list of models by their primary keys and returns their last persisted states.\n   * @param {(string[]|number[])} keys The primary keys to delete.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The deleted models.\n   */\n  override async deleteAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const results = await this.adapter.deleteAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      keys,\n      this.pk as string,\n      ...args\n    );\n    return results.map((r: Record<string, any>, i: number) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n}\n","import {\n  EntitySubscriberInterface,\n  EventSubscriber,\n  InsertEvent,\n  RemoveEvent,\n  UpdateEvent,\n} from \"typeorm\";\nimport { EventIds, Repository } from \"@decaf-ts/core\";\nimport { InternalError, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description TypeORM event subscriber that forwards entity lifecycle events to the adapter.\n * @summary Listens for insert, update, and remove events emitted by TypeORM and notifies the Decaf.ts adapter so that observers can be updated accordingly.\n * @param {TypeORMAdapter} adapter The TypeORM adapter used to propagate events and look up metadata.\n * @class\n * @example\n * // Registering the subscriber when creating a DataSource\n * // dataSourceOptions.subscribers = [new TypeORMEventSubscriber(adapter)];\n *\n * @mermaid\n * sequenceDiagram\n *   participant TypeORM\n *   participant Subscriber as TypeORMEventSubscriber\n *   participant Adapter as TypeORMAdapter\n *   participant Observers\n *\n *   TypeORM->>Subscriber: afterInsert(entity)\n *   Subscriber->>Adapter: updateObservers(table, CREATE, [id])\n *   Adapter->>Observers: notify(table, CREATE, [id])\n *\n *   TypeORM->>Subscriber: afterUpdate(event)\n *   Subscriber->>Adapter: updateObservers(table, UPDATE, [id])\n *   Adapter->>Observers: notify(table, UPDATE, [id])\n *\n *   TypeORM->>Subscriber: afterRemove(event)\n *   Subscriber->>Adapter: updateObservers(table, DELETE, [id])\n *   Adapter->>Observers: notify(table, DELETE, [id])\n */\n@EventSubscriber()\nexport class TypeORMEventSubscriber implements EntitySubscriberInterface {\n  constructor(\n    protected readonly handler: (\n      tableName: string,\n      operation: OperationKeys,\n      ids: EventIds\n    ) => void\n  ) {}\n\n  /**\n   * @description Handles post-insert events.\n   * @summary Notifies observers about a create operation for the inserted entity.\n   * @param {InsertEvent<any>} event The TypeORM insert event.\n   * @return {Promise<any>|void} A promise when async or void otherwise.\n   */\n  afterInsert(event: InsertEvent<any>): Promise<any> | void {\n    const constructor = Model.get(event.entity.constructor.name);\n    if (!constructor)\n      throw new InternalError(\n        `No registered model found for ${event.entity.constructor.name}`\n      );\n    const tableName = Repository.table(constructor);\n\n    this.handler(tableName, OperationKeys.CREATE, [event.entityId as any]);\n  }\n\n  /**\n   * @description Handles post-remove events.\n   * @summary Notifies observers about a delete operation for the removed entity.\n   * @param {RemoveEvent<any>} event The TypeORM remove event.\n   * @return {Promise<any>|void} A promise when async or void otherwise.\n   */\n  afterRemove(event: RemoveEvent<any>): Promise<any> | void {\n    const constructor = Model.get(event.entity.constructor.name);\n    if (!constructor)\n      throw new InternalError(\n        `No registered model found for ${event.entity.constructor.name}`\n      );\n    const tableName = Repository.table(constructor);\n\n    this.handler(tableName, OperationKeys.DELETE, [event.entityId as any]);\n  }\n\n  /**\n   * @description Handles post-update events.\n   * @summary Notifies observers about an update operation for the modified entity.\n   * @param {UpdateEvent<any>} event The TypeORM update event.\n   * @return {Promise<any>|void} A promise when async or void otherwise.\n   */\n  afterUpdate(event: UpdateEvent<any>): Promise<any> | void {\n    const constructor = Model.get(event.databaseEntity.constructor.name);\n    if (!constructor)\n      throw new InternalError(\n        `No registered model found for ${event.databaseEntity.constructor.name}`\n      );\n    const tableName = Repository.table(constructor);\n\n    return this.handler(tableName, OperationKeys.UPDATE, [\n      (event.entity as any)[\"id\"] as any,\n    ]);\n  }\n}\n","import { Dispatch, EventIds } from \"@decaf-ts/core\";\nimport { InternalError, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { DataSourceOptions } from \"typeorm/data-source/DataSourceOptions\";\nimport { TypeORMAdapter } from \"./TypeORMAdapter\";\nimport { TypeORMEventSubscriber } from \"./TypeORMEventSubscriber\";\n\n/**\n * @description Dispatcher for TypeORM-driven change events.\n * @summary Subscribes a TypeORM DataSource with a custom EntitySubscriber to notify observers when records are created, updated, or deleted.\n * @param {number} [timeout=5000] Timeout in milliseconds for initialization retries.\n * @class TypeORMDispatch\n * @example\n * // Create a dispatcher for a TypeORM DataSource\n * const dispatch = new TypeORMDispatch();\n * await dispatch.observe(adapter, adapter.dataSource.options);\n *\n * // The dispatcher registers a TypeORMEventSubscriber and notifies observers when entities change.\n * @mermaid\n * classDiagram\n *   class Dispatch {\n *     +initialize()\n *     +updateObservers()\n *   }\n *   class TypeORMDispatch {\n *     -observerLastUpdate?: string\n *     -attemptCounter: number\n *     -timeout: number\n *     +constructor(timeout)\n *     #notificationHandler()\n *     #initialize()\n *   }\n *   Dispatch <|-- TypeORMDispatch\n */\nexport class TypeORMDispatch extends Dispatch<DataSourceOptions> {\n  private observerLastUpdate?: string;\n  private attemptCounter: number = 0;\n\n  constructor(private timeout = 5000) {\n    super();\n  }\n\n  /**\n   * @description Processes TypeORM notification events.\n   * @summary Handles change notifications (translated from TypeORM events) and notifies observers about record changes.\n   * @param {string} table The notification payload.\n   * @param {OperationKeys} operation The notification payload.\n   * @param {EventIds} ids The notification payload.\n   * @return {Promise<void>} A promise that resolves when all notifications have been processed.\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as PostgreSQLDispatch\n   *   participant L as Logger\n   *   participant O as Observers\n   *   Note over D: Receive notification from PostgreSQL\n   *   D->>D: Parse notification payload\n   *   D->>D: Extract table, operation, and ids\n   *   D->>O: updateObservers(table, operation, ids)\n   *   D->>D: Update observerLastUpdate\n   *   D->>L: Log successful dispatch\n   */\n  protected async notificationHandler(\n    table: string,\n    operation: OperationKeys,\n    ids: EventIds\n  ): Promise<void> {\n    const log = this.log.for(this.notificationHandler);\n    try {\n      // Notify observers\n      await this.updateObservers(table, operation, ids);\n      this.observerLastUpdate = new Date().toISOString();\n      log.verbose(`Observer refresh dispatched by ${operation} for ${table}`);\n      log.debug(`pks: ${ids}`);\n    } catch (e: unknown) {\n      log.error(`Failed to process notification: ${e}`);\n    }\n  }\n\n  /**\n   * @description Initializes the dispatcher and subscribes to TypeORM notifications.\n   * @summary Registers the TypeORMEventSubscriber on the DataSource and logs the subscription lifecycle.\n   * @return {Promise<void>} A promise that resolves when the subscription is established.\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as TypeORMDispatch\n   *   participant S as subscribeToTypeORM\n   *   participant DS as TypeORM DataSource\n   *   participant L as Logger\n   *   D->>S: Call subscribeToTypeORM\n   *   S->>S: Check adapter and native\n   *   alt No adapter or native\n   *     S-->>S: throw InternalError\n   *   end\n   *   S->>DS: initialize()\n   *   S->>DS: subscribers.push(TypeORMEventSubscriber)\n   *   alt Success\n   *     DS-->>S: Subscription established\n   *     S-->>D: Promise resolves\n   *     D->>L: Log successful subscription\n   *   else Error\n   *     DS-->>S: Error\n   *     S-->>D: Promise rejects\n   *   end\n   */\n  protected override async initialize(): Promise<void> {\n    async function subscribeToTypeORM(this: TypeORMDispatch): Promise<void> {\n      if (!this.adapter || !this.native) {\n        throw new InternalError(`No adapter/native observed for dispatch`);\n      }\n\n      const adapter = this.adapter as TypeORMAdapter;\n\n      try {\n        if (!adapter.dataSource.isInitialized)\n          await adapter.dataSource.initialize();\n\n        adapter.dataSource.subscribers.push(\n          new TypeORMEventSubscriber(this.notificationHandler.bind(this))\n        );\n      } catch (e: unknown) {\n        throw new InternalError(e as Error);\n      }\n    }\n\n    subscribeToTypeORM\n      .call(this)\n      .then(() => {\n        this.log.info(`Subscribed to TypeORM notifications`);\n      })\n      .catch((e: unknown) => {\n        throw new InternalError(\n          `Failed to subscribe to TypeORM notifications: ${e}`\n        );\n      });\n  }\n\n  /**\n   * Cleanup method to release resources when the dispatcher is no longer needed\n   */\n  public cleanup(): void {\n    // if (this.adapter) {\n    //\n    //   const adapter = this.adapter as TypeORMAdapter;\n    //   await adapter.dataSource.destroy();\n    // }\n  }\n}\n","/**\n * @description Converts a JavaScript RegExp pattern to a PostgreSQL POSIX pattern string.\n * @summary Accepts either a RegExp object or a string representation (/pattern/flags) and returns the raw pattern compatible with PostgreSQL's ~ and ~* operators.\n * @param {RegExp|string} jsRegex JavaScript RegExp object or pattern string.\n * @return {string} PostgreSQL-compatible regex pattern string.\n * @function convertJsRegexToPostgres\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Utils as convertJsRegexToPostgres\n *   App->>Utils: convertJsRegexToPostgres(RegExp(\"foo.*\",\"i\"))\n *   Utils->>Utils: Parse string or use RegExp.source\n *   Utils-->>App: \"foo.*\"\n * @memberOf module:for-typeorm\n */\nexport function convertJsRegexToPostgres(jsRegex: RegExp | string): string {\n  const rxp = new RegExp(/^\\/(.+)\\/(\\w+)$/g);\n  if (typeof jsRegex === \"string\") {\n    const match = rxp.exec(jsRegex);\n    if (match) {\n      const [, p] = match;\n      jsRegex = p;\n    }\n  }\n  const regex = typeof jsRegex === \"string\" ? new RegExp(jsRegex) : jsRegex;\n\n  const pattern = regex.source;\n\n  return pattern;\n}\n","import { ColumnMetadataArgs } from \"typeorm/metadata-args/ColumnMetadataArgs\";\n\nexport function aggregateOrNewColumn(\n  target: any,\n  property: string,\n  columns: ColumnMetadataArgs[],\n  options: any = {},\n  mode: string = \"regular\"\n) {\n  const cols = columns.filter(\n    (c: ColumnMetadataArgs) =>\n      c.target === target && c.propertyName === property\n  );\n\n  if (cols.length > 1)\n    throw new Error(\n      `Multiple columns for ${property} found for given target: ${columns.map((c) => c.propertyName).join(\", \")}`\n    );\n\n  if (cols.length === 0) {\n    columns.push({\n      target: target,\n      propertyName: property,\n      mode: mode,\n      options: options,\n    } as ColumnMetadataArgs);\n    return;\n  }\n\n  const column = cols[0];\n  Object.defineProperty(column, \"options\", {\n    value: { ...column.options, ...options },\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n\n  if (mode !== \"regular\")\n    Object.defineProperty(column, \"mode\", {\n      value: mode,\n      writable: true,\n      enumerable: true,\n      configurable: true,\n    });\n}\n","import { GeneratedMetadataArgs } from \"typeorm/metadata-args/GeneratedMetadataArgs\";\nimport {\n  ColumnOptions,\n  ColumnType,\n  ColumnTypeUndefinedError,\n  getMetadataArgsStorage,\n} from \"typeorm\";\nimport {\n  SimpleColumnType,\n  SpatialColumnType,\n  WithLengthColumnType,\n  WithPrecisionColumnType,\n  WithWidthColumnType,\n} from \"typeorm/driver/types/ColumnTypes\";\nimport { ColumnCommonOptions } from \"typeorm/decorator/options/ColumnCommonOptions\";\nimport { SpatialColumnOptions } from \"typeorm/decorator/options/SpatialColumnOptions\";\nimport { ColumnWithLengthOptions } from \"typeorm/decorator/options/ColumnWithLengthOptions\";\nimport { ColumnWithWidthOptions } from \"typeorm/decorator/options/ColumnWithWidthOptions\";\nimport { ColumnNumericOptions } from \"typeorm/decorator/options/ColumnNumericOptions\";\nimport { ColumnEnumOptions } from \"typeorm/decorator/options/ColumnEnumOptions\";\nimport { ColumnHstoreOptions } from \"typeorm/decorator/options/ColumnHstoreOptions\";\nimport { ColumnEmbeddedOptions } from \"typeorm/decorator/options/ColumnEmbeddedOptions\";\nimport { EmbeddedMetadataArgs } from \"typeorm/metadata-args/EmbeddedMetadataArgs\";\nimport { ColumnMetadataArgs } from \"typeorm/metadata-args/ColumnMetadataArgs\";\nimport { aggregateOrNewColumn } from \"./utils\";\n\n/**\n * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this\n * decorator will be persisted to the database when entity be saved.\n */\nexport function Column(): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(options: ColumnOptions): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: SimpleColumnType,\n  options?: ColumnCommonOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: SpatialColumnType,\n  options?: ColumnCommonOptions & SpatialColumnOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: WithLengthColumnType,\n  options?: ColumnCommonOptions & ColumnWithLengthOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: WithWidthColumnType,\n  options?: ColumnCommonOptions & ColumnWithWidthOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: WithPrecisionColumnType,\n  options?: ColumnCommonOptions & ColumnNumericOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: \"enum\",\n  options?: ColumnCommonOptions & ColumnEnumOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: \"simple-enum\",\n  options?: ColumnCommonOptions & ColumnEnumOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: \"set\",\n  options?: ColumnCommonOptions & ColumnEnumOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\n// @ts-expect-error some typeorm thing\nexport function Column(\n  type: \"hstore\",\n  options?: ColumnCommonOptions & ColumnHstoreOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n *\n * Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the\n * single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the\n * embedded will be mapped to it from the single table.\n */\nexport function Column(\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  type: (type?: any) => Function,\n  options?: ColumnEmbeddedOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  typeOrOptions?: // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  | ((type?: any) => Function)\n    | ColumnType\n    | (ColumnOptions & ColumnEmbeddedOptions),\n  options?: ColumnOptions & ColumnEmbeddedOptions\n): PropertyDecorator {\n  return function (object: object, propertyName: any) {\n    // normalize parameters\n    let type: ColumnType | undefined;\n    if (\n      typeof typeOrOptions === \"string\" ||\n      typeof typeOrOptions === \"function\"\n    ) {\n      type = <ColumnType>typeOrOptions;\n    } else if (typeOrOptions) {\n      options = <ColumnOptions>typeOrOptions;\n      type = typeOrOptions.type;\n    }\n    if (!options) options = {} as ColumnOptions;\n\n    // if type is not given explicitly then try to guess it\n    const reflectMetadataType =\n      Reflect && (Reflect as any).getMetadata\n        ? (Reflect as any).getMetadata(\"design:type\", object, propertyName)\n        : undefined;\n    if (!type && reflectMetadataType)\n      // if type is not given explicitly then try to guess it\n      type = reflectMetadataType;\n\n    // check if there is no type in column options then set type from first function argument, or guessed one\n    if (!options.type && type) options.type = type;\n\n    // specify HSTORE type if column is HSTORE\n    if (options.type === \"hstore\" && !options.hstoreType)\n      options.hstoreType = reflectMetadataType === Object ? \"object\" : \"string\";\n\n    if (typeof typeOrOptions === \"function\") {\n      // register an embedded\n      getMetadataArgsStorage().embeddeds.push({\n        target: object.constructor,\n        propertyName: propertyName,\n        isArray: reflectMetadataType === Array || options.array === true,\n        prefix: options.prefix !== undefined ? options.prefix : undefined,\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n        type: typeOrOptions as (type?: any) => Function,\n      } as EmbeddedMetadataArgs);\n    } else {\n      // register a regular column\n\n      // if we still don't have a type then we need to give error to user that type is required\n      if (!options.type)\n        throw new ColumnTypeUndefinedError(object, propertyName);\n\n      // create unique\n      if (options.unique === true)\n        getMetadataArgsStorage().uniques.push({\n          target: object.constructor,\n          columns: [propertyName],\n        });\n\n      const columns = getMetadataArgsStorage().columns;\n      aggregateOrNewColumn(object.constructor, propertyName, columns, options);\n\n      if (options.generated) {\n        getMetadataArgsStorage().generations.push({\n          target: object.constructor,\n          propertyName: propertyName,\n          strategy:\n            typeof options.generated === \"string\"\n              ? options.generated\n              : \"increment\",\n        } as GeneratedMetadataArgs);\n      }\n    }\n  };\n}\n","import { ColumnOptions, getMetadataArgsStorage } from \"typeorm\";\nimport { aggregateOrNewColumn } from \"./utils\";\n\nexport function UpdateDateColumn(options?: ColumnOptions): PropertyDecorator {\n  return function (object: any, propertyName: any) {\n    const columns = getMetadataArgsStorage().columns;\n    aggregateOrNewColumn(\n      object.constructor,\n      propertyName,\n      columns,\n      options || {},\n      \"updateDate\"\n    );\n  };\n}\n","import { ColumnOptions, getMetadataArgsStorage } from \"typeorm\";\nimport { aggregateOrNewColumn } from \"./utils\";\n\nexport function CreateDateColumn(options?: ColumnOptions): PropertyDecorator {\n  return function (object: any, propertyName: any) {\n    const columns = getMetadataArgsStorage().columns;\n    aggregateOrNewColumn(\n      object.constructor,\n      propertyName,\n      columns,\n      options || {},\n      \"createDate\"\n    );\n  };\n}\n","import { ObjectUtils } from \"typeorm/util/ObjectUtils\";\nimport { PrimaryGeneratedColumnNumericOptions } from \"typeorm/decorator/options/PrimaryGeneratedColumnNumericOptions\";\nimport { PrimaryGeneratedColumnUUIDOptions } from \"typeorm/decorator/options/PrimaryGeneratedColumnUUIDOptions\";\nimport { PrimaryGeneratedColumnIdentityOptions } from \"typeorm/decorator/options/PrimaryGeneratedColumnIdentityOptions\";\nimport { ColumnOptions, getMetadataArgsStorage } from \"typeorm\";\nimport { GeneratedMetadataArgs } from \"typeorm/metadata-args/GeneratedMetadataArgs\";\nimport { aggregateOrNewColumn } from \"./utils\";\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n */\nexport function PrimaryGeneratedColumn(): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n */\nexport function PrimaryGeneratedColumn(\n  options: PrimaryGeneratedColumnNumericOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n */\nexport function PrimaryGeneratedColumn(\n  strategy: \"increment\",\n  options?: PrimaryGeneratedColumnNumericOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n */\nexport function PrimaryGeneratedColumn(\n  strategy: \"uuid\",\n  options?: PrimaryGeneratedColumnUUIDOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n */\nexport function PrimaryGeneratedColumn(\n  strategy: \"rowid\",\n  options?: PrimaryGeneratedColumnUUIDOptions\n): PropertyDecorator;\n\nexport function PrimaryGeneratedColumn(\n  strategy: \"identity\",\n  options?: PrimaryGeneratedColumnIdentityOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n * This column creates an integer PRIMARY COLUMN with generated set to true.\n */\nexport function PrimaryGeneratedColumn(\n  strategyOrOptions?:\n    | \"increment\"\n    | \"uuid\"\n    | \"rowid\"\n    | \"identity\"\n    | PrimaryGeneratedColumnNumericOptions\n    | PrimaryGeneratedColumnUUIDOptions\n    | PrimaryGeneratedColumnIdentityOptions,\n  maybeOptions?:\n    | PrimaryGeneratedColumnNumericOptions\n    | PrimaryGeneratedColumnUUIDOptions\n    | PrimaryGeneratedColumnIdentityOptions\n): PropertyDecorator {\n  // normalize parameters\n  const options: ColumnOptions = {};\n  let strategy: \"increment\" | \"uuid\" | \"rowid\" | \"identity\";\n  if (strategyOrOptions) {\n    if (typeof strategyOrOptions === \"string\")\n      strategy = strategyOrOptions as\n        | \"increment\"\n        | \"uuid\"\n        | \"rowid\"\n        | \"identity\";\n\n    if (ObjectUtils.isObject(strategyOrOptions)) {\n      strategy = \"increment\";\n      Object.assign(options, strategyOrOptions);\n    }\n  } else {\n    strategy = \"increment\";\n  }\n  if (ObjectUtils.isObject(maybeOptions)) Object.assign(options, maybeOptions);\n\n  return function (object: any, propertyName: any) {\n    // if column type is not explicitly set then determine it based on generation strategy\n    if (!options.type) {\n      if (strategy === \"increment\" || strategy === \"identity\") {\n        options.type = Number;\n      } else if (strategy === \"uuid\") {\n        options.type = \"uuid\";\n      } else if (strategy === \"rowid\") {\n        options.type = \"int\";\n      }\n    }\n\n    // explicitly set a primary and generated to column options\n    options.primary = true;\n\n    const columns = getMetadataArgsStorage().columns;\n    aggregateOrNewColumn(object.constructor, propertyName, columns, options);\n    // register generated metadata args\n    getMetadataArgsStorage().generations.push({\n      target: object.constructor,\n      propertyName: propertyName,\n      strategy: strategy,\n    } as GeneratedMetadataArgs);\n  };\n}\n","import {\n  ColumnOptions,\n  ColumnType,\n  ColumnTypeUndefinedError,\n  getMetadataArgsStorage,\n  PrimaryColumnCannotBeNullableError,\n} from \"typeorm\";\nimport { ColumnMetadataArgs } from \"typeorm/metadata-args/ColumnMetadataArgs\";\nimport { GeneratedMetadataArgs } from \"typeorm/metadata-args/GeneratedMetadataArgs\";\nimport { aggregateOrNewColumn } from \"./utils\";\n\n/**\n * Describes all primary key column's options.\n * If specified, the nullable field must be set to false.\n */\nexport type PrimaryColumnOptions = ColumnOptions & { nullable?: false };\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n * Primary columns also creates a PRIMARY KEY for this column in a db.\n */\nexport function PrimaryColumn(\n  options?: PrimaryColumnOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n * Primary columns also creates a PRIMARY KEY for this column in a db.\n */\nexport function PrimaryColumn(\n  type?: ColumnType,\n  options?: PrimaryColumnOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n * Primary columns also creates a PRIMARY KEY for this column in a db.\n */\nexport function PrimaryColumn(\n  typeOrOptions?: ColumnType | PrimaryColumnOptions,\n  options?: PrimaryColumnOptions\n): PropertyDecorator {\n  return function (object: any, propertyName: any) {\n    // normalize parameters\n    let type: ColumnType | undefined;\n    if (\n      typeof typeOrOptions === \"string\" ||\n      typeOrOptions === String ||\n      typeOrOptions === Boolean ||\n      typeOrOptions === Number\n    ) {\n      type = typeOrOptions as ColumnType;\n    } else {\n      options = Object.assign({}, <PrimaryColumnOptions>typeOrOptions);\n    }\n    if (!options) options = {} as PrimaryColumnOptions;\n\n    // if type is not given explicitly then try to guess it\n    const reflectMetadataType =\n      Reflect && (Reflect as any).getMetadata\n        ? (Reflect as any).getMetadata(\"design:type\", object, propertyName)\n        : undefined;\n    if (!type && reflectMetadataType) type = reflectMetadataType;\n\n    // check if there is no type in column options then set type from first function argument, or guessed one\n    if (!options.type && type) options.type = type;\n\n    // if we still don't have a type then we need to give error to user that type is required\n    if (!options.type) throw new ColumnTypeUndefinedError(object, propertyName);\n\n    // check if column is not nullable, because we cannot allow a primary key to be nullable\n    if (options.nullable)\n      throw new PrimaryColumnCannotBeNullableError(object, propertyName);\n\n    // explicitly set a primary to column options\n    options.primary = true;\n\n    const columns = getMetadataArgsStorage().columns;\n    aggregateOrNewColumn(object.constructor, propertyName, columns, options);\n\n    if (options.generated) {\n      getMetadataArgsStorage().generations.push({\n        target: object.constructor,\n        propertyName: propertyName,\n        strategy:\n          typeof options.generated === \"string\"\n            ? options.generated\n            : \"increment\",\n      } as GeneratedMetadataArgs);\n    }\n  };\n}\n","import { EntityOptions, getMetadataArgsStorage } from \"typeorm\";\nimport { ObjectUtils } from \"typeorm/util/ObjectUtils\";\nimport { TableMetadataArgs } from \"typeorm/metadata-args/TableMetadataArgs\";\n\n/**\n * This decorator is used to mark classes that will be an entity (table or document depend on database type).\n * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.\n */\nexport function Entity(options?: EntityOptions): ClassDecorator;\n\n/**\n * This decorator is used to mark classes that will be an entity (table or document depend on database type).\n * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.\n */\nexport function Entity(name?: string, options?: EntityOptions): ClassDecorator;\n\n/**\n * This decorator is used to mark classes that will be an entity (table or document depend on database type).\n * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.\n */\nexport function Entity(\n  nameOrOptions?: string | EntityOptions,\n  maybeOptions?: EntityOptions\n): ClassDecorator {\n  const options =\n    (ObjectUtils.isObject(nameOrOptions)\n      ? (nameOrOptions as EntityOptions)\n      : maybeOptions) || {};\n  const name = typeof nameOrOptions === \"string\" ? nameOrOptions : options.name;\n\n  return function (target) {\n    const tables = getMetadataArgsStorage().tables;\n    tables.push({\n      target: target,\n      name: name,\n      type: \"regular\",\n      orderBy: options.orderBy ? options.orderBy : undefined,\n      engine: options.engine ? options.engine : undefined,\n      database: options.database ? options.database : undefined,\n      schema: options.schema ? options.schema : undefined,\n      synchronize: options.synchronize,\n      withoutRowid: options.withoutRowid,\n      comment: options.comment ? options.comment : undefined,\n    } as TableMetadataArgs);\n  };\n}\n","import {\n  Adapter,\n  Cascade,\n  CascadeMetadata,\n  ConnectionError,\n  final,\n  PersistenceKeys,\n  RelationsMetadata,\n  Repository,\n  Sequence,\n  type SequenceOptions,\n} from \"@decaf-ts/core\";\nimport { reservedAttributes, TypeORMFlavour } from \"./constants\";\nimport {\n  BaseError,\n  ConflictError,\n  Context,\n  DBKeys,\n  DEFAULT_ERROR_MESSAGES as DB_DEFAULT_ERROR_MESSAGES,\n  findPrimaryKey,\n  InternalError,\n  NotFoundError,\n  OperationKeys,\n  readonly,\n  UpdateValidationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport \"reflect-metadata\";\nimport {\n  type Constructor,\n  date,\n  Decoration,\n  DEFAULT_ERROR_MESSAGES,\n  list,\n  MaxLengthValidatorOptions,\n  MaxValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  Model,\n  ModelKeys,\n  PatternValidatorOptions,\n  prop,\n  propMetadata,\n  required,\n  type,\n  TypeMetadata,\n  Validation,\n  ValidationKeys,\n  ValidatorOptions,\n} from \"@decaf-ts/decorator-validation\";\nimport { IndexError } from \"./errors\";\nimport { TypeORMStatement } from \"./query\";\nimport { TypeORMSequence } from \"./sequences\";\nimport { generateIndexes } from \"./indexes\";\nimport { TypeORMFlags, TypeORMQuery, TypeORMTableSpec } from \"./types\";\nimport { apply, Reflection } from \"@decaf-ts/reflection\";\nimport { TypeORMRepository } from \"./TypeORMRepository\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { TypeORMDispatch } from \"./TypeORMDispatch\";\nimport { convertJsRegexToPostgres } from \"./utils\";\nimport {\n  DataSource,\n  FindOneOptions,\n  In,\n  InsertResult,\n  RelationOptions,\n  OneToOne,\n  JoinColumn,\n  ManyToMany,\n  SelectQueryBuilder,\n  VersionColumn,\n  OneToMany,\n  ManyToOne,\n  JoinTable,\n} from \"typeorm\";\nimport { DataSourceOptions } from \"typeorm/data-source/DataSourceOptions\";\nimport { Column } from \"./overrides/Column\";\nimport { UpdateDateColumn } from \"./overrides/UpdateDateColumn\";\nimport { CreateDateColumn } from \"./overrides/CreateDateColumn\";\nimport { PrimaryGeneratedColumn } from \"./overrides/PrimaryGeneratedColumn\";\nimport { PrimaryColumn } from \"./overrides/PrimaryColumn\";\nimport { Entity } from \"./overrides/Entity\";\n\nexport async function createdByOnPostgresCreateUpdate<\n  M extends Model,\n  R extends TypeORMRepository<M>,\n  V extends RelationsMetadata,\n>(\n  this: R,\n  context: Context<TypeORMFlags>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  try {\n    const user = context.get(\"user\");\n    model[key] = user as M[typeof key];\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    throw new InternalError(\n      \"No User found in context. Please provide a user in the context\"\n    );\n  }\n}\n\n/**\n * @description Adapter for TypeORM-backed persistence operations.\n * @summary Implements the Decaf.ts Adapter over a TypeORM DataSource, providing CRUD operations, query/statement factories, sequence management, error parsing, and decoration helpers.\n * @template Y The native configuration type (TypeORM DataSourceOptions).\n * @template F The repository flags type.\n * @template C The context type.\n * @param {DataSourceOptions} scope The DataSource options for the adapter.\n * @param {string} flavour The flavour of the adapter.\n * @param {string} [alias] Optional alias for the adapter.\n * @class TypeORMAdapter\n * @example\n * const adapter = new TypeORMAdapter({ type: 'postgres', /* ... *\\/ });\n * await adapter.initialize();\n * const repo = new (adapter.repository<User>())(adapter, User);\n * const created = await repo.create(new User({ name: 'Alice' }));\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Adapter as TypeORMAdapter\n *   participant Repo as TypeORMRepository\n *   participant DS as TypeORM DataSource\n *\n *   App->>Adapter: new TypeORMAdapter(opts)\n *   Adapter->>DS: initialize()\n *   App->>Adapter: repository()\n *   Adapter-->>App: TypeORMRepository\n *   App->>Repo: create(model)\n *   Repo->>Adapter: prepare/create/revert\n *   Adapter-->>Repo: Model\n *   Repo-->>App: Model\n */\nexport class TypeORMAdapter extends Adapter<\n  DataSourceOptions,\n  TypeORMQuery,\n  TypeORMFlags,\n  Context<TypeORMFlags>\n> {\n  private _dataSource?: DataSource;\n\n  get dataSource(): DataSource {\n    if (!this._dataSource) {\n      const models = Adapter.models(this.flavour);\n      this._dataSource = new DataSource(\n        Object.assign(this.native, {\n          entities: models.map((c) => c[ModelKeys.ANCHOR as keyof typeof c]),\n        })\n      );\n    }\n    return this._dataSource;\n  }\n  // protected dataSou\n\n  constructor(options: DataSourceOptions, alias?: string) {\n    super(options, TypeORMFlavour, alias);\n  }\n\n  protected override async flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<TypeORMFlags>\n  ): Promise<TypeORMFlags> {\n    const f = await super.flags(operation, model, flags);\n    const newObj: any = {\n      user: (await TypeORMAdapter.getCurrentUser(this.dataSource)) as string,\n    };\n    const m = new model();\n\n    const exceptions: string[] = [];\n    if (operation === OperationKeys.CREATE) {\n      const pk = findPrimaryKey(m).id;\n      exceptions.push(pk as string);\n    }\n\n    if (\n      operation === OperationKeys.CREATE ||\n      operation === OperationKeys.UPDATE\n    ) {\n      const decs = Object.keys(m).reduce((accum: Record<string, any>, key) => {\n        const decs = Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          m,\n          key,\n          true\n        );\n        const dec = decs.decorators.find(\n          (dec: any) =>\n            dec.key === DBKeys.TIMESTAMP &&\n            dec.props.operation.indexOf(operation) !== -1\n        );\n        if (dec) {\n          accum[key] = dec.props;\n        }\n        return accum;\n      }, {});\n\n      exceptions.push(...Object.keys(decs));\n    }\n\n    newObj.ignoredValidationProperties = (\n      f.ignoredValidationProperties ? f.ignoredValidationProperties : []\n    ).concat(...exceptions);\n    return Object.assign(f, newObj) as TypeORMFlags;\n  }\n\n  @final()\n  protected override Dispatch(): TypeORMDispatch {\n    return new TypeORMDispatch();\n  }\n\n  @final()\n  override repository<M extends Model>(): Constructor<TypeORMRepository<M>> {\n    return TypeORMRepository;\n  }\n\n  /**\n   * @description Creates a new Postgres statement for querying\n   * @summary Factory method that creates a new PostgresStatement instance for building queries\n   * @template M - The model type\n   * @return {TypeORMStatement<M, any>} A new PostgresStatement instance\n   */\n  @final()\n  Statement<M extends Model>(): TypeORMStatement<M, any> {\n    return new TypeORMStatement(this);\n  }\n\n  /**\n   * @description Creates a new PostgreSQL sequence\n   * @summary Factory method that creates a new PostgreSQLSequence instance for managing sequences\n   * @param {SequenceOptions} options - The options for the sequence\n   * @return {Promise<Sequence>} A promise that resolves to a new Sequence instance\n   */\n  @final()\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new TypeORMSequence(options, this);\n  }\n\n  /**\n   * @description Initializes the adapter by creating indexes for all managed models\n   * @summary Sets up the necessary database indexes for all models managed by this adapter\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  async initialize(): Promise<void> {\n    const ds = this.dataSource;\n    try {\n      await ds.initialize();\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    const log = this.log.for(this.initialize);\n    log.verbose(`${this.flavour} adapter initialized`);\n  }\n\n  /**\n   * @description Creates indexes for the given models\n   * @summary Abstract method that must be implemented to create database indexes for the specified models\n   * @template M - The model type\n   * @param {...Constructor<M>} models - The model constructors to create indexes for\n   * @return {Promise<void>} A promise that resolves when all indexes are created\n   */\n  @final()\n  protected async index<M extends Model>(\n    ...models: Constructor<M>[]\n  ): Promise<void> {\n    const indexes: TypeORMQuery[] = generateIndexes(models);\n\n    try {\n      await this.dataSource.query(\"BEGIN\");\n\n      for (const index of indexes) {\n        await this.dataSource.query(index.query, index.values);\n      }\n\n      await this.dataSource.query(\"COMMIT\");\n    } catch (e: unknown) {\n      await this.dataSource.query(\"ROLLBACK\");\n      throw this.parseError(e as Error);\n    }\n  }\n\n  /**\n   * @description Executes a raw SQL query against the database\n   * @summary Abstract method that must be implemented to execute raw SQL queries\n   * @template R - The result type\n   * @param {TypeORMQuery} q - The query to execute\n   * @return {Promise<R>} A promise that resolves to the query result\n   */\n  override async raw<R>(q: TypeORMQuery): Promise<R> {\n    const log = this.log.for(this.raw);\n    try {\n      if (!this.dataSource.isInitialized) await this.dataSource.initialize();\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    try {\n      const { query, values } = q;\n      log.debug(\n        `executing query: ${(query as unknown as SelectQueryBuilder<any>).getSql()}`\n      );\n      const response = await this.dataSource.query(query, values);\n      return response as R;\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  override prepare<M extends Model>(\n    model: M,\n    pk: keyof M,\n    child = false\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const prepared = super.prepare(model, pk);\n\n    prepared.record = Object.entries(prepared.record).reduce(\n      (accum: Record<string, any>, [key, value]) => {\n        if (key === PersistenceKeys.METADATA || this.isReserved(key))\n          return accum;\n        if (value === undefined) {\n          return accum;\n        }\n\n        if (value instanceof Date) {\n          value = new Date(value.getTime());\n        } else if (Model.isModel(value)) {\n          value = this.prepare(value, findPrimaryKey(value).id, true).record;\n        } else {\n          switch (typeof value) {\n            case \"string\":\n              value = `${value}`;\n              break;\n            default:\n            //do nothing;\n          }\n        }\n        accum[key] = value;\n        return accum;\n      },\n      {}\n    );\n    const constr: Constructor<any> | undefined = Model.get(\n      model.constructor.name\n    );\n    if (!constr)\n      throw new InternalError(\n        `Model ${model.constructor.name} not found in registry`\n      );\n    const result = child\n      ? new (constr as any)[ModelKeys.ANCHOR as keyof typeof constr]()\n      : new constr();\n    if (child)\n      Object.defineProperty(result, \"constructor\", {\n        configurable: false,\n        enumerable: false,\n        value: (constr as any)[ModelKeys.ANCHOR as keyof typeof constr],\n        writable: false,\n      });\n    Object.entries(prepared.record).forEach(\n      ([key, val]) => (result[key as keyof typeof result] = val)\n    );\n    prepared.record = result;\n    return prepared;\n  }\n\n  override revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number | bigint,\n    transient?: Record<string, any>\n  ): M {\n    const log = this.log.for(this.revert);\n    if (transient) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in obj)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${typeof clazz === \"string\" ? clazz : clazz.name}. should be impossible`\n          );\n        (obj as M)[key as keyof M] = val;\n      });\n    }\n\n    return new (clazz as Constructor<M>)(obj);\n  }\n\n  /**\n   * @description Creates a new record in the database\n   * @summary Abstract method that must be implemented to create a new record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {Record<string, any>} model - The model to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves to the created record\n   */\n  override async create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      return await repo.save(model);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  /**\n   * @description Reads a record from the database\n   * @summary Abstract method that must be implemented to read a record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {string} pk - primary key colum\n   * @return {Promise<Record<string, any>>} A promise that resolves to the read record\n   */\n  override async read(\n    tableName: string,\n    id: string | number,\n    pk: string\n  ): Promise<Record<string, any>> {\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    let result: any;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      const q: FindOneOptions = {\n        where: {\n          [pk]: id,\n        },\n      };\n      result = (await repo.findOne(q)) as Record<string, any>;\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    if (!result)\n      throw new NotFoundError(\n        `Record with id: ${id} not found in table ${typeof tableName === \"string\" ? tableName : Repository.table(tableName)}`\n      );\n    return result;\n  }\n\n  /**\n   * @description Updates a record in the database\n   * @summary Abstract method that must be implemented to update a record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {Record<string, any>} model - The model to update\n   * @param {string} pk - Additional arguments\n   * @return A promise that resolves to the updated record\n   */\n  override async update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      return repo.save(model);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  /**\n   * @description Deletes a record from the database\n   * @summary Abstract method that must be implemented to delete a record\n   * @param {string} tableName - The name of the table\n   * @param {string|number} id - The ID of the record\n   * @param {string} pk - Additional arguments\n   * @return A promise that resolves to the deleted record\n   */\n  override async delete(\n    tableName: string,\n    id: string | number,\n    pk: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      const model = await this.read(tableName, id, pk);\n      const res = await repo.delete(id);\n      return model;\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  override async createAll(\n    tableName: string,\n    id: (string | number)[],\n    model: Record<string, any>[],\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      const result: InsertResult = await repo.insert(model);\n      return this.readAll(\n        tableName,\n        result.identifiers.map((id) => id.id),\n        \"id\"\n      );\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  override async readAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    pk: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (!id.length) return [];\n\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      return repo.findBy({ [pk]: In(id) });\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  override async updateAll(\n    tableName: string,\n    ids: string[] | number[],\n    model: Record<string, any>[],\n    pk: string,\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    const result = [];\n    for (const m of model) {\n      result.push(await this.update(tableName, m[pk], m, ...args));\n    }\n    return result;\n  }\n\n  override async deleteAll(\n    tableName: string,\n    ids: (string | number | bigint)[],\n    pk: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (!ids.length) return [];\n    const m: Constructor<Model> = tableName as unknown as Constructor<Model>;\n    try {\n      const repo = this.dataSource.getRepository(m);\n      const models = await this.readAll(tableName, ids, pk);\n      await repo.delete(ids);\n      return models;\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  /**\n   * @description Parses an error and converts it to a BaseError\n   * @summary Converts various error types to appropriate BaseError subtypes\n   * @param {Error|string} err - The error to parse\n   * @param {string} [reason] - Optional reason for the error\n   * @return {BaseError} The parsed error as a BaseError\n   */\n  parseError(err: Error | string, reason?: string): BaseError {\n    return TypeORMAdapter.parseError(err, reason);\n  }\n\n  /**\n   * @description Checks if an attribute is reserved\n   * @summary Determines if an attribute name is reserved in PostgreSQL\n   * @param {string} attr - The attribute name to check\n   * @return {boolean} True if the attribute is reserved, false otherwise\n   */\n  protected override isReserved(attr: string): boolean {\n    return !!attr.match(reservedAttributes);\n  }\n\n  /**\n   * @description Static method to parse an error and convert it to a BaseError\n   * @summary Converts various error types to appropriate BaseError subtypes based on PostgreSQL error codes and messages\n   * @param {Error|string} err - The error to parse\n   * @param {string} [reason] - Optional reason for the error\n   * @return {BaseError} The parsed error as a BaseError\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant parseError\n   *   participant ErrorTypes\n   *\n   *   Caller->>parseError: err, reason\n   *   Note over parseError: Check if err is already a BaseError\n   *   alt err is BaseError\n   *     parseError-->>Caller: return err\n   *   else err is string\n   *     Note over parseError: Extract code from string\n   *     alt code matches \"duplicate key|already exists\"\n   *       parseError->>ErrorTypes: new ConflictError(code)\n   *       ErrorTypes-->>Caller: ConflictError\n   *     else code matches \"does not exist|not found\"\n   *       parseError->>ErrorTypes: new NotFoundError(code)\n   *       ErrorTypes-->>Caller: NotFoundError\n   *     end\n   *   else err has code property\n   *     Note over parseError: Extract code and reason\n   *   else\n   *     Note over parseError: Use err.message as code\n   *   end\n   *\n   *   Note over parseError: Switch on PostgreSQL error code\n   *   alt code is 23505 (unique_violation)\n   *     parseError->>ErrorTypes: new ConflictError(reason)\n   *     ErrorTypes-->>Caller: ConflictError\n   *   else code is 23503 (foreign_key_violation)\n   *     parseError->>ErrorTypes: new ConflictError(reason)\n   *     ErrorTypes-->>Caller: ConflictError\n   *   else code is 42P01 (undefined_table)\n   *     parseError->>ErrorTypes: new NotFoundError(reason)\n   *     ErrorTypes-->>Caller: NotFoundError\n   *   else code is 42703 (undefined_column)\n   *     parseError->>ErrorTypes: new NotFoundError(reason)\n   *     ErrorTypes-->>Caller: NotFoundError\n   *   else code is 42P07 (duplicate_table)\n   *     parseError->>ErrorTypes: new ConflictError(reason)\n   *     ErrorTypes-->>Caller: ConflictError\n   *   else code is 42P16 (invalid_table_definition)\n   *     parseError->>ErrorTypes: new IndexError(err)\n   *     ErrorTypes-->>Caller: IndexError\n   *   else code matches \"ECONNREFUSED\"\n   *     parseError->>ErrorTypes: new ConnectionError(err)\n   *     ErrorTypes-->>Caller: ConnectionError\n   *   else\n   *     parseError->>ErrorTypes: new InternalError(err)\n   *     ErrorTypes-->>Caller: InternalError\n   *   end\n   */\n  protected static parseError(err: Error | string, reason?: string): BaseError {\n    if (err instanceof BaseError) return err as any;\n    const code: string = typeof err === \"string\" ? err : err.message;\n\n    if (code.match(/duplicate key|already exists/g))\n      return new ConflictError(code);\n    if (code.match(/does not exist|not found/g)) return new NotFoundError(code);\n\n    // PostgreSQL error codes: https://www.postgresql.org/docs/current/errcodes-appendix.html\n    switch (code.toString()) {\n      // Integrity constraint violations\n      case \"23505\": // unique_violation\n      case \"23503\": // foreign_key_violation\n      case \"42P07\": // duplicate_table\n        return new ConflictError(reason as string);\n\n      // Object not found errors\n      case \"42P01\": // undefined_table\n      case \"42703\": // undefined_column\n        return new NotFoundError(reason as string);\n\n      // Invalid object definition\n      case \"42P16\": // invalid_table_definition\n        return new IndexError(err);\n\n      // Connection errors\n      default:\n        if (code.toString().match(/ECONNREFUSED/g))\n          return new ConnectionError(err);\n        return new InternalError(err);\n    }\n  }\n\n  static async connect(config: DataSourceOptions): Promise<DataSource> {\n    const con = new DataSource(config);\n    if (!con.isInitialized) await con.initialize();\n    return con;\n  }\n\n  static async createDatabase(\n    dataSource: DataSource,\n    dbName: string\n  ): Promise<void> {\n    const log = Logging.for(this.createDatabase);\n    log.verbose(`Creating database ${dbName}`);\n    try {\n      await dataSource.query(`CREATE DATABASE ${dbName}`);\n      log.info(`Created database ${dbName}`);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  static async createNotifyFunction(\n    dataSource: DataSource,\n    user: string\n  ): Promise<void> {\n    const log = Logging.for(this.createNotifyFunction);\n    log.verbose(`Creating notify function`);\n    try {\n      await dataSource.query(\n        `CREATE OR REPLACE FUNCTION notify_table_changes()\nRETURNS trigger AS $$\nBEGIN\n    PERFORM pg_notify(\n        'table_changes',\n        json_build_object(\n            'table', TG_TABLE_NAME,\n            'action', TG_OP,\n            'data', row_to_json(NEW),\n            'old_data', row_to_json(OLD)\n        )::text\n    );\n    RETURN NEW;\nEND;\n$$ LANGUAGE plpgsql SECURITY DEFINER\n;`\n      );\n      await dataSource.query(\n        `ALTER FUNCTION notify_table_changes() OWNER TO ${user};`\n      );\n      await dataSource.query(`\n            GRANT EXECUTE ON FUNCTION notify_table_changes() TO public;\n        `);\n      log.info(`Created notify function`);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  static async deleteDatabase(\n    dataSource: DataSource,\n    dbName: string,\n    user?: string\n  ): Promise<void> {\n    try {\n      if (user) await dataSource.query(`DROP OWNED BY ${user} CASCADE;`);\n      await dataSource.query(`DROP DATABASE ${dbName}`);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  static async createUser(\n    dataSource: DataSource,\n    dbName: string,\n    user: string,\n    password: string\n  ): Promise<void> {\n    try {\n      await dataSource.query(`CREATE USER ${user} WITH PASSWORD '${password}'`);\n      await dataSource.query(`GRANT CONNECT ON DATABASE ${dbName} TO ${user}`);\n\n      await dataSource.query(`GRANT USAGE ON SCHEMA public TO ${user}`);\n      await dataSource.query(`GRANT CREATE ON SCHEMA public TO ${user}`);\n      await dataSource.query(\n        `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ${user}`\n      );\n      await dataSource.query(\n        `GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ${user}`\n      );\n      await dataSource.query(\n        `GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public TO ${user}`\n      );\n      await dataSource.query(\n        `ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO ${user}`\n      );\n      await dataSource.query(\n        `ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO ${user}`\n      );\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  static async deleteUser(\n    client: DataSource,\n    user: string,\n    admin: string\n  ): Promise<void> {\n    try {\n      await client.query(`REASSIGN OWNED BY ${user} TO ${admin}`);\n      await client.query(\n        `REVOKE ALL ON ALL TABLES IN SCHEMA public FROM ${user}`\n      );\n      await client.query(`REVOKE ALL ON SCHEMA public FROM ${user}`);\n      await client.query(\n        `REVOKE ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public FROM ${user}`\n      );\n      await client.query(\n        `REVOKE ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public FROM ${user}`\n      );\n      await client.query(\n        `ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON TABLES FROM ${user}`\n      );\n      await client.query(\n        `ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON SEQUENCES FROM ${user};`\n      );\n      await client.query(\n        `ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON FUNCTIONS FROM ${user}`\n      );\n      await client.query(`DROP OWNED BY ${user} CASCADE`);\n      await client.query(`DROP USER IF EXISTS \"${user}\"`);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  private static parseTypeToPostgres(\n    type: string,\n    isPk: boolean,\n    isFk = false\n  ) {\n    switch (type.toLowerCase()) {\n      case \"string\":\n        return isPk ? \"TEXT PRIMARY KEY\" : isFk ? \"TEXT\" : \"VARCHAR\";\n      case \"number\":\n        return isPk ? \"SERIAL PRIMARY KEY\" : \"INTEGER\";\n      case \"boolean\":\n        return \"BOOLEAN\";\n      case \"date\":\n        return \"TIMESTAMP\";\n      case \"bigint\":\n        return isPk ? \"BIGINT PRIMARY KEY\" : \"BIGINT\";\n      default: {\n        const m = Model.get(type);\n        if (m) {\n          const mm = new m();\n          const type = Reflection.getTypeFromDecorator(\n            mm,\n            findPrimaryKey(mm).id\n          );\n          return {\n            model: m,\n            pkType: type,\n          };\n        }\n        throw new InternalError(`Unsupported type: ${type}`);\n      }\n    }\n  }\n\n  private static parseValidationToPostgres(\n    prop: string,\n    type: string,\n    isPk: boolean,\n    key: string,\n    options: ValidatorOptions\n  ) {\n    switch (key) {\n      case ValidationKeys.REQUIRED:\n        return \"NOT NULL\";\n      case ValidationKeys.MAX_LENGTH:\n        if (isPk || !options || type.toLowerCase() !== \"string\") {\n          return \"\";\n        }\n        return `(${(options as MaxLengthValidatorOptions)[ValidationKeys.MAX_LENGTH]})`;\n      case ValidationKeys.MIN_LENGTH:\n        return `CONSTRAINT ${prop}_min_length_check CHECK (LENGTH(${prop}) >= ${(options as MinLengthValidatorOptions)[ValidationKeys.MIN_LENGTH]})`;\n      case ValidationKeys.PATTERN:\n      case ValidationKeys.URL:\n      case ValidationKeys.EMAIL:\n        return `CONSTRAINT ${prop}_pattern_check CHECK (${prop} ~ '${convertJsRegexToPostgres((options as PatternValidatorOptions)[ValidationKeys.PATTERN] as string)}')`;\n      case ValidationKeys.TYPE:\n      case ValidationKeys.DATE:\n        return \"\";\n      case ValidationKeys.MIN:\n        return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} >= ${(options as MinValidatorOptions)[ValidationKeys.MIN]})`;\n      case ValidationKeys.MAX:\n        return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} <= ${(options as MaxValidatorOptions)[ValidationKeys.MAX]})`;\n      case ValidationKeys.PASSWORD:\n      default:\n        throw new InternalError(`Unsupported type: ${key}`);\n    }\n  }\n\n  private static parseRelationsToPostgres(\n    prop: string,\n    clazz: Constructor<Model>,\n    pk: string,\n    key: PersistenceKeys,\n    options: RelationsMetadata\n  ) {\n    const tableName = Repository.table(clazz);\n    const { cascade } = options;\n    const cascadeStr = `${cascade.update ? \" ON UPDATE CASCADE\" : \"\"}${cascade.delete ? \" ON DELETE CASCADE\" : \"\"}`;\n    switch (`relations${key}`) {\n      case PersistenceKeys.ONE_TO_ONE:\n        return `FOREIGN KEY (${prop}) REFERENCES ${tableName}(${pk})${cascadeStr}`;\n      default:\n        throw new InternalError(`Unsupported operation: ${key}`);\n    }\n  }\n\n  static async createTable<M extends Model>(\n    client: DataSource,\n    model: Constructor<M>\n  ): Promise<Record<string, TypeORMTableSpec>> {\n    const result: Record<string, TypeORMTableSpec> = {};\n    const m = new model({});\n    const tableName = Repository.table(model);\n    const { id } = findPrimaryKey(m);\n\n    let isPk: boolean, column: string;\n    const properties = Object.getOwnPropertyNames(m) as (keyof M)[];\n    for (const prop of properties) {\n      if (\n        typeof (this as any)[prop] === \"function\" ||\n        prop.toString().startsWith(\"_\") ||\n        prop === \"constructor\"\n      ) {\n        continue;\n      }\n\n      isPk = prop === id;\n      column = Repository.column(m, prop.toString());\n\n      const allDecs = Reflection.getPropertyDecorators(\n        ValidationKeys.REFLECT,\n        m,\n        prop.toString(),\n        false,\n        true\n      );\n\n      const decoratorData = allDecs.decorators.reduce(\n        (accum: Record<string, any>, el) => {\n          const { key, props } = el;\n          if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {\n            accum[ValidationKeys.TYPE] = {\n              customTypes: [props.name as string],\n              message: DEFAULT_ERROR_MESSAGES.TYPE,\n              description: \"defines the accepted types for the attribute\",\n            };\n          } else if (key !== ValidationKeys.TYPE) {\n            // do nothing. we can only support basis ctypes at this time\n            accum[key] = props;\n          }\n          return accum;\n        },\n        {}\n      );\n\n      const dbDecs = Reflection.getPropertyDecorators(\n        Repository.key(\"relations\"),\n        m,\n        prop.toString(),\n        true,\n        true\n      );\n\n      const query: string[] = [];\n      const constraints: string[] = [];\n      const foreignKeys: string[] = [];\n      let typeData: TypeMetadata | undefined = undefined;\n      let childClass: Constructor<Model> | undefined = undefined;\n      let childPk: any;\n\n      if (Object.keys(decoratorData).length) {\n        typeData = decoratorData[ValidationKeys.TYPE] as TypeMetadata;\n\n        if (!typeData) {\n          throw new Error(`Missing type information`);\n        }\n\n        let parsedType:\n          | string\n          | { model: Constructor<Model> | string; pkType?: string } =\n          this.parseTypeToPostgres(\n            typeof (typeData.customTypes as any[])[0] === \"function\"\n              ? (typeData.customTypes as any)[0]()\n              : (typeData.customTypes as any)[0],\n            isPk\n          );\n        if (typeof parsedType === \"string\") {\n          parsedType = { model: parsedType };\n        }\n        let typeStr:\n          | string\n          | { model: Constructor<Model> | string; pkType?: string } =\n          parsedType.model as\n            | string\n            | { model: Constructor<Model> | string; pkType?: string };\n\n        if (typeof typeStr !== \"string\") {\n          if (Array.isArray(typeStr)) {\n            console.log(typeStr);\n          }\n\n          // continue;\n          // const res: Record<string, PostgresTableSpec> = await this.createTable(pool, typeStr);\n          try {\n            childClass = parsedType.model as Constructor<Model>;\n            const m = new childClass();\n            childPk = findPrimaryKey(m);\n            typeStr = this.parseTypeToPostgres(\n              parsedType.pkType as string,\n              false,\n              true\n            );\n            await this.createTable(client, childClass);\n          } catch (e: unknown) {\n            if (!(e instanceof ConflictError)) throw e;\n          }\n        }\n\n        let tp = Array.isArray(typeData.customTypes)\n          ? typeData.customTypes[0]\n          : typeData.customTypes;\n        tp = typeof tp === \"function\" && !tp.name ? tp() : tp;\n        const validationStr = this.parseValidationToPostgres(\n          column,\n          tp as any,\n          isPk,\n          ValidationKeys.MAX_LENGTH,\n          (decoratorData[\n            ValidationKeys.MAX_LENGTH\n          ] as MaxLengthValidatorOptions) || {\n            [ValidationKeys.MAX_LENGTH]: 255,\n          }\n        );\n\n        const q = `${column} ${typeStr}${validationStr}`;\n\n        if (isPk) {\n          query.unshift(q);\n        } else {\n          query.push(q);\n        }\n\n        for (const [key, props] of Object.entries(decoratorData).filter(\n          ([k]) =>\n            ![ValidationKeys.TYPE, ValidationKeys.MAX_LENGTH].includes(k as any)\n        )) {\n          const validation = this.parseValidationToPostgres(\n            column,\n            tp as any,\n            isPk,\n            key,\n            props\n          );\n          if (validation.startsWith(\"CONSTRAINT\")) {\n            constraints.push(validation);\n          } else {\n            if (validation) {\n              query.push(validation);\n            }\n          }\n        }\n      }\n\n      // TODO ignore for now. this leaves foreign keys out\n      // eslint-disable-next-line no-constant-binary-expression\n      if (false || (dbDecs && dbDecs.decorators.length)) {\n        if (!typeData) throw new Error(`Missing type information`);\n        for (const decorator of dbDecs.decorators) {\n          const { key, props } = decorator;\n          const validation = this.parseRelationsToPostgres(\n            column,\n            childClass as Constructor<Model>,\n            childPk.id,\n            key as PersistenceKeys,\n            props as unknown as RelationsMetadata\n          );\n          if (validation.startsWith(\"FOREIGN\")) {\n            foreignKeys.push(validation);\n          } else {\n            throw new InternalError(`Unsupported relation: ${key}`);\n          }\n        }\n      }\n\n      result[prop.toString()] = {\n        query: query.join(\" \"),\n        values: [],\n        primaryKey: isPk,\n        constraints: constraints,\n        foreignKeys: foreignKeys,\n      };\n    }\n\n    const values = Object.values(result);\n    const query = values.map((r) => r.query).join(\",\\n\");\n    const constraints = values\n      .filter((c) => !!c.constraints.length)\n      .map((r) => r.constraints)\n      .join(\",\\n\");\n    const foreignKeys = values\n      .filter((c) => !!c.foreignKeys.length)\n      .map((r) => r.foreignKeys)\n      .join(\",\\n\");\n    const vals = [query, constraints];\n    if (foreignKeys) {\n      vals.push(foreignKeys);\n    }\n    const queryString = `CREATE TABLE ${tableName} (${vals.filter((v) => !!v).join(\",\\n\")})`;\n    try {\n      await client.query(queryString);\n      await client.query(\n        `CREATE TRIGGER notify_changes_${tableName}\nAFTER INSERT OR UPDATE OR DELETE ON ${tableName}\n    FOR EACH ROW\n    EXECUTE FUNCTION notify_table_changes();`\n      );\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    return result;\n  }\n\n  static async getCurrentUser(client: DataSource): Promise<string> {\n    const queryString = `SELECT CURRENT_USER;`;\n    try {\n      const result = await client.query(queryString);\n      return result[0].current_user;\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n  }\n\n  static decoration() {\n    // @table() => @Entity()\n    const tableKey = Adapter.key(PersistenceKeys.TABLE);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(tableKey)\n      .extend((original: any) =>\n        Entity()(original[ModelKeys.ANCHOR] || original)\n      )\n      .apply();\n\n    // @pk() => @PrimaryGeneratedColumn() | @PrimaryColumn()\n    const pkKey = Repository.key(DBKeys.ID);\n\n    function pkDec(options: SequenceOptions) {\n      const decorators: any[] = [\n        required(),\n        readonly(),\n        propMetadata(pkKey, options),\n      ];\n      if (options.type) decorators.push(PrimaryGeneratedColumn());\n      else decorators.push(PrimaryColumn({ unique: true }));\n      return apply(...decorators);\n    }\n\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(pkKey)\n      .define({\n        decorator: pkDec,\n      })\n      .apply();\n\n    // @column(\"columnName\") => @Column({name: \"columnName\"})\n    const columnKey = Adapter.key(PersistenceKeys.COLUMN);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(columnKey)\n      .extend({\n        decorator: function columm(name: string) {\n          return function column(obj: any, prop: any) {\n            return Column({\n              name: name || prop,\n              nullable: true,\n            })(obj, prop);\n          };\n        },\n        transform: (args: any[]) => {\n          const columnName = args[1];\n          return [columnName];\n        },\n      })\n      .apply();\n\n    // @unique => @Column({unique: true})\n    const uniqueKey = Adapter.key(PersistenceKeys.UNIQUE);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(uniqueKey)\n      .define(propMetadata(uniqueKey, {}))\n      .extend(Column({ unique: true }))\n      .apply();\n\n    // @required => @Column({ nullable: false })\n    const requiredKey = Validation.key(ValidationKeys.REQUIRED);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(requiredKey)\n      .extend(Column({ nullable: false }))\n      .apply();\n\n    // @version => @VersionColumn()\n    const versionKey = Repository.key(DBKeys.VERSION);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(versionKey)\n      .define(type(Number.name), VersionColumn())\n      .apply();\n\n    function ValidationUpdateKey(key: string) {\n      return UpdateValidationKeys.REFLECT + key;\n    }\n\n    // @timestamp(op) => @CreateDateColumn() || @UpdateDateColumn()\n    const timestampKey = ValidationUpdateKey(DBKeys.TIMESTAMP);\n\n    function ts(operation: OperationKeys[], format: string) {\n      const decorators: any[] = [\n        date(format, DB_DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),\n        required(DB_DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),\n        propMetadata(Validation.key(DBKeys.TIMESTAMP), {\n          operation: operation,\n          format: format,\n        }),\n      ];\n      if (operation.indexOf(OperationKeys.UPDATE) !== -1)\n        decorators.push(\n          propMetadata(timestampKey, {\n            message: DB_DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID,\n          })\n        );\n      else decorators.push(readonly());\n      return apply(...decorators);\n    }\n\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(timestampKey)\n      .define({\n        decorator: ts,\n      })\n      .extend({\n        decorator: function timestamp(...ops: OperationKeys[]) {\n          return function timestamp(obj: any, prop: any) {\n            if (ops.indexOf(OperationKeys.UPDATE) !== -1)\n              return UpdateDateColumn()(obj, prop);\n            return CreateDateColumn()(obj, prop);\n          };\n        },\n        transform: (args: any[]) => {\n          return args[0];\n        },\n      })\n      .apply();\n\n    // @oneToOne(clazz) => @OneToOne(() => clazz)\n    const oneToOneKey = Repository.key(PersistenceKeys.ONE_TO_ONE);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(oneToOneKey)\n      .define({\n        decorator: function oneToOne(\n          clazz: Constructor<any> | (() => Constructor<any>),\n          cascade: CascadeMetadata,\n          populate: boolean\n        ) {\n          const metadata: RelationsMetadata = {\n            class: (clazz.name ? clazz.name : clazz) as string,\n            cascade: cascade,\n            populate: populate,\n          };\n          const ormMeta: RelationOptions = {\n            cascade:\n              cascade.update === Cascade.CASCADE ||\n              cascade.delete === Cascade.CASCADE,\n            onDelete: cascade.delete ? \"CASCADE\" : \"DEFAULT\",\n            onUpdate: cascade.update ? \"CASCADE\" : \"DEFAULT\",\n            nullable: true,\n            eager: populate,\n          };\n          return apply(\n            prop(PersistenceKeys.RELATIONS),\n            type([\n              (typeof clazz === \"function\" && !clazz.name\n                ? clazz\n                : clazz.name) as any,\n              String.name,\n              Number.name,\n              BigInt.name,\n            ]),\n            propMetadata(oneToOneKey, metadata),\n            OneToOne(\n              () => {\n                if (!clazz.name) clazz = (clazz as any)();\n                if (!clazz[ModelKeys.ANCHOR as keyof typeof clazz])\n                  throw new InternalError(\n                    \"Original Model not found in constructor\"\n                  );\n                return clazz[ModelKeys.ANCHOR as keyof typeof clazz];\n              },\n              (model: any) => {\n                const pk = findPrimaryKey(new (clazz as Constructor<any>)()).id;\n                return model[pk];\n              },\n              ormMeta\n            ),\n            JoinColumn()\n          );\n        },\n      })\n      .apply();\n\n    // @oneToMany(clazz) => @OneToMany(() => clazz)\n    const oneToManyKey = Repository.key(PersistenceKeys.ONE_TO_MANY);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(oneToManyKey)\n      .define({\n        decorator: function oneToMany(\n          clazz: Constructor<any> | (() => Constructor<any>),\n          cascade: CascadeMetadata,\n          populate: boolean\n        ) {\n          const metadata: RelationsMetadata = {\n            class: (clazz.name ? clazz.name : clazz) as string,\n            cascade: cascade,\n            populate: populate,\n          };\n          return apply(\n            prop(PersistenceKeys.RELATIONS),\n            list(clazz),\n            propMetadata(oneToManyKey, metadata),\n            function OneToManyWrapper(obj: any, prop: any): any {\n              const ormMeta: RelationOptions = {\n                cascade:\n                  cascade.update === Cascade.CASCADE ||\n                  cascade.delete === Cascade.CASCADE,\n                onDelete: cascade.delete ? \"CASCADE\" : \"DEFAULT\",\n                onUpdate: cascade.update ? \"CASCADE\" : \"DEFAULT\",\n                nullable: true,\n                eager: populate,\n              };\n              return OneToMany(\n                () => {\n                  if (!clazz.name) clazz = (clazz as any)();\n                  if (!clazz[ModelKeys.ANCHOR as keyof typeof clazz])\n                    throw new InternalError(\n                      \"Original Model not found in constructor\"\n                    );\n                  return clazz[ModelKeys.ANCHOR as keyof typeof clazz];\n                },\n                (model: any) => {\n                  if (!clazz.name) clazz = (clazz as any)();\n                  const m = new (clazz as Constructor<any>)();\n                  const crossRelationKey = Object.keys(m).find((k) => {\n                    const decs = Reflection.getPropertyDecorators(\n                      Repository.key(PersistenceKeys.MANY_TO_ONE),\n                      m,\n                      k,\n                      true\n                    );\n                    if (!decs || !decs.decorators || !decs.decorators.length)\n                      return false;\n                    const designType = Reflect.getMetadata(\n                      ModelKeys.TYPE,\n                      m,\n                      k\n                    );\n                    if (!designType)\n                      throw new InternalError(\n                        `No Type Definition found for ${k} in ${m.constructor.name}`\n                      );\n                    return designType.name === obj.constructor.name;\n                  });\n                  if (!crossRelationKey)\n                    throw new InternalError(\n                      `Cross relation not found. Did you use @manyToOne on the ${clazz.name}?`\n                    );\n                  return model[crossRelationKey];\n                },\n                ormMeta\n              )(obj, prop);\n            }\n          );\n        },\n      })\n      .apply();\n\n    // @manyToOne(clazz) => @ManyToOne(() => clazz)\n    const manyToOneKey = Repository.key(PersistenceKeys.MANY_TO_ONE);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(manyToOneKey)\n      .define({\n        decorator: function manyToOne(\n          clazz: Constructor<any> | (() => Constructor<any>),\n          cascade: CascadeMetadata,\n          populate: boolean\n        ) {\n          const metadata: RelationsMetadata = {\n            class: (clazz.name ? clazz.name : clazz) as string,\n            cascade: cascade,\n            populate: populate,\n          };\n          const ormMeta: RelationOptions = {\n            cascade:\n              cascade.update === Cascade.CASCADE ||\n              cascade.delete === Cascade.CASCADE,\n            onDelete: cascade.delete ? \"CASCADE\" : \"DEFAULT\",\n            onUpdate: cascade.update ? \"CASCADE\" : \"DEFAULT\",\n            nullable: true,\n            eager: populate,\n          };\n          return apply(\n            prop(PersistenceKeys.RELATIONS),\n            type([\n              (typeof clazz === \"function\" && !clazz.name\n                ? clazz\n                : clazz.name) as any,\n              String.name,\n              Number.name,\n              BigInt.name,\n            ]),\n            propMetadata(manyToOneKey, metadata),\n            function ManyToOneWrapper(obj: any, prop: any): any {\n              return ManyToOne(\n                () => {\n                  if (!clazz.name) clazz = (clazz as any)();\n                  if (!clazz[ModelKeys.ANCHOR as keyof typeof clazz])\n                    throw new InternalError(\n                      \"Original Model not found in constructor\"\n                    );\n                  return clazz[ModelKeys.ANCHOR as keyof typeof clazz];\n                },\n                (model: any) => {\n                  if (!clazz.name) clazz = (clazz as any)();\n                  const m = new (clazz as Constructor<any>)();\n                  const crossRelationKey = Object.keys(m).find((k) => {\n                    const decs = Reflection.getPropertyDecorators(\n                      Repository.key(PersistenceKeys.ONE_TO_MANY),\n                      m,\n                      k,\n                      true\n                    );\n                    if (!decs || !decs.decorators || !decs.decorators.length)\n                      return false;\n                    const listDec = Reflect.getMetadata(\n                      Validation.key(ValidationKeys.LIST),\n                      m,\n                      k\n                    );\n                    if (!listDec)\n                      throw new InternalError(\n                        `No Type Definition found for ${k} in ${m.constructor.name}`\n                      );\n                    const name = listDec.clazz[0]().name;\n                    return name === obj.constructor.name;\n                  });\n                  if (!crossRelationKey)\n                    throw new InternalError(\n                      `Cross relation not found. Did you use @manyToOne on the ${clazz.name}?`\n                    );\n                  return model[crossRelationKey];\n                }\n              )(obj, prop);\n            }\n          );\n        },\n      })\n      .apply();\n\n    // @manyToMany(clazz) => @ManyToMany(() => clazz)\n    const manyToManyKey = Repository.key(PersistenceKeys.MANY_TO_MANY);\n    Decoration.flavouredAs(TypeORMFlavour)\n      .for(manyToManyKey)\n      .define({\n        decorator: function manyToMany(\n          clazz: Constructor<any> | (() => Constructor<any>),\n          cascade: CascadeMetadata,\n          populate: boolean\n        ) {\n          const metadata: RelationsMetadata = {\n            class: clazz.name,\n            cascade: cascade,\n            populate: populate,\n          };\n          const ormMeta: RelationOptions = {\n            cascade:\n              cascade.update === Cascade.CASCADE ||\n              cascade.delete === Cascade.CASCADE,\n            onDelete: cascade.delete ? \"CASCADE\" : \"DEFAULT\",\n            onUpdate: cascade.update ? \"CASCADE\" : \"DEFAULT\",\n            nullable: true,\n            eager: populate,\n          };\n          return apply(\n            prop(PersistenceKeys.RELATIONS),\n            list(clazz),\n            propMetadata(manyToManyKey, metadata),\n            ManyToMany(\n              () => {\n                if (!clazz.name) clazz = (clazz as any)();\n                if (!clazz[ModelKeys.ANCHOR as keyof typeof clazz])\n                  throw new InternalError(\n                    \"Original Model not found in constructor\"\n                  );\n                return clazz[ModelKeys.ANCHOR as keyof typeof clazz];\n              },\n              (model: any) => {\n                if (!clazz.name) clazz = (clazz as any)();\n                const pk = findPrimaryKey(new (clazz as Constructor<any>)()).id;\n                return model[pk];\n              },\n              ormMeta\n            ),\n            JoinTable()\n          );\n        },\n      })\n      .apply();\n  }\n}\n","import { TypeORMAdapter } from \"./TypeORMAdapter\";\n\nTypeORMAdapter.decoration();\n\nexport * from \"./indexes\";\nexport * from \"./query\";\nexport * from \"./sequences\";\nexport * from \"./TypeORMAdapter\";\nexport * from \"./constants\";\nexport * from \"./errors\";\nexport * from \"./TypeORMDispatch\";\nexport * from \"./TypeORMRepository\";\nexport * from \"./types\";\nexport * from \"./utils\";\n\n/**\n * @description TypeORM integration for Decaf.ts.\n * @summary Provides the TypeORM-backed implementation of the Decaf.ts data access abstractions, including the adapter, repository, statement builder, pagination utilities, index helpers, and type definitions. Key exports include {@link TypeORMAdapter}, {@link TypeORMRepository}, {@link TypeORMStatement}, {@link TypeORMPaginator}, and index generation utilities.\n * @module for-typeorm\n */\n\n/**\n * @description Stores the current package version.\n * @summary The version string of the for-typeorm package.\n * @const VERSION\n * @memberOf module:for-typeorm\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["BaseError","SQLOperator","Paginator","ModelKeys","PagingError","findPrimaryKey","QueryError","Statement","Repository","OrderDirection","InternalError","GroupOperator","Operator","Sequence","NotFoundError","DefaultSeparator","PersistenceKeys","TypeORMRepository","Context","OperationKeys","enforceDBDecorators","ValidationError","__decorate","uses","Model","EventSubscriber","Dispatch","getMetadataArgsStorage","ColumnTypeUndefinedError","ObjectUtils","PrimaryColumnCannotBeNullableError","Adapter","DataSource","Reflection","ValidationKeys","DBKeys","In","ConflictError","ConnectionError","Logging","DEFAULT_ERROR_MESSAGES","Decoration","required","readonly","propMetadata","apply","Validation","type","VersionColumn","UpdateValidationKeys","date","DB_DEFAULT_ERROR_MESSAGES","Cascade","prop","OneToOne","JoinColumn","list","OneToMany","ManyToOne","ManyToMany","JoinTable","final"],"mappings":"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"}