@cheetah.js/orm 0.1.45 → 0.1.46

package/dist/driver/bun-driver.base.d.ts

@@ -1,5 +1,5 @@
 import { SQL } from 'bun';
-import { ConnectionSettings, DriverInterface } from './driver.interface';
+import { ConnectionSettings, DriverInterface, Statement, SnapshotConstraintInfo, ColDiff } from './driver.interface';
 export declare abstract class BunDriverBase implements Partial<DriverInterface> {
     protected sql: SQL;
     connectionString: string;
@@ -7,6 +7,7 @@ export declare abstract class BunDriverBase implements Partial<DriverInterface>
     constructor(options: ConnectionSettings);
     protected buildConnectionString(options: ConnectionSettings): string;
     protected abstract getProtocol(): string;
+    protected abstract getIdentifierQuote(): string;
     connect(): Promise<void>;
     protected validateConnection(): Promise<void>;
     disconnect(): Promise<void>;
@@ -18,4 +19,37 @@ export declare abstract class BunDriverBase implements Partial<DriverInterface>
     protected buildOrderByClause(orderBy: string[] | undefined): string;
     protected buildLimitClause(limit: number | undefined): string;
     protected buildOffsetClause(offset: number | undefined): string;
+    protected quote(identifier: string): string;
+    protected buildTableIdentifier(schema: string | undefined, tableName: string): string;
+    protected buildColumnConstraints(colDiff: ColDiff): string;
+    protected abstract buildAutoIncrementType(colDiff: ColDiff): string;
+    protected abstract buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
+        beforeSql: string;
+        columnType: string;
+    };
+    protected abstract handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    executeStatement(statement: Statement<any>): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    protected buildInsertSqlWithReturn(statement: Statement<any>): string;
+    protected abstract appendReturningClause(sql: string, statement: Statement<any>): string;
+    protected buildStatementSql(statement: Statement<any>): string;
+    protected buildBaseSql(statement: Statement<any>): string;
+    protected buildInsertSql(table: string, values: any, columns: string[] | undefined, alias: string): string;
+    protected buildUpdateSql(table: string, values: any, alias: string): string;
+    protected buildJoinClause(statement: Statement<any>): string;
+    protected buildWhereAndOrderClauses(statement: Statement<any>): string;
+    protected buildLimitAndOffsetClause(statement: Statement<any>): string;
+    protected getForeignKeysFromConstraints(constraints: SnapshotConstraintInfo[], row: any, columnNameField: string): any[];
+    protected isForeignKeyConstraint(constraint: SnapshotConstraintInfo, columnName: string): boolean;
+    protected parseForeignKeyDefinition(consDef: string): {
+        referencedColumnName: string;
+        referencedTableName: string;
+    };
 }

package/dist/driver/bun-driver.base.js

@@ -83,4 +83,136 @@ export class BunDriverBase {
         }
         return ` OFFSET ${offset}`;
     }
