@cheetah.js/orm 0.1.45 → 0.1.47

package/dist/query/sql-column-manager.d.ts

@@ -0,0 +1,25 @@
+import { Statement } from '../driver/driver.interface';
+import { EntityStorage, Options } from '../domain/entities';
+export declare class SqlColumnManager {
+    private entityStorage;
+    private statements;
+    private entity;
+    constructor(entityStorage: EntityStorage, statements: Statement<any>, entity: Options);
+    generateColumns(model: Function, updatedColumns: string[]): string[];
+    processUserColumns(columns: string[]): string[];
+    getColumnsForEntity(entity: Function, alias: string): string[];
+    discoverAlias(column: string, onlyAlias?: boolean): string | undefined;
+    private getJoinColumns;
+    private getPropertyColumns;
+    private getRelationColumns;
+    private extractAliases;
+    private filterValid;
+    private isNestedColumn;
+    private buildSimpleColumnAlias;
+    private buildNestedColumnAlias;
+    private validateJoinsExist;
+    private resolveNestedAlias;
+    private buildJoinMaps;
+    private findNextAlias;
+    private formatColumnWithAlias;
+}

package/dist/query/sql-column-manager.js

@@ -0,0 +1,124 @@
+export class SqlColumnManager {
+    constructor(entityStorage, statements, entity) {
+        this.entityStorage = entityStorage;
+        this.statements = statements;
+        this.entity = entity;
+    }
+    generateColumns(model, updatedColumns) {
+        const baseColumns = this.getColumnsForEntity(model, this.statements.alias);
+        const joinColumns = this.getJoinColumns();
+        const allColumns = [...baseColumns, ...joinColumns];
+        return [...allColumns, ...updatedColumns];
+    }
+    processUserColumns(columns) {
+        const aliasedColumns = this.extractAliases(columns);
+        return this.filterValid(aliasedColumns);
+    }
+    getColumnsForEntity(entity, alias) {
+        const entityOptions = this.entityStorage.get(entity);
+        if (!entityOptions) {
+            throw new Error('Entity not found');
+        }
+        const propertyColumns = this.getPropertyColumns(entityOptions, alias);
+        const relationColumns = this.getRelationColumns(entityOptions, alias);
+        return [...propertyColumns, ...relationColumns];
+    }
+    discoverAlias(column, onlyAlias = false) {
+        if (!this.isNestedColumn(column)) {
+            return this.buildSimpleColumnAlias(column, this.statements.alias, onlyAlias);
+        }
+        return this.buildNestedColumnAlias(column, onlyAlias);
+    }
+    getJoinColumns() {
+        if (!this.statements.join) {
+            return [];
+        }
+        return this.statements.join.flatMap(join => this.getColumnsForEntity(join.joinEntity, join.joinAlias));
+    }
+    getPropertyColumns(entityOptions, alias) {
+        return Object.keys(entityOptions.properties).map(key => {
+            const columnName = entityOptions.properties[key].options.columnName;
+            return `${alias}."${columnName}" as "${alias}_${columnName}"`;
+        });
+    }
+    getRelationColumns(entityOptions, alias) {
+        if (!entityOptions.relations) {
+            return [];
+        }
+        return entityOptions.relations
+            .filter(relation => relation.relation === 'many-to-one')
+            .map(relation => `${alias}."${relation.columnName}" as "${alias}_${relation.columnName}"`);
+    }
+    extractAliases(columns) {
+        return columns
+            .map(column => this.discoverAlias(column))
+            .flat()
+            .filter((col) => col !== undefined);
+    }
+    filterValid(columns) {
+        return columns.filter(Boolean);
+    }
+    isNestedColumn(column) {
+        return column.includes('.');
+    }
+    buildSimpleColumnAlias(column, alias, onlyAlias) {
+        if (onlyAlias) {
+            return `${alias}."${column}"`;
+        }
+        return `${alias}."${column}" as ${alias}_${column}`;
+    }
+    buildNestedColumnAlias(column, onlyAlias) {
+        this.validateJoinsExist();
+        const parts = column.split('.');
+        const aliasInfo = this.resolveNestedAlias(parts);
+        if (!aliasInfo) {
+            return undefined;
+        }
+        return this.formatColumnWithAlias(aliasInfo.alias, parts[parts.length - 1], onlyAlias);
+    }
+    validateJoinsExist() {
+        if (!this.statements.join && !this.statements.selectJoin) {
+            throw new Error('Join not found');
+        }
+    }
+    resolveNestedAlias(parts) {
+        const joinMaps = this.buildJoinMaps();
+        let currentAlias = this.statements.alias;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLastPart = i === parts.length - 1;
+            if (isLastPart) {
+                return { alias: currentAlias };
+            }
+            const nextAlias = this.findNextAlias(part, joinMaps, i === 0);
+            if (!nextAlias) {
+                return null;
+            }
+            currentAlias = nextAlias;
+        }
+        return { alias: currentAlias };
+    }
+    buildJoinMaps() {
+        const relationsMap = new Map(this.entity.relations.map(rel => [rel.propertyKey, rel]));
+        const joinMap = new Map();
+        this.statements.join?.forEach(join => joinMap.set(join.joinProperty, join));
+        const selectJoinMap = new Map();
+        this.statements.selectJoin?.forEach(join => selectJoinMap.set(join.joinProperty, join));
+        return { joinMap, selectJoinMap, relationsMap };
+    }
+    findNextAlias(part, maps, isFirstPart) {
+        if (maps.joinMap.has(part)) {
+            return maps.joinMap.get(part).joinAlias;
+        }
+        if (maps.selectJoinMap.has(part)) {
+            return null;
+        }
+        return null;
+    }
+    formatColumnWithAlias(alias, columnName, onlyAlias) {
+        if (onlyAlias) {
+            return `${alias}."${columnName}"`;
+        }
+        return `${alias}."${columnName}" as ${alias}_${columnName}`;
+    }
+}

