@iamkirbki/database-handler-core 4.4.6 → 4.4.8

package/dist/runtime/Repository.d.ts

@@ -1,32 +1,43 @@
-import type Model from "../abstract/Model.js";
-import Record from "../base/Record.js";
-import { columnType, QueryWhereCondition, relation, QueryComparisonParameters, QueryIsEqualParameter, TableFactory, QueryLayers } from "../types/index.js";
-export default class Repository<Type extends columnType, ModelType extends Model<Type>> {
+import type { Model } from '../abstract/Model.js';
+import { columnType, relation, QueryComparisonParameters, QueryIsEqualParameter, QueryLayers } from '../types/index.js';
+import { QueryFactory } from '../types/factories';
+export declare class Repository<Type extends columnType, ModelType extends Model<Type>> {
     private static _instances;
     private models;
     private manyToManyRelations;
-    private Table;
     private customDatabaseAdapter?;
-    private tableFactory;
-    constructor(tableName: string, ModelClass: ModelType, customDatabaseAdapter?: string, tableFactory?: TableFactory);
-    static getInstance<ModelType extends columnType>(ModelClass: new () => Model<ModelType>, tableName: string, customDatabaseAdapter?: string, tableFactory?: TableFactory): Repository<ModelType, Model<ModelType>>;
+    private queryFactory;
+    private tableName;
+    private queryCache;
+    constructor(tableName: string, ModelClass: ModelType, customDatabaseAdapter?: string, queryFactory?: QueryFactory);
+    static getInstance<ModelType extends columnType>(ModelClass: new () => Model<ModelType>, tableName: string, customDatabaseAdapter?: string, queryFactory?: QueryFactory): Repository<ModelType, Model<ModelType>>;
     static clearInstances(): void;
+    private getAdapter;
     private generatePivotTableKeys;
     insertRecordIntoPivotTable(foreignKey: string, modelOfOrigin: ModelType, relation: relation): Promise<void>;
     deleteRecordFromPivotTable(foreignKey: string, modelOfOrigin: ModelType, relation: relation): Promise<void>;
     getManyToManyRelation(relation: relation): Promise<relation | undefined>;
     doesTableExist(name: string): Promise<boolean>;
     syncModel(model: ModelType): void;
-    getModel(name: string): ModelType;
+    getModel(name: string): ModelType | undefined;
     save(attributes: Type): Promise<void>;
     first(queryLayers: QueryLayers, Model: Model<Type>): Promise<Type | undefined>;
     get(QueryLayers: QueryLayers, Model: Model<Type>): Promise<Type[]>;
     all(Model: Model<Type>, QueryLayers: QueryLayers): Promise<Type[]>;
-    update(primaryKey: QueryIsEqualParameter, newAttributes: Partial<Type>, table: string): Promise<Record<Type> | undefined>;
+    update(primaryKey: QueryIsEqualParameter, newAttributes: Partial<Type>, table: string): Promise<Type | undefined>;
+    private getRecords;
+    private getRecord;
     private join;
+    private getJoinRecords;
+    private mapJoinedResults;
     toSql(queryLayers: QueryLayers, Model: Model<Type>): Promise<string>;
+    private buildQueryString;
+    private hydrateJoinedRecords;
     private buildJoinObject;
-    mergeQueryWhereConditions(base: QueryWhereCondition, additional: QueryWhereCondition): QueryComparisonParameters[];
-    ConvertParamsToArray(params: QueryWhereCondition): QueryComparisonParameters[];
+    mergeQueryWhereConditions(base: QueryComparisonParameters[], additional: QueryComparisonParameters[]): QueryComparisonParameters[];
+    private convertParamsToObject;
+    private buildInsertQuery;
+    private buildUpdateQuery;
+    private buildDeleteQuery;
 }
 //# sourceMappingURL=Repository.d.ts.map

package/dist/runtime/Repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Repository.d.ts","sourceRoot":"","sources":["../../src/runtime/Repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,yBAAyB,CAAC;AACjD,OAAO,MAAM,MAAM,sBAAsB,CAAC;AAE1C,OAAO,EAAE,UAAU,EAAQ,mBAAmB,EAAE,QAAQ,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEpK,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,IAAI,SAAS,UAAU,EAAE,SAAS,SAAS,KAAK,CAAC,IAAI,CAAC;IAClF,OAAO,CAAC,MAAM,CAAC,UAAU,CAAqE;IAC9F,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,mBAAmB,CAAoC;IAC/D,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,YAAY,CAAe;gBAG/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,SAAS,EACrB,qBAAqB,CAAC,EAAE,MAAM,EAC9B,YAAY,GAAE,YAA0D;WAS9D,WAAW,CAAC,SAAS,SAAS,UAAU,EAClD,UAAU,EAAE,UAAU,KAAK,CAAC,SAAS,CAAC,EACtC,SAAS,EAAE,MAAM,EACjB,qBAAqB,CAAC,EAAE,MAAM,EAC9B,YAAY,CAAC,EAAE,YAAY,GAC5B,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;WAiB5B,cAAc,IAAI,IAAI;IAIpC,OAAO,CAAC,sBAAsB;IAajB,0BAA0B,CACnC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,QAAQ,GACnB,OAAO,CAAC,IAAI,CAAC;IAKH,0BAA0B,CACnC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,QAAQ,GACnB,OAAO,CAAC,IAAI,CAAC;IAMH,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAaxE,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpD,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAKjC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAI3B,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrC,KAAK,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAY9E,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IASlE,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAIlE,MAAM,CAAC,UAAU,EAAE,qBAAqB,EAAE,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;YAOxH,IAAI;IAaL,KAAK,CACd,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GACnB,OAAO,CAAC,MAAM,CAAC;IAYlB,OAAO,CAAC,eAAe;IAmHhB,yBAAyB,CAAC,IAAI,EAAE,mBAAmB,EAAE,UAAU,EAAE,mBAAmB,GAAG,yBAAyB,EAAE;IAKlH,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,yBAAyB,EAAE;CAIxF"}
+{"version":3,"file":"Repository.d.ts","sourceRoot":"","sources":["../../src/runtime/Repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EACL,UAAU,EAEV,QAAQ,EACR,yBAAyB,EACzB,qBAAqB,EACrB,WAAW,EAGZ,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAMrD,qBAAa,UAAU,CACrB,IAAI,SAAS,UAAU,EACvB,SAAS,SAAS,KAAK,CAAC,IAAI,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAC,UAAU,CAGX;IACd,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,mBAAmB,CAAoC;IAC/D,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAa;gBAG7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,SAAS,EACrB,qBAAqB,CAAC,EAAE,MAAM,EAC9B,YAAY,GAAE,YAA4C;WAW9C,WAAW,CAAC,SAAS,SAAS,UAAU,EACpD,UAAU,EAAE,UAAU,KAAK,CAAC,SAAS,CAAC,EACtC,SAAS,EAAE,MAAM,EACjB,qBAAqB,CAAC,EAAE,MAAM,EAC9B,YAAY,CAAC,EAAE,YAAY,GAC1B,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;WAiB5B,cAAc,IAAI,IAAI;IAIpC,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,sBAAsB;IAmBjB,0BAA0B,CACrC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC;IAiBH,0BAA0B,CACrC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC;IAiBH,qBAAqB,CAChC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAmBnB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYpD,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAKjC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIvC,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAWrC,KAAK,CAChB,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAiBf,GAAG,CACd,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,EAAE,CAAC;IAQL,GAAG,CACd,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,IAAI,EAAE,CAAC;IAIL,MAAM,CACjB,UAAU,EAAE,qBAAqB,EACjC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,EAC5B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;YAyDd,UAAU;YAgCV,SAAS;YAYT,IAAI;YAeJ,cAAc;YAwDd,gBAAgB;IA6CjB,KAAK,CAChB,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,MAAM,CAAC;YAYJ,gBAAgB;IAsB9B,OAAO,CAAC,oBAAoB;IAwD5B,OAAO,CAAC,eAAe;IA0GhB,yBAAyB,CAC9B,IAAI,EAAE,yBAAyB,EAAE,EACjC,UAAU,EAAE,yBAAyB,EAAE,GACtC,yBAAyB,EAAE;IAI9B,OAAO,CAAC,qBAAqB;YAgBf,gBAAgB;YAOhB,gBAAgB;YAwBhB,gBAAgB;CAiB/B"}

package/dist/runtime/Repository.js

@@ -1,47 +1,76 @@
-import Table from "../base/Table.js";
-class Repository {
-    constructor(tableName, ModelClass, customDatabaseAdapter, tableFactory = (name, adapter) => new Table(name, adapter)) {
+import { Query } from '../base/Query.js';
+import { QueryStatementBuilder } from '../helpers/QueryBuilders/QueryStatementBuilder.js';
+import { Container } from '../index.js';
+import { QueryCache } from '../runtime/QueryCache.js';
+import { RelationError } from '../helpers/Errors/ModelErrors/RelationError.js';
+import { InvalidOperationError } from '../helpers/Errors/ModelErrors/InvalidOperationError.js';
+import { UnknownTableError } from '../helpers/Errors/TableErrors/UnknownTableError.js';
+import { DepricatedQueryStatementBuilder } from '../helpers/QueryBuilders/depricatedQueryStatementBuilder.js';
+export class Repository {
+    constructor(tableName, ModelClass, customDatabaseAdapter, queryFactory = (config) => new Query(config)) {
         var _a;
         this.models = new Map();
         this.manyToManyRelations = new Map();
         const modelPk = ((_a = ModelClass.primaryKey) === null || _a === void 0 ? void 0 : _a.toString()) || ModelClass.constructor.name;
         this.models.set(modelPk, ModelClass);
-        this.tableFactory = tableFactory;
-        this.Table = this.tableFactory(tableName, customDatabaseAdapter);
+        this.queryFactory = queryFactory;
+        this.tableName = tableName;
         this.customDatabaseAdapter = customDatabaseAdapter;
+        this.queryCache = QueryCache.getInstance();
     }
-    static getInstance(ModelClass, tableName, customDatabaseAdapter, tableFactory) {
-        // Use tableName as key to differentiate instances for different tables
-        const key = tableName || ModelClass.name;
-        if (!this._instances.has(key)) {
-            const instance = new Repository(tableName, new ModelClass(), customDatabaseAdapter, tableFactory);
-            this._instances.set(key, instance);
+    static getInstance(ModelClass, tableName, customDatabaseAdapter, queryFactory) {
+        const modelNameKey = tableName || ModelClass.name;
+        const existing = this._instances.get(modelNameKey);
+        if (!existing) {
+            const instance = new Repository(tableName, new ModelClass(), customDatabaseAdapter, queryFactory);
+            this._instances.set(modelNameKey, instance);
             return instance;
         }
-        return this._instances.get(key);
+        return existing;
     }
     static clearInstances() {
         this._instances.clear();
     }
+    getAdapter() {
+        return Container.getInstance().getAdapter(this.customDatabaseAdapter);
+    }
     generatePivotTableKeys(foreignKey, modelOfOrigin, relation) {
         var _a;
         const isLocal = !((_a = relation.pivotLocalKey) === null || _a === void 0 ? void 0 : _a.includes(modelOfOrigin.Configuration.table));
         return {
-            [relation.pivotLocalKey]: isLocal ? foreignKey : modelOfOrigin.values[relation.foreignKey],
-            [relation.pivotForeignKey]: isLocal ? modelOfOrigin.values[relation.foreignKey] : foreignKey
+            [relation.pivotLocalKey]: isLocal
+                ? foreignKey
+                : modelOfOrigin.values[relation.foreignKey],
+            [relation.pivotForeignKey]: isLocal
+                ? modelOfOrigin.values[relation.foreignKey]
+                : foreignKey,
         };
     }
     async insertRecordIntoPivotTable(foreignKey, modelOfOrigin, relation) {
-        const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
-        await table.Insert(this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation));
+        const keys = this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation);
+        const queryStr = await this.buildInsertQuery(relation.pivotTable, keys);
+        const query = this.queryFactory({
+            tableName: relation.pivotTable,
+            query: queryStr,
+            parameters: keys,
+            adapterName: this.customDatabaseAdapter,
+        });
+        await query.Run();
     }
     async deleteRecordFromPivotTable(foreignKey, modelOfOrigin, relation) {
-        const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
-        const record = await table.Record({ base: { where: this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation) } });
-        await (record === null || record === void 0 ? void 0 : record.Delete());
+        const keys = this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation);
+        const queryStr = await this.buildDeleteQuery(relation.pivotTable, keys);
+        const query = this.queryFactory({
+            tableName: relation.pivotTable,
+            query: queryStr,
+            parameters: keys,
+            adapterName: this.customDatabaseAdapter,
+        });
+        await query.Run();
     }
     async getManyToManyRelation(relation) {
-        if (relation.pivotTable && this.manyToManyRelations.has(relation.pivotTable)) {
+        if (relation.pivotTable &&
+            this.manyToManyRelations.has(relation.pivotTable)) {
             return this.manyToManyRelations.get(relation.pivotTable);
         }
         if (await this.doesTableExist(relation.pivotTable)) {
@@ -49,12 +78,19 @@ class Repository {
             return relation;
         }
         else {
-            throw new Error(`Pivot table ${relation.pivotTable} does not exist. Create it in alphabetical order before using many-to-many relationships.`);
+            throw new UnknownTableError(relation.pivotTable, 'Create it in alphabetical order before using many-to-many relationships.');
         }
     }
     async doesTableExist(name) {
-        const table = this.tableFactory(name, this.customDatabaseAdapter);
-        return await table.exists();
+        if (this.queryCache.doesTableExist(name)) {
+            return true;
+        }
+        const adapter = this.getAdapter();
+        const exists = await adapter.tableExists(name);
+        if (exists) {
+            this.queryCache.addExistingTable(name);
+        }
+        return exists;
     }
     syncModel(model) {
         var _a;
@@ -65,42 +101,186 @@ class Repository {
         return this.models.get(name);
     }
     async save(attributes) {
-        await this.Table.Insert(attributes);
+        const queryStr = await this.buildInsertQuery(this.tableName, attributes);
+        const query = this.queryFactory({
+            tableName: this.tableName,
+            query: queryStr,
+            parameters: attributes,
+            adapterName: this.customDatabaseAdapter,
+        });
+        await query.Run();
     }
     async first(queryLayers, Model) {
         let record;
         if (Model.JoinedEntities.length > 0) {
-            const result = (await this.join(Model, { ...queryLayers, final: { ...queryLayers.final, limit: 1 } }))[0];
-            record = result ? { values: result } : undefined;
+            const result = (await this.join(Model, {
+                ...queryLayers,
+                final: { ...queryLayers.final, limit: 1 },
+            }))[0];
+            record = result;
         }
         else {
-            record = await this.Table.Record(queryLayers);
+            record = await this.getRecord(queryLayers, true);
         }
-        return record === null || record === void 0 ? void 0 : record.values;
+        return record;
     }
     async get(QueryLayers, Model) {
         if (Model.JoinedEntities.length > 0) {
             return await this.join(Model, QueryLayers);
         }
         else {
-            const records = await this.Table.Records(QueryLayers);
-            return records.map(record => record.values);
+            return await this.getRecords(QueryLayers);
         }
     }
     async all(Model, QueryLayers) {
         return this.get(QueryLayers, Model);
     }
     async update(primaryKey, newAttributes, table) {
-        const record = await this.Table.Record({ base: { from: table, where: primaryKey } });
-        if (record) {
-            return await record.Update(newAttributes, primaryKey);
+        const checkQuery = this.queryFactory({
+            tableName: table,
+            query: '',
+            parameters: {},
+            adapterName: this.customDatabaseAdapter,
+        });
+        const columns = await checkQuery.TableColumnInformation(table);
+        if (columns.some((col) => col.name === 'updated_at')) {
+            newAttributes['updated_at'] = new Date();
         }
+        const filteredAttributes = Object.fromEntries(Object.entries(newAttributes).filter(([, value]) => value !== undefined));
+        if (Object.keys(filteredAttributes).length === 0) {
+            return undefined;
+        }
+        const queryStr = await this.buildUpdateQuery(table, filteredAttributes, primaryKey);
+        const whereParams = {};
+        Object.entries(primaryKey).forEach(([key, value]) => {
+            whereParams[`where_${key}`] = value;
+        });
+        const params = { ...filteredAttributes, ...whereParams };
+        const query = this.queryFactory({
+            tableName: table,
+            query: queryStr,
+            parameters: params,
+            adapterName: this.customDatabaseAdapter,
+        });
+        await query.Run();
+        const normalizedPrimaryKey = Object.entries(primaryKey).map(([column, value]) => ({
+            column,
+            operator: '=',
+            value,
+        }));
+        const updatedRecord = await this.getRecord({ base: { from: table, where: normalizedPrimaryKey } }, true);
+        return updatedRecord;
+    }
+    async getRecords(queryLayers) {
+        var _a, _b;
+        const builder = new QueryStatementBuilder(queryLayers);
+        const queryStr = await builder.build();
+        let params = {};
+        if (((_a = queryLayers === null || queryLayers === void 0 ? void 0 : queryLayers.base) === null || _a === void 0 ? void 0 : _a.where) &&
+            Object.keys(queryLayers.base.where).length > 0) {
+            params = this.convertParamsToObject(queryLayers.base.where);
+        }
+        if (((_b = queryLayers === null || queryLayers === void 0 ? void 0 : queryLayers.pretty) === null || _b === void 0 ? void 0 : _b.where) &&
+            Object.keys(queryLayers.pretty.where).length > 0) {
+            params = {
+                ...params,
+                ...this.convertParamsToObject(queryLayers.pretty.where),
+            };
+        }
+        const query = this.queryFactory({
+            tableName: this.tableName,
+            query: queryStr,
+            parameters: params,
+            adapterName: this.customDatabaseAdapter,
+        });
+        const results = await query.All();
+        return results.map((r) => r.values);
+    }
+    async getRecord(queryLayers, limitOne = false) {
+        const layers = limitOne
+            ? { ...queryLayers, final: { ...queryLayers === null || queryLayers === void 0 ? void 0 : queryLayers.final, limit: 1 } }
+            : queryLayers;
+        const records = await this.getRecords(layers);
+        return records[0];
     }
     async join(Model, queryLayers) {
         const { joins, queryLayers: nextLayers } = this.buildJoinObject(Model, queryLayers);
         nextLayers.base.joins = joins;
-        const records = await this.Table.Join(nextLayers);
-        return records.map(record => record.values);
+        const records = await this.getJoinRecords(nextLayers);
+        return records;
+    }
+    async getJoinRecords(queryLayers) {
+        var _a, _b;
+        if (queryLayers.base.joins === undefined ||
+            (Array.isArray(queryLayers.base.joins) &&
+                queryLayers.base.joins.length === 0)) {
+            throw new InvalidOperationError('No joins defined for the Join operation.');
+        }
+        const joinedTables = queryLayers.base.joins.map((j) => j.fromTable);
+        const tableColumnCache = new Map();
+        const adapter = this.getAdapter();
+        const columnInfo = await adapter.tableColumnInformation(this.tableName);
+        tableColumnCache.set(this.tableName, columnInfo);
+        for (const tableName of joinedTables) {
+            const columnInfo = await adapter.tableColumnInformation(tableName);
+            tableColumnCache.set(tableName, columnInfo);
+        }
+        const builder = new QueryStatementBuilder(queryLayers, tableColumnCache);
+        const queryString = await builder.build();
+        let params = {};
+        if ((_a = queryLayers === null || queryLayers === void 0 ? void 0 : queryLayers.base) === null || _a === void 0 ? void 0 : _a.where) {
+            params = this.convertParamsToObject(queryLayers.base.where);
+        }
+        if ((_b = queryLayers === null || queryLayers === void 0 ? void 0 : queryLayers.pretty) === null || _b === void 0 ? void 0 : _b.where) {
+            params = {
+                ...params,
+                ...this.convertParamsToObject(queryLayers.pretty.where),
+            };
+        }
+        const query = this.queryFactory({
+            tableName: this.tableName,
+            query: queryString,
+            parameters: params,
+            adapterName: this.customDatabaseAdapter,
+        });
+        const records = await query.All();
+        const rawMapped = await this.mapJoinedResults(records, queryLayers.base.joins);
+        const joinAliases = queryLayers.base.joins.map((j) => j.name || j.fromTable);
+        const splitTables = this.hydrateJoinedRecords(rawMapped, joinAliases);
+        return splitTables;
+    }
+    async mapJoinedResults(records, joins) {
+        return records.map((record) => {
+            var _a;
+            const mainTableData = {};
+            const joinedTableData = {};
+            for (const [aliasedKey, value] of Object.entries(record.values)) {
+                if (aliasedKey.includes('__')) {
+                    const [tableName, columnName] = aliasedKey.split('__');
+                    if (tableName === this.tableName) {
+                        mainTableData[columnName] = value;
+                    }
+                    else {
+                        // Check if tableName matches any join alias or table name
+                        const currentJoin = joins.find((j) => (j.name || j.fromTable) === tableName);
+                        if (currentJoin) {
+                            const aliasedTableName = currentJoin.name || currentJoin.fromTable;
+                            (_a = joinedTableData[aliasedTableName]) !== null && _a !== void 0 ? _a : (joinedTableData[aliasedTableName] = {});
+                            joinedTableData[aliasedTableName][columnName] = value;
+                        }
+                    }
+                }
+                else {
+                    mainTableData[aliasedKey] = value;
+                }
+            }
+            const filteredJoinedData = Object.fromEntries(Object.entries(joinedTableData).filter(([, data]) => Object.keys(data).length > 0));
+            const combinedData = {
+                ...mainTableData,
+                ...filteredJoinedData,
+            };
+            return combinedData;
+        });
     }
     async toSql(queryLayers, Model) {
         let nextLayers = queryLayers;
@@ -109,7 +289,66 @@ class Repository {
             nextLayers = result.queryLayers;
             nextLayers.base.joins = result.joins;
         }
-        return this.Table.toSql(nextLayers);
+        return this.buildQueryString(nextLayers);
+    }
+    async buildQueryString(queryLayers) {
+        if (queryLayers.base.joins && queryLayers.base.joins.length > 0) {
+            const joinedTables = queryLayers.base.joins.map((j) => j.fromTable);
+            const tableColumnCache = new Map();
+            const adapter = this.getAdapter();
+            const columnInfo = await adapter.tableColumnInformation(this.tableName);
+            tableColumnCache.set(this.tableName, columnInfo);
+            for (const tableName of joinedTables) {
+                const columnInfo = await adapter.tableColumnInformation(tableName);
+                tableColumnCache.set(tableName, columnInfo);
+            }
+            const builder = new QueryStatementBuilder(queryLayers, tableColumnCache);
+            return await builder.build();
+        }
+        else {
+            const builder = new QueryStatementBuilder(queryLayers);
+            return await builder.build();
+        }
+    }
+    hydrateJoinedRecords(records, joinedTables, primaryKey = 'id') {
+        var _a;
+        const parentMap = new Map();
+        for (const values of records) {
+            const parentId = values[primaryKey];
+            const parentData = {};
+            const childData = {};
+            for (const [key, val] of Object.entries(values)) {
+                if (joinedTables.includes(key)) {
+                    childData[key] = val;
+                }
+                else {
+                    parentData[key] = val;
+                }
+            }
+            if (!parentMap.has(parentId)) {
+                const childMaps = {};
+                for (const table of joinedTables) {
+                    childMaps[table] = new Map();
+                }
+                parentMap.set(parentId, { parent: parentData, childMaps });
+            }
+            const entry = parentMap.get(parentId);
+            for (const [table, child] of Object.entries(childData)) {
+                const childId = (_a = child[primaryKey]) !== null && _a !== void 0 ? _a : Object.values(child)
+                    .filter((v) => v !== null)
+                    .join('__');
+                if (childId !== undefined && childId !== '') {
+                    entry.childMaps[table].set(childId, child);
+                }
+            }
+        }
+        return Array.from(parentMap.values()).map(({ parent, childMaps }) => {
+            const merged = { ...parent };
+            for (const [table, childMap] of Object.entries(childMaps)) {
+                merged[table] = Array.from(childMap.values());
+            }
+            return merged;
+        });
     }
     buildJoinObject(Model, inputLayers) {
         const queryLayers = {
@@ -117,21 +356,18 @@ class Repository {
             base: {
                 ...inputLayers.base,
             },
-            final: inputLayers.final
-                ? { ...inputLayers.final }
-                : undefined
+            final: inputLayers.final ? { ...inputLayers.final } : undefined,
         };
-        const joins = Model.JoinedEntities.flatMap(join => {
+        const joins = Model.JoinedEntities.flatMap((join) => {
             var _a, _b;
             var _c;
-            let relation = Model.Relations.find(rel => rel.model.Configuration.table
-                .replace("_", "")
-                .toLowerCase() === join.relation.toLowerCase());
+            let relation = Model.Relations.find((rel) => rel.model.Configuration.table.replace('_', '').toLowerCase() ===
+                join.relation.toLowerCase());
             if (!relation) {
-                relation = Model.Relations.find(rel => rel.path.split(".")[1] === join.path.split('.')[1]); //Try a little harder
+                relation = Model.Relations.find((rel) => rel.path === join.path);
             }
             if (!relation) {
-                throw new Error(`Relation for joined entity ${join.relation} not found.`);
+                throw new RelationError(join.relation, 'Relation not found.');
             }
             if (join.queryScopes && queryLayers.base.where) {
                 queryLayers.base.where = this.mergeQueryWhereConditions(queryLayers.base.where, join.queryScopes);
@@ -160,24 +396,26 @@ class Repository {
                         baseKey = relation.localKey;
                     }
                 }
+                const relationName = join.alias || relation.name;
                 return [
                     {
-                        fromTable: targetTable ? targetTable : relation.model.Configuration.table,
+                        fromTable: targetTable
+                            ? targetTable
+                            : relation.model.Configuration.table,
                         baseTable: baseTable ? baseTable : Model.Configuration.table,
                         joinType,
-                        name: relation.name,
+                        name: relationName,
                         on: [
-                            { [relation.foreignKey]: baseKey ? baseKey : relation.localKey }
-                        ]
-                    }
+                            { [relation.foreignKey]: baseKey ? baseKey : relation.localKey },
+                        ],
+                    },
                 ];
             }
-            // many to many
             (_a = queryLayers.final) !== null && _a !== void 0 ? _a : (queryLayers.final = {});
             (_b = (_c = queryLayers.final).blacklistTables) !== null && _b !== void 0 ? _b : (_c.blacklistTables = []);
             queryLayers.final.blacklistTables = [
                 ...queryLayers.final.blacklistTables,
-                relation.pivotTable
+                relation.pivotTable,
             ];
             return [
                 {
@@ -185,31 +423,52 @@ class Repository {
                     baseTable: Model.Configuration.table,
                     joinType: 'INNER',
                     name: relation.name,
-                    on: [
-                        { [relation.pivotForeignKey]: relation.localKey }
-                    ]
+                    on: [{ [relation.pivotForeignKey]: relation.localKey }],
                 },
                 {
                     fromTable: relation.model.Configuration.table,
                     baseTable: relation.pivotTable,
                     joinType: 'INNER',
                     name: relation.name,
-                    on: [
-                        { [relation.foreignKey]: relation.pivotLocalKey }
-                    ]
-                }
+                    on: [{ [relation.foreignKey]: relation.pivotLocalKey }],
+                },
             ];
         });
         return { joins, queryLayers };
     }
     mergeQueryWhereConditions(base, additional) {
-        const query = this.Table.QueryHelperObject;
-        return [...query.ConvertParamsToArray(base), ...query.ConvertParamsToArray(additional)];
+        return [...base, ...additional];
+    }
+    convertParamsToObject(params) {
+        const paramObject = {};
+        params.forEach((param) => {
+            const colName = param.column.trim();
+            const paramName = colName.includes('.')
+                ? colName.split('.')[1].trim()
+                : colName;
+            paramObject[paramName] = param.value;
+        });
+        return paramObject;
+    }
+    async buildInsertQuery(tableName, data) {
+        return DepricatedQueryStatementBuilder.BuildInsert(tableName, data);
+    }
+    async buildUpdateQuery(tableName, data, where) {
+        const filteredData = Object.fromEntries(Object.entries(data).filter(([, value]) => value !== undefined));
+        const whereConditions = Object.entries(where).map(([key, value]) => ({
+            column: key,
+            operator: '=',
+            value: value,
+        }));
+        return DepricatedQueryStatementBuilder.BuildUpdate(tableName, filteredData, whereConditions);
     }
-    ConvertParamsToArray(params) {
-        const query = this.Table.QueryHelperObject;
-        return query.ConvertParamsToArray(params);
+    async buildDeleteQuery(tableName, where) {
+        const whereConditions = Object.entries(where).map(([key, value]) => ({
+            column: key,
+            operator: '=',
+            value: value,
+        }));
+        return DepricatedQueryStatementBuilder.BuildDelete(tableName, whereConditions);
     }
 }
 Repository._instances = new Map();
-export default Repository;