+    quote(identifier) {
+        const q = this.getIdentifierQuote();
+        return `${q}${identifier}${q}`;
+    }
+    buildTableIdentifier(schema, tableName) {
+        return schema
+            ? `${this.quote(schema)}.${this.quote(tableName)}`
+            : this.quote(tableName);
+    }
+    buildColumnConstraints(colDiff) {
+        const parts = [];
+        if (!colDiff.colChanges?.nullable) {
+            parts.push('NOT NULL');
+        }
+        if (colDiff.colChanges?.primary) {
+            parts.push('PRIMARY KEY');
+        }
+        if (colDiff.colChanges?.unique) {
+            parts.push('UNIQUE');
+        }
+        if (colDiff.colChanges?.default) {
+            parts.push(`DEFAULT ${colDiff.colChanges.default}`);
+        }
+        return parts.length > 0 ? ' ' + parts.join(' ') : '';
+    }
+    async executeStatement(statement) {
+        const startTime = Date.now();
+        if (statement.statement === 'insert') {
+            const sql = this.buildInsertSqlWithReturn(statement);
+            const result = await this.sql.unsafe(sql);
+            return this.handleInsertReturn(statement, result, sql, startTime);
+        }
+        const sql = this.buildStatementSql(statement);
+        const result = await this.sql.unsafe(sql);
+        return {
+            query: { rows: Array.isArray(result) ? result : [] },
+            startTime,
+            sql,
+        };
+    }
+    buildInsertSqlWithReturn(statement) {
+        const baseSql = this.buildInsertSql(statement.table, statement.values, statement.columns, statement.alias);
+        return this.appendReturningClause(baseSql, statement);
+    }
+    buildStatementSql(statement) {
+        let sql = this.buildBaseSql(statement);
+        sql += this.buildJoinClause(statement);
+        sql += this.buildWhereAndOrderClauses(statement);
+        return sql;
+    }
+    buildBaseSql(statement) {
+        const { statement: type, table, columns, values, alias } = statement;
+        switch (type) {
+            case 'select':
+                return `SELECT ${columns ? columns.join(', ') : '*'} FROM ${table} ${alias}`;
+            case 'insert':
+                return this.buildInsertSql(table, values, columns, alias);
+            case 'update':
+                return this.buildUpdateSql(table, values, alias);
+            default:
+                return '';
+        }
+    }
+    buildInsertSql(table, values, columns, alias) {
+        const q = this.getIdentifierQuote();
+        const fields = Object.keys(values)
+            .map((v) => `${q}${v}${q}`)
+            .join(', ');
+        const vals = Object.values(values)
+            .map((value) => this.toDatabaseValue(value))
+            .join(', ');
+        return `INSERT INTO ${table} (${fields}) VALUES (${vals})`;
+    }
+    buildUpdateSql(table, values, alias) {
+        const sets = Object.entries(values)
+            .map(([key, value]) => `${key} = ${this.toDatabaseValue(value)}`)
+            .join(', ');
+        return `UPDATE ${table} as ${alias} SET ${sets}`;
+    }
+    buildJoinClause(statement) {
+        if (!statement.join)
+            return '';
+        return statement.join
+            .map((join) => {
+            const table = `${join.joinSchema}.${join.joinTable}`;
+            return ` ${join.type} JOIN ${table} ${join.joinAlias} ON ${join.on}`;
+        })
+            .join('');
+    }
+    buildWhereAndOrderClauses(statement) {
+        if (statement.statement === 'insert')
+            return '';
+        let sql = this.buildWhereClause(statement.where);
+        sql += this.buildOrderByClause(statement.orderBy);
+        sql += this.buildLimitAndOffsetClause(statement);
+        return sql;
+    }
+    buildLimitAndOffsetClause(statement) {
+        const { offset, limit } = statement;
+        if (offset && limit) {
+            return this.buildOffsetClause(offset) + this.buildLimitClause(limit);
+        }
+        if (limit) {
+            return this.buildLimitClause(limit);
+        }
+        return '';
+    }
+    getForeignKeysFromConstraints(constraints, row, columnNameField) {
+        const columnName = row[columnNameField];
+        return constraints
+            .filter((c) => this.isForeignKeyConstraint(c, columnName))
+            .map((c) => this.parseForeignKeyDefinition(c.consDef));
+    }
+    isForeignKeyConstraint(constraint, columnName) {
+        return (constraint.type === 'FOREIGN KEY' &&
+            constraint.consDef.includes(columnName));
+    }
+    parseForeignKeyDefinition(consDef) {
+        const q = this.getIdentifierQuote();
+        const pattern = new RegExp(`REFERENCES\\s+${q}([^${q}]+)${q}\\s*\\(([^)]+)\\)`);
+        const filter = consDef.match(pattern);
+        if (!filter) {
+            throw new Error('Invalid constraint definition');
+        }
+        return {
+            referencedColumnName: filter[2]
+                .split(',')[0]
+                .trim()
+                .replace(new RegExp(q, 'g'), ''),
+            referencedTableName: filter[1],
+        };
+    }
 }

