@decaf-ts/for-typeorm 0.0.6

package/dist/for-typeorm.esm.cjs

@@ -0,0 +1,2538 @@
+import { __decorate, __metadata } from 'tslib';
+import { Paginator, PagingError, QueryError, Statement, Repository, OrderDirection, GroupOperator, Operator, Sequence, PersistenceKeys, uses, Dispatch, Adapter, ConnectionError, Cascade, final } from '@decaf-ts/core';
+import { BaseError, findPrimaryKey, InternalError, NotFoundError, DefaultSeparator, Context, OperationKeys, enforceDBDecorators, ValidationError, DBKeys, ConflictError, readonly, UpdateValidationKeys, DEFAULT_ERROR_MESSAGES as DEFAULT_ERROR_MESSAGES$1 } from '@decaf-ts/db-decorators';
+import 'reflect-metadata';
+import { ModelKeys, Model, ValidationKeys, DEFAULT_ERROR_MESSAGES, Decoration, propMetadata, Validation, type, prop, list, required, date } from '@decaf-ts/decorator-validation';
+import { Reflection, apply } from '@decaf-ts/reflection';
+import { Logging } from '@decaf-ts/logging';
+import { EventSubscriber, getMetadataArgsStorage, ColumnTypeUndefinedError, PrimaryColumnCannotBeNullableError, DataSource, In, VersionColumn, OneToOne, JoinColumn, OneToMany, ManyToOne, ManyToMany, JoinTable } from 'typeorm';
+import { ObjectUtils } from 'typeorm/util/ObjectUtils';
+
+/**
+ * @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 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
+ */
+var SQLOperator;
+(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";
+})(SQLOperator || (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: SQLOperator.EQUAL,
+    DIFFERENT: SQLOperator.NOT_EQUAL,
+    BIGGER: SQLOperator.GREATER_THAN,
+    BIGGER_EQ: SQLOperator.GREATER_THAN_OR_EQUAL,
+    SMALLER: SQLOperator.LESS_THAN,
+    SMALLER_EQ: SQLOperator.LESS_THAN_OR_EQUAL,
+    BETWEEN: SQLOperator.BETWEEN,
+    NOT: "NOT",
+    IN: SQLOperator.IN,
+    IS_NULL: SQLOperator.IS_NULL,
+    IS_NOT_NULL: SQLOperator.IS_NOT_NULL,
+    REGEXP: "~",
+    IREGEXP: "~*",
+    LIKE: SQLOperator.LIKE,
+    ILIKE: 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 Paginator {
+    /**
+     * @description Gets the total number of pages
+     * @summary Returns the total number of pages based on the record count and page size
+     * @return {number} The total number of pages
+     */
+    get total() {
+        return this._totalPages;
+    }
+    /**
+     * @description Gets the total record count
+     * @summary Returns the total number of records matching the query
+     * @return {number} The total record count
+     */
+    get count() {
+        return this._recordCount;
+    }
+    get repo() {
+        if (!this.__repo) {
+            this.__repo = this.adapter.dataSource.getRepository(this.clazz[ModelKeys.ANCHOR]);
+        }
+        return this.__repo;
+    }
+    /**
+     * @description Creates a new TypeORMPaginator instance.
+     * @summary Initializes a paginator for TypeORM query results.
+     * @param {TypeORMAdapter} adapter The TypeORM adapter.
+     * @param {TypeORMQuery} query The TypeORM query container to paginate.
+     * @param {number} size The page size.
+     * @param {Constructor<M>} clazz The model constructor.
+     */
+    constructor(adapter, query, size, clazz) {
+        super(adapter, query, size, clazz);
+    }
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {TypeORMQuery} rawStatement - The original PostgreSQL query
+     * @return {TypeORMQuery} The prepared query with pagination parameters
+     */
+    prepare(rawStatement) {
+        const query = { ...rawStatement };
+        return query;
+    }
+    /**
+     * @description Retrieves a specific page of results.
+     * @summary Executes the query with pagination and processes the results.
+     * @param {number} [page=1] The page number to retrieve.
+     * @return {Promise<R[]>} A promise that resolves to an array of results.
+     * @throws {PagingError} If trying to access an invalid page or if no class is defined.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant Paginator as TypeORMPaginator
+     *   participant Adapter
+     *   participant DB as Database
+     *
+     *   Client->>Paginator: page(pageNumber)
+     *   Note over Paginator: Prepare options (skip/take)
+     *
+     *   alt First time or need count
+     *     Paginator->>Adapter: Get count
+     *     Adapter->>DB: Execute COUNT
+     *     DB-->>Adapter: count
+     *     Adapter-->>Paginator: count
+     *     Paginator->>Paginator: Calculate total pages
+     *   end
+     *
+     *   Paginator->>Adapter: Execute query
+     *   Adapter->>DB: findAndCount(options)
+     *   DB-->>Adapter: rows, count
+     *   Adapter-->>Paginator: rows, count
+     *
+     *   Paginator->>Paginator: Map rows to models
+     *   Paginator-->>Client: results
+     */
+    async page(page = 1) {
+        const statement = { ...this.statement };
+        // Get total count if not already calculated
+        if (!this._recordCount || !this._totalPages) {
+            this._totalPages = this._recordCount = 0;
+        }
+        const opts = Object.assign(statement, {
+            skip: (this.current || 0) * this.size,
+            take: this.size,
+        });
+        // this.validatePage(page);
+        const result = await this.repo.findAndCount(opts);
+        this._recordCount = result[1];
+        this._totalPages = Math.ceil(this._recordCount / this.size);
+        if (!this.clazz)
+            throw new PagingError("No statement target defined");
+        const pkDef = findPrimaryKey(new this.clazz());
+        const rows = result[0] || [];
+        const results = 
+        // statement.columns && statement.columns.length
+        //   ? rows // has columns means it's not full model
+        rows.map((row) => {
+            return this.adapter.revert(row, this.clazz, pkDef.id, row[pkDef.id]);
+        });
+        this._currentPage = page;
+        return results;
+    }
+}
+
+/**
+ * @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 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 Statement {
+    constructor(adapter) {
+        super(adapter);
+    }
+    /**
+     * @description Builds a TypeORM SelectQueryBuilder from the statement.
+     * @summary Converts the statement's conditions, selectors, and options into a TypeORM-backed query object.
+     * @return {TypeORMQuery} The built TypeORM query container.
+     * @throws {Error} If there are invalid query conditions.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize query
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add columns to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed conditions
+     *     Statement->>Statement: Add conditions to query
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add orderBy to query
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set offset
+     *   end
+     *
+     *   Statement-->>Statement: Return query
+     */
+    build() {
+        const log = this.log.for(this.build);
+        const tableName = Repository.table(this.fromSelector);
+        const m = new this.fromSelector();
+        const q = {
+            query: this.adapter.dataSource
+                .getRepository(this.fromSelector[ModelKeys.ANCHOR])
+                .createQueryBuilder(tableName),
+        };
+        if (this.selectSelector)
+            q.query = q.query.select(this.selectSelector.map((s) => `${tableName}.${s}`));
+        else
+            q.query = q.query.select();
+        //
+        // q.query = (q.query as SelectQueryBuilder<any>).from(
+        //   this.fromSelector[ModelKeys.ANCHOR as keyof typeof this.fromSelector],
+        //   tableName
+        // );
+        if (this.whereCondition)
+            q.query = this.parseCondition(this.whereCondition, tableName, q.query).query;
+        let orderByArgs;
+        if (!this.orderBySelector)
+            orderByArgs = [
+                `${tableName}.${findPrimaryKey(m).id}`,
+                OrderDirection.ASC.toUpperCase(),
+            ];
+        else
+            orderByArgs = [
+                `${tableName}.${this.orderBySelector[0]}`,
+                this.orderBySelector[1].toUpperCase(),
+            ];
+        q.query = q.query.orderBy(...orderByArgs);
+        if (this.limitSelector) {
+            q.query = q.query.limit(this.limitSelector);
+        }
+        else {
+            log.debug(`No limit selector defined. Using default limit of ${TypeORMQueryLimit}`);
+            q.query = q.query.limit(TypeORMQueryLimit);
+        }
+        // Add offset
+        if (this.offsetSelector)
+            q.query = q.query.skip(this.offsetSelector);
+        return q;
+    }
+    /**
+     * @description Creates a paginator for the statement.
+     * @summary Builds the query and returns a TypeORMPaginator for paginated results.
+     * @template R The result type.
+     * @param {number} size The page size.
+     * @return {Promise<Paginator<M, R, TypeORMQuery>>} A promise that resolves to a paginator.
+     * @throws {InternalError} If there's an error building the query.
+     */
+    async paginate(size) {
+        try {
+            const query = this.build();
+            const transformedQuery = {};
+            const a = query.query;
+            if (this.whereCondition)
+                transformedQuery.where = this.parseConditionForPagination(this.whereCondition, Repository.table(this.fromSelector));
+            if (this.orderBySelector)
+                transformedQuery.order = {
+                    [this.orderBySelector[0]]: this.orderBySelector[1].toString(),
+                };
+            return new TypeORMPaginator(this.adapter, transformedQuery, size, this.fromSelector);
+        }
+        catch (e) {
+            throw new InternalError(e);
+        }
+    }
+    /**
+     * @description Processes a record.
+     * @summary Converts a raw result row to a model instance using the adapter.
+     * @param {any} r The raw record.
+     * @param {keyof M} pkAttr The primary key attribute of the model.
+     * @param {"Number" | "BigInt" | undefined} sequenceType The type of the sequence.
+     * @return {any} The processed record.
+     */
+    processRecord(r, pkAttr) {
+        if (typeof r[pkAttr] !== "undefined") {
+            return this.adapter.revert(r, this.fromSelector, pkAttr, r[pkAttr]);
+        }
+        return r;
+    }
+    /**
+     * @description Executes a raw TypeORM query builder.
+     * @summary Sends the built SelectQueryBuilder to the database via TypeORM and returns the results.
+     * @template R The result type.
+     * @param {TypeORMQuery} rawInput The query container to execute.
+     * @return {Promise<R>} A promise that resolves to the query results.
+     */
+    async raw(rawInput) {
+        const log = this.log.for(this.raw);
+        log.debug(`Executing raw query: ${rawInput.query.getSql()}`);
+        return (await rawInput.query.getMany());
+    }
+    parseConditionForPagination(condition, tableName, counter = 0, conditionalOp) {
+        throw new InternalError("Not implemented");
+    }
+    /**
+     * @description Parses a condition into PostgreSQL conditions
+     * @summary Converts a Condition object into PostgreSQL condition structures
+     * @param {Condition<M>} condition - The condition to parse
+     * @param {string} [tableName] - the positional index of the arguments
+     * @return {TypeORMQuery} The PostgresSQL condition
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return PostgreSQL operator
+     *     Statement->>Statement: Create condition with column, operator, and value
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: Add NOT to conditions
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>Statement: Combine conditions with AND/OR
+     *   end
+     *
+     *   Statement-->>Statement: Return conditions array
+     */
+    parseCondition(condition, tableName, qb, counter = 0, conditionalOp) {
+        const { attr1, operator, comparison } = condition;
+        function parse() {
+            const sqlOperator = translateOperators(operator);
+            const attrRef = `${attr1}${counter}`;
+            const queryStr = `${tableName}.${attr1} ${sqlOperator} :${attrRef}`;
+            const values = {
+                [attrRef]: comparison,
+            };
+            switch (conditionalOp) {
+                case GroupOperator.AND:
+                    return {
+                        query: qb.andWhere(queryStr, values),
+                    };
+                case GroupOperator.OR:
+                    return {
+                        query: qb.orWhere(queryStr, values),
+                    };
+                case Operator.NOT:
+                    throw new Error("NOT operator not implemented");
+                default:
+                    return {
+                        query: qb.where(queryStr, values),
+                    };
+            }
+        }
+        if ([GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(operator) === -1) {
+            return parse();
+        }
+        // For NOT operator
+        else if (operator === Operator.NOT) {
+            throw new Error("NOT operator not implemented");
+        }
+        // For AND/OR operators
+        else {
+            qb = this.parseCondition(attr1, tableName, qb, ++counter)
+                .query;
+            return this.parseCondition(comparison, tableName, qb, ++counter, operator);
+        }
+    }
+}
+
+/**
+ * @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 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 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 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 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 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 = 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 = Repository.indexes(m);
+        Object.entries(ind).forEach(([key, value]) => {
+            const k = Object.keys(value)[0];
+            let { compositions } = value[k];
+            const tableName = Repository.table(m);
+            compositions = compositions || [];
+            function generate() {
+                const name = [key, ...compositions, PersistenceKeys.INDEX].join(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
+ */
+let TypeORMRepository = class TypeORMRepository extends 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[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[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[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[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[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 Context.args(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 enforceDBDecorators(this, contextArgs.context, m, OperationKeys.CREATE, 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 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[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[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[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[ModelKeys.ANCHOR], keys, this.pk, ...args);
+        return results.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+    }
+};
+TypeORMRepository = __decorate([
+    uses(TypeORMFlavour),
+    __metadata("design:paramtypes", [TypeORMAdapter, Object, Object])
+], 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 = Model.get(event.entity.constructor.name);
+        if (!constructor)
+            throw new InternalError(`No registered model found for ${event.entity.constructor.name}`);
+        const tableName = Repository.table(constructor);
+        this.handler(tableName, 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 = Model.get(event.entity.constructor.name);
+        if (!constructor)
+            throw new InternalError(`No registered model found for ${event.entity.constructor.name}`);
+        const tableName = Repository.table(constructor);
+        this.handler(tableName, 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 = Model.get(event.databaseEntity.constructor.name);
+        if (!constructor)
+            throw new InternalError(`No registered model found for ${event.databaseEntity.constructor.name}`);
+        const tableName = Repository.table(constructor);
+        return this.handler(tableName, OperationKeys.UPDATE, [
+            event.entity["id"],
+        ]);
+    }
+};
+TypeORMEventSubscriber = __decorate([
+    EventSubscriber(),
+    __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 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 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 InternalError(e);
+            }
+        }
+        subscribeToTypeORM
+            .call(this)
+            .then(() => {
+            this.log.info(`Subscribed to TypeORM notifications`);
+        })
+            .catch((e) => {
+            throw new 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
+            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 ColumnTypeUndefinedError(object, propertyName);
+            // create unique
+            if (options.unique === true)
+                getMetadataArgsStorage().uniques.push({
+                    target: object.constructor,
+                    columns: [propertyName],
+                });
+            const columns = getMetadataArgsStorage().columns;
+            aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+            if (options.generated) {
+                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 = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, {}, "updateDate");
+    };
+}
+
+function CreateDateColumn(options) {
+    return function (object, propertyName) {
+        const columns = 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.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 = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+        // register generated metadata args
+        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 ColumnTypeUndefinedError(object, propertyName);
+        // check if column is not nullable, because we cannot allow a primary key to be nullable
+        if (options.nullable)
+            throw new PrimaryColumnCannotBeNullableError(object, propertyName);
+        // explicitly set a primary to column options
+        options.primary = true;
+        const columns = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+        if (options.generated) {
+            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.isObject(nameOrOptions)
+        ? nameOrOptions
+        : maybeOptions) || {};
+    const name = options.name;
+    return function (target) {
+        const tables = 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 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 Adapter {
+    get dataSource() {
+        if (!this._dataSource) {
+            const models = Adapter.models(this.flavour);
+            this._dataSource = new DataSource(Object.assign(this.native, {
+                entities: models.map((c) => c[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 === OperationKeys.CREATE) {
+            const pk = findPrimaryKey(m).id;
+            exceptions.push(pk);
+        }
+        if (operation === OperationKeys.CREATE ||
+            operation === OperationKeys.UPDATE) {
+            const decs = Object.keys(m).reduce((accum, key) => {
+                const decs = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, m, key, true);
+                const dec = decs.decorators.find((dec) => dec.key === 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 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 === PersistenceKeys.METADATA || this.isReserved(key))
+                return accum;
+            if (value === undefined) {
+                return accum;
+            }
+            if (value instanceof Date) {
+                value = new Date(value.getTime());
+            }
+            else if (Model.isModel(value)) {
+                value = this.prepare(value, findPrimaryKey(value).id, true).record;
+            }
+            else {
+                switch (typeof value) {
+                    case "string":
+                        value = `${value}`;
+                        break;
+                    //do nothing;
+                }
+            }
+            accum[key] = value;
+            return accum;
+        }, {});
+        const constr = Model.get(model.constructor.name);
+        if (!constr)
+            throw new InternalError(`Model ${model.constructor.name} not found in registry`);
+        const result = child
+            ? new constr[ModelKeys.ANCHOR]()
+            : new constr();
+        if (child)
+            Object.defineProperty(result, "constructor", {
+                configurable: false,
+                enumerable: false,
+                value: constr[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 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 NotFoundError(`Record with id: ${id} not found in table ${typeof tableName === "string" ? tableName : 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]: 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 BaseError)
+            return err;
+        const code = typeof err === "string" ? err : err.message;
+        if (code.match(/duplicate key|already exists/g))
+            return new ConflictError(code);
+        if (code.match(/does not exist|not found/g))
+            return new 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 ConflictError(reason);
+            // Object not found errors
+            case "42P01": // undefined_table
+            case "42703": // undefined_column
+                return new 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 ConnectionError(err);
+                return new InternalError(err);
+        }
+    }
+    static async connect(config) {
+        const con = new DataSource(config);
+        if (!con.isInitialized)
+            await con.initialize();
+        return con;
+    }
+    static async createDatabase(dataSource, dbName) {
+        const log = 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.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 = Model.get(type);
+                if (m) {
+                    const mm = new m();
+                    const type = Reflection.getTypeFromDecorator(mm, findPrimaryKey(mm).id);
+                    return {
+                        model: m,
+                        pkType: type,
+                    };
+                }
+                throw new InternalError(`Unsupported type: ${type}`);
+            }
+        }
+    }
+    static parseValidationToPostgres(prop, type, isPk, key, options) {
+        switch (key) {
+            case ValidationKeys.REQUIRED:
+                return "NOT NULL";
+            case ValidationKeys.MAX_LENGTH:
+                if (isPk || !options || type.toLowerCase() !== "string") {
+                    return "";
+                }
+                return `(${options[ValidationKeys.MAX_LENGTH]})`;
+            case ValidationKeys.MIN_LENGTH:
+                return `CONSTRAINT ${prop}_min_length_check CHECK (LENGTH(${prop}) >= ${options[ValidationKeys.MIN_LENGTH]})`;
+            case ValidationKeys.PATTERN:
+            case ValidationKeys.URL:
+            case ValidationKeys.EMAIL:
+                return `CONSTRAINT ${prop}_pattern_check CHECK (${prop} ~ '${convertJsRegexToPostgres(options[ValidationKeys.PATTERN])}')`;
+            case ValidationKeys.TYPE:
+            case ValidationKeys.DATE:
+                return "";
+            case ValidationKeys.MIN:
+                return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} >= ${options[ValidationKeys.MIN]})`;
+            case ValidationKeys.MAX:
+                return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} <= ${options[ValidationKeys.MAX]})`;
+            case ValidationKeys.PASSWORD:
+            default:
+                throw new InternalError(`Unsupported type: ${key}`);
+        }
+    }
+    static parseRelationsToPostgres(prop, clazz, pk, key, options) {
+        const tableName = Repository.table(clazz);
+        const { cascade } = options;
+        const cascadeStr = `${cascade.update ? " ON UPDATE CASCADE" : ""}${cascade.delete ? " ON DELETE CASCADE" : ""}`;
+        switch (`relations${key}`) {
+            case PersistenceKeys.ONE_TO_ONE:
+                return `FOREIGN KEY (${prop}) REFERENCES ${tableName}(${pk})${cascadeStr}`;
+            default:
+                throw new InternalError(`Unsupported operation: ${key}`);
+        }
+    }
+    static async createTable(client, model) {
+        const result = {};
+        const m = new model({});
+        const tableName = Repository.table(model);
+        const { id } = 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 = Repository.column(m, prop.toString());
+            const allDecs = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, m, prop.toString(), false, true);
+            const decoratorData = allDecs.decorators.reduce((accum, el) => {
+                const { key, props } = el;
+                if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {
+                    accum[ValidationKeys.TYPE] = {
+                        customTypes: [props.name],
+                        message: DEFAULT_ERROR_MESSAGES.TYPE,
+                        description: "defines the accepted types for the attribute",
+                    };
+                }
+                else if (key !== ValidationKeys.TYPE) {
+                    // do nothing. we can only support basis ctypes at this time
+                    accum[key] = props;
+                }
+                return accum;
+            }, {});
+            const dbDecs = Reflection.getPropertyDecorators(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[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 = findPrimaryKey(m);
+                        typeStr = this.parseTypeToPostgres(parsedType.pkType, false, true);
+                        await this.createTable(client, childClass);
+                    }
+                    catch (e) {
+                        if (!(e instanceof 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, ValidationKeys.MAX_LENGTH, decoratorData[ValidationKeys.MAX_LENGTH] || {
+                    [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]) => ![ValidationKeys.TYPE, 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 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 = Adapter.key(PersistenceKeys.TABLE);
+        Decoration.flavouredAs(TypeORMFlavour)
+            .for(tableKey)
+            .extend((original) => Entity()(original[ModelKeys.ANCHOR] || original))
+            .apply();
+        // @pk() => @PrimaryGeneratedColumn() | @PrimaryColumn()
+        const pkKey = Repository.key(DBKeys.ID);
+        function pkDec(options) {
+            const decorators = [
+                required(),
+                readonly(),
+                propMetadata(pkKey, options),
+            ];
+            if (options.type)
+                decorators.push(PrimaryGeneratedColumn());
+            else
+                decorators.push(PrimaryColumn({ unique: true }));
+            return apply(...decorators);
+        }
+        Decoration.flavouredAs(TypeORMFlavour)
+            .for(pkKey)
+            .define({
+            decorator: pkDec,
+        })
+            .apply();
+        // @column("columnName") => @Column({name: "columnName"})
+        const columnKey = Adapter.key(PersistenceKeys.COLUMN);
+        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 = Adapter.key(PersistenceKeys.UNIQUE);
+        Decoration.flavouredAs(TypeORMFlavour)
+            .for(uniqueKey)
+            .define(propMetadata(uniqueKey, {}))
+            .extend(Column({ unique: true }))
+            .apply();
+        // @required => @Column({ nullable: false })
+        const requiredKey = Validation.key(ValidationKeys.REQUIRED);
+        Decoration.flavouredAs(TypeORMFlavour)
+            .for(requiredKey)
+            .extend(Column({ nullable: false }))
+            .apply();
+        // @version => @VersionColumn()
+        const versionKey = Repository.key(DBKeys.VERSION);
+        Decoration.flavouredAs(TypeORMFlavour)
+            .for(versionKey)
+            .define(type(Number.name), VersionColumn())
+            .apply();
+        function ValidationUpdateKey(key) {
+            return UpdateValidationKeys.REFLECT + key;
+        }
+        // @timestamp(op) => @CreateDateColumn() || @UpdateDateColumn()
+        const timestampKey = ValidationUpdateKey(DBKeys.TIMESTAMP);
+        function ts(operation, format) {
+            const decorators = [
+                date(format, DEFAULT_ERROR_MESSAGES$1.TIMESTAMP.DATE),
+                required(DEFAULT_ERROR_MESSAGES$1.TIMESTAMP.REQUIRED),
+                propMetadata(Validation.key(DBKeys.TIMESTAMP), {
+                    operation: operation,
+                    format: format,
+                }),
+            ];
+            if (operation.indexOf(OperationKeys.UPDATE) !== -1)
+                decorators.push(propMetadata(timestampKey, {
+                    message: DEFAULT_ERROR_MESSAGES$1.TIMESTAMP.INVALID,
+                }));
+            else
+                decorators.push(readonly());
+            return apply(...decorators);
+        }
+        Decoration.flavouredAs(TypeORMFlavour)
+            .for(timestampKey)
+            .define({
+            decorator: ts,
+        })
+            .extend({
+            decorator: function timestamp(...ops) {
+                return function timestamp(obj, prop) {
+                    if (ops.indexOf(OperationKeys.UPDATE) !== -1)
+                        return UpdateDateColumn()(obj, prop);
+                    return CreateDateColumn()(obj, prop);
+                };
+            },
+            transform: (args) => {
+                return args[0];
+            },
+        })
+            .apply();
+        // @oneToOne(clazz) => @OneToOne(() => clazz)
+        const oneToOneKey = Repository.key(PersistenceKeys.ONE_TO_ONE);
+        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 === Cascade.CASCADE ||
+                        cascade.delete === Cascade.CASCADE,
+                    onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                    onUpdate: cascade.update ? "CASCADE" : "DEFAULT",
+                    nullable: true,
+                    eager: populate,
+                };
+                return apply(prop(PersistenceKeys.RELATIONS), type([
+                    (typeof clazz === "function" && !clazz.name
+                        ? clazz
+                        : clazz.name),
+                    String.name,
+                    Number.name,
+                    BigInt.name,
+                ]), propMetadata(oneToOneKey, metadata), OneToOne(() => {
+                    if (!clazz.name)
+                        clazz = clazz();
+                    if (!clazz[ModelKeys.ANCHOR])
+                        throw new InternalError("Original Model not found in constructor");
+                    return clazz[ModelKeys.ANCHOR];
+                }, (model) => {
+                    const pk = findPrimaryKey(new clazz()).id;
+                    return model[pk];
+                }, ormMeta), JoinColumn());
+            },
+        })
+            .apply();
+        // @oneToMany(clazz) => @OneToMany(() => clazz)
+        const oneToManyKey = Repository.key(PersistenceKeys.ONE_TO_MANY);
+        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 apply(prop(PersistenceKeys.RELATIONS), list(clazz), propMetadata(oneToManyKey, metadata), function OneToManyWrapper(obj, prop) {
+                    const ormMeta = {
+                        cascade: cascade.update === Cascade.CASCADE ||
+                            cascade.delete === Cascade.CASCADE,
+                        onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                        onUpdate: cascade.update ? "CASCADE" : "DEFAULT",
+                        nullable: true,
+                        eager: populate,
+                    };
+                    return OneToMany(() => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        if (!clazz[ModelKeys.ANCHOR])
+                            throw new InternalError("Original Model not found in constructor");
+                        return clazz[ModelKeys.ANCHOR];
+                    }, (model) => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        const m = new clazz();
+                        const crossRelationKey = Object.keys(m).find((k) => {
+                            const decs = Reflection.getPropertyDecorators(Repository.key(PersistenceKeys.MANY_TO_ONE), m, k, true);
+                            if (!decs || !decs.decorators || !decs.decorators.length)
+                                return false;
+                            const designType = Reflect.getMetadata(ModelKeys.TYPE, m, k);
+                            if (!designType)
+                                throw new InternalError(`No Type Definition found for ${k} in ${m.constructor.name}`);
+                            return designType.name === obj.constructor.name;
+                        });
+                        if (!crossRelationKey)
+                            throw new 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 = Repository.key(PersistenceKeys.MANY_TO_ONE);
+        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 === Cascade.CASCADE ||
+                        cascade.delete === Cascade.CASCADE,
+                    onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                    onUpdate: cascade.update ? "CASCADE" : "DEFAULT"});
+                return apply(prop(PersistenceKeys.RELATIONS), type([
+                    (typeof clazz === "function" && !clazz.name
+                        ? clazz
+                        : clazz.name),
+                    String.name,
+                    Number.name,
+                    BigInt.name,
+                ]), propMetadata(manyToOneKey, metadata), function ManyToOneWrapper(obj, prop) {
+                    return ManyToOne(() => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        if (!clazz[ModelKeys.ANCHOR])
+                            throw new InternalError("Original Model not found in constructor");
+                        return clazz[ModelKeys.ANCHOR];
+                    }, (model) => {
+                        if (!clazz.name)
+                            clazz = clazz();
+                        const m = new clazz();
+                        const crossRelationKey = Object.keys(m).find((k) => {
+                            const decs = Reflection.getPropertyDecorators(Repository.key(PersistenceKeys.ONE_TO_MANY), m, k, true);
+                            if (!decs || !decs.decorators || !decs.decorators.length)
+                                return false;
+                            const listDec = Reflect.getMetadata(Validation.key(ValidationKeys.LIST), m, k);
+                            if (!listDec)
+                                throw new 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 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 = Repository.key(PersistenceKeys.MANY_TO_MANY);
+        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 === Cascade.CASCADE ||
+                        cascade.delete === Cascade.CASCADE,
+                    onDelete: cascade.delete ? "CASCADE" : "DEFAULT",
+                    onUpdate: cascade.update ? "CASCADE" : "DEFAULT",
+                    nullable: true,
+                    eager: populate,
+                };
+                return apply(prop(PersistenceKeys.RELATIONS), list(clazz), propMetadata(manyToManyKey, metadata), ManyToMany(() => {
+                    if (!clazz.name)
+                        clazz = clazz();
+                    if (!clazz[ModelKeys.ANCHOR])
+                        throw new InternalError("Original Model not found in constructor");
+                    return clazz[ModelKeys.ANCHOR];
+                }, (model) => {
+                    if (!clazz.name)
+                        clazz = clazz();
+                    const pk = findPrimaryKey(new clazz()).id;
+                    return model[pk];
+                }, ormMeta), JoinTable());
+            },
+        })
+            .apply();
+    }
+}
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", TypeORMDispatch)
+], TypeORMAdapter.prototype, "Dispatch", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], TypeORMAdapter.prototype, "repository", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", TypeORMStatement)
+], TypeORMAdapter.prototype, "Statement", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TypeORMAdapter.prototype, "Sequence", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __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";
+
+export { IndexError, SQLOperator, TypeORMAdapter, TypeORMConst, TypeORMDispatch, TypeORMFlavour, TypeORMGroupOperator, TypeORMKeys, TypeORMOperator, TypeORMPaginator, TypeORMQueryLimit, TypeORMRepository, TypeORMSequence, TypeORMStatement, VERSION, convertJsRegexToPostgres, createdByOnPostgresCreateUpdate, generateIndexes, reservedAttributes, translateOperators };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-typeorm.esm.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":["DB_DEFAULT_ERROR_MESSAGES"],"mappings":"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"}