drizzle-seed 0.4.0-08bb2d5 → 0.4.0-4ec2def

package/index.mjs

@@ -1,12 +1,188 @@
-import { is, entityKind, sql, eq, Relations, getTableName, extractTablesRelationalConfig, createTableRelationsHelpers, One } from 'drizzle-orm';
-import { MySqlDatabase, MySqlTable, getTableConfig as getTableConfig$2 } from 'drizzle-orm/mysql-core';
-import { PgDatabase, getTableConfig as getTableConfig$3, PgTable } from 'drizzle-orm/pg-core';
-import { BaseSQLiteDatabase, SQLiteTable, getTableConfig as getTableConfig$5 } from 'drizzle-orm/sqlite-core';
-import { MsSqlDatabase, getTableConfig, MsSqlTable } from 'drizzle-orm/mssql-core';
-import { CockroachDatabase, getTableConfig as getTableConfig$1, CockroachTable } from 'drizzle-orm/cockroach-core';
-import { SingleStoreDatabase, SingleStoreTable, getTableConfig as getTableConfig$4 } from 'drizzle-orm/singlestore-core';
+import { getTableName, is, getColumnTable, Column, entityKind, sql, eq } from 'drizzle-orm';
+import { MySqlTable, getTableConfig as getTableConfig$2, MySqlDatabase } from 'drizzle-orm/mysql-core';
+import { PgTable, getTableConfig as getTableConfig$1, PgDatabase } from 'drizzle-orm/pg-core';
+import { SQLiteTable, getTableConfig as getTableConfig$3, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { MsSqlTable, getTableConfig as getTableConfig$5, MsSqlDatabase } from 'drizzle-orm/mssql-core';
+import { CockroachTable, getTableConfig as getTableConfig$4, CockroachDatabase } from 'drizzle-orm/cockroach-core';
+import { getTableConfig as getTableConfig$6, SingleStoreDatabase, SingleStoreTable } from 'drizzle-orm/singlestore-core';
+import { extractTablesRelationalConfig, createTableRelationsHelpers, One, Relations } from 'drizzle-orm/_relations';
 import prand from 'pure-rand';
 
+const isRelationCyclic = (startRel) => {
+    // self relation
+    if (startRel.table === startRel.refTable)
+        return false;
+    // DFS
+    const targetTable = startRel.table;
+    const queue = [startRel];
+    let path = [];
+    while (queue.length !== 0) {
+        const currRel = queue.shift();
+        if (path.includes(currRel.table)) {
+            const idx = path.indexOf(currRel.table);
+            path = path.slice(0, idx);
+        }
+        path.push(currRel.table);
+        for (const rel of currRel.refTableRels) {
+            // self relation
+            if (rel.table === rel.refTable)
+                continue;
+            if (rel.refTable === targetTable)
+                return true;
+            // found cycle, but not the one we are looking for
+            if (path.includes(rel.refTable))
+                continue;
+            queue.unshift(rel);
+        }
+    }
+    return false;
+};
+const generateHashFromString = (s) => {
+    let hash = 0;
+    // p and m are prime numbers
+    const p = 53;
+    const m = 28871271685163;
+    for (let i = 0; i < s.length; i++) {
+        hash += ((s.codePointAt(i) || 0) * Math.pow(p, i)) % m;
+    }
+    return hash;
+};
+const equalSets = (set1, set2) => {
+    return set1.size === set2.size && [...set1].every((si) => set2.has(si));
+};
+
+const getTableConfig = (table) => {
+    if (is(table, PgTable))
+        return getTableConfig$1(table);
+    else if (is(table, MySqlTable))
+        return getTableConfig$2(table);
+    else if (is(table, SQLiteTable))
+        return getTableConfig$3(table);
+    else if (is(table, CockroachTable))
+        return getTableConfig$4(table);
+    else if (is(table, MsSqlTable))
+        return getTableConfig$5(table);
+    else
+        return getTableConfig$6(table); // if (is(table, SingleStoreTable))
+};
+const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
+    const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
+    const relations = [];
+    for (const table of Object.values(schemaConfig.tables)) {
+        if (table.relations === undefined)
+            continue;
+        for (const drizzleRel of Object.values(table.relations)) {
+            if (!is(drizzleRel, One))
+                continue;
+            const tableConfig = getTableConfig(drizzleRel.sourceTable);
+            const tableDbSchema = tableConfig.schema ?? 'public';
+            const tableDbName = tableConfig.name;
+            const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
+            const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
+            const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
+                ?? [];
+            const refTableConfig = getTableConfig(drizzleRel.referencedTable);
+            const refTableDbSchema = refTableConfig.schema ?? 'public';
+            const refTableDbName = refTableConfig.name;
+            const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
+                ?? refTableDbName;
+            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
+            const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
+                ?? [];
+            if (tableRelations[refTableTsName] === undefined) {
+                tableRelations[refTableTsName] = [];
+            }
+            const relation = {
+                table: tableTsName,
+                columns,
+                refTable: refTableTsName,
+                refColumns,
+                refTableRels: tableRelations[refTableTsName],
+                type: 'one',
+            };
+            // do not add duplicate relation
+            if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
+                && rel.refTable === relation.refTable)) {
+                console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
+                    + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
+                    + `In this case, the foreign key constraint will be used.\n`);
+                continue;
+            }
+            relations.push(relation);
+            tableRelations[tableTsName].push(relation);
+        }
+    }
+    return relations;
+};
+const getSchemaInfo = (drizzleTablesAndRelations, drizzleTables, mapTable) => {
+    let tableConfig;
+    let dbToTsColumnNamesMap;
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(drizzleTables).map(([key, value]) => [getTableName(value), key]));
+    const tables = [];
+    const relations = [];
+    const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
+    const getDbToTsColumnNamesMap = (table) => {
+        let dbToTsColumnNamesMap = {};
+        const tableName = getTableName(table);
+        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
+            return dbToTsColumnNamesMap;
+        }
+        const tableConfig = getTableConfig(table);
+        for (const [tsCol, col] of Object.entries(getColumnTable(tableConfig.columns[0]))) {
+            if (is(col, Column))
+                dbToTsColumnNamesMap[col.name] = tsCol;
+        }
+        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
+        return dbToTsColumnNamesMap;
+    };
+    for (const table of Object.values(drizzleTables)) {
+        tableConfig = getTableConfig(table);
+        dbToTsColumnNamesMap = getDbToTsColumnNamesMap(table);
+        // might be empty list
+        const newRelations = tableConfig.foreignKeys === undefined ? [] : tableConfig.foreignKeys.map((fk) => {
+            const table = dbToTsTableNamesMap[tableConfig.name];
+            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
+            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
+            if (tableRelations[refTable] === undefined) {
+                tableRelations[refTable] = [];
+            }
+            return {
+                table,
+                columns: fk
+                    .reference()
+                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
+                refTable,
+                refColumns: fk
+                    .reference()
+                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
+                refTableRels: tableRelations[refTable],
+            };
+        });
+        relations.push(...newRelations);
+        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
+            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
+        }
+        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
+        // console.log(tableConfig.columns);
+        tables.push(mapTable(tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap));
+    }
+    const transformedDrizzleRelations = transformFromDrizzleRelation(drizzleTablesAndRelations, getDbToTsColumnNamesMap, tableRelations);
+    relations.push(...transformedDrizzleRelations);
+    const isCyclicRelations = relations.map((relI) => {
+        // if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
+        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
+        if (isRelationCyclic(relI)) {
+            tableRel['isCyclic'] = true;
+            return { ...relI, isCyclic: true };
+        }
+        tableRel['isCyclic'] = false;
+        return { ...relI, isCyclic: false };
+    });
+    return { tables, relations: isCyclicRelations, tableRelations };
+};
+
 /**
  * The original source for the Adjectives data was taken from https://www.kaggle.com/datasets/jordansiem/adjectives-list
  */
