@carno.js/orm 0.2.3

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

@@ -0,0 +1,51 @@
+import { FilterQuery, Relationship, Statement } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+import { SqlSubqueryBuilder } from './sql-subquery-builder';
+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;
+    private subqueryBuilder?;
+    constructor(entityStorage: EntityStorage, applyJoinCallback: ApplyJoinCallback, statements: Statement<T>);
+    setSubqueryBuilder(subqueryBuilder: SqlSubqueryBuilder): void;
+    build(condition: FilterQuery<T>, alias: string, model: Function): string;
+    private processConditions;
+    private processEntry;
+    private hasExistsOperator;
+    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 formatDate;
+    private isNullish;
+    private buildNullCondition;
+    private isPrimitive;
+    private formatPrimitive;
+    private formatJson;
+    private escapeString;
+    private findRelationship;
+    private isScalarValue;
+    private isArrayValue;
+    private isLogicalOperator;
+    private extractLogicalOperator;
+    private trackLastNonOperatorKey;
+    private buildExistsCondition;
+    private buildTopLevelExistsCondition;
+    private resolveColumnName;
+    private resolveRelationColumn;
+}
+export {};

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlConditionBuilder = void 0;
+const value_object_1 = require("../common/value-object");
+const utils_1 = require("../utils");
+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', '$exists', '$nexists'];
+        this.lastKeyNotOperator = '';
+    }
+    setSubqueryBuilder(subqueryBuilder) {
+        this.subqueryBuilder = subqueryBuilder;
+    }
+    build(condition, alias, model) {
+        const sqlParts = this.processConditions(condition, alias, model);
+        if (sqlParts.length === 0) {
+            return '';
+        }
+        const result = this.wrapWithLogicalOperator(sqlParts, 'AND');
+        return result;
+    }
+    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, model);
+        const relationship = this.findRelationship(key, model);
+        if (relationship && !this.hasExistsOperator(value)) {
+            return this.handleRelationship(relationship, value, alias);
+        }
+        if (this.isScalarValue(value)) {
+            return this.handleScalarValue(key, value, alias, model);
+        }
+        if (this.isArrayValue(key, value)) {
+            return this.buildInCondition(key, value, alias, model);
+        }
+        return this.handleObjectValue(key, value, alias, model);
+    }
+    hasExistsOperator(value) {
+        return typeof value === 'object' && value !== null && ('$exists' in value || '$nexists' in value);
+    }
+    handleRelationship(relationship, value, alias) {
+        const sql = this.applyJoinCallback(relationship, value, alias);
+        if (this.statements.strategy === 'joined') {
+            return sql;
+        }
+        return '';
+    }
+    handleScalarValue(key, value, alias, model) {
+        if (key === '$eq') {
+            return this.buildSimpleCondition(this.lastKeyNotOperator, value, alias, '=', model);
+        }
+        return this.buildSimpleCondition(key, value, alias, '=', model);
+    }
+    handleObjectValue(key, value, alias, model) {
+        if (this.isLogicalOperator(key)) {
+            return this.buildLogicalOperatorCondition(key, value, alias, model);
+        }
+        if (key === '$exists' || key === '$nexists') {
+            return this.buildTopLevelExistsCondition(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, '=', model);
+            case '$ne':
+                return this.buildSimpleCondition(key, value, alias, '!=', model);
+            case '$in':
+                return this.buildInCondition(key, value, alias, model);
+            case '$nin':
+                return this.buildNotInCondition(key, value, alias, model);
+            case '$like':
+                return this.buildLikeCondition(key, value, alias, model);
+            case '$gt':
+                return this.buildComparisonCondition(key, value, alias, '>', model);
+            case '$gte':
+                return this.buildComparisonCondition(key, value, alias, '>=', model);
+            case '$lt':
+                return this.buildComparisonCondition(key, value, alias, '<', model);
+            case '$lte':
+                return this.buildComparisonCondition(key, value, alias, '<=', model);
+            case '$and':
+            case '$or':
+                return this.buildNestedLogicalCondition(operator, value, alias, model);
+            case '$exists':
+                return this.buildExistsCondition(key, value, alias, model, false);
+            case '$nexists':
+                return this.buildExistsCondition(key, value, alias, model, true);
+            default:
+                return '';
+        }
+    }
+    buildSimpleCondition(key, value, alias, operator, model) {
+        const column = this.resolveColumnName(key, model);
+        if (this.isNullish(value))
+            return this.buildNullCondition(alias, column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${alias}.${column} ${operator} ${formattedValue}`;
+    }
+    buildInCondition(key, values, alias, model) {
+        const column = this.resolveColumnName(key, model);
+        const formattedValues = values.map(val => this.formatValue(val)).join(', ');
+        return `${alias}.${column} IN (${formattedValues})`;
+    }
+    buildNotInCondition(key, values, alias, model) {
+        const column = this.resolveColumnName(key, model);
+        const formattedValues = values.map(val => this.formatValue(val)).join(', ');
+        return `${alias}.${column} NOT IN (${formattedValues})`;
+    }
+    buildLikeCondition(key, value, alias, model) {
+        const column = this.resolveColumnName(key, model);
+        return `${alias}.${column} LIKE '${value}'`;
+    }
+    buildComparisonCondition(key, value, alias, operator, model) {
+        const column = this.resolveColumnName(key, model);
+        if (this.isNullish(value))
+            return this.buildNullCondition(alias, column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${alias}.${column} ${operator} ${formattedValue}`;
+    }
+    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 ((0, utils_1.extendsFrom)(value_object_1.ValueObject, value?.constructor?.prototype)) {
+            return value.getValue();
+        }
+        return value;
+    }
+    formatValue(value) {
+        if (value instanceof Date)
+            return this.formatDate(value);
+        if (this.isNullish(value))
+            return 'NULL';
+        if (this.isPrimitive(value))
+            return this.formatPrimitive(value);
+        return this.formatJson(value);
+    }
+    formatDate(value) {
+        return `'${value.toISOString()}'`;
+    }
+    isNullish(value) {
+        return value === null || value === undefined;
+    }
+    buildNullCondition(alias, column, operator) {
+        if (operator === '!=' || operator === '<>')
+            return `${alias}.${column} IS NOT NULL`;
+        return `${alias}.${column} IS NULL`;
+    }
+    isPrimitive(value) {
+        return ['string', 'number', 'boolean', 'bigint'].includes(typeof value);
+    }
+    formatPrimitive(value) {
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        return `${value}`;
+    }
+    formatJson(value) {
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    escapeString(value) {
+        return value.replace(/'/g, "''");
+    }
+    findRelationship(key, model) {
+        const entity = this.entityStorage.get(model);
+        return entity?.relations?.find(rel => rel.propertyKey === key);
+    }
+    isScalarValue(value) {
+        const isDate = value instanceof Date;
+        return typeof value !== 'object' || value === null || isDate;
+    }
+    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, model) {
+        if (!this.OPERATORS.includes(key)) {
+            this.lastKeyNotOperator = key;
+        }
+    }
+    buildExistsCondition(key, filters, alias, model, negate) {
+        const relationship = this.findRelationship(key, model);
+        if (!relationship) {
+            const entity = this.entityStorage.get(model);
+            const availableRelations = entity?.relations
+                ?.map((r) => r.propertyKey)
+                .join(', ') || 'none';
+            throw new Error(`Cannot use $${negate ? 'nexists' : 'exists'} on non-relationship field '${key}'. ` +
+                `Available relationships: ${availableRelations}`);
+        }
+        if (!this.subqueryBuilder) {
+            throw new Error('SqlSubqueryBuilder not initialized. This is an internal error.');
+        }
+        return this.subqueryBuilder.buildExistsSubquery(relationship, filters, alias, negate, model);
+    }
+    buildTopLevelExistsCondition(operator, value, alias, model) {
+        const negate = operator === '$nexists';
+        const conditions = [];
+        for (const [relationshipKey, filters] of Object.entries(value)) {
+            const condition = this.buildExistsCondition(relationshipKey, filters, alias, model, negate);
+            conditions.push(condition);
+        }
+        const result = this.wrapWithLogicalOperator(conditions, 'AND');
+        return result;
+    }
+    resolveColumnName(property, model) {
+        if (property.startsWith('$')) {
+            return property;
+        }
+        const entity = this.entityStorage.get(model);
+        if (!entity) {
+            return property;
+        }
+        const column = entity.properties?.[property]?.options.columnName;
+        if (column) {
+            return column;
+        }
+        return this.resolveRelationColumn(property, entity) ?? property;
+    }
+    resolveRelationColumn(property, entity) {
+        const relation = entity.relations?.find(rel => rel.propertyKey === property);
+        const column = relation?.columnName;
+        return typeof column === 'string' ? column : undefined;
+    }
+}
+exports.SqlConditionBuilder = SqlConditionBuilder;

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 '@carno.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,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlJoinManager = void 0;
+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;
+        for (const relationshipName of relationshipNames) {
+            const relationship = currentEntity.relations.find((rel) => rel.propertyKey === relationshipName);
+            if (!relationship) {
+                throw new Error(`Relationship "${relationshipName}" not found in entity "${currentEntity.tableName}"`);
+            }
+            const statement = this.statements.strategy === 'joined'
+                ? this.statements.join
+                : this.statements.selectJoin;
+            const nameAliasProperty = this.statements.strategy === 'joined' ? 'joinAlias' : 'alias';
+            const existingJoin = statement?.find((j) => j.joinProperty === relationshipName && j.originAlias === currentAlias);
+            if (existingJoin) {
+                currentAlias = existingJoin[nameAliasProperty];
+                currentEntity = this.entityStorage.get(relationship.entity());
+                continue;
+            }
+            this.applyJoin(relationship, {}, currentAlias);
+            const newStatement = this.statements.strategy === 'joined'
+                ? this.statements.join
+                : this.statements.selectJoin;
+            currentAlias = newStatement[newStatement.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());
+        if (!entity) {
+            throw new Error(`Entity not found in storage for relationship. ` +
+                `Make sure the entity ${relationShip.entity().name} is decorated with @Entity()`);
+        }
+        const property = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+        if (property) {
+            return property.options.columnName;
+        }
+        const relation = entity.relations.find(rel => rel.propertyKey === propertyKey);
+        if (relation && relation.columnName) {
+            return relation.columnName;
+        }
+        throw new Error(`Property or relation "${propertyKey}" not found in entity "${entity.tableName}". ` +
+            `Available properties: ${Object.keys(entity.properties).join(', ')}. ` +
+            `Available relations: ${entity.relations.map(r => r.propertyKey).join(', ')}`);
+    }
+    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;
+    }
+}
+exports.SqlJoinManager = SqlJoinManager;

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

@@ -0,0 +1,20 @@
+import { FilterQuery, Relationship } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+import { SqlConditionBuilder } from './sql-condition-builder';
+export declare class SqlSubqueryBuilder {
+    private entityStorage;
+    private getConditionBuilder;
+    private aliasCounter;
+    constructor(entityStorage: EntityStorage, getConditionBuilder: () => SqlConditionBuilder<any>);
+    buildExistsSubquery(relationship: Relationship<any>, filters: FilterQuery<any>, outerAlias: string, negate: boolean, outerModel?: Function): string;
+    private buildSubquery;
+    private buildWhereClause;
+    private buildCorrelation;
+    private getOuterPrimaryKey;
+    private buildFilterConditions;
+    private combineConditions;
+    private resolveTableName;
+    private generateAlias;
+    private getFkKey;
+    private getRelatedPrimaryKey;
+}