drizzle-seed 0.4.0-f0d7da2 → 0.4.0

package/index.cjs

@@ -7,8 +7,191 @@ var sqliteCore = require('drizzle-orm/sqlite-core');
 var mssqlCore = require('drizzle-orm/mssql-core');
 var cockroachCore = require('drizzle-orm/cockroach-core');
 var singlestoreCore = require('drizzle-orm/singlestore-core');
+var _relations = require('drizzle-orm/_relations');
 var prand = require('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 equalSets = (set1, set2) => {
+    return set1.size === set2.size && [...set1].every((si) => set2.has(si));
+};
+
+const getTableConfig = (table) => {
+    if (drizzleOrm.is(table, pgCore.PgTable))
+        return pgCore.getTableConfig(table);
+    else if (drizzleOrm.is(table, mysqlCore.MySqlTable))
+        return mysqlCore.getTableConfig(table);
+    else if (drizzleOrm.is(table, sqliteCore.SQLiteTable))
+        return sqliteCore.getTableConfig(table);
+    else if (drizzleOrm.is(table, cockroachCore.CockroachTable))
+        return cockroachCore.getTableConfig(table);
+    else if (drizzleOrm.is(table, mssqlCore.MsSqlTable))
+        return mssqlCore.getTableConfig(table);
+    else
+        return singlestoreCore.getTableConfig(table); // if (is(table, SingleStoreTable))
+};
+const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
+    const schemaConfig = _relations.extractTablesRelationalConfig(schema, _relations.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 (!drizzleOrm.is(drizzleRel, _relations.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, mapColumns) => {
+    let tableConfig;
+    let dbToTsColumnNamesMap;
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(drizzleTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const tables = [];
+    const relations = [];
+    const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
+    const getDbToTsColumnNamesMap = (table) => {
+        let dbToTsColumnNamesMap = {};
+        const tableName = drizzleOrm.getTableName(table);
+        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
+            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
+            return dbToTsColumnNamesMap;
+        }
+        const tableConfig = getTableConfig(table);
+        for (const [tsCol, col] of Object.entries(drizzleOrm.getColumnTable(tableConfig.columns[0]))) {
+            if (drizzleOrm.is(col, drizzleOrm.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[drizzleOrm.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 stringsSet = [];
+        const uniqueConstraints = [];
+        for (const uniCon of tableConfig.uniqueConstraints) {
+            const uniConColumns = uniCon.columns.map((col) => dbToTsColumnNamesMap[col.name]);
+            const uniConColumnsStr = JSON.stringify(uniConColumns);
+            if (!stringsSet.includes(uniConColumnsStr)) {
+                stringsSet.push(uniConColumnsStr);
+                uniqueConstraints.push(uniConColumns);
+            }
+        }
+        const mappedTable = {
+            name: dbToTsTableNamesMap[tableConfig.name],
+            uniqueConstraints,
+            primaryKeys: tableConfig.columns
+                .filter((column) => column.primary)
+                .map((column) => dbToTsColumnNamesMap[column.name]),
+            columns: mapColumns(tableConfig, dbToTsColumnNamesMap),
+        };
+        tables.push(mappedTable);
+    }
+    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
  */
@@ -131274,10 +131457,12 @@ const isObject = (value) => {
 class AbstractGenerator {
     static entityKind = 'AbstractGenerator';
     static version = 1;
+    isGeneratorUnique = false;
     isUnique = false;
     notNull = false;
     // param for generators which have a unique version of themselves
     uniqueVersionOfGen;
+    maxUniqueCount = -1;
     dataType;
     timeSpent;
     //
@@ -131289,6 +131474,7 @@ class AbstractGenerator {
     weightedCountSeed;
     maxRepeatedValuesCount;
     typeParams = {};
+    uniqueKey;
     params;
     constructor(params) {
         this.params = params === undefined ? {} : params;
@@ -131311,9 +131497,13 @@ class AbstractGenerator {
         const constructor = this.constructor;
         return constructor.entityKind;
     }
+    getMaxUniqueCount() {
+        // override if you need to initialize this.maxUniqueCount after constructor
+        return this.maxUniqueCount;
+    }
     replaceIfUnique() {
         this.updateParams();
-        if (this.uniqueVersionOfGen !== undefined
+        if ((this.uniqueVersionOfGen !== undefined)
             && this.isUnique === true) {
             const uniqueGen = new this.uniqueVersionOfGen({
                 ...this.params,
@@ -131344,6 +131534,20 @@ class AbstractGenerator {
     }
 }
 // Generators Classes -----------------------------------------------------------------------------------------------------------------------
+class GenerateHashFromString extends AbstractGenerator {
+    static entityKind = 'GenerateHashFromString';
+    init() { }
+    generate({ input }) {
+        let hash = 0;
+        // p and m are prime numbers
+        const p = 53;
+        const m = 28871271685163;
+        for (let i = 0; i < input.length; i++) {
+            hash += ((input.codePointAt(i) || 0) * Math.pow(p, i)) % m;
+        }
+        return hash;
+    }
+}
 class GenerateArray extends AbstractGenerator {
     static entityKind = 'GenerateArray';
     arraySize = 10;
@@ -131403,6 +131607,23 @@ class GenerateValuesFromArray extends AbstractGenerator {
     static entityKind = 'GenerateValuesFromArray';
     state;
     timeSpent = 0;
+    maxUniqueCount;
+    allValuesCount = 0; // TODO rewrite generator
+    constructor(params) {
+        super(params);
+        this.allValuesCount = this.params.values.length;
+        if (isObject(this.params.values[0])) {
+            this.allValuesCount = this.params.values.reduce((acc, currVal) => acc + currVal.values.length, 0);
+        }
+        this.maxUniqueCount = this.allValuesCount;
+    }
+    getMaxUniqueCount() {
+        this.allValuesCount = this.params.values.length;
+        if (isObject(this.params.values[0])) {
+            this.allValuesCount = this.params.values.reduce((acc, currVal) => acc + currVal.values.length, 0);
+        }
+        return this.allValuesCount;
+    }
     checks({ count }) {
         const { values } = this.params;
         const { maxRepeatedValuesCount, notNull, isUnique } = this;
@@ -131420,16 +131641,13 @@ class GenerateValuesFromArray extends AbstractGenerator {
                 : obj.count.every((count) => count > 0))))) {
             throw new Error('maxRepeatedValuesCount should be greater than zero.');
         }
-        let allValuesCount = values.length;
-        if (isObject(values[0])) {
-            allValuesCount = values.reduce((acc, currVal) => acc + currVal.values.length, 0);
-        }
         if (notNull === true
             && maxRepeatedValuesCount !== undefined
             && ((!isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
                 && maxRepeatedValuesCount * values.length < count)
                 || (isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
-                    && maxRepeatedValuesCount * allValuesCount < count))) {
+                    // eslint-disable-next-line unicorn/consistent-destructuring
+                    && maxRepeatedValuesCount * this.allValuesCount < count))) {
             throw new Error("Can't fill notNull column with null values.");
         }
         if (isUnique === true && maxRepeatedValuesCount !== undefined && ((typeof maxRepeatedValuesCount === 'number' && maxRepeatedValuesCount > 1)
@@ -131440,7 +131658,8 @@ class GenerateValuesFromArray extends AbstractGenerator {
             throw new Error("Can't be greater than 1 if column is unique.");
         }
         if (isUnique === true && notNull === true && ((!isObject(values[0]) && values.length < count)
-            || (isObject(values[0]) && allValuesCount < count))) {
+            // eslint-disable-next-line unicorn/consistent-destructuring
+            || (isObject(values[0]) && this.allValuesCount < count))) {
             // console.log(maxRepeatedValuesCount, values.length, allValuesCount, count)
             throw new Error('There are no enough values to fill unique column.');
         }
@@ -131576,6 +131795,8 @@ class GenerateSelfRelationsValuesFromArray extends AbstractGenerator {
 class GenerateIntPrimaryKey extends AbstractGenerator {
     static entityKind = 'GenerateIntPrimaryKey';
     maxValue;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
+    isGeneratorUnique = true;
     init({ count }) {
         if (this.maxValue !== undefined && count > this.maxValue) {
             throw new Error('count exceeds max number for this column type.');
@@ -131626,14 +131847,39 @@ class GenerateNumber extends AbstractGenerator {
 class GenerateUniqueNumber extends AbstractGenerator {
     static entityKind = 'GenerateUniqueNumber';
     state;
-    isUnique = true;
-    init({ count, seed }) {
+    precision;
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        let { minValue, maxValue } = this.params;
+        const { precision } = this.params;
+        this.precision = precision ?? 100;
+        if (maxValue === undefined) {
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return;
+        }
+        else {
+            maxValue *= this.precision;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        else {
+            minValue *= this.precision;
+        }
+        this.maxUniqueCount = maxValue - minValue + 1;
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
         let { minValue, maxValue, precision } = this.params;
         if (precision === undefined) {
             precision = 100;
         }
         if (maxValue === undefined) {
-            maxValue = count * precision;
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return this.maxUniqueCount;
         }
         else {
             maxValue *= precision;
@@ -131644,9 +131890,26 @@ class GenerateUniqueNumber extends AbstractGenerator {
         else {
             minValue *= precision;
         }
+        this.maxUniqueCount = maxValue - minValue + 1;
+        return this.maxUniqueCount;
+    }
+    init({ count, seed }) {
+        let { minValue, maxValue } = this.params;
+        if (maxValue === undefined) {
+            maxValue = count * this.precision;
+        }
+        else {
+            maxValue *= this.precision;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        else {
+            minValue *= this.precision;
+        }
         const genUniqueIntObj = new GenerateUniqueInt({ minValue, maxValue });
         genUniqueIntObj.init({ count, seed });
-        this.state = { genUniqueIntObj, minValue, maxValue, precision };
+        this.state = { genUniqueIntObj, minValue, maxValue, precision: this.precision };
     }
     generate() {
         if (this.state === undefined) {
@@ -131701,8 +131964,48 @@ class GenerateUniqueInt extends AbstractGenerator {
     genMaxRepeatedValuesCount;
     skipCheck = false;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
     timeSpent = 0;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        let minValue = this.params.minValue, maxValue = this.params.maxValue;
+        if (maxValue === undefined) {
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+            maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+            this.maxUniqueCount = Number(maxValue - minValue) + 1;
+        }
+        else if (typeof minValue === 'bigint' && typeof maxValue === 'bigint') {
+            this.maxUniqueCount = Number(maxValue - minValue) + 1;
+        }
+        else
+            this.maxUniqueCount = Number(Number(maxValue) - Number(minValue)) + 1; // error should be triggered in init method
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        let minValue = this.params.minValue, maxValue = this.params.maxValue;
+        if (maxValue === undefined) {
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return this.maxUniqueCount;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+            maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+        }
+        this.maxUniqueCount = Number(maxValue - minValue) + 1;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         const rng = prand.xoroshiro128plus(seed);
         let { minValue, maxValue } = this.params;
@@ -132132,11 +132435,10 @@ class GenerateInterval extends AbstractGenerator {
         return interval;
     }
 }
-// has a newer version
 class GenerateUniqueInterval extends AbstractGenerator {
     static 'entityKind' = 'GenerateUniqueInterval';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
     config = {
         year: {
             from: 0,
@@ -132163,6 +132465,47 @@ class GenerateUniqueInterval extends AbstractGenerator {
             to: 60,
         },
     };
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+        let fieldsToGenerate = allFields;
+        if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+            const tokens = this.params.fields.split(' to ');
+            const endIdx = allFields.indexOf(tokens[1]);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        else if (this.params.fields !== undefined) {
+            const endIdx = allFields.indexOf(this.params.fields);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        this.maxUniqueCount = 1;
+        for (const field of fieldsToGenerate) {
+            const from = this.config[field].from, to = this.config[field].to;
+            this.maxUniqueCount *= from - to + 1;
+        }
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+        let fieldsToGenerate = allFields;
+        if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+            const tokens = this.params.fields.split(' to ');
+            const endIdx = allFields.indexOf(tokens[1]);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        else if (this.params.fields !== undefined) {
+            const endIdx = allFields.indexOf(this.params.fields);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        this.maxUniqueCount = 1;
+        for (const field of fieldsToGenerate) {
+            const from = this.config[field].from, to = this.config[field].to;
+            this.maxUniqueCount *= from - to + 1;
+        }
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
         let fieldsToGenerate = allFields;
@@ -132231,6 +132574,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;
     }
 }
@@ -132238,7 +132583,11 @@ class GenerateString extends AbstractGenerator {
 class GenerateUniqueString extends AbstractGenerator {
     static entityKind = 'GenerateUniqueString';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
+    getMaxUniqueCount() {
+        return Number.POSITIVE_INFINITY;
+    }
     init({ seed }) {
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
@@ -132259,13 +132608,20 @@ 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 {
     static entityKind = 'GenerateUUID';
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
     state;
+    getMaxUniqueCount() {
+        return Number.POSITIVE_INFINITY;
+    }
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
@@ -132320,9 +132676,16 @@ class GenerateFirstName extends AbstractGenerator {
 class GenerateUniqueFirstName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueFirstName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = firstNames.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = firstNames.length;
+        return firstNames.length;
+    }
     init({ count, seed }) {
-        if (count > firstNames.length) {
+        if (count > this.getMaxUniqueCount()) {
             throw new Error('count exceeds max number of unique first names.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$5) {
@@ -132366,9 +132729,16 @@ class GenerateLastName extends AbstractGenerator {
 class GenerateUniqueLastName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueLastName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = lastNames.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = lastNames.length;
+        return lastNames.length;
+    }
     init({ count, seed }) {
-        if (count > lastNames.length) {
+        if (count > this.getMaxUniqueCount()) {
             throw new Error('count exceeds max number of unique last names.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$3) {
@@ -132415,13 +132785,19 @@ class GenerateFullName extends AbstractGenerator {
 class GenerateUniqueFullName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueFullName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
     timeSpent = 0;
+    maxUniqueCount = firstNames.length * lastNames.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = firstNames.length * lastNames.length;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         const t0 = new Date();
-        const maxUniqueFullNamesNumber = firstNames.length * lastNames.length;
-        if (count > maxUniqueFullNamesNumber) {
-            throw new RangeError(`count exceeds max number of unique full names(${maxUniqueFullNamesNumber}).`);
+        if (count > this.getMaxUniqueCount()) {
+            throw new RangeError(`count exceeds max number of unique full names(${this.getMaxUniqueCount()}).`);
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxStringLength$5 + maxStringLength$3 + 1)) {
             throw new Error(`You can't use full name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$5 + maxStringLength$3 + 1}.`);
@@ -132456,13 +132832,17 @@ class GenerateEmail extends AbstractGenerator {
     static entityKind = 'GenerateEmail';
     state;
     timeSpent = 0;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = adjectives.length * firstNames.length * emailDomains.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = adjectives.length * firstNames.length * emailDomains.length;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         super.init({ count, seed });
-        const domainsArray = emailDomains;
-        const adjectivesArray = adjectives;
-        const namesArray = firstNames;
-        const maxUniqueEmailsNumber = adjectivesArray.length * namesArray.length * domainsArray.length;
+        const maxUniqueEmailsNumber = adjectives.length * firstNames.length * emailDomains.length;
         if (count > maxUniqueEmailsNumber) {
             throw new RangeError(`count exceeds max number of unique emails(${maxUniqueEmailsNumber}).`);
         }
@@ -132470,7 +132850,7 @@ class GenerateEmail extends AbstractGenerator {
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxEmailLength) {
             throw new Error(`You can't use email generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxEmailLength}.`);
         }
-        const arraysToGenerateFrom = [adjectivesArray, namesArray, domainsArray];
+        const arraysToGenerateFrom = [adjectives, firstNames, emailDomains];
         const genIndicesObj = new GenerateUniqueInt({
             minValue: 0,
             maxValue: maxUniqueEmailsNumber - 1,
@@ -132494,20 +132874,75 @@ class GenerateEmail extends AbstractGenerator {
 class GeneratePhoneNumber extends AbstractGenerator {
     static entityKind = 'GeneratePhoneNumber';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        const { template } = this.params;
+        if (template === undefined) {
+            const { generatedDigitsNumbers } = this.prepareWithoutTemplate();
+            this.maxUniqueCount = generatedDigitsNumbers.reduce((a, b) => a + Math.pow(10, b), 0);
+        }
+        else {
+            const { placeholdersCount } = this.prepareWithTemplate();
+            this.maxUniqueCount = Math.pow(10, placeholdersCount);
+        }
+    }
+    prepareWithTemplate() {
+        const { template } = this.params;
+        const iterArray = [...template.matchAll(/#/g)];
+        const placeholdersCount = iterArray.length;
+        return { placeholdersCount };
+    }
+    prepareWithoutTemplate() {
+        let { generatedDigitsNumbers, prefixes } = this.params;
+        if (prefixes === undefined || prefixes.length === 0) {
+            prefixes = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
+            generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
+                // tokens = ["380","99","9"] =
+                // = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
+                const tokens = phoneInfo.split(',');
+                const operatorPrefixLength = tokens[1].replaceAll(' ', '').length;
+                return Number(tokens[2]) - operatorPrefixLength;
+            });
+        }
+        else {
+            if (typeof generatedDigitsNumbers === 'number') {
+                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(generatedDigitsNumbers);
+            }
+            else if (generatedDigitsNumbers === undefined
+                || generatedDigitsNumbers.length === 0) {
+                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(7);
+            }
+        }
+        return { prefixes, generatedDigitsNumbers };
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        const { template } = this.params;
+        if (template === undefined) {
+            const { generatedDigitsNumbers } = this.prepareWithoutTemplate();
+            this.maxUniqueCount = generatedDigitsNumbers.reduce((a, b) => a + Math.pow(10, b), 0);
+            return this.maxUniqueCount;
+        }
+        else {
+            const { placeholdersCount } = this.prepareWithTemplate();
+            this.maxUniqueCount = Math.pow(10, placeholdersCount);
+            return this.maxUniqueCount;
+        }
+    }
     init({ count, seed }) {
         super.init({ count, seed });
-        let { generatedDigitsNumbers } = this.params;
-        const { prefixes, template } = this.params;
+        const { template } = this.params;
         const rng = prand.xoroshiro128plus(seed);
         if (template !== undefined) {
             if (this.typeParams?.length !== undefined && this.typeParams?.length < template.length) {
                 throw new Error(`Length of phone number template is shorter than db column length restriction: ${this.typeParams?.length}. 
 					Set the maximum string length to at least ${template.length}.`);
             }
-            const iterArray = [...template.matchAll(/#/g)];
-            const placeholdersCount = iterArray.length;
-            const maxUniquePhoneNumbersCount = Math.pow(10, placeholdersCount);
+            const { placeholdersCount } = this.prepareWithTemplate();
+            const maxUniquePhoneNumbersCount = this.getMaxUniqueCount();
             if (maxUniquePhoneNumbersCount < count) {
                 throw new RangeError(`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`);
             }
@@ -132524,27 +132959,8 @@ class GeneratePhoneNumber extends AbstractGenerator {
             this.state = { rng, placeholdersCount, generatorsMap, prefixesArray, generatedDigitsNumbers, phoneNumbersSet };
             return;
         }
-        let prefixesArray;
-        if (prefixes === undefined || prefixes.length === 0) {
-            prefixesArray = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
-            generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
-                // tokens = ["380","99","9"] =
-                // = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
-                const tokens = phoneInfo.split(',');
-                const operatorPrefixLength = tokens[1].replaceAll(' ', '').length;
-                return Number(tokens[2]) - operatorPrefixLength;
-            });
-        }
-        else {
-            prefixesArray = prefixes;
-            if (typeof generatedDigitsNumbers === 'number') {
-                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(generatedDigitsNumbers);
-            }
-            else if (generatedDigitsNumbers === undefined
-                || generatedDigitsNumbers.length === 0) {
-                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(7);
-            }
-        }
+        const { generatedDigitsNumbers, prefixes } = this.prepareWithoutTemplate();
+        const prefixesArray = [...prefixes];
         const maxPrefixLength = Math.max(...prefixesArray.map((prefix) => prefix.length));
         const maxGeneratedDigits = Math.max(...generatedDigitsNumbers);
         if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxPrefixLength + maxGeneratedDigits)) {
@@ -132553,7 +132969,7 @@ class GeneratePhoneNumber extends AbstractGenerator {
         if (new Set(prefixesArray).size !== prefixesArray.length) {
             throw new Error('prefixes are not unique.');
         }
-        const maxUniquePhoneNumbersCount = generatedDigitsNumbers.reduce((a, b) => a + Math.pow(10, b), 0);
+        const maxUniquePhoneNumbersCount = this.getMaxUniqueCount();
         if (maxUniquePhoneNumbersCount < count) {
             throw new RangeError(`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`);
         }
@@ -132643,9 +133059,16 @@ class GenerateCountry extends AbstractGenerator {
 class GenerateUniqueCountry extends AbstractGenerator {
     static entityKind = 'GenerateUniqueCountry';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = countries.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = countries.length;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
-        if (count > countries.length) {
+        if (count > this.getMaxUniqueCount()) {
             throw new Error('count exceeds max number of unique countries.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$7) {
@@ -132714,11 +133137,17 @@ class GenerateStreetAddress extends AbstractGenerator {
 class GenerateUniqueStreetAddress extends AbstractGenerator {
     static entityKind = 'GenerateUniqueStreetAddress';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    streetNumbersCount = 999;
+    maxUniqueCount = this.streetNumbersCount * (firstNames.length + lastNames.length)
+        * streetSuffix.length;
+    getMaxUniqueCount() {
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
-        const streetNumberStrs = Array.from({ length: 999 }, (_, i) => String(i + 1));
-        const maxUniqueStreetnamesNumber = streetNumberStrs.length * firstNames.length * streetSuffix.length
-            + streetNumberStrs.length * firstNames.length * streetSuffix.length;
+        const streetNumberStrs = Array.from({ length: this.streetNumbersCount }, (_, i) => String(i + 1));
+        const maxUniqueStreetnamesNumber = streetNumberStrs.length * (firstNames.length + lastNames.length)
+            * streetSuffix.length;
         if (count > maxUniqueStreetnamesNumber) {
             throw new RangeError(`count exceeds max number of unique street names(${maxUniqueStreetnamesNumber}).`);
         }
@@ -132743,7 +133172,7 @@ class GenerateUniqueStreetAddress extends AbstractGenerator {
                     minValue: 0,
                     maxValue: streetNumberStrs.length * lastNames.length * streetSuffix.length - 1,
                 }),
-                maxUniqueStreetNamesNumber: streetNumberStrs.length * firstNames.length * streetSuffix.length,
+                maxUniqueStreetNamesNumber: streetNumberStrs.length * lastNames.length * streetSuffix.length,
                 count: 0,
                 arraysToChooseFrom: [streetNumberStrs, lastNames, streetSuffix],
             },
@@ -132797,9 +133226,10 @@ class GenerateCity extends AbstractGenerator {
 class GenerateUniqueCity extends AbstractGenerator {
     static entityKind = 'GenerateUniqueCity';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = cityNames.length;
     init({ count, seed }) {
-        if (count > cityNames.length) {
+        if (count > this.maxUniqueCount) {
             throw new Error('count exceeds max number of unique cities.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$9) {
@@ -132854,11 +133284,11 @@ class GeneratePostcode extends AbstractGenerator {
 class GenerateUniquePostcode extends AbstractGenerator {
     static entityKind = 'GenerateUniquePostcode';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = Math.pow(10, 5) + Math.pow(10, 9);
     init({ count, seed }) {
-        const maxUniquePostcodeNumber = Math.pow(10, 5) + Math.pow(10, 9);
-        if (count > maxUniquePostcodeNumber) {
-            throw new RangeError(`count exceeds max number of unique postcodes(${maxUniquePostcodeNumber}).`);
+        if (count > this.maxUniqueCount) {
+            throw new RangeError(`count exceeds max number of unique postcodes(${this.maxUniqueCount}).`);
         }
         const rng = prand.xoroshiro128plus(seed);
         const templates = [
@@ -132980,12 +133410,12 @@ class GenerateCompanyName extends AbstractGenerator {
 class GenerateUniqueCompanyName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueCompanyName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
+        + Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
     init({ count, seed }) {
-        const maxUniqueCompanyNameNumber = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
-            + Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
-        if (count > maxUniqueCompanyNameNumber) {
-            throw new RangeError(`count exceeds max number of unique company names(${maxUniqueCompanyNameNumber}).`);
+        if (count > this.maxUniqueCount) {
+            throw new RangeError(`count exceeds max number of unique company names(${this.maxUniqueCount}).`);
         }
         // max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
         const maxCompanyNameLength = Math.max(maxStringLength$3 + maxStringLength$8 + 1, 3 * maxStringLength$3 + 7);
@@ -133156,7 +133586,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') {
@@ -133171,22 +133601,29 @@ class GeneratePoint extends AbstractGenerator {
 class GenerateUniquePoint extends AbstractGenerator {
     static entityKind = 'GenerateUniquePoint';
     state;
-    isUnique = true;
-    init({ count, seed }) {
-        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique points.
-        const xCoordinateGen = new GenerateUniqueNumber({
+    isGeneratorUnique = true;
+    xCoordinateGen;
+    yCoordinateGen;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        this.xCoordinateGen = new GenerateUniqueNumber({
             minValue: this.params.minXValue,
             maxValue: this.params.maxXValue,
             precision: 10,
         });
-        xCoordinateGen.init({ count, seed });
-        const yCoordinateGen = new GenerateUniqueNumber({
+        this.yCoordinateGen = new GenerateUniqueNumber({
             minValue: this.params.minYValue,
             maxValue: this.params.maxYValue,
             precision: 10,
         });
-        yCoordinateGen.init({ count, seed });
-        this.state = { xCoordinateGen, yCoordinateGen };
+        this.maxUniqueCount = Math.min(this.xCoordinateGen.maxUniqueCount, this.yCoordinateGen.maxUniqueCount);
+    }
+    init({ count, seed }) {
+        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique points.
+        this.xCoordinateGen.init({ count, seed });
+        this.yCoordinateGen.init({ count, seed });
+        this.state = { xCoordinateGen: this.xCoordinateGen, yCoordinateGen: this.yCoordinateGen };
     }
     generate() {
         if (this.state === undefined) {
@@ -133194,7 +133631,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') {
@@ -133243,7 +133680,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') {
@@ -133258,28 +133695,40 @@ class GenerateLine extends AbstractGenerator {
 class GenerateUniqueLine extends AbstractGenerator {
     static entityKind = 'GenerateUniqueLine';
     state;
-    isUnique = true;
-    init({ count, seed }) {
-        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique triplets(liens).
-        const aCoefficientGen = new GenerateUniqueNumber({
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    aCoefficientGen;
+    bCoefficientGen;
+    cCoefficientGen;
+    constructor(params) {
+        super(params);
+        this.aCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minAValue,
             maxValue: this.params.maxAValue,
             precision: 10,
         });
-        aCoefficientGen.init({ count, seed });
-        const bCoefficientGen = new GenerateUniqueNumber({
+        this.bCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minBValue,
             maxValue: this.params.maxBValue,
             precision: 10,
         });
-        bCoefficientGen.init({ count, seed });
-        const cCoefficientGen = new GenerateUniqueNumber({
+        this.cCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minCValue,
             maxValue: this.params.maxCValue,
             precision: 10,
         });
-        cCoefficientGen.init({ count, seed });
-        this.state = { aCoefficientGen, bCoefficientGen, cCoefficientGen };
+        this.maxUniqueCount = Math.min(this.aCoefficientGen.maxUniqueCount, this.bCoefficientGen.maxUniqueCount, this.cCoefficientGen.maxUniqueCount);
+    }
+    init({ count, seed }) {
+        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique triplets(liens).
+        this.aCoefficientGen.init({ count, seed });
+        this.bCoefficientGen.init({ count, seed });
+        this.cCoefficientGen.init({ count, seed });
+        this.state = {
+            aCoefficientGen: this.aCoefficientGen,
+            bCoefficientGen: this.bCoefficientGen,
+            cCoefficientGen: this.cCoefficientGen,
+        };
     }
     generate() {
         if (this.state === undefined) {
@@ -133292,7 +133741,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') {
@@ -133337,7 +133786,15 @@ class GenerateUniqueBitString extends AbstractGenerator {
     static entityKind = 'GenerateUniqueBitString';
     dimensions = 11;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount >= 0)
+            return this.maxUniqueCount;
+        this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+        this.maxUniqueCount = Math.pow(2, this.dimensions);
+        // TODO revise: will work incorrect with this.dimensions > 53, due to node js number limitations
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
         let intGen;
@@ -133408,18 +133865,35 @@ class GenerateInet extends AbstractGenerator {
         }
     }
 }
-// TODO: add defaults to js doc
 class GenerateUniqueInet extends AbstractGenerator {
     static entityKind = 'GenerateUniqueInet';
     ipAddress = 'ipv4';
     includeCidr = true;
     delimiter = '.';
     state;
-    isUnique = true;
-    init({ count, seed }) {
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
         this.ipAddress = this.params.ipAddress ?? this.ipAddress;
-        this.delimiter = this.ipAddress === 'ipv4' ? '.' : ':';
         this.includeCidr = this.params.includeCidr ?? this.includeCidr;
+        if (this.ipAddress === 'ipv4') {
+            this.maxUniqueCount = 256 ** 4;
+            if (this.includeCidr) {
+                this.maxUniqueCount *= 33;
+            }
+        }
+        else {
+            // this.ipAddress === 'ipv6'
+            // TODO revise: this.maxUniqueCount can exceed Number.MAX_SAFE_INTEGER
+            this.maxUniqueCount = 65535 ** 8;
+            if (this.includeCidr) {
+                this.maxUniqueCount *= 129;
+            }
+        }
+    }
+    init({ count, seed }) {
+        this.delimiter = this.ipAddress === 'ipv4' ? '.' : ':';
         // maxValue - number of combinations for cartesian product: {0…255} × {0…255} × {0…255} × {0…255} × {0…32}
         // where pattern for ipv4 ip is {0–255}.{0–255}.{0–255}.{0–255}[/{0–32}?]
         // or number of combinations for cartesian product: {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…128}
@@ -133535,11 +134009,42 @@ class GenerateUniqueGeometry extends AbstractGenerator {
     srid = 4326;
     decimalPlaces = 6;
     state;
-    isUnique = true;
-    init({ count, seed }) {
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
         this.type = this.params.type ?? this.type;
         this.srid = this.params.srid ?? this.srid;
         this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+        let minXValue, maxXValue, minYValue, maxYValue, denominator;
+        if (this.type === 'point') {
+            if (this.srid === 4326) {
+                // Degrees (latitude / longitude)
+                denominator = 10 ** this.decimalPlaces;
+                minXValue = -180 * denominator;
+                maxXValue = 180 * denominator;
+                minYValue = -90 * denominator;
+                maxYValue = 90 * denominator;
+            }
+            else {
+                // this.srid === 3857
+                // Meters (projected X / Y)
+                denominator = 1;
+                minXValue = -20026376;
+                maxXValue = 20026376;
+                minYValue = -20048966;
+                maxYValue = 20048966;
+            }
+        }
+        else {
+            // error should be triggered in init method
+            this.maxUniqueCount = -1;
+            return;
+        }
+        // TODO revise: can lose accuracy due to exceeding Number.MAX_SAFE_INTEGER
+        this.maxUniqueCount = Number(BigInt(maxXValue - minXValue + 1) * BigInt(maxYValue - minYValue + 1));
+    }
+    init({ count, seed }) {
         let minXValue, maxXValue, minYValue, maxYValue, denominator;
         if (this.type === 'point') {
             if (this.srid === 4326) {
@@ -133646,11 +134151,10 @@ class GenerateUniqueVector extends AbstractGenerator {
     maxValue = 1000;
     decimalPlaces = 2;
     state;
-    isUnique = true;
-    init({ count, seed }) {
-        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+    isGeneratorUnique = true;
+    constructor(params) {
+        super(params);
         this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
-        const denominator = 10 ** this.decimalPlaces;
         this.minValue = this.params.minValue ?? this.minValue;
         this.maxValue = this.params.maxValue ?? this.maxValue;
         if (this.minValue > this.maxValue) {
@@ -133660,6 +134164,18 @@ class GenerateUniqueVector extends AbstractGenerator {
         if (this.decimalPlaces < 0) {
             throw new Error(`decimalPlaces value must be greater than or equal to zero.`);
         }
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount >= 0)
+            return this.maxUniqueCount;
+        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+        const denominator = 10 ** this.decimalPlaces;
+        this.maxUniqueCount = (this.maxValue * denominator - this.minValue * denominator + 1) ** this.dimensions;
+        return this.maxUniqueCount;
+    }
+    init({ count, seed }) {
+        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+        const denominator = 10 ** this.decimalPlaces;
         if (abs(BigInt(this.minValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER
             || abs(BigInt(this.maxValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER) {
             console.warn(`vector generator: minValue or maxValue multiplied by 10^decimalPlaces exceeds Number.MAX_SAFE_INTEGER (2^53 -1).\n`
@@ -133695,13 +134211,80 @@ class GenerateUniqueVector extends AbstractGenerator {
         return vector;
     }
 }
+class GenerateCompositeUniqueKey extends AbstractGenerator {
+    static entityKind = 'GenerateCompositeUniqueKey';
+    columnGenerators = [];
+    isInitialized = false;
+    state;
+    addGenerator(columnName, generator) {
+        this.columnGenerators.push({ columnName, generator });
+    }
+    init({ count, seed }) {
+        if (this.isInitialized)
+            return;
+        if (this.columnGenerators.length === 0) {
+            throw new Error(`composite unique key generator has no generators to work with.`);
+        }
+        let countPerGen = Math.ceil(count ** (1 / this.columnGenerators.length));
+        // const gensMaxUniqueCount: { columnName: string; count: number; maxUniqueCount: number }[] = [];
+        for (const colGen of this.columnGenerators) {
+            colGen.maxUniqueCount = colGen.generator.getMaxUniqueCount();
+        }
+        this.columnGenerators.sort((a, b) => a.maxUniqueCount - b.maxUniqueCount);
+        let currCount = count;
+        let canGenerate = false;
+        for (const [idx, colGen] of this.columnGenerators.entries()) {
+            if (colGen.maxUniqueCount < countPerGen) {
+                colGen.count = colGen.maxUniqueCount;
+                currCount /= colGen.count;
+                countPerGen = Math.ceil(currCount ** (1 / (this.columnGenerators.length - idx - 1)));
+                canGenerate = false;
+            }
+            else {
+                colGen.count = countPerGen;
+                canGenerate = true;
+            }
+        }
+        if (!canGenerate) {
+            const colGensCountInfo = this.columnGenerators.map((colGen) => `generator:${colGen.generator.getEntityKind()};count:${colGen.count}`).join('\n');
+            throw new Error(`There are no enough unique values in each generator to generate ${count} values; \n${colGensCountInfo}`);
+        }
+        const sets = [];
+        for (const colGen of this.columnGenerators) {
+            colGen.generator.init({ count: colGen.count, seed });
+            const setI = [];
+            for (let i = 0; i < countPerGen; i++) {
+                setI.push(colGen.generator.generate({ i }));
+            }
+            sets.push(setI);
+        }
+        this.state = { sets, currI: -1, currValue: {} };
+        this.isInitialized = true;
+    }
+    generate({ i, columnName }) {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        if (i > this.state.currI) {
+            const rowI = fastCartesianProduct(this.state.sets, i);
+            const newCurrValue = {};
+            for (const [idx, colGen] of this.columnGenerators.entries()) {
+                newCurrValue[colGen.columnName] = rowI[idx];
+            }
+            this.state.currValue = newCurrValue;
+            this.state.currI = i;
+        }
+        return this.state.currValue[columnName];
+    }
+}
 
 /* eslint-disable drizzle-internal/require-entity-kind */
 class GenerateUniqueIntervalV2 extends AbstractGenerator {
     static 'entityKind' = 'GenerateUniqueInterval';
     static version = 2;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount;
     config = {
         year: {
             from: 0,
@@ -133728,29 +134311,33 @@ class GenerateUniqueIntervalV2 extends AbstractGenerator {
             to: 59,
         },
     };
-    init({ count, seed }) {
+    fieldsToGenerate;
+    constructor(params) {
+        super(params);
         const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
-        let fieldsToGenerate = allFields;
+        this.fieldsToGenerate = allFields;
         if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
             const tokens = this.params.fields.split(' to ');
             const endIdx = allFields.indexOf(tokens[1]);
-            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+            this.fieldsToGenerate = allFields.slice(0, endIdx + 1);
         }
         else if (this.params.fields !== undefined) {
             const endIdx = allFields.indexOf(this.params.fields);
-            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+            this.fieldsToGenerate = allFields.slice(0, endIdx + 1);
         }
-        let maxUniqueIntervalsNumber = 1;
-        for (const field of fieldsToGenerate) {
+        this.maxUniqueCount = 1;
+        for (const field of this.fieldsToGenerate) {
             const from = this.config[field].from, to = this.config[field].to;
-            maxUniqueIntervalsNumber *= from - to + 1;
+            this.maxUniqueCount *= from - to + 1;
         }
-        if (count > maxUniqueIntervalsNumber) {
-            throw new RangeError(`count exceeds max number of unique intervals(${maxUniqueIntervalsNumber})`);
+    }
+    init({ count, seed }) {
+        if (count > this.maxUniqueCount) {
+            throw new RangeError(`count exceeds max number of unique intervals(${this.maxUniqueCount})`);
         }
         const rng = prand.xoroshiro128plus(seed);
         const intervalSet = new Set();
-        this.state = { rng, fieldsToGenerate, intervalSet };
+        this.state = { rng, fieldsToGenerate: this.fieldsToGenerate, intervalSet };
     }
     generate() {
         if (this.state === undefined) {
@@ -133772,6 +134359,7 @@ class GenerateUniqueIntervalV2 extends AbstractGenerator {
         return interval;
     }
 }
+// TODO need to rework this generator
 class GenerateStringV2 extends AbstractGenerator {
     static 'entityKind' = 'GenerateString';
     static version = 2;
@@ -133804,7 +134392,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;
     }
@@ -133813,21 +134401,27 @@ class GenerateUniqueStringV2 extends AbstractGenerator {
     static 'entityKind' = 'GenerateUniqueString';
     static version = 2;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxStringLength = 20;
+    minStringLength = 7;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount >= 0)
+            return this.maxUniqueCount;
+        this.maxStringLength = this.typeParams?.length ?? this.maxStringLength;
+        this.maxUniqueCount = Number.parseInt('f'.repeat(this.maxStringLength), 16);
+        return this.maxUniqueCount;
+    }
     init({ seed, count }) {
         const rng = prand.xoroshiro128plus(seed);
-        let minStringLength = 7;
-        let maxStringLength = 20;
         // TODO: revise later
-        if (this.typeParams?.length !== undefined) {
-            maxStringLength = this.typeParams?.length;
-            if (maxStringLength === 1 || maxStringLength < minStringLength)
-                minStringLength = maxStringLength;
+        this.maxStringLength = this.typeParams?.length ?? this.maxStringLength;
+        if (this.maxStringLength === 1 || this.maxStringLength < this.minStringLength) {
+            this.minStringLength = this.maxStringLength;
         }
-        if (maxStringLength < count.toString(16).length) {
-            throw new Error(`You can't generate ${count} unique strings, with a maximum string length of ${maxStringLength}.`);
+        if (count > this.getMaxUniqueCount()) {
+            throw new Error(`You can't generate ${count} unique strings, with a maximum string length of ${this.maxStringLength}.`);
         }
-        this.state = { rng, minStringLength, maxStringLength };
+        this.state = { rng, minStringLength: this.minStringLength, maxStringLength: this.maxStringLength };
     }
     generate({ i }) {
         if (this.state === undefined) {
@@ -133844,10 +134438,31 @@ 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;
     }
 }
 
+/* eslint-disable drizzle-internal/require-entity-kind */
+class GenerateHashFromStringV3 extends AbstractGenerator {
+    static entityKind = 'GenerateHashFromString';
+    static version = 3;
+    init() { }
+    generate({ input }) {
+        let hash = 0n;
+        // p and m are prime numbers
+        const p = 53n;
+        const m = 28871271685163n; // < 2^53
+        let power = 1n; // will track p^i, where i is character index
+        for (const ch of input) {
+            hash = (hash + (BigInt(ch.codePointAt(0) || 0) * power)) % m;
+            power = (power * p) % m;
+        }
+        return Number(hash);
+    }
+}
+
 function createGenerator(generatorConstructor) {
     return (...args) => {
         let params = args[0];
@@ -134643,7 +135258,14 @@ const generatorsFuncs = {
 const generatorsFuncsV2 = {
     ...generatorsFuncs,
 };
+({
+    ...generatorsFuncs,
+});
 const generatorsMap = {
+    GenerateHashFromString: [
+        GenerateHashFromString,
+        GenerateHashFromStringV3,
+    ],
     HollowGenerator: [
         HollowGenerator,
     ],
@@ -134821,6 +135443,9 @@ const generatorsMap = {
     GenerateUniqueVector: [
         GenerateUniqueVector,
     ],
+    GenerateCompositeUniqueKey: [
+        GenerateCompositeUniqueKey,
+    ],
 };
 
 // TODO: revise serial part generators
@@ -134976,8 +135601,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;
         }
@@ -135039,7 +135664,7 @@ const selectGeneratorForCockroachColumn = (table, col) => {
     return generator;
 };
 
-const latestVersion = 2;
+const latestVersion = 3;
 
 const selectGeneratorForMssqlColumn = (table, col) => {
     const pickGenerator = (table, col) => {
@@ -135805,7 +136430,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;
         }
@@ -135876,49 +136501,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';
@@ -135931,6 +136513,7 @@ class SeedService {
     sqliteMaxParametersNumber = 32766;
     mssqlMaxParametersNumber = 2100;
     version;
+    hashFromStringGenerator;
     generatePossibleGenerators = (connectionType, tables, relations, refinements, options) => {
         let columnPossibleGenerator;
         let tablePossibleGenerators;
@@ -135939,6 +136522,7 @@ class SeedService {
         if (Number.isNaN(this.version) || this.version < 1 || this.version > latestVersion) {
             throw new Error(`Version should be in range [1, ${latestVersion}].`);
         }
+        this.hashFromStringGenerator = this.selectVersionOfGenerator(new generatorsMap.GenerateHashFromString[0]());
         // sorting table in order which they will be filled up (tables with foreign keys case)
         const { tablesInOutRelations } = this.getInfoFromRelations(relations);
         const orderedTablesNames = this.getOrderedTablesList(tablesInOutRelations);
@@ -135958,6 +136542,7 @@ class SeedService {
             withFromTable: {},
         }));
         for (const [i, table] of tables.entries()) {
+            const compositeUniqueKeyGenMap = {};
             // get foreignKey columns relations
             const foreignKeyColumns = {};
             for (const rel of relations
@@ -135999,7 +136584,7 @@ class SeedService {
                                 const weightedRepeatedValuesCount = refinements[table.name]
                                     .with[fkTableName];
                                 weightedCountSeed = customSeed
-                                    + generateHashFromString(`${table.name}.${fkTableName}`);
+                                    + this.hashFromStringGenerator.generate({ input: `${table.name}.${fkTableName}` });
                                 newTableWithCount = this.getWeightedWithCount(weightedRepeatedValuesCount, (tablesPossibleGenerators[i].withCount
                                     || tablesPossibleGenerators[i].count), weightedCountSeed);
                             }
@@ -136035,6 +136620,18 @@ class SeedService {
                     && refinements[table.name].columns !== undefined
                     && refinements[table.name].columns[col.name] !== undefined) {
                     const genObj = refinements[table.name].columns[col.name];
+                    if (genObj === false) {
+                        if (col.notNull === true && col.hasDefault === false) {
+                            throw new Error(`You cannot set the '${col.name}' column in the '${table.name}' table to false in your refinements.`
+                                + `\nDoing so will result in a null value being inserted into the '${col.name}' column,`
+                                + `\nwhich will cause an error because the column has a not null constraint and no default value.`);
+                        }
+                        // Generating undefined as a value for a column and then inserting it via drizzle-orm
+                        // will result in the value not being inserted into that column.
+                        columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: undefined });
+                        columnPossibleGenerator.wasRefined = true;
+                        continue;
+                    }
                     if (col.columnType.match(/\[\w*]/g) !== null) {
                         if ((col.baseColumn?.dataType === 'array' && col.baseColumn.columnType.match(/\[\w*]/g) !== null)
                             // studio case
@@ -136106,16 +136703,66 @@ class SeedService {
                     columnPossibleGenerator.generator = arrayGen;
                 }
                 columnPossibleGenerator.generator.isUnique = col.isUnique;
+                // composite unique keys handling
+                let compositeKeyColumnNames = table.uniqueConstraints.filter((colNames) => colNames.includes(col.name));
+                if (compositeKeyColumnNames.some((colNames) => colNames.length === 1)) {
+                    // composite unique key contains only one column, therefore it equals to just unique column
+                    columnPossibleGenerator.generator.isUnique = true;
+                }
+                // removing column from composite unique keys if current column is unique
+                if (columnPossibleGenerator.generator.isUnique && compositeKeyColumnNames.length > 0) {
+                    const newUniqueConstraints = [];
+                    for (const colNames of table.uniqueConstraints) {
+                        if (colNames.includes(col.name)) {
+                            const newColNames = colNames.filter((colName) => colName !== col.name);
+                            if (newColNames.length === 0)
+                                continue;
+                            newUniqueConstraints.push(newColNames);
+                        }
+                        else {
+                            newUniqueConstraints.push(colNames);
+                        }
+                    }
+                    table.uniqueConstraints = newUniqueConstraints;
+                }
+                compositeKeyColumnNames = table.uniqueConstraints.filter((colNames) => colNames.includes(col.name));
+                if (compositeKeyColumnNames.length > 1) {
+                    throw new Error('Currently, multiple composite unique keys that share the same column are not supported.');
+                }
+                // to handle composite unique key generation, I will need a unique generator for each column in the composite key
+                if (compositeKeyColumnNames.length === 1) {
+                    if (columnPossibleGenerator.generator.params.isUnique === false) {
+                        throw new Error(`To handle the composite unique key on columns: ${compositeKeyColumnNames[0]}, `
+                            + `column: ${col.name} should either be assigned a generator with isUnique set to true, or have isUnique omitted.`);
+                    }
+                    columnPossibleGenerator.generator.params.isUnique = true;
+                }
                 const uniqueGen = columnPossibleGenerator.generator.replaceIfUnique();
                 if (uniqueGen !== undefined) {
                     columnPossibleGenerator.generator = uniqueGen;
                 }
+                if (compositeKeyColumnNames.length === 1 && !columnPossibleGenerator.generator.isGeneratorUnique
+                    && !(columnPossibleGenerator.generator.getEntityKind() === 'GenerateValuesFromArray')) {
+                    throw new Error(`To handle the composite unique key on columns: ${compositeKeyColumnNames[0]}, `
+                        + `column: ${col.name} should be assigned a generator with its own unique version.`);
+                }
                 // selecting version of generator
                 columnPossibleGenerator.generator = this.selectVersionOfGenerator(columnPossibleGenerator.generator);
                 // TODO: for now only GenerateValuesFromArray support notNull property
                 columnPossibleGenerator.generator.notNull = col.notNull;
                 columnPossibleGenerator.generator.dataType = col.dataType;
-                // columnPossibleGenerator.generator.stringLength = col.typeParams.length;
+                // assigning composite key generator
+                if (compositeKeyColumnNames.length === 1) {
+                    const key = compositeKeyColumnNames[0].join('_');
+                    if (compositeUniqueKeyGenMap[key] === undefined) {
+                        let compositeUniqueKeyGen = new generatorsMap.GenerateCompositeUniqueKey[0]();
+                        compositeUniqueKeyGen.uniqueKey = key;
+                        compositeUniqueKeyGen = this.selectVersionOfGenerator(compositeUniqueKeyGen);
+                        compositeUniqueKeyGenMap[key] = compositeUniqueKeyGen;
+                    }
+                    compositeUniqueKeyGenMap[key].addGenerator(col.name, columnPossibleGenerator.generator);
+                    columnPossibleGenerator.generator = compositeUniqueKeyGenMap[key];
+                }
                 tablePossibleGenerators.columnsPossibleGenerators.push(columnPossibleGenerator);
             }
         }
@@ -136144,6 +136791,7 @@ class SeedService {
         newGenerator.dataType = generator.dataType;
         // newGenerator.stringLength = generator.stringLength;
         newGenerator.typeParams = generator.typeParams ?? newGenerator.typeParams;
+        newGenerator.uniqueKey = generator.uniqueKey;
         return newGenerator;
     };
     cyclicTablesCompare = (table1, table2, relation, reverseRelation) => {
@@ -136304,8 +136952,13 @@ class SeedService {
                 const columnRelations = filteredRelations.filter((rel) => rel.columns.includes(col.columnName));
                 pRNGSeed = (columnRelations.length !== 0
                     && columnRelations[0].columns.length >= 2)
-                    ? (customSeed + generateHashFromString(`${columnRelations[0].table}.${columnRelations[0].columns.join('_')}`))
-                    : (customSeed + generateHashFromString(`${table.tableName}.${col.columnName}`));
+                    ? (customSeed
+                        + this.hashFromStringGenerator.generate({
+                            input: `${columnRelations[0].table}.${columnRelations[0].columns.join('_')}`,
+                        }))
+                    : col.generator?.uniqueKey === undefined
+                        ? (customSeed + this.hashFromStringGenerator.generate({ input: `${table.tableName}.${col.columnName}` }))
+                        : (customSeed + this.hashFromStringGenerator.generate({ input: col.generator.uniqueKey }));
                 tableGenerators[col.columnName] = {
                     pRNGSeed,
                     ...col,
@@ -136327,7 +136980,9 @@ class SeedService {
                         if (rel.table === rel.refTable
                             && tableGenerators[rel.columns[colIdx]]?.wasRefined === false) {
                             const refColName = rel.refColumns[colIdx];
-                            pRNGSeed = generateHashFromString(`${table.tableName}.${refColName}`);
+                            pRNGSeed = this.hashFromStringGenerator.generate({
+                                input: `${table.tableName}.${refColName}`,
+                            });
                             const refColumnGenerator = {};
                             refColumnGenerator[refColName] = {
                                 ...tableGenerators[refColName],
@@ -136476,11 +137131,7 @@ class SeedService {
             row = {};
             generatedValues.push(row);
             for (const columnName of Object.keys(columnsGenerators)) {
-                // generatedValue = columnsGenerators[columnName].next().value as
-                //   | string
-                //   | number
-                //   | boolean;
-                generatedValue = columnsGenerators[columnName].generate({ i });
+                generatedValue = columnsGenerators[columnName].generate({ i, columnName });
                 row[columnName] = generatedValue;
             }
             if ((insertDataInDb === true || updateDataInDb === true)
@@ -136620,14 +137271,14 @@ const resetCockroach = async (db, cockroachTables) => {
     await db.execute(drizzleOrm.sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
 };
 const filterCockroachSchema = (schema) => {
-    const cockroachSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], cockroachCore.CockroachTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const cockroachSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], cockroachCore.CockroachTable) || drizzleOrm.is(keyValue[1], _relations.Relations)));
     const cockroachTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], cockroachCore.CockroachTable)));
     return { cockroachSchema, cockroachTables };
 };
 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, mapCockroachColumns);
     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 });
@@ -136635,197 +137286,76 @@ 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]) => [drizzleOrm.getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = drizzleOrm.getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = cockroachCore.getTableConfig(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
+const mapCockroachColumns = (tableConfig, 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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
-                    continue;
-                const tableConfig = cockroachCore.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 = cockroachCore.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);
+    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 = cockroachCore.getTableConfig(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[drizzleOrm.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;
-                }
+        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]);
             }
-            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]);
-                }
-            }
-            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;
+    };
+    const mappedColumns = 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),
+    }));
+    return mappedColumns;
 };
 
 // MySql-----------------------------------------------------------------------------------------------------
@@ -136908,13 +137438,13 @@ const resetMsSql = async (db, schema) => {
     }
 };
 const filterMsSqlTables = (schema) => {
-    const mssqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mssqlCore.MsSqlTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const mssqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mssqlCore.MsSqlTable) || drizzleOrm.is(keyValue[1], _relations.Relations)));
     const mssqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mssqlCore.MsSqlTable)));
     return { mssqlSchema, mssqlTables };
 };
 const seedMsSql = async (db, schema, options = {}, refinements) => {
     const { mssqlSchema, mssqlTables } = filterMsSqlTables(schema);
-    const { tables, relations } = getMsSqlInfo(mssqlSchema, mssqlTables);
+    const { tables, relations } = getSchemaInfo(mssqlSchema, mssqlTables, mapMsSqlColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mssql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -136923,163 +137453,45 @@ 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]) => [drizzleOrm.getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = drizzleOrm.getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = mssqlCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
-                    continue;
-                const tableConfig = mssqlCore.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 = mssqlCore.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 = mssqlCore.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[drizzleOrm.getTableName(fk.reference().foreignTable)];
-            const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
-            if (tableRelations[refTable] === undefined) {
-                tableRelations[refTable] = [];
+const mapMsSqlColumns = (tableConfig, 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;
+    };
+    const mappedColumns = 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,
+    }));
+    return mappedColumns;
 };
 
 // MySql-----------------------------------------------------------------------------------------------------
@@ -137096,13 +137508,13 @@ const resetMySql = async (db, schema) => {
     await db.execute(drizzleOrm.sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
 };
 const filterMysqlTables = (schema) => {
-    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable) || drizzleOrm.is(keyValue[1], _relations.Relations)));
     const mysqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable)));
     return { mysqlSchema, mysqlTables };
 };
 const seedMySql = async (db, schema, options = {}, refinements) => {
     const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
-    const { tables, relations } = getMySqlInfo(mysqlSchema, mysqlTables);
+    const { tables, relations } = getSchemaInfo(mysqlSchema, mysqlTables, mapMySqlColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137111,162 +137523,44 @@ 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]) => [drizzleOrm.getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = drizzleOrm.getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = mysqlCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
-                    continue;
-                const tableConfig = mysqlCore.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 = mysqlCore.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);
+const mapMySqlColumns = (tableConfig, 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 = mysqlCore.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[drizzleOrm.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('binary')
+            || sqlType.startsWith('varbinary')) {
+            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')
-                || 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]);
-                }
-            }
-            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;
+    };
+    const mappedColumns = 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,
+    }));
+    return mappedColumns;
 };
 
 // Postgres-----------------------------------------------------------------------------------------------------------
@@ -137279,14 +137573,15 @@ const resetPostgres = async (db, pgTables) => {
     await db.execute(drizzleOrm.sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
 };
 const filterPgSchema = (schema) => {
-    const pgSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], pgCore.PgTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const pgSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], pgCore.PgTable) || drizzleOrm.is(keyValue[1], _relations.Relations)));
     const pgTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], pgCore.PgTable)));
     return { pgSchema, pgTables };
 };
 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, mapPgColumns);
+    // 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 });
@@ -137294,198 +137589,77 @@ 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]) => [drizzleOrm.getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = drizzleOrm.getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = pgCore.getTableConfig(table);
-        for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
-            dbToTsColumnNamesMap[col.name] = tsCol;
-        }
-        dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
-        return dbToTsColumnNamesMap;
+const mapPgColumns = (tableConfig, 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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
-                    continue;
-                const tableConfig = pgCore.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 = pgCore.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);
+    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 = pgCore.getTableConfig(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[drizzleOrm.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;
+    };
+    const mappedColumns = 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),
+    }));
+    return mappedColumns;
 };
 
 // SingleStore-----------------------------------------------------------------------------------------------------
@@ -137502,13 +137676,13 @@ const resetSingleStore = async (db, schema) => {
     await db.execute(drizzleOrm.sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
 };
 const filterSingleStoreTables = (schema) => {
-    const singleStoreSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], singlestoreCore.SingleStoreTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const singleStoreSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], singlestoreCore.SingleStoreTable) || drizzleOrm.is(keyValue[1], _relations.Relations)));
     const singleStoreTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], singlestoreCore.SingleStoreTable)));
     return { singleStoreSchema, singleStoreTables };
 };
 const seedSingleStore = async (db, schema, options = {}, refinements) => {
     const { singleStoreSchema, singleStoreTables } = filterSingleStoreTables(schema);
-    const { tables, relations } = getSingleStoreInfo(singleStoreSchema, singleStoreTables);
+    const { tables, relations } = getSchemaInfo(singleStoreSchema, singleStoreTables, mapSingleStoreColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('singlestore', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137517,175 +137691,52 @@ 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]) => [drizzleOrm.getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = drizzleOrm.getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = singlestoreCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
-                    continue;
-                const tableConfig = singlestoreCore.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 = singlestoreCore.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);
+const mapSingleStoreColumns = (tableConfig, 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 = singlestoreCore.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] 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('text')
+            || 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;
+    };
+    const mappedColumns = 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,
+    }));
+    return mappedColumns;
 };
 
 // Sqlite------------------------------------------------------------------------------------------------------------------------
@@ -137702,13 +137753,13 @@ const resetSqlite = async (db, schema) => {
     await db.run(drizzleOrm.sql.raw('PRAGMA foreign_keys = ON'));
 };
 const filterSqliteTables = (schema) => {
-    const sqliteSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], sqliteCore.SQLiteTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const sqliteSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], sqliteCore.SQLiteTable) || drizzleOrm.is(keyValue[1], _relations.Relations)));
     const sqliteTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], sqliteCore.SQLiteTable)));
     return { sqliteSchema, sqliteTables };
 };
 const seedSqlite = async (db, schema, options = {}, refinements) => {
     const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
-    const { tables, relations } = getSqliteInfo(sqliteSchema, sqliteTables);
+    const { tables, relations } = getSchemaInfo(sqliteSchema, sqliteTables, mapSqliteColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137717,159 +137768,43 @@ 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]) => [drizzleOrm.getTableName(value), key]));
-    const tables = [];
-    const relations = [];
-    const dbToTsColumnNamesMapGlobal = {};
-    const tableRelations = {};
-    const getDbToTsColumnNamesMap = (table) => {
-        let dbToTsColumnNamesMap = {};
-        const tableName = drizzleOrm.getTableName(table);
-        if (Object.hasOwn(dbToTsColumnNamesMapGlobal, tableName)) {
-            dbToTsColumnNamesMap = dbToTsColumnNamesMapGlobal[tableName];
-            return dbToTsColumnNamesMap;
-        }
-        const tableConfig = sqliteCore.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 = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.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 (!drizzleOrm.is(drizzleRel, drizzleOrm.One))
-                    continue;
-                const tableConfig = sqliteCore.getTableConfig(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 = sqliteCore.getTableConfig(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 mapSqliteColumns = (tableConfig, 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 = sqliteCore.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[drizzleOrm.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;
+    };
+    const mappedColumns = 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,
+    }));
+    return mappedColumns;
 };
 
+/* eslint-disable drizzle-internal/require-entity-kind */
 class SeedPromise {
     db;
     schema;
@@ -137930,6 +137865,7 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
                 name: tableName,
                 columns,
                 primaryKeys: drizzleStudioColumns.filter((col) => col.primaryKey === true).map((col) => col.name),
+                uniqueConstraints: [], // TODO change later
             });
         }
         relations = drizzleStudioRelations.filter((rel) => rel.schema === schemaName && rel.refSchema === schemaName);