@iamkirbki/database-handler-core 4.2.0 → 4.3.1

package/dist/base/Table.js

@@ -12,19 +12,30 @@ import { Record, Query } from "../index.js";
 /** Table class for interacting with a database table */
 export default class Table {
     /** Private constructor - use Table.create() */
-    constructor(name) {
+    constructor(name, customAdapter, queryFactory = (config) => new Query(config), recordFactory = (table, values, adapter) => new Record(table, values, adapter)) {
         this._name = name;
+        this._customAdapter = customAdapter;
+        this._queryFactory = queryFactory;
+        this._recordFactory = recordFactory;
+        this._query = this._queryFactory({
+            tableName: this._name,
+            adapterName: this._customAdapter,
+            recordFactory: this._recordFactory
+        });
+    }
+    get QueryHelperObject() {
+        return this._query;
     }
     /** Get raw column information */
-    TableColumnInformation() {
+    TableColumnInformation(tableName) {
         return __awaiter(this, void 0, void 0, function* () {
-            return Query.tableColumnInformation(this._name);
+            return this._query.TableColumnInformation(tableName || this._name);
         });
     }
     /** Get readable, formatted column information */
     ReadableTableColumnInformation() {
         return __awaiter(this, void 0, void 0, function* () {
-            const columns = yield this.TableColumnInformation();
+            const columns = yield this.TableColumnInformation(this._name);
             return columns.map((col) => ({
                 name: col.name,
                 type: col.type,
@@ -37,7 +48,12 @@ export default class Table {
     Drop() {
         return __awaiter(this, void 0, void 0, function* () {
             const queryStr = `DROP TABLE IF EXISTS "${this._name}";`;
-            const query = new Query(this._name, queryStr);
+            const query = this._queryFactory({
+                tableName: this._name,
+                query: queryStr,
+                adapterName: this._customAdapter,
+                recordFactory: this._recordFactory
+            });
             yield query.Run();
         });
     }
@@ -51,9 +67,15 @@ export default class Table {
                 limit: options === null || options === void 0 ? void 0 : options.limit,
                 offset: options === null || options === void 0 ? void 0 : options.offset,
             });
-            const query = new Query(this._name, queryStr);
+            let params = {};
             if ((options === null || options === void 0 ? void 0 : options.where) && Object.keys(options.where).length > 0)
-                query.Parameters = options.where;
+                params = options.where;
+            const query = this._queryFactory({
+                tableName: this._name,
+                query: queryStr,
+                parameters: params,
+                recordFactory: this._recordFactory
+            });
             const results = yield query.All();
             return results;
         });
@@ -73,15 +95,29 @@ export default class Table {
     /** Get the total count of records */
     RecordsCount() {
         return __awaiter(this, void 0, void 0, function* () {
-            const query = new Query(this._name, `SELECT COUNT(*) as count FROM "${this._name}";`);
+            const query = this._queryFactory({
+                tableName: this._name,
+                query: `SELECT COUNT(*) as count FROM "${this._name}"`,
+                recordFactory: this._recordFactory
+            });
             const count = yield query.Count();
             return count || 0;
         });
     }
+    exists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this._queryFactory({
+                tableName: this._name,
+                adapterName: this._customAdapter,
+                recordFactory: this._recordFactory
+            });
+            return yield query.DoesTableExist();
+        });
+    }
     /** Insert a record into the table */
     Insert(values) {
         return __awaiter(this, void 0, void 0, function* () {
-            const record = new Record(values, this._name);
+            const record = this._recordFactory(this._name, values, this._customAdapter);
             yield record.Insert();
             return record;
         });
@@ -89,38 +125,52 @@ export default class Table {
     /** Perform JOIN operations with other tables */
     Join(Joins, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const queryString = QueryStatementBuilder.BuildJoin(this._name, Joins, options);
-            const query = new Query(this._name, queryString);
-            // Set parameters if WHERE clause is present
-            if (options === null || options === void 0 ? void 0 : options.where) {
-                query.Parameters = options.where;
-            }
+            const queryString = yield QueryStatementBuilder.BuildJoin(this._name, Joins, this.QueryHelperObject, options);
+            let params = {};
+            if (options === null || options === void 0 ? void 0 : options.where)
+                params = options.where;
+            const query = this._queryFactory({
+                tableName: this._name,
+                query: queryString,
+                parameters: params,
+                recordFactory: this._recordFactory
+            });
             const joinedTables = Array.isArray(Joins) ? Joins.map(j => j.fromTable) : [Joins.fromTable];
+            if (options) {
+                options.select = joinedTables.map(table => `${table}.*`).join(', ');
+            }
             const records = yield query.All();
-            return yield this.splitJoinValues(records, joinedTables);
+            const splitTables = yield this.splitJoinValues(records, joinedTables);
+            return splitTables;
         });
     }
     splitJoinValues(records, joinedTables) {
         return __awaiter(this, void 0, void 0, function* () {
-            const thisRecordColumns = (yield this.TableColumnInformation()).map(col => col.name);
-            const tableColumnsMap = new Map();
-            for (const tableName of joinedTables) {
-                const columns = (yield Query.tableColumnInformation(tableName)).map(col => col.name);
-                tableColumnsMap.set(tableName, columns);
-            }
             return records.map(record => {
                 if (!record.values)
                     return record;
-                const thisRecordEntries = thisRecordColumns
-                    .map(colName => [colName, record.values[colName]])
-                    .filter(([, value]) => value !== undefined);
-                const joinedRecords = {};
-                for (const [tableName, tableColumns] of tableColumnsMap) {
-                    const joinedRecordEntries = Object.entries(record.values)
-                        .filter(([key]) => tableColumns.includes(key));
-                    joinedRecords[tableName] = Object.fromEntries(joinedRecordEntries);
+                const mainTableData = {};
+                const joinedTableData = {};
+                for (const tableName of joinedTables) {
+                    joinedTableData[tableName] = {};
+                }
+                for (const [aliasedKey, value] of Object.entries(record.values)) {
+                    if (aliasedKey.includes('__')) {
+                        const [tableName, columnName] = aliasedKey.split('__');
+                        if (tableName === this._name) {
+                            mainTableData[columnName] = value;
+                        }
+                        else if (joinedTables.includes(tableName)) {
+                            joinedTableData[tableName][columnName] = value;
+                        }
+                    }
+                    else {
+                        mainTableData[aliasedKey] = value;
+                    }
                 }
-                return new Record(Object.assign(Object.assign({}, Object.fromEntries(thisRecordEntries)), joinedRecords), this._name);
+                // Combine main table data with nested joined table data
+                const combinedData = Object.assign(Object.assign({}, mainTableData), joinedTableData);
+                return this._recordFactory(this._name, combinedData, this._customAdapter);
             });
         });
     }

package/dist/helpers/QueryStatementBuilder.d.ts

@@ -1,4 +1,5 @@
-import { DefaultQueryOptions, QueryOptions, QueryCondition, Join, QueryWhereParameters } from "../types/index.js";
+import { Query } from "../index.js";
+import { DefaultQueryParameters, ExtraQueryParameters, QueryWhereCondition, Join, QueryIsEqualParameter } from "../types/index.js";
 /** Utility class for building SQL query strings */
 export default class QueryStatementBuilder {
     /**
@@ -25,7 +26,7 @@ export default class QueryStatementBuilder {
      * // "SELECT id, name, email FROM users WHERE status = @status AND age = @age ORDER BY created_at DESC LIMIT 10 OFFSET 20"
      * ```
      */
-    static BuildSelect(tableName: string, options?: DefaultQueryOptions & QueryOptions): string;
+    static BuildSelect(tableName: string, options?: DefaultQueryParameters & ExtraQueryParameters): string;
     /**
      * Build an INSERT SQL statement with named parameter placeholders
      *
@@ -45,7 +46,7 @@ export default class QueryStatementBuilder {
      * // Note: The actual values will be bound separately using the Parameters object
      * ```
      */
-    static BuildInsert(tableName: string, record: QueryWhereParameters): string;
+    static BuildInsert(tableName: string, record: QueryIsEqualParameter): string;
     /**
      * Build an UPDATE SQL statement with SET clause and WHERE conditions
      *
@@ -72,7 +73,7 @@ export default class QueryStatementBuilder {
      * // "UPDATE users SET status = @status WHERE status = @status AND last_login = @last_login"
      * ```
      */
-    static BuildUpdate(tableName: string, record: QueryCondition, where: QueryCondition): string;
+    static BuildUpdate(tableName: string, record: QueryWhereCondition, where: QueryWhereCondition): string;
     /**
      * Build a DELETE SQL statement with WHERE conditions
      *
@@ -93,7 +94,7 @@ export default class QueryStatementBuilder {
      * // "DELETE FROM users WHERE status = @status AND last_login = @last_login"
      * ```
      */
-    static BuildDelete(tableName: string, where: QueryCondition): string;
+    static BuildDelete(tableName: string, where: QueryWhereCondition): string;
     /**
      * Build a COUNT SQL statement to count rows, optionally with WHERE conditions
      *
@@ -115,7 +116,7 @@ export default class QueryStatementBuilder {
      * // "SELECT COUNT(*) as count FROM users WHERE status = @status AND age = @age"
      * ```
      */
-    static BuildCount(tableName: string, where?: QueryCondition): string;
+    static BuildCount(tableName: string, where?: QueryWhereCondition): string;
     /**
      * Build a WHERE clause from parameter conditions (helper method)
      *
@@ -144,7 +145,7 @@ export default class QueryStatementBuilder {
      * // ""
      * ```
      */
-    static BuildWhere(where?: QueryCondition): string;
+    static BuildWhere(where?: QueryWhereCondition): string;
     private static buildWhereWithOperators;
     private static buildWhereSimple;
     /**
@@ -191,7 +192,8 @@ export default class QueryStatementBuilder {
      * );
      * ```
      */
-    static BuildJoin(fromTableName: string, joins: Join | Join[], options?: DefaultQueryOptions & QueryOptions): string;
+    static BuildJoin(fromTableName: string, joins: Join | Join[], query: Query, options?: DefaultQueryParameters & ExtraQueryParameters): Promise<string>;
+    static BuildJoinSelect(fromTableName: string, joins: Join | Join[], query: Query): Promise<string>;
     /**
      * Build JOIN clause(s) recursively (helper method)
      *
@@ -264,7 +266,7 @@ export default class QueryStatementBuilder {
      * // "ON users.id = orders.user_id AND users.company_id = orders.company_id"
      * ```
      */
-    static BuildJoinOnPart(tableName: string, joinTableName: string, on: QueryWhereParameters | QueryWhereParameters[]): string;
+    static BuildJoinOnPart(tableName: string, joinTableName: string, on: QueryIsEqualParameter | QueryIsEqualParameter[]): string;
     /**
      * Build query options clause (ORDER BY, LIMIT, OFFSET) (helper method)
      *
@@ -298,6 +300,6 @@ export default class QueryStatementBuilder {
      * // "LIMIT 25 OFFSET 50"
      * ```
      */
-    static BuildQueryOptions(options: QueryOptions): string;
+    static BuildQueryOptions(options: ExtraQueryParameters): string;
 }
 //# sourceMappingURL=QueryStatementBuilder.d.ts.map

package/dist/helpers/QueryStatementBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../src/helpers/QueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,cAAc,EAAE,IAAI,EAAmB,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEtI,mDAAmD;AACnD,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAAG,MAAM;IAWlG;;;;;;;;;;;;;;;;;;OAkBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,MAAM;IAYlF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM;IAWnG;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM;IAS3E;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,cAAc,GAAG,MAAM;IAQ3E;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,UAAU,CAAC,KAAK,CAAC,EAAE,cAAc,GAAG,MAAM;IAgBxD,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAStC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;WACW,SAAS,CACnB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY,GAC7C,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;WACW,aAAa,CACvB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,GACrB,MAAM;IAcT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,eAAe,CACzB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,oBAAoB,GAAG,oBAAoB,EAAE,GAClD,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;CAiBjE"}
+{"version":3,"file":"QueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../src/helpers/QueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,IAAI,EAA6B,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAEjK,mDAAmD;AACnD,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,oBAAoB,GAAG,MAAM;IAW7G;;;;;;;;;;;;;;;;;;OAkBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,GAAG,MAAM;IAYnF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAW7G;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAShF;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,mBAAmB,GAAG,MAAM;IAQhF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,UAAU,CAAC,KAAK,CAAC,EAAE,mBAAmB,GAAG,MAAM;IAgB7D,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAStC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;WACiB,SAAS,CACzB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,sBAAsB,GAAG,oBAAoB,GACxD,OAAO,CAAC,MAAM,CAAC;WAaE,eAAe,CAC/B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,KAAK,EAAE,KAAK,GACb,OAAO,CAAC,MAAM,CAAC;IAmBlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;WACW,aAAa,CACvB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,GACrB,MAAM;IAaT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,eAAe,CACzB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,qBAAqB,GAAG,qBAAqB,EAAE,GACpD,MAAM;IAWT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM;CAiBzE"}

package/dist/helpers/QueryStatementBuilder.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 /** Utility class for building SQL query strings */
 export default class QueryStatementBuilder {
     /**
@@ -245,15 +254,29 @@ export default class QueryStatementBuilder {
      * );
      * ```
      */
-    static BuildJoin(fromTableName, joins, options) {
-        var _a;
-        const queryParts = [];
-        queryParts.push(`SELECT ${(_a = options === null || options === void 0 ? void 0 : options.select) !== null && _a !== void 0 ? _a : "*"}`);
-        queryParts.push(`FROM "${fromTableName}"`);
-        queryParts.push(this.BuildJoinPart(fromTableName, joins));
-        queryParts.push(this.BuildWhere(options === null || options === void 0 ? void 0 : options.where));
-        queryParts.push(this.BuildQueryOptions(options !== null && options !== void 0 ? options : {}));
-        return queryParts.join(" ");
+    static BuildJoin(fromTableName, joins, query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParts = [];
+            const selectClause = yield QueryStatementBuilder.BuildJoinSelect(fromTableName, joins, query);
+            queryParts.push(`SELECT ${selectClause}`);
+            queryParts.push(`FROM "${fromTableName}"`);
+            queryParts.push(this.BuildJoinPart(fromTableName, joins));
+            queryParts.push(this.BuildWhere(options === null || options === void 0 ? void 0 : options.where));
+            queryParts.push(this.BuildQueryOptions(options !== null && options !== void 0 ? options : {}));
+            return queryParts.join(" ");
+        });
+    }
+    static BuildJoinSelect(fromTableName, joins, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mainTableCols = yield query.TableColumnInformation(fromTableName);
+            const mainTableSelect = mainTableCols.map(col => `"${fromTableName}"."${col.name}" AS "${fromTableName}__${col.name}"`).join(', ');
+            const joinArray = Array.isArray(joins) ? joins : [joins];
+            const joinedSelects = yield Promise.all(joinArray.map((join) => __awaiter(this, void 0, void 0, function* () {
+                const cols = yield query.TableColumnInformation(join.fromTable);
+                return cols.map(col => `"${join.fromTable}"."${col.name}" AS "${join.fromTable}__${col.name}"`).join(', ');
+            })));
+            return [mainTableSelect, ...joinedSelects].join(', ');
+        });
     }
     /**
      * Build JOIN clause(s) recursively (helper method)
@@ -296,12 +319,11 @@ export default class QueryStatementBuilder {
      */
     static BuildJoinPart(fromTableName, joins) {
         const queryParts = [];
-        const joinsArray = Array.isArray(joins) ? joins : [joins];
-        let currentTableName = fromTableName;
-        for (const join of joinsArray) {
+        joins = Array.isArray(joins) ? joins : [joins];
+        for (const join of joins) {
+            const baseTable = join.baseTable || fromTableName; // Use explicit base or default
             queryParts.push(`${join.joinType} JOIN "${join.fromTable}"`);
-            queryParts.push(this.BuildJoinOnPart(currentTableName, join.fromTable, join.on));
-            currentTableName = join.fromTable;
+            queryParts.push(this.BuildJoinOnPart(baseTable, join.fromTable, join.on));
         }
         return queryParts.join(" ");
     }

package/dist/interfaces/IDatabaseAdapter.d.ts

@@ -6,6 +6,7 @@ export default interface IDatabaseAdapter {
     exec(query: string): Promise<void>;
     transaction(fn: (items: any[]) => void): Promise<Function>;
     tableColumnInformation(tableName: string): Promise<TableColumnInfo[]>;
+    tableExists(tableName: string): Promise<boolean>;
     close(): Promise<void>;
 }
 //# sourceMappingURL=IDatabaseAdapter.d.ts.map

package/dist/interfaces/IDatabaseAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IDatabaseAdapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/IDatabaseAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,iBAAiB,MAAM,wBAAwB,CAAC;AAEvD,MAAM,CAAC,OAAO,WAAW,gBAAgB;IACrC,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC3D,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IACtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}
+{"version":3,"file":"IDatabaseAdapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/IDatabaseAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,iBAAiB,MAAM,wBAAwB,CAAC;AAEvD,MAAM,CAAC,OAAO,WAAW,gBAAgB;IACrC,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,WAAW,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC3D,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IACtE,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dist/interfaces/ISchemaBuilder.d.ts

@@ -1,7 +1,7 @@
 import SchemaTableBuilder from "../abstract/SchemaTableBuilder.js";
 export default interface AbstractSchemaBuilder {
     createTable(name: string, callback: (table: SchemaTableBuilder) => void): Promise<void>;
-    dropTable(name: string): Promise<void>;
+    dropTable(name: string, cascade?: boolean): Promise<void>;
     alterTable(oldName: string, callback: (table: SchemaTableBuilder) => void): Promise<void>;
 }
 //# sourceMappingURL=ISchemaBuilder.d.ts.map

package/dist/interfaces/ISchemaBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ISchemaBuilder.d.ts","sourceRoot":"","sources":["../../src/interfaces/ISchemaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,sCAAsC,CAAC;AAEtE,MAAM,CAAC,OAAO,WAAW,qBAAqB;IAC1C,WAAW,CACP,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,SAAS,CACL,IAAI,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,UAAU,CACN,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB"}
+{"version":3,"file":"ISchemaBuilder.d.ts","sourceRoot":"","sources":["../../src/interfaces/ISchemaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,sCAAsC,CAAC;AAEtE,MAAM,CAAC,OAAO,WAAW,qBAAqB;IAC1C,WAAW,CACP,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,SAAS,CACL,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,UAAU,CACN,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB"}

package/dist/runtime/Container.d.ts

@@ -7,6 +7,8 @@ declare class Container {
     static getInstance(): Container;
     registerAdapter(name: string, adapter: IDatabaseAdapter, isDefault?: boolean): void;
     getAdapter(name?: string): IDatabaseAdapter;
+    clear(): void;
+    static resetInstance(): void;
 }
 export default Container;
 //# sourceMappingURL=Container.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../src/runtime/Container.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AAEpE,cAAM,SAAS;IACX,OAAO,CAAC,MAAM,CAAC,SAAS,CAAY;IACpC,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,eAAe,CAAC,CAAmB;IAE3C,OAAO;WAEO,WAAW,IAAI,SAAS;IAO/B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,UAAQ,GAAG,IAAI;IAYjF,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB;CASrD;AAED,eAAe,SAAS,CAAC"}
+{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../src/runtime/Container.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,sCAAsC,CAAC;AAEpE,cAAM,SAAS;IACX,OAAO,CAAC,MAAM,CAAC,SAAS,CAAY;IACpC,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,eAAe,CAAC,CAAmB;IAE3C,OAAO;WAEO,WAAW,IAAI,SAAS;IAO/B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,UAAQ,GAAG,IAAI;IAYjF,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB;IAU3C,KAAK,IAAI,IAAI;WAKN,aAAa,IAAI,IAAI;CAGtC;AAED,eAAe,SAAS,CAAC"}

package/dist/runtime/Container.js

@@ -29,5 +29,12 @@ class Container {
             throw new Error("No default adapter set");
         return this._defaultAdapter;
     }
+    clear() {
+        this._adapters.clear();
+        this._defaultAdapter = undefined;
+    }
+    static resetInstance() {
+        Container._instance = new Container();
+    }
 }
 export default Container;

package/dist/runtime/Repository.d.ts

@@ -1,20 +1,30 @@
 import type Model from "../abstract/Model.js";
 import Record from "../base/Record.js";
-import { columnType, QueryCondition, QueryOptions, QueryWhereParameters } from "../types/index.js";
+import { columnType, QueryWhereCondition, ExtraQueryParameters, relation, QueryComparisonParameters, QueryIsEqualParameter, TableFactory } from "../types/index.js";
 export default class Repository<Type extends columnType, ModelType extends Model<Type>> {
     private static _instances;
     private models;
+    private manyToManyRelations;
     private Table;
-    constructor(tableName: string, ModelClass: ModelType);
-    static getInstance<ModelType extends columnType>(ModelClass: new () => Model<ModelType>, tableName: string): Repository<ModelType, Model<ModelType>>;
+    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>>;
+    static clearInstances(): void;
+    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;
     save(attributes: Type): Promise<void>;
-    first(conditions: QueryCondition, Model: Model<Type>): Promise<Type | null>;
-    get(conditions: QueryCondition, queryOptions: QueryOptions, Model: Model<Type>): Promise<Type[]>;
-    all(Model: Model<Type>, queryscopes?: QueryCondition, queryOptions?: QueryOptions): Promise<Type[]>;
-    update(primaryKey: QueryWhereParameters, newAttributes: Partial<Type>): Promise<Record<Type> | undefined>;
+    first(conditions: QueryWhereCondition, Model: Model<Type>): Promise<Type | null>;
+    get(conditions: QueryWhereCondition, queryOptions: ExtraQueryParameters, Model: Model<Type>): Promise<Type[]>;
+    all(Model: Model<Type>, queryscopes?: QueryWhereCondition, queryOptions?: ExtraQueryParameters): Promise<Type[]>;
+    update(primaryKey: QueryIsEqualParameter, newAttributes: Partial<Type>): Promise<Record<Type> | undefined>;
     private join;
-    private mergeQueryConditions;
+    mergeQueryWhereConditions(base: QueryWhereCondition, additional: QueryWhereCondition): QueryComparisonParameters[];
+    ConvertParamsToArray(params: QueryWhereCondition): QueryComparisonParameters[];
 }
 //# 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;AAG1C,OAAO,EAAE,UAAU,EAAQ,cAAc,EAAE,YAAY,EAA6B,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEvI,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,KAAK,CAAO;gBAER,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS;WAMtC,WAAW,CAAC,SAAS,SAAS,UAAU,EAClD,UAAU,EAAE,UAAU,KAAK,CAAC,SAAS,CAAC,EACtC,SAAS,EAAE,MAAM,GAClB,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAWnC,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,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAW3E,GAAG,CAAC,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAQhG,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAQnG,MAAM,CAAC,UAAU,EAAE,oBAAoB,EAAE,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;YAOxG,IAAI;IAyBlB,OAAO,CAAC,oBAAoB;CAG/B"}
+{"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,oBAAoB,EAAE,QAAQ,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE7K,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;WAgB5B,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,UAAU,EAAE,mBAAmB,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAYhF,GAAG,CAAC,UAAU,EAAE,mBAAmB,EAAE,YAAY,EAAE,oBAAoB,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAS7G,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,EAAE,mBAAmB,EAAE,YAAY,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAShH,MAAM,CAAC,UAAU,EAAE,qBAAqB,EAAE,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;YAOzG,IAAI;IAgDX,yBAAyB,CAAC,IAAI,EAAE,mBAAmB,EAAE,UAAU,EAAE,mBAAmB,GAAG,yBAAyB,EAAE;IAKlH,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,yBAAyB,EAAE;CAIxF"}

package/dist/runtime/Repository.js

@@ -7,25 +7,71 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Query from "../base/Query.js";
 import Table from "../base/Table.js";
 class Repository {
-    constructor(tableName, ModelClass) {
+    constructor(tableName, ModelClass, customDatabaseAdapter, tableFactory = (name, adapter) => new Table(name, adapter)) {
         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.Table = new Table(tableName);
+        this.tableFactory = tableFactory;
+        this.Table = this.tableFactory(tableName, customDatabaseAdapter);
+        this.customDatabaseAdapter = customDatabaseAdapter;
     }
-    static getInstance(ModelClass, tableName) {
+    static getInstance(ModelClass, tableName, customDatabaseAdapter, tableFactory) {
         const className = ModelClass.name;
         if (!this._instances.has(className)) {
-            const instance = new Repository(tableName, new ModelClass());
+            const instance = new Repository(tableName, new ModelClass(), customDatabaseAdapter, tableFactory);
             this._instances.set(className, instance);
             return instance;
         }
         return this._instances.get(className);
     }
+    static clearInstances() {
+        this._instances.clear();
+    }
+    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
+        };
+    }
+    insertRecordIntoPivotTable(foreignKey, modelOfOrigin, relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
+            yield table.Insert(this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation));
+        });
+    }
+    deleteRecordFromPivotTable(foreignKey, modelOfOrigin, relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
+            const record = yield table.Record(this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation));
+            yield (record === null || record === void 0 ? void 0 : record.Delete());
+        });
+    }
+    getManyToManyRelation(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (relation.pivotTable && this.manyToManyRelations.has(relation.pivotTable)) {
+                return this.manyToManyRelations.get(relation.pivotTable);
+            }
+            if (yield this.doesTableExist(relation.pivotTable)) {
+                this.manyToManyRelations.set(relation.pivotTable, relation);
+                return relation;
+            }
+            else {
+                throw new Error(`Pivot table ${relation.pivotTable} does not exist. Create it in alphabetical order before using many-to-many relationships.`);
+            }
+        });
+    }
+    doesTableExist(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = this.tableFactory(name, this.customDatabaseAdapter);
+            return yield table.exists();
+        });
+    }
     syncModel(model) {
         var _a;
         const modelPk = ((_a = model.primaryKey) === null || _a === void 0 ? void 0 : _a.toString()) || model.constructor.name;
@@ -43,7 +89,8 @@ class Repository {
         return __awaiter(this, void 0, void 0, function* () {
             let record;
             if (Model.JoinedEntities.length > 0) {
-                record = yield this.join(Model, conditions, { limit: 1 }).then(results => results[0]);
+                const results = yield this.join(Model, conditions, { limit: 1 });
+                record = results[0] ? { values: results[0] } : undefined;
             }
             else {
                 record = yield this.Table.Record({ where: conditions });
@@ -57,7 +104,8 @@ class Repository {
                 return yield this.join(Model, conditions, queryOptions);
             }
             else {
-                return yield this.Table.Records(Object.assign({ where: conditions }, queryOptions)).then(records => records.map(record => record.values));
+                const records = yield this.Table.Records(Object.assign({ where: conditions }, queryOptions));
+                return records.map(record => record.values);
             }
         });
     }
@@ -67,7 +115,8 @@ class Repository {
                 return yield this.join(Model);
             }
             else {
-                return yield this.Table.Records(Object.assign({ where: queryscopes }, queryOptions)).then(records => records.map(record => record.values));
+                const records = yield this.Table.Records(Object.assign({ where: queryscopes }, queryOptions));
+                return records.map(record => record.values);
             }
         });
     }
