@decaf-ts/for-typeorm 0.0.6

package/lib/esm/TypeORMAdapter.js

@@ -0,0 +1,1124 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Adapter, Cascade, ConnectionError, final, PersistenceKeys, Repository, } from "@decaf-ts/core";
+import { reservedAttributes, TypeORMFlavour } from "./constants.js";
+import { BaseError, ConflictError, DBKeys, DEFAULT_ERROR_MESSAGES as DB_DEFAULT_ERROR_MESSAGES, findPrimaryKey, InternalError, NotFoundError, OperationKeys, readonly, UpdateValidationKeys, } from "@decaf-ts/db-decorators";
+import "reflect-metadata";
+import { date, Decoration, DEFAULT_ERROR_MESSAGES, list, Model, ModelKeys, prop, propMetadata, required, type, Validation, ValidationKeys, } from "@decaf-ts/decorator-validation";
+import { IndexError } from "./errors.js";
+import { TypeORMStatement } from "./query/index.js";
+import { TypeORMSequence } from "./sequences/index.js";
+import { generateIndexes } from "./indexes/index.js";
+import { apply, Reflection } from "@decaf-ts/reflection";
+import { TypeORMRepository } from "./TypeORMRepository.js";
+import { Logging } from "@decaf-ts/logging";
+import { TypeORMDispatch } from "./TypeORMDispatch.js";
+import { convertJsRegexToPostgres } from "./utils.js";
+import { DataSource, In, OneToOne, JoinColumn, ManyToMany, VersionColumn, OneToMany, ManyToOne, JoinTable, } from "typeorm";
+import { Column } from "./overrides/Column.js";
+import { UpdateDateColumn } from "./overrides/UpdateDateColumn.js";
+import { CreateDateColumn } from "./overrides/CreateDateColumn.js";
+import { PrimaryGeneratedColumn } from "./overrides/PrimaryGeneratedColumn.js";
+import { PrimaryColumn } from "./overrides/PrimaryColumn.js";
+import { Entity } from "./overrides/Entity.js";
+export 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
+ */
+export 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;
+                    default:
+                    //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 (false || (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, DB_DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),
+                required(DB_DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),
+                propMetadata(Validation.key(DBKeys.TIMESTAMP), {
+                    operation: operation,
+                    format: format,
+                }),
+            ];
+            if (operation.indexOf(OperationKeys.UPDATE) !== -1)
+                decorators.push(propMetadata(timestampKey, {
+                    message: DB_DEFAULT_ERROR_MESSAGES.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,
+                };
+                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(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);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TypeORMAdapter.js","sourceRoot":"","sources":["../../src/TypeORMAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}