@cheetah.js/orm 0.1.44 → 0.1.46

package/dist/common/email.vo.js

@@ -5,4 +5,3 @@ export class Email extends ValueObject {
         return REGEX.test(value);
     }
 }
-//# sourceMappingURL=email.vo.js.map

package/dist/common/uuid.js

@@ -4,4 +4,3 @@ export class Uuid extends ValueObject {
         return /^[a-f\d]{8}(-[a-f\d]{4}){4}[a-f\d]{8}$/i.test(value);
     }
 }
-//# sourceMappingURL=uuid.js.map

package/dist/common/value-object.js

@@ -93,4 +93,3 @@ export class ValueObject {
         return true;
     }
 }
-//# sourceMappingURL=value-object.js.map

package/dist/constants.js

@@ -3,4 +3,3 @@ export const PROPERTIES = 'cheetah:properties';
 export const PROPERTIES_METADATA = 'cheetah:properties:metadata';
 export const PROPERTIES_RELATIONS = 'cheetah:properties:relations';
 export const EVENTS_METADATA = 'cheetah:events:metadata';
-//# sourceMappingURL=constants.js.map

package/dist/decorators/entity.decorator.js

@@ -7,4 +7,3 @@ export function Entity(options) {
         Metadata.set(ENTITIES, entities, Reflect);
     };
 }
-//# sourceMappingURL=entity.decorator.js.map

package/dist/decorators/enum.decorator.js

@@ -8,4 +8,3 @@ export function Enum(options) {
     }
     return Property({ ...options, isEnum, enumItems, dbType: 'enum' });
 }
-//# sourceMappingURL=enum.decorator.js.map

package/dist/decorators/event-hook.decorator.js

@@ -23,4 +23,3 @@ export function AfterUpdate() {
         Reflect.defineMetadata(EVENTS_METADATA, [...metadata, { type: 'afterUpdate', propertyName }], target.constructor);
     };
 }
-//# sourceMappingURL=event-hook.decorator.js.map

package/dist/decorators/index.decorator.js

@@ -14,4 +14,3 @@ export function Index(options) {
         Metadata.set('indexes', indexes, target.constructor);
     };
 }
-//# sourceMappingURL=index.decorator.js.map

package/dist/decorators/one-many.decorator.js

@@ -21,4 +21,3 @@ export function ManyToOne(entity) {
         Metadata.set(PROPERTIES_RELATIONS, existing, target.constructor);
     };
 }
-//# sourceMappingURL=one-many.decorator.js.map

package/dist/decorators/primary-key.decorator.js

@@ -3,4 +3,3 @@ export function PrimaryKey(options) {
     const isPrimary = true;
     return Property({ ...options, isPrimary });
 }
-//# sourceMappingURL=primary-key.decorator.js.map

package/dist/decorators/property.decorator.js

@@ -35,4 +35,3 @@ export function Property(options) {
         });
     };
 }
-//# sourceMappingURL=property.decorator.js.map

package/dist/domain/base-entity.js

@@ -129,4 +129,3 @@ export class BaseEntity {
         return data;
     }
 }
-//# sourceMappingURL=base-entity.js.map

package/dist/domain/collection.js

@@ -8,4 +8,3 @@ export class Collection extends ArrayCollection {
         super();
     }
 }
-//# sourceMappingURL=collection.js.map

package/dist/domain/entities.js

@@ -153,4 +153,3 @@ EntityStorage = EntityStorage_1 = __decorate([
     __metadata("design:paramtypes", [])
 ], EntityStorage);
 export { EntityStorage };
-//# sourceMappingURL=entities.js.map

package/dist/domain/reference.js

@@ -4,4 +4,3 @@ export class Reference {
         console.log('Reference constructor');
     }
 }
-//# sourceMappingURL=reference.js.map

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,5 +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],
+        };
+    }
 }
-//# sourceMappingURL=bun-driver.base.js.map

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
@@ -256,4 +231,3 @@ export class BunMysqlDriver extends BunDriverBase {
         });
     }
 }
-//# sourceMappingURL=bun-mysql.driver.js.map

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
@@ -272,4 +240,3 @@ export class BunPgDriver extends BunDriverBase {
         });
     }
 }
-//# sourceMappingURL=bun-pg.driver.js.map

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

@@ -47,7 +47,7 @@ export type SnapshotConstraintInfo = {
     consDef: string;
     type: string;
 };
-export interface ConnectionSettings<T extends DriverInterface = DriverInterface> {
+export interface ConnectionSettings<T extends Partial<DriverInterface> = Partial<DriverInterface>> {
     host?: string;
     port?: number;
     username?: string;
@@ -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/driver/driver.interface.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=driver.interface.js.map

package/dist/entry.js

@@ -3,4 +3,3 @@ import { Orm } from './orm';
 import { OrmService } from './orm.service';
 import { EntityStorage } from './domain/entities';
 export const CheetahOrm = new Cheetah({ exports: [Orm, OrmService, EntityStorage] });
-//# sourceMappingURL=entry.js.map

package/dist/index.d.ts

@@ -12,7 +12,6 @@ export { EntityStorage } from './domain/entities';
 export * from './driver/bun-pg.driver';
 export * from './driver/bun-mysql.driver';
 export * from './driver/bun-driver.base';
-export * from './driver/pg-driver';
 export * from './utils';
 export * from './driver/driver.interface';
 export * from './entry';