@carno.js/orm 0.2.3

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

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunMysqlDriver = void 0;
+const bun_driver_base_1 = require("./bun-driver.base");
+class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
+    constructor(options) {
+        super(options);
+        this.dbType = 'mysql';
+    }
+    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
+            .map((colDiff) => {
+            const isAutoIncrement = colDiff.colChanges?.autoIncrement;
+            let sql = ``;
+            if (colDiff.colChanges?.enumItems) {
+                const enumValues = colDiff.colChanges.enumItems
+                    .map((item) => `'${item}'`)
+                    .join(', ');
+                sql += `\`${colDiff.colName}\` ENUM(${enumValues})`;
+            }
+            else {
+                const type = isAutoIncrement
+                    ? 'INT AUTO_INCREMENT'
+                    : colDiff.colType + (colDiff.colLength ? `(${colDiff.colLength})` : '');
+                sql += `\`${colDiff.colName}\` ${type}`;
+            }
+            if (!colDiff.colChanges?.nullable) {
+                sql += ' NOT NULL';
+            }
+            if (colDiff.colChanges?.primary) {
+                sql += ' PRIMARY KEY';
+            }
+            if (colDiff.colChanges?.unique) {
+                sql += ' UNIQUE';
+            }
+            if (colDiff.colChanges?.default) {
+                sql += ` DEFAULT ${colDiff.colChanges.default}`;
+            }
+            return sql;
+        })
+            .join(', ')});`;
+        return beforeSql + st;
+    }
+    getAlterTableFkInstruction(schema, tableName, colDiff, fk) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${tableName}_${colDiff.colName}_fk\` FOREIGN KEY (\`${colDiff.colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`;
+    }
+    getCreateIndex(index, schema, tableName) {
+        const properties = index.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Index properties are required.");
+        }
+        if (index.where) {
+            throw new Error("Partial indexes are only supported on postgres.");
+        }
+        const columns = properties.map((prop) => `\`${prop}\``).join(', ');
+        return `CREATE INDEX \`${index.name}\` ON \`${schema}\`.\`${tableName}\` (${columns});`;
+    }
+    getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions) {
+        let sql = ``;
+        if (colDiff.colChanges?.enumItems) {
+            const enumValues = colDiff.colChanges.enumItems
+                .map((item) => `'${item}'`)
+                .join(', ');
+            sql += `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD COLUMN \`${colDiff.colName}\` ENUM(${enumValues})`;
+        }
+        else {
+            sql += `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''}`;
+        }
+        if (!colDiff.colChanges?.nullable) {
+            sql += ' NOT NULL';
+        }
+        if (colDiff.colChanges?.primary) {
+            sql += ' PRIMARY KEY';
+        }
+        if (colDiff.colChanges?.unique) {
+            sql += ' UNIQUE';
+        }
+        if (colDiff.colChanges?.default) {
+            sql += ` DEFAULT ${colDiff.colChanges.default}`;
+        }
+        colDiffInstructions.push(sql.concat(';'));
+        if (colDiff.colChanges?.foreignKeys) {
+            colDiff.colChanges.foreignKeys.forEach((fk) => {
+                colDiffInstructions.push(`ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${tableName}_${colName}_fk\` FOREIGN KEY (\`${colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`);
+            });
+        }
+    }
+    getDropColumn(colDiffInstructions, schema, tableName, colName) {
+        colDiffInstructions.push(`ALTER TABLE \`${schema}\`.\`${tableName}\` DROP COLUMN IF EXISTS \`${colName}\`;`);
+    }
+    getDropIndex(index, schema, tableName) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${index.name}\`;`;
+    }
+    getCreateUniqueConstraint(unique, schema, tableName) {
+        const properties = unique.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Unique properties are required.");
+        }
+        const columns = properties.map((prop) => `\`${prop}\``).join(', ');
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${unique.name}\` UNIQUE (${columns});`;
+    }
+    getDropUniqueConstraint(unique, schema, tableName) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${unique.name}\`;`;
+    }
+    getAlterTableType(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
+    }
+    getAlterTableDefaultInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ALTER COLUMN \`${colName}\` SET DEFAULT ${colDiff.colChanges.default};`;
+    }
+    getAlterTablePrimaryKeyInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD PRIMARY KEY (\`${colName}\`);`;
+    }
+    getDropConstraint(param, schema, tableName) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP FOREIGN KEY \`${param.name}\`;`;
+    }
+    getAddUniqueConstraint(schema, tableName, colName) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD UNIQUE (\`${colName}\`);`;
+    }
+    getAlterTableDropNullInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType} NULL;`;
+    }
+    getAlterTableDropNotNullInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType} NOT NULL;`;
+    }
+    getAlterTableEnumInstruction(schema, tableName, colName, colDiff) {
+        const enumValues = colDiff.colChanges.enumItems
+            .map((item) => `'${item}'`)
+            .join(', ');
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ENUM(${enumValues});`;
+    }
+    getDropTypeEnumInstruction(param, schema, tableName) {
+        return '';
+    }
+    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()`;
+        const result = await this.sql.unsafe(sql);
+        if (!result || result.length === 0) {
+            return;
+        }
+        const indexes = (await this.index(tableName, options)) || [];
+        const constraints = (await this.constraints(tableName, options)) || [];
+        return {
+            tableName,
+            schema,
+            indexes,
+            columns: result.map((row) => {
+                return {
+                    default: row.COLUMN_DEFAULT,
+                    length: row.CHARACTER_MAXIMUM_LENGTH ||
+                        row.NUMERIC_PRECISION ||
+                        row.DATETIME_PRECISION,
+                    name: row.COLUMN_NAME,
+                    nullable: row.IS_NULLABLE === 'YES',
+                    primary: row.COLUMN_KEY === 'PRI',
+                    unique: row.COLUMN_KEY === 'UNI' || row.COLUMN_KEY === 'PRI',
+                    type: row.DATA_TYPE,
+                    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,
+                    scale: row.NUMERIC_SCALE,
+                    isDecimal: row.DATA_TYPE === 'decimal',
+                };
+            }),
+        };
+    }
+    parseEnumValues(columnType) {
+        const match = columnType.match(/enum\((.*)\)/);
+        if (!match) {
+            return [];
+        }
+        return match[1].split(',').map((v) => v.trim().replace(/'/g, ''));
+    }
+    async index(tableName, options) {
+        const result = await this.sql.unsafe(`SHOW INDEX FROM \`${tableName}\` FROM \`${options.schema || 'information_schema'}\``);
+        return result
+            .filter((row) => row.Key_name !== 'PRIMARY')
+            .map((row) => {
+            return {
+                table: tableName,
+                indexName: row.Key_name,
+                columnName: row.Column_name,
+            };
+        });
+    }
+    async constraints(tableName, options) {
+        const result = await this.sql.unsafe(`SELECT
+        CONSTRAINT_NAME as index_name,
+        CONCAT('REFERENCES \`', REFERENCED_TABLE_NAME, '\` (\`', REFERENCED_COLUMN_NAME, '\`)') as consdef,
+        'FOREIGN KEY' as constraint_type
+       FROM information_schema.KEY_COLUMN_USAGE
+       WHERE TABLE_NAME = '${tableName}'
+         AND TABLE_SCHEMA = DATABASE()
+         AND REFERENCED_TABLE_NAME IS NOT NULL`);
+        return result.map((row) => {
+            return {
+                indexName: row.index_name,
+                type: row.constraint_type,
+                consDef: row.consdef,
+            };
+        });
+    }
+}
+exports.BunMysqlDriver = BunMysqlDriver;

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

@@ -0,0 +1,52 @@
+import { ColDiff, ConnectionSettings, DriverInterface, ForeignKeyInfo, IndexStatement, SnapshotConstraintInfo, SnapshotIndexInfo, SnapshotTable, Statement } from './driver.interface';
+import { BunDriverBase } from './bun-driver.base';
+export declare class BunPgDriver extends BunDriverBase implements DriverInterface {
+    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: IndexStatement, schema: string | undefined, tableName: string): string;
+    getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void;
+    getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string): void;
+    getDropIndex(index: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getDropConstraint(param: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    getAddUniqueConstraint(schema: string | undefined, tableName: string, colName: string): string;
+    getAlterTableDropNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableDropNotNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableEnumInstruction(schema: string, tableName: string, colName: string, colDiff: ColDiff): string;
+    getDropTypeEnumInstruction(param: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
+    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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunPgDriver = void 0;
+const bun_driver_base_1 = require("./bun-driver.base");
+class BunPgDriver extends bun_driver_base_1.BunDriverBase {
+    constructor(options) {
+        super(options);
+        this.dbType = 'postgres';
+    }
+    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
+            .map((colDiff) => {
+            const isAutoIncrement = colDiff.colChanges?.autoIncrement;
+            let sql = ``;
+            if (colDiff.colChanges?.enumItems) {
+                beforeSql += `CREATE TYPE "${schema}_${tableName}_${colDiff.colName}_enum" AS ENUM (${colDiff.colChanges.enumItems.map((item) => `'${item}'`).join(', ')});`;
+                sql += `"${colDiff.colName}" "${schema}_${tableName}_${colDiff.colName}_enum"`;
+            }
+            else {
+                sql += `"${colDiff.colName}" ${isAutoIncrement ? 'SERIAL' : colDiff.colType + (colDiff.colLength ? `(${colDiff.colLength})` : '')}`;
+            }
+            if (!colDiff.colChanges?.nullable) {
+                sql += ' NOT NULL';
+            }
+            if (colDiff.colChanges?.primary) {
+                sql += ' PRIMARY KEY';
+            }
+            if (colDiff.colChanges?.unique) {
+                sql += ' UNIQUE';
+            }
+            if (colDiff.colChanges?.default) {
+                sql += ` DEFAULT ${colDiff.colChanges.default}`;
+            }
+            return sql;
+        })
+            .join(', ')});`;
+        return beforeSql + st;
+    }
+    getAlterTableFkInstruction(schema, tableName, colDiff, fk) {
+        return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${tableName}_${colDiff.colName}_fk" FOREIGN KEY ("${colDiff.colName}") REFERENCES "${fk.referencedTableName}" ("${fk.referencedColumnName}");`;
+    }
+    getCreateIndex(index, schema, tableName) {
+        const properties = index.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Index properties are required.");
+        }
+        const columns = properties.map((prop) => `"${prop}"`).join(', ');
+        const where = this.buildWhereClause(index.where);
+        return `CREATE INDEX "${index.name}" ON "${schema}"."${tableName}" (${columns})${where};`;
+    }
+    getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions) {
+        let beforeSql = ``;
+        let sql = ``;
+        if (colDiff.colChanges?.enumItems) {
+            beforeSql += `CREATE TYPE "${schema}_${tableName}_${colDiff.colName}_enum" AS ENUM (${colDiff.colChanges.enumItems.map((item) => `'${item}'`).join(', ')});`;
+            colDiffInstructions.push(beforeSql);
+            sql += `ALTER TABLE "${schema}"."${tableName}" ADD COLUMN "${colDiff.colName}" "${schema}_${tableName}_${colDiff.colName}_enum"`;
+        }
+        else {
+            sql += `ALTER TABLE "${schema}"."${tableName}" ADD COLUMN "${colName}" ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''}`;
+        }
+        if (!colDiff.colChanges?.nullable) {
+            sql += ' NOT NULL';
+        }
+        if (colDiff.colChanges?.primary) {
+            sql += ' PRIMARY KEY';
+        }
+        if (colDiff.colChanges?.unique) {
+            sql += ' UNIQUE';
+        }
+        if (colDiff.colChanges?.default) {
+            sql += ` DEFAULT ${colDiff.colChanges.default}`;
+        }
+        colDiffInstructions.push(sql.concat(';'));
+        if (colDiff.colChanges?.foreignKeys) {
+            colDiff.colChanges.foreignKeys.forEach((fk) => {
+                colDiffInstructions.push(`ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${tableName}_${colName}_fk" FOREIGN KEY ("${colName}") REFERENCES "${fk.referencedTableName}" ("${fk.referencedColumnName}");`);
+            });
+        }
+    }
+    getDropColumn(colDiffInstructions, schema, tableName, colName) {
+        colDiffInstructions.push(`ALTER TABLE "${schema}"."${tableName}" DROP COLUMN IF EXISTS "${colName}";`);
+    }
+    getDropIndex(index, schema, tableName) {
+        return this.getDropConstraint(index, schema, tableName);
+    }
+    getCreateUniqueConstraint(unique, schema, tableName) {
+        const properties = unique.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Unique properties are required.");
+        }
+        const columns = properties.map((prop) => `"${prop}"`).join(', ');
+        return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${unique.name}" UNIQUE (${columns});`;
+    }
+    getDropUniqueConstraint(unique, schema, tableName) {
+        return this.getDropConstraint(unique, schema, tableName);
+    }
+    getAlterTableType(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" TYPE ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
+    }
+    getAlterTableDefaultInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" SET DEFAULT ${colDiff.colChanges.default};`;
+    }
+    getAlterTablePrimaryKeyInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE "${schema}"."${tableName}" ADD PRIMARY KEY ("${colName}");`;
+    }
+    getDropConstraint(param, schema, tableName) {
+        return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${param.name}";`;
+    }
+    getAddUniqueConstraint(schema, tableName, colName) {
+        return `ALTER TABLE "${schema}"."${tableName}" ADD UNIQUE ("${colName}");`;
+    }
+    getAlterTableDropNullInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" DROP NOT NULL;`;
+    }
+    getAlterTableDropNotNullInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" SET NOT NULL;`;
+    }
+    getAlterTableEnumInstruction(schema, tableName, colName, colDiff) {
+        return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" TYPE varchar(255);DROP TYPE IF EXISTS "${schema}_${tableName}_${colName}_enum";CREATE TYPE "${schema}_${tableName}_${colName}_enum" AS ENUM (${colDiff.colChanges.enumItems.map((item) => `'${item}'`).join(', ')});ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" TYPE "${schema}_${tableName}_${colName}_enum" USING "${colName}"::text::"${schema}_${tableName}_${colName}_enum"`;
+    }
+    getDropTypeEnumInstruction(param, schema, tableName) {
+        return `DROP TYPE IF EXISTS "${param.name}";`;
+    }
+    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}'`;
+        const result = await this.sql.unsafe(sql);
+        if (!result || result.length === 0) {
+            return;
+        }
+        const indexes = (await this.index(tableName, options)) || [];
+        const constraints = (await this.constraints(tableName, options)) || [];
+        let enums = await this.getEnums(tableName, schema);
+        enums = enums.reduce((acc, curr) => {
+            if (!acc[curr.type]) {
+                acc[curr.type] = [];
+            }
+            acc[curr.type].push(curr.label);
+            return acc;
+        }, {});
+        return {
+            tableName,
+            schema,
+            indexes,
+            columns: result.map((row) => {
+                return {
+                    default: row.column_default,
+                    length: row.character_maximum_length ||
+                        row.numeric_precision ||
+                        row.datetime_precision,
+                    name: row.column_name,
+                    nullable: row.is_nullable === 'YES',
+                    primary: constraints.some((c) => c.type === 'PRIMARY KEY' && c.consDef.includes(row.column_name)),
+                    unique: constraints.some((c) => (c.type === 'UNIQUE' || c.type === 'PRIMARY KEY') &&
+                        c.consDef.includes(row.column_name)),
+                    type: row.data_type,
+                    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`]
+                        : undefined,
+                    precision: row.numeric_precision,
+                    scale: row.numeric_scale,
+                    isDecimal: row.data_type === 'numeric',
+                };
+            }),
+        };
+    }
+    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
+       FROM pg_indexes
+       WHERE tablename = '${tableName}' AND schemaname = '${schema}'`);
+        result = result.filter((row) => row.index_name.includes('_pkey') || !row.column_name.includes('UNIQUE INDEX'));
+        return result.map((row) => {
+            return {
+                table: tableName,
+                indexName: row.index_name,
+                columnName: row.column_name,
+            };
+        });
+    }
+    async constraints(tableName, options) {
+        const schema = (options && options.schema) || 'public';
+        const result = await this.sql.unsafe(`SELECT
+        conname AS index_name,
+        pg_get_constraintdef(pg_constraint.oid) as consdef,
+        CASE contype
+            WHEN 'c' THEN 'CHECK'
+            WHEN 'f' THEN 'FOREIGN KEY'
+            WHEN 'p' THEN 'PRIMARY KEY'
+            WHEN 'u' THEN 'UNIQUE'
+            WHEN 't' THEN 'TRIGGER'
+            WHEN 'x' THEN 'EXCLUSION'
+            ELSE 'UNKNOWN'
+            END AS constraint_type
+       FROM pg_constraint
+       where conrelid =  (
+           SELECT oid
+           FROM pg_class
+           WHERE relname = '${tableName}'
+             AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = '${schema}')
+       )
+         AND conkey @> ARRAY(
+           SELECT attnum
+    FROM pg_attribute
+    WHERE attrelid = conrelid
+      AND attname = '${schema}'
+  )`);
+        return result.map((row) => {
+            return {
+                indexName: row.index_name,
+                type: row.constraint_type,
+                consDef: row.consdef,
+            };
+        });
+    }
+    async getEnums(tableName, schema) {
+        const result = await this.sql.unsafe(`SELECT e.enumlabel as label, t.typname as type
+       FROM pg_type t
+       JOIN pg_enum e ON t.oid = e.enumtypid
+       JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+       WHERE n.nspname = '${schema}'`);
+        return result.map((row) => {
+            return {
+                label: row.label,
+                type: row.type,
+            };
+        });
+    }
+}
+exports.BunPgDriver = BunPgDriver;