package/dist/query/sql-condition-builder.d.ts

@@ -0,0 +1,36 @@
+import { FilterQuery, Relationship, Statement } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+type ApplyJoinCallback = (relationship: Relationship<any>, value: FilterQuery<any>, alias: string) => string;
+export declare class SqlConditionBuilder<T> {
+    private entityStorage;
+    private applyJoinCallback;
+    private statements;
+    private readonly OPERATORS;
+    private lastKeyNotOperator;
+    constructor(entityStorage: EntityStorage, applyJoinCallback: ApplyJoinCallback, statements: Statement<T>);
+    build(condition: FilterQuery<T>, alias: string, model: Function): string;
+    private processConditions;
+    private processEntry;
+    private handleRelationship;
+    private handleScalarValue;
+    private handleObjectValue;
+    private buildLogicalOperatorCondition;
+    private buildOperatorConditions;
+    private buildOperatorCondition;
+    private buildSimpleCondition;
+    private buildInCondition;
+    private buildNotInCondition;
+    private buildLikeCondition;
+    private buildComparisonCondition;
+    private buildNestedLogicalCondition;
+    private wrapWithLogicalOperator;
+    private extractValueFromValueObject;
+    private formatValue;
+    private findRelationship;
+    private isScalarValue;
+    private isArrayValue;
+    private isLogicalOperator;
+    private extractLogicalOperator;
+    private trackLastNonOperatorKey;
+}
+export {};

package/dist/query/sql-condition-builder.js