@@ -132229,6 +132405,8 @@ class GenerateString extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
+        if (this.dataType === 'object')
+            return Buffer.from(currStr);
         return currStr;
     }
 }
@@ -132257,7 +132435,10 @@ class GenerateUniqueString extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
-        return currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
+        currStr = currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
+        if (this.dataType === 'object')
+            return Buffer.from(currStr);
+        return currStr;
     }
 }
 class GenerateUUID extends AbstractGenerator {
@@ -133154,7 +133335,7 @@ class GeneratePoint extends AbstractGenerator {
         }
         const x = this.state.xCoordinateGen.generate();
         const y = this.state.yCoordinateGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { x, y };
         }
         else if (this.dataType === 'string') {
@@ -133192,7 +133373,7 @@ class GenerateUniquePoint extends AbstractGenerator {
         }
         const x = this.state.xCoordinateGen.generate();
         const y = this.state.yCoordinateGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { x, y };
         }
         else if (this.dataType === 'string') {
@@ -133241,7 +133422,7 @@ class GenerateLine extends AbstractGenerator {
             b = this.state.bCoefficientGen.generate();
         }
         const c = this.state.cCoefficientGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { a, b, c };
         }
         else if (this.dataType === 'string') {
@@ -133290,7 +133471,7 @@ class GenerateUniqueLine extends AbstractGenerator {
             b = this.state.bCoefficientGen.generate();
         }
         const c = this.state.cCoefficientGen.generate();
-        if (this.dataType === 'json') {
+        if (this.dataType === 'object') {
             return { a, b, c };
         }
         else if (this.dataType === 'string') {
@@ -133802,7 +133983,7 @@ class GenerateStringV2 extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
-        if (this.dataType === 'buffer')
+        if (this.dataType === 'object')
             return Buffer.from(currStr);
         return currStr;
     }
@@ -133842,6 +134023,8 @@ class GenerateUniqueStringV2 extends AbstractGenerator {
             [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
             currStr += stringChars[idx];
         }
+        if (this.dataType === 'object')
+            return Buffer.from(uniqueStr + currStr);
         return uniqueStr + currStr;
     }
 }
@@ -134974,8 +135157,8 @@ const selectGeneratorForCockroachColumn = (table, col) => {
             const generator = new generatorsMap.GenerateUUID[0]();
             return generator;
         }
-        // BOOLEAN
-        if (col.columnType === 'boolean') {
+        // BOOL
+        if (col.columnType === 'bool') {
             const generator = new generatorsMap.GenerateBoolean[0]();
             return generator;
         }
@@ -135803,7 +135986,7 @@ const selectGeneratorForSqlite = (table, col) => {
             const generator = new generatorsMap.GenerateBoolean[0]();
             return generator;
         }
-        if ((col.columnType === 'integer' && col.dataType === 'date')) {
+        if ((col.columnType === 'integer' && col.dataType === 'object')) {
             const generator = new generatorsMap.GenerateTimestamp[0]();
             return generator;
         }
@@ -135874,49 +136057,6 @@ const selectGeneratorForSqlite = (table, col) => {
     return generator;
 };
 
-const isRelationCyclic = (startRel) => {
-    // self relation
-    if (startRel.table === startRel.refTable)
-        return false;
-    // DFS
-    const targetTable = startRel.table;
-    const queue = [startRel];
-    let path = [];
-    while (queue.length !== 0) {
-        const currRel = queue.shift();
-        if (path.includes(currRel.table)) {
-            const idx = path.indexOf(currRel.table);
-            path = path.slice(0, idx);
-        }
-        path.push(currRel.table);
-        for (const rel of currRel.refTableRels) {
-            // self relation
-            if (rel.table === rel.refTable)
-                continue;
-            if (rel.refTable === targetTable)
-                return true;
-            // found cycle, but not the one we are looking for
-            if (path.includes(rel.refTable))
-                continue;
-            queue.unshift(rel);
-        }
-    }
-    return false;
-};
-const generateHashFromString = (s) => {
-    let hash = 0;
-    // p and m are prime numbers
-    const p = 53;
-    const m = 28871271685163;
-    for (let i = 0; i < s.length; i++) {
-        hash += ((s.codePointAt(i) || 0) * Math.pow(p, i)) % m;
-    }
-    return hash;
-};
-const equalSets = (set1, set2) => {
-    return set1.size === set2.size && [...set1].every((si) => set2.has(si));
-};
-
 /* eslint-disable drizzle-internal/require-entity-kind */
 class SeedService {
     static entityKind = 'SeedService';
@@ -136551,7 +136691,7 @@ class SeedService {
             let schemaDbName;
             let tableDbName;
             if (override === true) {
-                const tableConfig = getTableConfig(schema[tableName]);
+                const tableConfig = getTableConfig$5(schema[tableName]);
                 schemaDbName = tableConfig.schema ?? 'dbo';
                 tableDbName = tableConfig.name;
                 await db.execute(sql.raw(`SET IDENTITY_INSERT [${schemaDbName}].[${tableDbName}] ON;`));
@@ -136611,7 +136751,7 @@ class SeedService {
 // Cockroach-----------------------------------------------------------------------------------------------------------
 const resetCockroach = async (db, cockroachTables) => {
     const tablesToTruncate = Object.entries(cockroachTables).map(([_, table]) => {
-        const config = getTableConfig$1(table);
+        const config = getTableConfig$4(table);
         config.schema = config.schema === undefined ? 'public' : config.schema;
         return `"${config.schema}"."${config.name}"`;
     });
@@ -136625,7 +136765,7 @@ const filterCockroachSchema = (schema) => {
 const seedCockroach = async (db, schema, options = {}, refinements) => {
     const seedService = new SeedService();
     const { cockroachSchema, cockroachTables } = filterCockroachSchema(schema);
-    const { tables, relations } = getCockroachInfo(cockroachSchema, cockroachTables);
+    const { tables, relations } = getSchemaInfo(cockroachSchema, cockroachTables, mapCockroachTable);
     const generatedTablesGenerators = seedService.generatePossibleGenerators('cockroach', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
     const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, cockroachTables, { ...options, preserveCyclicTablesData });
@@ -136633,203 +136773,88 @@ const seedCockroach = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, cockroachTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getCockroachInfo = (cockroachSchema, cockroachTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(cockroachTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$1(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
+const mapCockroachTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getAllBaseColumns = (baseColumn) => {
+        const baseColumnResult = {
+            name: baseColumn.name,
+            columnType: baseColumn.getSQLType(),
+            typeParams: getTypeParams(baseColumn.getSQLType()),
+            dataType: baseColumn.dataType.split(' ')[0],
+            size: baseColumn.length,
+            hasDefault: baseColumn.hasDefault,
+            enumValues: baseColumn.enumValues,
+            default: baseColumn.default,
+            isUnique: baseColumn.isUnique,
+            notNull: baseColumn.notNull,
+            primary: baseColumn.primary,
+            baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
+        };
+        return baseColumnResult;
     };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$1(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$1(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
+    const getTypeParams = (sqlType) => {
+        // get type params
+        const typeParams = {};
+        // handle dimensions
+        if (sqlType.includes('[')) {
+            const match = sqlType.match(/\[\w*]/g);
+            if (match) {
+                typeParams['dimensions'] = match.length;
             }
         }
-        return relations;
-    };
-    for (const table of Object.values(cockroachTables)) {
-        tableConfig = getTableConfig$1(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        // might be empty list
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
+        if (sqlType.startsWith('numeric')
+            || sqlType.startsWith('decimal')
+            || sqlType.startsWith('double precision')
+            || sqlType.startsWith('real')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
             }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
         }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getAllBaseColumns = (baseColumn) => {
-            const baseColumnResult = {
-                name: baseColumn.name,
-                columnType: baseColumn.getSQLType(),
-                typeParams: getTypeParams(baseColumn.getSQLType()),
-                dataType: baseColumn.dataType,
-                size: baseColumn.size,
-                hasDefault: baseColumn.hasDefault,
-                enumValues: baseColumn.enumValues,
-                default: baseColumn.default,
-                isUnique: baseColumn.isUnique,
-                notNull: baseColumn.notNull,
-                primary: baseColumn.primary,
-                baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
-            };
-            return baseColumnResult;
-        };
-        const getTypeParams = (sqlType) => {
-            // get type params
-            const typeParams = {};
-            // handle dimensions
-            if (sqlType.includes('[')) {
-                const match = sqlType.match(/\[\w*]/g);
-                if (match) {
-                    typeParams['dimensions'] = match.length;
-                }
-            }
-            if (sqlType.startsWith('numeric')
-                || sqlType.startsWith('decimal')
-                || sqlType.startsWith('double precision')
-                || sqlType.startsWith('real')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
+        else if (sqlType.startsWith('varchar')
+            || sqlType.startsWith('char')
+            || sqlType.startsWith('bit')
+            || sqlType.startsWith('vector')
+            || sqlType.startsWith('time')
+            || sqlType.startsWith('timestamp')
+            || sqlType.startsWith('interval')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
             }
-            else if (sqlType.startsWith('varchar')
-                || sqlType.startsWith('char')
-                || sqlType.startsWith('bit')
-                || sqlType.startsWith('vector')
-                || sqlType.startsWith('time')
-                || sqlType.startsWith('timestamp')
-                || sqlType.startsWith('interval')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            return typeParams;
-        };
-        // console.log(tableConfig.columns);
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                size: column.size,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-                generatedIdentityType: column.generatedIdentity?.type,
-                baseColumn: (column.baseColumn === undefined)
-                    ? undefined
-                    : getAllBaseColumns(column.baseColumn),
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(cockroachSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        // if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
+        return typeParams;
+    };
+    // console.log(tableConfig.columns);
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            size: column.length,
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+            generatedIdentityType: column.generatedIdentity?.type,
+            baseColumn: (column.baseColumn === undefined)
+                ? undefined
+                : getAllBaseColumns(column.baseColumn),
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
 };
 
 // MySql-----------------------------------------------------------------------------------------------------
 const resetMsSql = async (db, schema) => {
     const tablesToTruncate = Object.entries(schema).map(([_tsTableName, table]) => {
-        const tableConfig = getTableConfig(table);
+        const tableConfig = getTableConfig$5(table);
         return { dbName: tableConfig.name, dbSchema: tableConfig.schema ?? 'dbo' };
     });
     const allFkConstraints = {};
@@ -136912,7 +136937,7 @@ const filterMsSqlTables = (schema) => {
 };
 const seedMsSql = async (db, schema, options = {}, refinements) => {
     const { mssqlSchema, mssqlTables } = filterMsSqlTables(schema);
-    const { tables, relations } = getMsSqlInfo(mssqlSchema, mssqlTables);
+    const { tables, relations } = getSchemaInfo(mssqlSchema, mssqlTables, mapMsSqlTable);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mssql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -136921,163 +136946,50 @@ const seedMsSql = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mssqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getMsSqlInfo = (mssqlSchema, mssqlTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(mssqlTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
-            }
-        }
-        return relations;
-    };
-    for (const table of Object.values(mssqlTables)) {
-        tableConfig = getTableConfig(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
+const mapMsSqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    // TODO: rewrite
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')
+            || sqlType.startsWith('real')
+            || sqlType.startsWith('float')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
             }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
         }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        // TODO: rewrite
-        const getTypeParams = (sqlType) => {
-            // get type params and set only type
-            const typeParams = {};
-            if (sqlType.startsWith('decimal')
-                || sqlType.startsWith('real')
-                || sqlType.startsWith('float')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('binary')
+            || sqlType.startsWith('varbinary')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
             }
-            else if (sqlType.startsWith('char')
-                || sqlType.startsWith('varchar')
-                || sqlType.startsWith('binary')
-                || sqlType.startsWith('varbinary')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            return typeParams;
-        };
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-                identity: column.identity ? true : false,
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(mssqlSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const modifiedRelations = relations.map((relI) => {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: modifiedRelations, tableRelations };
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+            identity: column.identity ? true : false,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
 };
 
 // MySql-----------------------------------------------------------------------------------------------------
@@ -137100,7 +137012,7 @@ const filterMysqlTables = (schema) => {
 };
 const seedMySql = async (db, schema, options = {}, refinements) => {
     const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
-    const { tables, relations } = getMySqlInfo(mysqlSchema, mysqlTables);
+    const { tables, relations } = getSchemaInfo(mysqlSchema, mysqlTables, mapMySqlTable);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137109,168 +137021,55 @@ const seedMySql = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mysqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getMySqlInfo = (mysqlSchema, mysqlTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(mysqlTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$2(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$2(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$2(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
+const mapMySqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')
+            || sqlType.startsWith('real')
+            || sqlType.startsWith('double')
+            || sqlType.startsWith('float')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
             }
         }
-        return relations;
-    };
-    for (const table of Object.values(mysqlTables)) {
-        tableConfig = getTableConfig$2(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
-            }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
-        }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getTypeParams = (sqlType) => {
-            // get type params and set only type
-            const typeParams = {};
-            if (sqlType.startsWith('decimal')
-                || sqlType.startsWith('real')
-                || sqlType.startsWith('double')
-                || sqlType.startsWith('float')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
-            }
-            else if (sqlType.startsWith('char')
-                || sqlType.startsWith('varchar')
-                || sqlType.startsWith('binary')
-                || sqlType.startsWith('varbinary')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('binary')
+            || sqlType.startsWith('varbinary')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
             }
-            return typeParams;
-        };
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(mysqlSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
 };
 
 // Postgres-----------------------------------------------------------------------------------------------------------
 const resetPostgres = async (db, pgTables) => {
     const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
-        const config = getTableConfig$3(table);
+        const config = getTableConfig$1(table);
         config.schema = config.schema === undefined ? 'public' : config.schema;
         return `"${config.schema}"."${config.name}"`;
     });
@@ -137284,7 +137083,8 @@ const filterPgSchema = (schema) => {
 const seedPostgres = async (db, schema, options = {}, refinements) => {
     const seedService = new SeedService();
     const { pgSchema, pgTables } = filterPgSchema(schema);
-    const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
+    const { tables, relations } = getSchemaInfo(pgSchema, pgTables, mapPgTable);
+    // const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
     const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
     const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, pgTables, { ...options, preserveCyclicTablesData });
@@ -137292,198 +137092,82 @@ const seedPostgres = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, pgTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getPostgresInfo = (pgSchema, pgTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(pgTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$3(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
+const mapPgTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getAllBaseColumns = (baseColumn) => {
+        const baseColumnResult = {
+            name: baseColumn.name,
+            columnType: baseColumn.getSQLType(),
+            typeParams: getTypeParams(baseColumn.getSQLType()),
+            dataType: baseColumn.dataType.split(' ')[0],
+            size: baseColumn.length,
+            hasDefault: baseColumn.hasDefault,
+            enumValues: baseColumn.enumValues,
+            default: baseColumn.default,
+            isUnique: baseColumn.isUnique,
+            notNull: baseColumn.notNull,
+            primary: baseColumn.primary,
+            baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
+        };
+        return baseColumnResult;
     };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$3(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$3(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
+    const getTypeParams = (sqlType) => {
+        // get type params
+        const typeParams = {};
+        // handle dimensions
+        if (sqlType.includes('[')) {
+            const match = sqlType.match(/\[\w*]/g);
+            if (match) {
+                typeParams['dimensions'] = match.length;
             }
         }
-        return relations;
-    };
-    for (const table of Object.values(pgTables)) {
-        tableConfig = getTableConfig$3(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        // might be empty list
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
+        if (sqlType.startsWith('numeric')
+            || sqlType.startsWith('decimal')
+            || sqlType.startsWith('double precision')
+            || sqlType.startsWith('real')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
             }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
         }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getAllBaseColumns = (baseColumn) => {
-            const baseColumnResult = {
-                name: baseColumn.name,
-                columnType: baseColumn.getSQLType(),
-                typeParams: getTypeParams(baseColumn.getSQLType()),
-                dataType: baseColumn.dataType,
-                size: baseColumn.size,
-                hasDefault: baseColumn.hasDefault,
-                enumValues: baseColumn.enumValues,
-                default: baseColumn.default,
-                isUnique: baseColumn.isUnique,
-                notNull: baseColumn.notNull,
-                primary: baseColumn.primary,
-                baseColumn: baseColumn.baseColumn === undefined ? undefined : getAllBaseColumns(baseColumn.baseColumn),
-            };
-            return baseColumnResult;
-        };
-        const getTypeParams = (sqlType) => {
-            // get type params
-            const typeParams = {};
-            // handle dimensions
-            if (sqlType.includes('[')) {
-                const match = sqlType.match(/\[\w*]/g);
-                if (match) {
-                    typeParams['dimensions'] = match.length;
-                }
-            }
-            if (sqlType.startsWith('numeric')
-                || sqlType.startsWith('decimal')
-                || sqlType.startsWith('double precision')
-                || sqlType.startsWith('real')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
-            }
-            else if (sqlType.startsWith('varchar')
-                || sqlType.startsWith('bpchar')
-                || sqlType.startsWith('char')
-                || sqlType.startsWith('bit')
-                || sqlType.startsWith('vector')
-                || sqlType.startsWith('time')
-                || sqlType.startsWith('timestamp')
-                || sqlType.startsWith('interval')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
+        else if (sqlType.startsWith('varchar')
+            || sqlType.startsWith('bpchar')
+            || sqlType.startsWith('char')
+            || sqlType.startsWith('bit')
+            || sqlType.startsWith('vector')
+            || sqlType.startsWith('time')
+            || sqlType.startsWith('timestamp')
+            || sqlType.startsWith('interval')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
             }
-            return typeParams;
-        };
-        // console.log(tableConfig.columns);
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                size: column.size,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-                generatedIdentityType: column.generatedIdentity?.type,
-                baseColumn: (column.baseColumn === undefined)
-                    ? undefined
-                    : getAllBaseColumns(column.baseColumn),
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(pgSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        // if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            size: column.length,
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+            generatedIdentityType: column.generatedIdentity?.type,
+            baseColumn: (column.baseColumn === undefined)
+                ? undefined
+                : getAllBaseColumns(column.baseColumn),
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
 };
 
 // SingleStore-----------------------------------------------------------------------------------------------------
@@ -137506,7 +137190,7 @@ const filterSingleStoreTables = (schema) => {
 };
 const seedSingleStore = async (db, schema, options = {}, refinements) => {
     const { singleStoreSchema, singleStoreTables } = filterSingleStoreTables(schema);
-    const { tables, relations } = getSingleStoreInfo(singleStoreSchema, singleStoreTables);
+    const { tables, relations } = getSchemaInfo(singleStoreSchema, singleStoreTables, mapSingleStoreTable);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('singlestore', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137515,175 +137199,56 @@ const seedSingleStore = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, singleStoreTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getSingleStoreInfo = (singleStoreSchema, singleStoreTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(singleStoreTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$4(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$4(drizzleRel.sourceTable);
-                const tableDbSchema = tableConfig.schema ?? 'public';
-                const tableDbName = tableConfig.name;
-                const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$4(drizzleRel.referencedTable);
-                const refTableDbSchema = refTableConfig.schema ?? 'public';
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
+const mapSingleStoreTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')
+            || sqlType.startsWith('real')
+            || sqlType.startsWith('double')
+            || sqlType.startsWith('float')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
             }
         }
-        return relations;
-    };
-    for (const table of Object.values(singleStoreTables)) {
-        tableConfig = getTableConfig$4(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        // const newRelations = tableConfig.foreignKeys.map((fk) => {
-        // 	const table = dbToTsTableNamesMap[tableConfig.name] as string;
-        // 	const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)] as string;
-        // 	const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(
-        // 		fk.reference().foreignTable,
-        // 	);
-        // 	if (tableRelations[refTable] === undefined) {
-        // 		tableRelations[refTable] = [];
-        // 	}
-        // 	return {
-        // 		table,
-        // 		columns: fk
-        // 			.reference()
-        // 			.columns.map((col) => dbToTsColumnNamesMap[col.name] as string),
-        // 		refTable,
-        // 		refColumns: fk
-        // 			.reference()
-        // 			.foreignColumns.map(
-        // 				(fCol) => dbToTsColumnNamesMapForRefTable[fCol.name] as string,
-        // 			),
-        // 		refTableRels: tableRelations[refTable],
-        // 	};
-        // });
-        // relations.push(
-        // 	...newRelations,
-        // );
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
-        }
-        // tableRelations[dbToTsTableNamesMap[tableConfig.name] as string]!.push(...newRelations);
-        const getTypeParams = (sqlType) => {
-            // get type params and set only type
-            const typeParams = {};
-            if (sqlType.startsWith('decimal')
-                || sqlType.startsWith('real')
-                || sqlType.startsWith('double')
-                || sqlType.startsWith('float')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('binary')
+            || sqlType.startsWith('varbinary')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
             }
-            else if (sqlType.startsWith('char')
-                || sqlType.startsWith('varchar')
-                || sqlType.startsWith('binary')
-                || sqlType.startsWith('varbinary')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            else if (sqlType.startsWith('vector')) {
-                const match = sqlType.match(/\((\d+),? ?((F|I)\d{1,2})?\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                    typeParams['vectorValueType'] = match[2];
-                }
+        }
+        else if (sqlType.startsWith('vector')) {
+            const match = sqlType.match(/\((\d+),? ?((F|I)\d{1,2})?\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
+                typeParams['vectorValueType'] = match[2];
             }
-            return typeParams;
-        };
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(singleStoreSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
 };
 
 // Sqlite------------------------------------------------------------------------------------------------------------------------
@@ -137706,7 +137271,7 @@ const filterSqliteTables = (schema) => {
 };
 const seedSqlite = async (db, schema, options = {}, refinements) => {
     const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
-    const { tables, relations } = getSqliteInfo(sqliteSchema, sqliteTables);
+    const { tables, relations } = getSchemaInfo(sqliteSchema, sqliteTables, mapSqliteTable);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137715,159 +137280,48 @@ const seedSqlite = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, sqliteTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getSqliteInfo = (sqliteSchema, sqliteTables) => {
-    let tableConfig;
-    let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(sqliteTables).map(([key, value]) => [getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = getTableConfig$5(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
-    };
-    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
-        const schemaConfig = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
-        const relations = [];
-        for (const table of Object.values(schemaConfig.tables)) {
-            if (table.relations === undefined)
-                continue;
-            for (const drizzleRel of Object.values(table.relations)) {
-                if (!is(drizzleRel, One))
-                    continue;
-                const tableConfig = getTableConfig$5(drizzleRel.sourceTable);
-                const tableDbName = tableConfig.name;
-                // TODO: tableNamesMap: have {public.customer: 'customer'} structure in sqlite
-                const tableTsName = schemaConfig.tableNamesMap[`public.${tableDbName}`] ?? tableDbName;
-                const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
-                const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
-                    ?? [];
-                const refTableConfig = getTableConfig$5(drizzleRel.referencedTable);
-                const refTableDbName = refTableConfig.name;
-                const refTableTsName = schemaConfig.tableNamesMap[`public.${refTableDbName}`]
-                    ?? refTableDbName;
-                const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
-                const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
-                    ?? [];
-                if (tableRelations[refTableTsName] === undefined) {
-                    tableRelations[refTableTsName] = [];
-                }
-                const relation = {
-                    table: tableTsName,
-                    columns,
-                    refTable: refTableTsName,
-                    refColumns,
-                    refTableRels: tableRelations[refTableTsName],
-                    type: 'one',
-                };
-                // do not add duplicate relation
-                if (tableRelations[tableTsName]?.some((rel) => rel.table === relation.table
-                    && rel.refTable === relation.refTable)) {
-                    console.warn(`You are providing a one-to-many relation between the '${relation.refTable}' and '${relation.table}' tables,\n`
-                        + `while the '${relation.table}' table object already has foreign key constraint in the schema referencing '${relation.refTable}' table.\n`
-                        + `In this case, the foreign key constraint will be used.\n`);
-                    continue;
-                }
-                relations.push(relation);
-                tableRelations[tableTsName].push(relation);
+const mapSqliteTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+    const getTypeParams = (sqlType) => {
+        // get type params and set only type
+        const typeParams = {};
+        if (sqlType.startsWith('decimal')) {
+            const match = sqlType.match(/\((\d+), *(\d+)\)/);
+            if (match) {
+                typeParams['precision'] = Number(match[1]);
+                typeParams['scale'] = Number(match[2]);
             }
         }
-        return relations;
-    };
-    for (const table of Object.values(sqliteTables)) {
-        tableConfig = getTableConfig$5(table);
-        dbToTsColumnNamesMap = {};
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        const newRelations = tableConfig.foreignKeys.map((fk) => {
-            const table = dbToTsTableNamesMap[tableConfig.name];
-            const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
+        else if (sqlType.startsWith('char')
+            || sqlType.startsWith('varchar')
+            || sqlType.startsWith('text')) {
+            const match = sqlType.match(/\((\d+)\)/);
+            if (match) {
+                typeParams['length'] = Number(match[1]);
             }
-            return {
-                table,
-                columns: fk
-                    .reference()
-                    .columns.map((col) => dbToTsColumnNamesMap[col.name]),
-                refTable,
-                refColumns: fk
-                    .reference()
-                    .foreignColumns.map((fCol) => dbToTsColumnNamesMapForRefTable[fCol.name]),
-                refTableRels: tableRelations[refTable],
-            };
-        });
-        relations.push(...newRelations);
-        if (tableRelations[dbToTsTableNamesMap[tableConfig.name]] === undefined) {
-            tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
-        }
-        tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        const getTypeParams = (sqlType) => {
-            // get type params and set only type
-            const typeParams = {};
-            if (sqlType.startsWith('decimal')) {
-                const match = sqlType.match(/\((\d+), *(\d+)\)/);
-                if (match) {
-                    typeParams['precision'] = Number(match[1]);
-                    typeParams['scale'] = Number(match[2]);
-                }
-            }
-            else if (sqlType.startsWith('char')
-                || sqlType.startsWith('varchar')
-                || sqlType.startsWith('text')) {
-                const match = sqlType.match(/\((\d+)\)/);
-                if (match) {
-                    typeParams['length'] = Number(match[1]);
-                }
-            }
-            return typeParams;
-        };
-        tables.push({
-            name: dbToTsTableNamesMap[tableConfig.name],
-            columns: tableConfig.columns.map((column) => ({
-                name: dbToTsColumnNamesMap[column.name],
-                columnType: column.getSQLType(),
-                typeParams: getTypeParams(column.getSQLType()),
-                dataType: column.dataType,
-                hasDefault: column.hasDefault,
-                default: column.default,
-                enumValues: column.enumValues,
-                isUnique: column.isUnique,
-                notNull: column.notNull,
-                primary: column.primary,
-            })),
-            primaryKeys: tableConfig.columns
-                .filter((column) => column.primary)
-                .map((column) => dbToTsColumnNamesMap[column.name]),
-        });
-    }
-    const transformedDrizzleRelations = transformFromDrizzleRelation(sqliteSchema, getDbToTsColumnNamesMap, tableRelations);
-    relations.push(...transformedDrizzleRelations);
-    const isCyclicRelations = relations.map((relI) => {
-        const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
-        if (isRelationCyclic(relI)) {
-            tableRel['isCyclic'] = true;
-            return { ...relI, isCyclic: true };
         }
-        tableRel['isCyclic'] = false;
-        return { ...relI, isCyclic: false };
-    });
-    return { tables, relations: isCyclicRelations, tableRelations };
+        return typeParams;
+    };
+    return {
+        name: dbToTsTableNamesMap[tableConfig.name],
+        columns: tableConfig.columns.map((column) => ({
+            name: dbToTsColumnNamesMap[column.name],
+            columnType: column.getSQLType(),
+            typeParams: getTypeParams(column.getSQLType()),
+            dataType: column.dataType.split(' ')[0],
+            hasDefault: column.hasDefault,
+            default: column.default,
+            enumValues: column.enumValues,
+            isUnique: column.isUnique,
+            notNull: column.notNull,
+            primary: column.primary,
+        })),
+        primaryKeys: tableConfig.columns
+            .filter((column) => column.primary)
+            .map((column) => dbToTsColumnNamesMap[column.name]),
+    };
 };
 
+/* eslint-disable drizzle-internal/require-entity-kind */
 class SeedPromise {
     db;
     schema;