package/dist/driver/bun-mysql.driver.d.ts

@@ -4,6 +4,19 @@ export declare class BunMysqlDriver extends BunDriverBase implements DriverInter
     readonly dbType: "mysql";
     constructor(options: ConnectionSettings);
     protected getProtocol(): string;
+    protected getIdentifierQuote(): string;
+    protected buildAutoIncrementType(colDiff: ColDiff): string;
+    protected buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
+        beforeSql: string;
+        columnType: string;
+    };
+    protected appendReturningClause(sql: string, statement: Statement<any>): string;
+    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    protected buildLimitAndOffsetClause(statement: Statement<any>): string;
     getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
     getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
     getCreateIndex(index: {
@@ -29,14 +42,8 @@ export declare class BunMysqlDriver extends BunDriverBase implements DriverInter
     getDropTypeEnumInstruction(param: {
         name: string;
     }, schema: string | undefined, tableName: string): string;
-    executeStatement(statement: Statement<any>): Promise<{
-        query: any;
-        startTime: number;
-        sql: string;
-    }>;
     snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
     private parseEnumValues;
-    private getForeignKeys;
     index(tableName: string, options: any): Promise<SnapshotIndexInfo[] | undefined>;
     constraints(tableName: string, options: any): Promise<SnapshotConstraintInfo[] | undefined>;
 }

package/dist/driver/bun-mysql.driver.js

@@ -7,6 +7,52 @@ export class BunMysqlDriver extends BunDriverBase {
     getProtocol() {
         return 'mysql';
     }
+    getIdentifierQuote() {
+        return '`';
+    }
+    buildAutoIncrementType(colDiff) {
+        return 'INT AUTO_INCREMENT';
+    }
+    buildEnumType(schema, tableName, colDiff) {
+        const enumValues = colDiff.colChanges.enumItems
+            .map((item) => `'${item}'`)
+            .join(', ');
+        return {
+            beforeSql: '',
+            columnType: `ENUM(${enumValues})`,
+        };
+    }
+    appendReturningClause(sql, statement) {
+        return sql;
+    }
+    async handleInsertReturn(statement, result, sql, startTime) {
+        if (!statement.columns) {
+            return {
+                query: { rows: Array.isArray(result) ? result : [] },
+                startTime,
+                sql,
+            };
+        }
+        const insertId = result.lastInsertRowid;
+        const cols = statement.columns.join(', ').replaceAll(`${statement.alias}.`, '');
+        const selectSql = `SELECT ${cols} FROM ${statement.table} WHERE id = ${insertId}`;
+        const selectResult = await this.sql.unsafe(selectSql);
+        return {
+            query: { rows: Array.isArray(selectResult) ? selectResult : [] },
+            startTime,
+            sql,
+        };
+    }
+    buildLimitAndOffsetClause(statement) {
+        const { offset, limit } = statement;
+        if (offset && limit) {
+            return ` LIMIT ${offset}, ${limit}`;
+        }
+        if (limit) {
+            return this.buildLimitClause(limit);
+        }
+        return '';
+    }
     getCreateTableInstruction(schema, tableName, creates) {
         let beforeSql = ``;
         const st = `CREATE TABLE \`${schema}\`.\`${tableName}\` (${creates
@@ -114,63 +160,6 @@ export class BunMysqlDriver extends BunDriverBase {
     getDropTypeEnumInstruction(param, schema, tableName) {
         return '';
     }
-    async executeStatement(statement) {
-        let { statement: statementType, table, columns, where, limit, alias } = statement;
-        let sql = '';
-        switch (statementType) {
-            case 'select':
-                sql = `SELECT ${columns ? columns.join(', ') : '*'} FROM ${table} ${alias}`;
-                break;
-            case 'insert':
-                const fields = Object.keys(statement.values)
-                    .map((v) => `\`${v}\``)
-                    .join(', ');
-                const values = Object.values(statement.values)
-                    .map((value) => this.toDatabaseValue(value))
-                    .join(', ');
-                sql = `INSERT INTO ${table} (${fields}) VALUES (${values})`;
-                break;
-            case 'update':
-                sql = `UPDATE ${table} as ${alias} SET ${Object.entries(statement.values)
-                    .map(([key, value]) => `${key} = ${this.toDatabaseValue(value)}`)
-                    .join(', ')}`;
-                break;
-            case 'delete':
-                break;
-        }
-        if (statement.join) {
-            statement.join.forEach((join) => {
-                sql += ` ${join.type} JOIN ${join.joinSchema}.${join.joinTable} ${join.joinAlias} ON ${join.on}`;
-            });
-        }
-        if (statementType !== 'insert') {
-            sql += this.buildWhereClause(where);
-            sql += this.buildOrderByClause(statement.orderBy);
-            if (statement.offset && limit) {
-                sql += ` LIMIT ${statement.offset}, ${limit}`;
-            }
-            else if (limit) {
-                sql += this.buildLimitClause(limit);
-            }
-        }
-        const startTime = Date.now();
-        const result = await this.sql.unsafe(sql);
-        if (statementType === 'insert' && statement.columns) {
-            const insertId = result.lastInsertRowid;
-            const selectSql = `SELECT ${statement.columns.join(', ').replaceAll(`${alias}.`, '')} FROM ${table} WHERE id = ${insertId}`;
-            const insertResult = await this.sql.unsafe(selectSql);
-            return {
-                query: { rows: Array.isArray(insertResult) ? insertResult : [] },
-                startTime,
-                sql,
-            };
-        }
-        return {
-            query: { rows: Array.isArray(result) ? result : [] },
-            startTime,
-            sql,
-        };
-    }
     async snapshot(tableName, options) {
         const schema = (options && options.schema) || 'information_schema';
         const sql = `SELECT * FROM information_schema.columns WHERE table_name = '${tableName}' AND table_schema = DATABASE()`;
@@ -195,7 +184,7 @@ export class BunMysqlDriver extends BunDriverBase {
                     primary: row.COLUMN_KEY === 'PRI',
                     unique: row.COLUMN_KEY === 'UNI' || row.COLUMN_KEY === 'PRI',
                     type: row.DATA_TYPE,
-                    foreignKeys: this.getForeignKeys(constraints, row),
+                    foreignKeys: this.getForeignKeysFromConstraints(constraints, row, 'COLUMN_NAME'),
                     isEnum: row.DATA_TYPE === 'enum',
                     enumItems: row.DATA_TYPE === 'enum' ? this.parseEnumValues(row.COLUMN_TYPE) : undefined,
                     precision: row.NUMERIC_PRECISION,
@@ -212,20 +201,6 @@ export class BunMysqlDriver extends BunDriverBase {
         }
         return match[1].split(',').map((v) => v.trim().replace(/'/g, ''));
     }
-    getForeignKeys(constraints, row) {
-        return constraints
-            .filter((c) => c.type === 'FOREIGN KEY' && c.consDef.includes(row.COLUMN_NAME))
-            .map((c) => {
-            const filter = c.consDef.match(/REFERENCES\s+`([^`]+)`\s*\(([^)]+)\)/);
-            if (!filter) {
-                throw new Error('Invalid constraint definition');
-            }
-            return {
-                referencedColumnName: filter[2].split(',')[0].trim().replace(/`/g, ''),
-                referencedTableName: filter[1],
-            };
-        });
-    }
     async index(tableName, options) {
         const result = await this.sql.unsafe(`SHOW INDEX FROM \`${tableName}\` FROM \`${options.schema || 'information_schema'}\``);
         return result

package/dist/driver/bun-pg.driver.d.ts

@@ -4,6 +4,18 @@ export declare class BunPgDriver extends BunDriverBase implements DriverInterfac
     readonly dbType: "postgres";
     constructor(options: ConnectionSettings);
     protected getProtocol(): string;
+    protected getIdentifierQuote(): string;
+    protected buildAutoIncrementType(colDiff: ColDiff): string;
+    protected buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
+        beforeSql: string;
+        columnType: string;
+    };
+    protected appendReturningClause(sql: string, statement: Statement<any>): string;
+    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
     getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
     getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
     getCreateIndex(index: {
@@ -29,13 +41,7 @@ export declare class BunPgDriver extends BunDriverBase implements DriverInterfac
     getDropTypeEnumInstruction(param: {
         name: string;
     }, schema: string | undefined, tableName: string): string;
-    executeStatement(statement: Statement<any>): Promise<{
-        query: any;
-        startTime: number;
-        sql: string;
-    }>;
     snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
-    private getForeignKeys;
     index(tableName: string, options: any): Promise<SnapshotIndexInfo[] | undefined>;
     constraints(tableName: string, options: any): Promise<SnapshotConstraintInfo[] | undefined>;
     private getEnums;

package/dist/driver/bun-pg.driver.js

@@ -7,6 +7,32 @@ export class BunPgDriver extends BunDriverBase {
     getProtocol() {
         return 'postgres';
     }
+    getIdentifierQuote() {
+        return '"';
+    }
+    buildAutoIncrementType(colDiff) {
+        return 'SERIAL';
+    }
+    buildEnumType(schema, tableName, colDiff) {
+        const enumName = `${schema}_${tableName}_${colDiff.colName}_enum`;
+        const enumValues = colDiff.colChanges.enumItems
+            .map((item) => `'${item}'`)
+            .join(', ');
+        const beforeSql = `CREATE TYPE "${enumName}" AS ENUM (${enumValues});`;
+        const columnType = `"${enumName}"`;
+        return { beforeSql, columnType };
+    }
+    appendReturningClause(sql, statement) {
+        const cols = statement.columns.join(', ').replaceAll(`${statement.alias}.`, '');
+        return `${sql} RETURNING ${cols}`;
+    }
+    async handleInsertReturn(statement, result, sql, startTime) {
+        return {
+            query: { rows: Array.isArray(result) ? result : [] },
+            startTime,
+            sql,
+        };
+    }
     getCreateTableInstruction(schema, tableName, creates) {
         let beforeSql = ``;
         const st = `CREATE TABLE "${schema}"."${tableName}" (${creates
@@ -106,49 +132,6 @@ export class BunPgDriver extends BunDriverBase {
     getDropTypeEnumInstruction(param, schema, tableName) {
         return `DROP TYPE IF EXISTS "${param.name}";`;
     }
-    async executeStatement(statement) {
-        let { statement: statementType, table, columns, where, limit, alias } = statement;
-        let sql = '';
-        switch (statementType) {
-            case 'select':
-                sql = `SELECT ${columns ? columns.join(', ') : '*'} FROM ${table} ${alias}`;
-                break;
-            case 'insert':
-                const fields = Object.keys(statement.values)
-                    .map((v) => `"${v}"`)
-                    .join(', ');
-                const values = Object.values(statement.values)
-                    .map((value) => this.toDatabaseValue(value))
-                    .join(', ');
-                sql = `INSERT INTO ${table} (${fields}) VALUES (${values}) RETURNING ${statement.columns.join(', ').replaceAll(`${alias}.`, '')}`;
-                break;
-            case 'update':
-                sql = `UPDATE ${table} as ${alias} SET ${Object.entries(statement.values)
-                    .map(([key, value]) => `${key} = ${this.toDatabaseValue(value)}`)
-                    .join(', ')}`;
-                break;
-            case 'delete':
-                break;
-        }
-        if (statement.join) {
-            statement.join.forEach((join) => {
-                sql += ` ${join.type} JOIN ${join.joinSchema}.${join.joinTable} ${join.joinAlias} ON ${join.on}`;
-            });
-        }
-        if (statementType !== 'insert') {
-            sql += this.buildWhereClause(where);
-            sql += this.buildOrderByClause(statement.orderBy);
-            sql += this.buildOffsetClause(statement.offset);
-            sql += this.buildLimitClause(limit);
-        }
-        const startTime = Date.now();
-        const result = await this.sql.unsafe(sql);
-        return {
-            query: { rows: Array.isArray(result) ? result : [] },
-            startTime,
-            sql,
-        };
-    }
     async snapshot(tableName, options) {
         const schema = (options && options.schema) || 'public';
         const sql = `SELECT * FROM information_schema.columns WHERE table_name = '${tableName}' AND table_schema = '${schema}'`;
@@ -182,7 +165,7 @@ export class BunPgDriver extends BunDriverBase {
                     unique: constraints.some((c) => (c.type === 'UNIQUE' || c.type === 'PRIMARY KEY') &&
                         c.consDef.includes(row.column_name)),
                     type: row.data_type,
-                    foreignKeys: this.getForeignKeys(constraints, row),
+                    foreignKeys: this.getForeignKeysFromConstraints(constraints, row, 'column_name'),
                     isEnum: row.data_type === 'USER-DEFINED',
                     enumItems: row.data_type === 'USER-DEFINED'
                         ? enums[`${schema}_${tableName}_${row.column_name}_enum`]
@@ -194,21 +177,6 @@ export class BunPgDriver extends BunDriverBase {
             }),
         };
     }
-    getForeignKeys(constraints, row) {
-        return constraints
-            .filter((c) => c.type === 'FOREIGN KEY' &&
-            c.consDef.match(new RegExp(`FOREIGN KEY \\("${row.column_name}"\\)`)))
-            .map((c) => {
-            const filter = c.consDef.match(/REFERENCES\s+"([^"]+)"\s*\(([^)]+)\)/);
-            if (!filter) {
-                throw new Error('Invalid constraint definition');
-            }
-            return {
-                referencedColumnName: filter[2].split(',')[0].trim(),
-                referencedTableName: filter[1],
-            };
-        });
-    }
     async index(tableName, options) {
         const schema = (options && options.schema) || 'public';
         let result = await this.sql.unsafe(`SELECT indexname AS index_name, indexdef AS column_name, tablename AS table_name

package/dist/driver/driver.interface.d.ts

@@ -108,7 +108,7 @@ export type Statement<T> = {
     table?: string;
     alias?: string;
     customSchema?: string;
-    columns?: Array<keyof T>;
+    columns?: string[];
     join?: JoinStatement<T>[];
     selectJoin?: Statement<T>[];
     strategy?: 'select' | 'joined';

package/dist/query/model-transformer.d.ts

@@ -0,0 +1,21 @@
+import { Statement } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+export declare class ModelTransformer {
+    private entityStorage;
+    constructor(entityStorage: EntityStorage);
+    transform<T>(model: any, statement: Statement<any>, data: any): T;
+    private createInstances;
+    private createInstance;
+    private addJoinedInstances;
+    private buildOptionsMap;
+    private populateProperties;
+    private parseColumnKey;
+    private setPropertyValue;
+    private findPropertyByColumnName;
+    private isValueObjectType;
+    private linkJoinedEntities;
+    private linkSingleJoin;
+    private findRelationProperty;
+    private attachJoinedEntity;
+    private appendToArray;
+}

package/dist/query/model-transformer.js

@@ -0,0 +1,118 @@
+import { ValueObject } from '../common/value-object';
+import { extendsFrom } from '../utils';
+export class ModelTransformer {
+    constructor(entityStorage) {
+        this.entityStorage = entityStorage;
+    }
+    transform(model, statement, data) {
+        const instanceMap = this.createInstances(model, statement);
+        const optionsMap = this.buildOptionsMap(instanceMap);
+        this.populateProperties(data, instanceMap, optionsMap);
+        this.linkJoinedEntities(statement, instanceMap, optionsMap);
+        return instanceMap[statement.alias];
+    }
+    createInstances(model, statement) {
+        const instance = this.createInstance(model);
+        const instanceMap = {
+            [statement.alias]: instance,
+        };
+        if (statement.join) {
+            this.addJoinedInstances(statement, instanceMap);
+        }
+        return instanceMap;
+    }
+    createInstance(model) {
+        const instance = new model();
+        instance.$_isPersisted = true;
+        return instance;
+    }
+    addJoinedInstances(statement, instanceMap) {
+        statement.join.forEach(join => {
+            const joinInstance = this.createInstance(join.joinEntity);
+            instanceMap[join.joinAlias] = joinInstance;
+        });
+    }
+    buildOptionsMap(instanceMap) {
+        const optionsMap = new Map();
+        for (const [alias, instance] of Object.entries(instanceMap)) {
+            const options = this.entityStorage.get(instance.constructor);
+            if (options) {
+                optionsMap.set(alias, options);
+            }
+        }
+        return optionsMap;
+    }
+    populateProperties(data, instanceMap, optionsMap) {
+        Object.entries(data).forEach(([key, value]) => {
+            const { alias, propertyName } = this.parseColumnKey(key);
+            const entity = instanceMap[alias];
+            if (!entity) {
+                return;
+            }
+            this.setPropertyValue(entity, propertyName, value, optionsMap.get(alias));
+        });
+    }
+    parseColumnKey(key) {
+        const index = key.indexOf('_');
+        return {
+            alias: key.substring(0, index),
+            propertyName: key.substring(index + 1),
+        };
+    }
+    setPropertyValue(entity, columnName, value, options) {
+        const propertyInfo = this.findPropertyByColumnName(columnName, options);
+        if (!propertyInfo) {
+            return;
+        }
+        const { key, property } = propertyInfo;
+        if (this.isValueObjectType(property.type)) {
+            entity[key] = new property.type(value);
+            return;
+        }
+        entity[key] = value;
+    }
+    findPropertyByColumnName(columnName, options) {
+        const entry = Object.entries(options.properties).find(([_, prop]) => prop.options.columnName === columnName);
+        if (!entry) {
+            return null;
+        }
+        return { key: entry[0], property: entry[1] };
+    }
+    isValueObjectType(type) {
+        return extendsFrom(ValueObject, type?.prototype);
+    }
+    linkJoinedEntities(statement, instanceMap, optionsMap) {
+        if (!statement.join) {
+            return;
+        }
+        statement.join.forEach(join => {
+            this.linkSingleJoin(join, instanceMap, optionsMap);
+        });
+    }
+    linkSingleJoin(join, instanceMap, optionsMap) {
+        const { joinAlias, originAlias, propertyKey } = join;
+        const originEntity = instanceMap[originAlias];
+        const joinEntity = instanceMap[joinAlias];
+        if (!originEntity || !joinEntity) {
+            return;
+        }
+        const property = this.findRelationProperty(originAlias, propertyKey, optionsMap);
+        if (property) {
+            this.attachJoinedEntity(originEntity, joinEntity, propertyKey, property);
+        }
+    }
+    findRelationProperty(alias, propertyKey, optionsMap) {
+        return optionsMap.get(alias)?.relations.find(rel => rel.propertyKey === propertyKey);
+    }
+    attachJoinedEntity(originEntity, joinEntity, propertyKey, property) {
+        if (property.type === Array) {
+            originEntity[propertyKey] = this.appendToArray(originEntity[propertyKey], joinEntity);
+        }
+        else {
+            originEntity[propertyKey] = joinEntity;
+        }
+    }
+    appendToArray(existingArray, newItem) {
+        return existingArray ? [...existingArray, newItem] : [newItem];
+    }
+}