@@ -0,0 +1,160 @@
+import { ValueObject } from '../common/value-object';
+import { extendsFrom } from '../utils';
+export class SqlConditionBuilder {
+    constructor(entityStorage, applyJoinCallback, statements) {
+        this.entityStorage = entityStorage;
+        this.applyJoinCallback = applyJoinCallback;
+        this.statements = statements;
+        this.OPERATORS = ['$eq', '$ne', '$in', '$nin', '$like', '$gt', '$gte', '$lt', '$lte', '$and', '$or'];
+        this.lastKeyNotOperator = '';
+    }
+    build(condition, alias, model) {
+        const sqlParts = this.processConditions(condition, alias, model);
+        if (sqlParts.length === 0) {
+            return '';
+        }
+        return this.wrapWithLogicalOperator(sqlParts, 'AND');
+    }
+    processConditions(condition, alias, model) {
+        const sqlParts = [];
+        for (let [key, value] of Object.entries(condition)) {
+            const extractedValue = this.extractValueFromValueObject(value);
+            const conditionSql = this.processEntry(key, extractedValue, alias, model);
+            if (conditionSql) {
+                sqlParts.push(conditionSql);
+            }
+        }
+        return sqlParts;
+    }
+    processEntry(key, value, alias, model) {
+        this.trackLastNonOperatorKey(key);
+        const relationship = this.findRelationship(key, model);
+        if (relationship) {
+            return this.handleRelationship(relationship, value, alias);
+        }
+        if (this.isScalarValue(value)) {
+            return this.handleScalarValue(key, value, alias);
+        }
+        if (this.isArrayValue(key, value)) {
+            return this.buildInCondition(key, value, alias);
+        }
+        return this.handleObjectValue(key, value, alias, model);
+    }
+    handleRelationship(relationship, value, alias) {
+        const sql = this.applyJoinCallback(relationship, value, alias);
+        if (this.statements.strategy === 'joined') {
+            return sql;
+        }
+        return '';
+    }
+    handleScalarValue(key, value, alias) {
+        if (key === '$eq') {
+            return this.buildSimpleCondition(this.lastKeyNotOperator, value, alias, '=');
+        }
+        return this.buildSimpleCondition(key, value, alias);
+    }
+    handleObjectValue(key, value, alias, model) {
+        if (this.isLogicalOperator(key)) {
+            return this.buildLogicalOperatorCondition(key, value, alias, model);
+        }
+        return this.buildOperatorConditions(key, value, alias, model);
+    }
+    buildLogicalOperatorCondition(key, value, alias, model) {
+        const conditions = value.map((cond) => this.build(cond, alias, model));
+        const operator = this.extractLogicalOperator(key);
+        return this.wrapWithLogicalOperator(conditions, operator);
+    }
+    buildOperatorConditions(key, value, alias, model) {
+        const parts = [];
+        for (const operator of this.OPERATORS) {
+            if (operator in value) {
+                const condition = this.buildOperatorCondition(key, operator, value[operator], alias, model);
+                parts.push(condition);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    buildOperatorCondition(key, operator, value, alias, model) {
+        switch (operator) {
+            case '$eq':
+                return this.buildSimpleCondition(key, value, alias, '=');
+            case '$ne':
+                return this.buildSimpleCondition(key, value, alias, '!=');
+            case '$in':
+                return this.buildInCondition(key, value, alias);
+            case '$nin':
+                return this.buildNotInCondition(key, value, alias);
+            case '$like':
+                return this.buildLikeCondition(key, value, alias);
+            case '$gt':
+                return this.buildComparisonCondition(key, value, alias, '>');
+            case '$gte':
+                return this.buildComparisonCondition(key, value, alias, '>=');
+            case '$lt':
+                return this.buildComparisonCondition(key, value, alias, '<');
+            case '$lte':
+                return this.buildComparisonCondition(key, value, alias, '<=');
+            case '$and':
+            case '$or':
+                return this.buildNestedLogicalCondition(operator, value, alias, model);
+            default:
+                return '';
+        }
+    }
+    buildSimpleCondition(key, value, alias, operator = '=') {
+        const formattedValue = this.formatValue(value);
+        return `${alias}.${key} ${operator} ${formattedValue}`;
+    }
+    buildInCondition(key, values, alias) {
+        const formattedValues = values.map(val => this.formatValue(val)).join(', ');
+        return `${alias}.${key} IN (${formattedValues})`;
+    }
+    buildNotInCondition(key, values, alias) {
+        const formattedValues = values.map(val => this.formatValue(val)).join(', ');
+        return `${alias}.${key} NOT IN (${formattedValues})`;
+    }
+    buildLikeCondition(key, value, alias) {
+        return `${alias}.${key} LIKE '${value}'`;
+    }
+    buildComparisonCondition(key, value, alias, operator) {
+        return `${alias}.${key} ${operator} ${value}`;
+    }
+    buildNestedLogicalCondition(operator, value, alias, model) {
+        const conditions = value.map((cond) => this.build(cond, alias, model));
+        const logicalOp = this.extractLogicalOperator(operator);
+        return this.wrapWithLogicalOperator(conditions, logicalOp);
+    }
+    wrapWithLogicalOperator(conditions, operator) {
+        return `(${conditions.join(` ${operator} `)})`;
+    }
+    extractValueFromValueObject(value) {
+        if (extendsFrom(ValueObject, value?.constructor?.prototype)) {
+            return value.getValue();
+        }
+        return value;
+    }
+    formatValue(value) {
+        return (typeof value === 'string') ? `'${value}'` : value;
+    }
+    findRelationship(key, model) {
+        const entity = this.entityStorage.get(model);
+        return entity?.relations?.find(rel => rel.propertyKey === key);
+    }
+    isScalarValue(value) {
+        return typeof value !== 'object' || value === null;
+    }
+    isArrayValue(key, value) {
+        return !this.OPERATORS.includes(key) && Array.isArray(value);
+    }
+    isLogicalOperator(key) {
+        return ['$or', '$and'].includes(key);
+    }
+    extractLogicalOperator(key) {
+        return key.toUpperCase().replace('$', '');
+    }
+    trackLastNonOperatorKey(key) {
+        if (!this.OPERATORS.includes(key)) {
+            this.lastKeyNotOperator = key;
+        }
+    }
+}

package/dist/query/sql-join-manager.d.ts

@@ -0,0 +1,39 @@
+import { Statement, Relationship, FilterQuery, DriverInterface } from '../driver/driver.interface';
+import { EntityStorage, Options } from '../domain/entities';
+import { SqlConditionBuilder } from './sql-condition-builder';
+import { SqlColumnManager } from './sql-column-manager';
+import { ModelTransformer } from './model-transformer';
+import { LoggerService } from '@cheetah.js/core';
+export declare class SqlJoinManager<T> {
+    private entityStorage;
+    private statements;
+    private entity;
+    private model;
+    private driver;
+    private logger;
+    private conditionBuilder;
+    private columnManager;
+    private modelTransformer;
+    private getOriginalColumnsCallback;
+    private getAliasCallback;
+    constructor(entityStorage: EntityStorage, statements: Statement<T>, entity: Options, model: new () => T, driver: DriverInterface, logger: LoggerService, conditionBuilder: SqlConditionBuilder<T>, columnManager: SqlColumnManager, modelTransformer: ModelTransformer, getOriginalColumnsCallback: () => string[], getAliasCallback: (tableName: string) => string);
+    addJoinForRelationshipPath(relationshipPath: string): void;
+    applyJoin(relationShip: Relationship<any>, value: FilterQuery<any>, alias: string): string;
+    handleSelectJoin(entities: any, models: any): Promise<void>;
+    getPathForSelectJoin(selectJoin: Statement<any>): string[] | null;
+    private buildJoinOn;
+    private addJoinedJoin;
+    private addSelectJoin;
+    private processSelectJoin;
+    private getIds;
+    private updateJoinWhere;
+    private updateJoinColumns;
+    private attachJoinResults;
+    private setValueByPath;
+    private getPathForSelectJoinRecursive;
+    private findIdRecursively;
+    private getFkKey;
+    private getTableName;
+    private getPrimaryKey;
+    private formatValue;
+}

package/dist/query/sql-join-manager.js

@@ -0,0 +1,224 @@
+export class SqlJoinManager {
+    constructor(entityStorage, statements, entity, model, driver, logger, conditionBuilder, columnManager, modelTransformer, getOriginalColumnsCallback, getAliasCallback) {
+        this.entityStorage = entityStorage;
+        this.statements = statements;
+        this.entity = entity;
+        this.model = model;
+        this.driver = driver;
+        this.logger = logger;
+        this.conditionBuilder = conditionBuilder;
+        this.columnManager = columnManager;
+        this.modelTransformer = modelTransformer;
+        this.getOriginalColumnsCallback = getOriginalColumnsCallback;
+        this.getAliasCallback = getAliasCallback;
+    }
+    addJoinForRelationshipPath(relationshipPath) {
+        const relationshipNames = relationshipPath.split('.');
+        let currentEntity = this.entity;
+        let currentAlias = this.statements.alias;
+        let statement = this.statements.strategy === 'joined' ? this.statements.join : this.statements.selectJoin;
+        let nameAliasProperty = this.statements.strategy === 'joined' ? 'joinAlias' : 'alias';
+        relationshipNames.forEach((relationshipName, index) => {
+            const relationship = currentEntity.relations.find(rel => rel.propertyKey === relationshipName);
+            if (!relationship) {
+                throw new Error(`Relationship "${relationshipName}" not found in entity`);
+            }
+            const isLastRelationship = index === relationshipNames.length - 1;
+            if (index === (relationshipNames.length - 2 >= 0 ? relationshipNames.length - 2 : 0)) {
+                const join = statement?.find(j => j.joinProperty === relationshipName);
+                if (join) {
+                    currentAlias = join[nameAliasProperty];
+                }
+            }
+            if (relationship.relation === 'many-to-one' && isLastRelationship) {
+                this.applyJoin(relationship, {}, currentAlias);
+                statement = this.statements.strategy === 'joined' ? this.statements.join : this.statements.selectJoin;
+                currentAlias = statement[statement.length - 1][nameAliasProperty];
+            }
+            currentEntity = this.entityStorage.get(relationship.entity());
+        });
+    }
+    applyJoin(relationShip, value, alias) {
+        const { tableName, schema } = this.getTableName();
+        const { tableName: joinTableName, schema: joinSchema, hooks: joinHooks, } = this.entityStorage.get(relationShip.entity()) || {
+            tableName: relationShip.entity().name.toLowerCase(),
+            schema: 'public',
+        };
+        const originPrimaryKey = this.getPrimaryKey();
+        const joinAlias = this.getAliasCallback(joinTableName);
+        const joinWhere = this.conditionBuilder.build(value, joinAlias, relationShip.entity());
+        const on = this.buildJoinOn(relationShip, alias, joinAlias, originPrimaryKey);
+        if (this.statements.strategy === 'joined') {
+            this.addJoinedJoin(relationShip, joinTableName, joinSchema, joinAlias, joinWhere, on, alias, schema, tableName, joinHooks);
+        }
+        else {
+            this.addSelectJoin(relationShip, joinTableName, joinSchema, joinAlias, joinWhere, originPrimaryKey, alias, joinHooks);
+        }
+        return joinWhere;
+    }
+    async handleSelectJoin(entities, models) {
+        if (!this.statements.selectJoin || this.statements.selectJoin.length === 0) {
+            return;
+        }
+        for (const join of this.statements.selectJoin.reverse()) {
+            await this.processSelectJoin(join, entities, models);
+        }
+        return models;
+    }
+    getPathForSelectJoin(selectJoin) {
+        const path = this.getPathForSelectJoinRecursive(selectJoin);
+        return path.reverse();
+    }
+    buildJoinOn(relationShip, alias, joinAlias, originPrimaryKey) {
+        let on = '';
+        switch (relationShip.relation) {
+            case "one-to-many":
+                on = `${joinAlias}."${this.getFkKey(relationShip)}" = ${alias}."${originPrimaryKey}"`;
+                break;
+            case "many-to-one":
+                on = `${alias}."${relationShip.columnName}" = ${joinAlias}."${this.getFkKey(relationShip)}"`;
+                break;
+        }
+        return on;
+    }
+    addJoinedJoin(relationShip, joinTableName, joinSchema, joinAlias, joinWhere, on, alias, schema, tableName, joinHooks) {
+        this.statements.join = this.statements.join || [];
+        this.statements.join.push({
+            joinAlias: joinAlias,
+            joinTable: joinTableName,
+            joinSchema: joinSchema || 'public',
+            joinWhere: joinWhere,
+            joinProperty: relationShip.propertyKey,
+            originAlias: alias,
+            originSchema: schema,
+            originTable: tableName,
+            propertyKey: relationShip.propertyKey,
+            joinEntity: relationShip.entity(),
+            type: 'LEFT',
+            on,
+            originalEntity: relationShip.originalEntity,
+            hooks: joinHooks,
+        });
+    }
+    addSelectJoin(relationShip, joinTableName, joinSchema, joinAlias, joinWhere, originPrimaryKey, alias, joinHooks) {
+        this.statements.selectJoin = this.statements.selectJoin || [];
+        this.statements.selectJoin.push({
+            statement: 'select',
+            columns: this.getOriginalColumnsCallback().filter(column => column.startsWith(`${relationShip.propertyKey}`)).map(column => column.split('.')[1]) || [],
+            table: `"${joinSchema || 'public'}"."${joinTableName}"`,
+            alias: joinAlias,
+            where: joinWhere,
+            joinProperty: relationShip.propertyKey,
+            fkKey: this.getFkKey(relationShip),
+            primaryKey: originPrimaryKey,
+            originAlias: alias,
+            originProperty: relationShip.propertyKey,
+            joinEntity: relationShip.entity(),
+            originEntity: relationShip.originalEntity,
+            hooks: joinHooks,
+        });
+    }
+    async processSelectJoin(join, entities, models) {
+        let ids = this.getIds(join, entities, models);
+        if (Array.isArray(ids)) {
+            ids = ids.map((id) => this.formatValue(id)).join(', ');
+        }
+        this.updateJoinWhere(join, ids);
+        this.updateJoinColumns(join);
+        const child = await this.driver.executeStatement(join);
+        this.logger.debug(`SQL: ${child.sql} [${Date.now() - child.startTime}ms]`);
+        this.attachJoinResults(join, child, models);
+    }
+    getIds(join, entities, models) {
+        let ids = entities[`${join.originAlias}_${join.primaryKey}`];
+        if (typeof ids === 'undefined') {
+            const selectJoined = this.statements.selectJoin.find(j => j.joinEntity === join.originEntity);
+            if (!selectJoined) {
+                return undefined;
+            }
+            ids = this.findIdRecursively(models, selectJoined, join);
+        }
+        return ids;
+    }
+    updateJoinWhere(join, ids) {
+        if (join.where) {
+            join.where = `${join.where} AND ${join.alias}."${join.fkKey}" IN (${ids})`;
+        }
+        else {
+            join.where = `${join.alias}."${join.fkKey}" IN (${ids})`;
+        }
+    }
+    updateJoinColumns(join) {
+        if (join.columns && join.columns.length > 0) {
+            join.columns = join.columns.map((column) => `${join.alias}."${column}" as "${join.alias}_${column}"`);
+        }
+        else {
+            join.columns = this.columnManager.getColumnsForEntity(join.joinEntity, join.alias);
+        }
+    }
+    attachJoinResults(join, child, models) {
+        const property = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
+        const values = child.query.rows.map((row) => this.modelTransformer.transform(join.joinEntity, join, row));
+        const path = this.getPathForSelectJoin(join);
+        this.setValueByPath(models, path, property?.type === Array ? [...values] : values[0]);
+    }
+    setValueByPath(obj, path, value) {
+        let currentObj = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            const key = path[i];
+            currentObj[key] = currentObj[key] || {};
+            currentObj = currentObj[key];
+        }
+        currentObj[path[path.length - 1]] = value;
+    }
+    getPathForSelectJoinRecursive(selectJoin) {
+        const originJoin = this.statements.selectJoin.find(j => j.joinEntity === selectJoin.originEntity);
+        let pathInJoin = [];
+        if (!originJoin) {
+            return [selectJoin.joinProperty];
+        }
+        if (originJoin.originEntity !== this.statements.originEntity) {
+            pathInJoin = this.getPathForSelectJoinRecursive(originJoin);
+        }
+        return [selectJoin.joinProperty, ...pathInJoin];
+    }
+    findIdRecursively(models, selectJoined, join) {
+        let ids = models[selectJoined.originProperty][join.primaryKey];
+        if (typeof ids === 'undefined') {
+            const nextSelectJoined = this.statements.selectJoin.find(j => j.joinEntity === selectJoined.originEntity);
+            if (nextSelectJoined) {
+                ids = this.findIdRecursively(models, nextSelectJoined, join);
+            }
+        }
+        return ids;
+    }
+    getFkKey(relationShip) {
+        if (typeof relationShip.fkKey === 'undefined') {
+            return 'id';
+        }
+        if (typeof relationShip.fkKey === 'string') {
+            return relationShip.fkKey;
+        }
+        const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
+        const propertyKey = match ? match.groups.propriedade : '';
+        const entity = this.entityStorage.get(relationShip.entity());
+        const property = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+        return property.options.columnName;
+    }
+    getTableName() {
+        const tableName = this.entity.tableName || this.model.name.toLowerCase();
+        const schema = this.entity.schema || 'public';
+        return { tableName, schema };
+    }
+    getPrimaryKey() {
+        for (const prop in this.entity.properties) {
+            if (this.entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+    formatValue(value) {
+        return (typeof value === 'string') ? `'${value}'` : value;
+    }
+}