@@ -81,28 +130,55 @@ class Repository {
     }
     join(Model, conditions, queryOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const Join = Model.JoinedEntities.map(join => {
-                const relation = Model.Relations.find(rel => rel.model.Configuration.table.toLowerCase() === join.relation.toLowerCase());
+            const Join = Model.JoinedEntities.flatMap(join => {
+                const relation = Model.Relations.find(rel => rel.model.Configuration.table.replace("_", "").toLowerCase() === join.relation.toLowerCase());
                 if (join.queryScopes) {
-                    conditions = this.mergeQueryConditions(conditions || {}, join.queryScopes);
+                    conditions = this.mergeQueryWhereConditions(conditions || {}, join.queryScopes);
                 }
                 if (!relation) {
                     throw new Error(`Relation for joined entity ${join} not found.`);
                 }
+                if (relation.type === 'manyToMany') {
+                    return [
+                        {
+                            fromTable: relation.pivotTable,
+                            baseTable: Model.Configuration.table,
+                            joinType: 'INNER',
+                            on: [
+                                { [relation.pivotForeignKey]: relation.localKey }
+                            ]
+                        },
+                        {
+                            fromTable: relation.model.Configuration.table,
+                            baseTable: relation.pivotTable,
+                            joinType: 'INNER',
+                            on: [
+                                { [relation.foreignKey]: relation.pivotLocalKey }
+                            ]
+                        }
+                    ];
+                }
                 const JoinType = relation.type === 'hasOne' || relation.type === 'belongsTo' ? 'INNER' : 'LEFT';
-                return {
-                    fromTable: relation.model.Configuration.table,
-                    joinType: JoinType,
-                    on: [
-                        { [relation.foreignKey]: relation.localKey }
-                    ]
-                };
+                return [{
+                        fromTable: relation.model.Configuration.table,
+                        baseTable: Model.Configuration.table,
+                        joinType: JoinType,
+                        on: [
+                            { [relation.foreignKey]: relation.localKey }
+                        ]
+                    }];
             });
-            return (yield this.Table.Join(Join, Object.assign({ where: conditions }, queryOptions))).map(record => record.values);
+            const records = yield this.Table.Join(Join, Object.assign({ where: conditions }, queryOptions));
+            return records.map(record => record.values);
         });
     }
-    mergeQueryConditions(base, additional) {
-        return [...Query.ConvertParamsToArray(base), ...Query.ConvertParamsToArray(additional)];
+    mergeQueryWhereConditions(base, additional) {
+        const query = this.Table.QueryHelperObject;
+        return [...query.ConvertParamsToArray(base), ...query.ConvertParamsToArray(additional)];
+    }
+    ConvertParamsToArray(params) {
+        const query = this.Table.QueryHelperObject;
+        return query.ConvertParamsToArray(params);
     }
 }
 Repository._instances = new Map();

package/dist/types/factories.d.ts

@@ -0,0 +1,6 @@
+import type Table from "../base/Table";
+import type { columnType, Query, QueryConstructorType, Record } from "../index.js";
+export type TableFactory = (name: string, adapter?: string) => Table;
+export type QueryFactory = (config: QueryConstructorType) => Query;
+export type RecordFactory = <T extends columnType>(table: string, values: T, adapter?: string, queryFactory?: QueryFactory, recordFactory?: RecordFactory) => Record<T>;
+//# sourceMappingURL=factories.d.ts.map