drizzle-seed 0.1.2 → 0.1.3-e14a5a2

package/index.mjs

@@ -1,4 +1,4 @@
-import { entityKind, is, sql, getTableName } from 'drizzle-orm';
+import { entityKind, is, eq, sql, getTableName } from 'drizzle-orm';
 import { MySqlDatabase, MySqlTable, getTableConfig as getTableConfig$1 } from 'drizzle-orm/mysql-core';
 import { PgDatabase, getTableConfig, PgTable } from 'drizzle-orm/pg-core';
 import { BaseSQLiteDatabase, SQLiteTable, getTableConfig as getTableConfig$2 } from 'drizzle-orm/sqlite-core';
@@ -131190,6 +131190,19 @@ const fillTemplate = ({ template, placeholdersCount, values, defaultValue = ' '
     }
     return resultStr;
 };
+// is variable is object-like.
+// Example:
+// isObject({f: 4}) === true;
+// isObject([1,2,3]) === false;
+// isObject(new Set()) === false;
+const isObject = (value) => {
+    if (value !== null && value !== undefined && value.constructor === Object)
+        return true;
+    return false;
+};
+const equalSets = (set1, set2) => {
+    return set1.size === set2.size && [...set1].every((si) => set2.has(si));
+};
 
 class AbstractGenerator {
     params;
@@ -131199,9 +131212,56 @@ class AbstractGenerator {
     uniqueVersionOfGen;
     dataType;
     timeSpent;
+    arraySize;
+    baseColumnDataType;
     constructor(params) {
         this.params = params;
     }
+    init() {
+        if (this.params.arraySize !== undefined) {
+            this.arraySize = this.params.arraySize;
+        }
+        if (this.params.isUnique !== undefined) {
+            if (this.params.isUnique === false && this.isUnique === true) {
+                throw new Error('specifying non unique generator to unique column.');
+            }
+            this.isUnique = this.params.isUnique;
+        }
+    }
+    getEntityKind() {
+        const constructor = this.constructor;
+        return constructor[entityKind];
+    }
+    replaceIfUnique({ count, seed }) {
+        if (this.uniqueVersionOfGen !== undefined
+            && this.isUnique === true) {
+            const uniqueGen = new this.uniqueVersionOfGen({
+                ...this.params,
+            });
+            uniqueGen.init({
+                count,
+                seed,
+            });
+            uniqueGen.isUnique = this.isUnique;
+            uniqueGen.dataType = this.dataType;
+            return uniqueGen;
+        }
+        return;
+    }
+    replaceIfArray({ count, seed }) {
+        if (!(this.getEntityKind() === 'GenerateArray') && this.arraySize !== undefined) {
+            const uniqueGen = this.replaceIfUnique({ count, seed });
+            const baseColumnGen = uniqueGen === undefined ? this : uniqueGen;
+            baseColumnGen.dataType = this.baseColumnDataType;
+            const arrayGen = new GenerateArray({
+                baseColumnGen,
+                size: this.arraySize,
+            });
+            arrayGen.init({ count, seed });
+            return arrayGen;
+        }
+        return;
+    }
 }
 function createGenerator(generatorConstructor) {
     return (...args) => {
@@ -131212,6 +131272,22 @@ function createGenerator(generatorConstructor) {
     };
 }
 // Generators Classes -----------------------------------------------------------------------------------------------------------------------
+class GenerateArray extends AbstractGenerator {
+    static [entityKind] = 'GenerateArray';
+    arraySize = 10;
+    init({ count, seed }) {
+        super.init({ count, seed });
+        this.arraySize = this.params.size === undefined ? this.arraySize : this.params.size;
+        this.params.baseColumnGen.init({ count: count * this.arraySize, seed });
+    }
+    generate() {
+        const array = [];
+        for (let i = 0; i < this.arraySize; i++) {
+            array.push(this.params.baseColumnGen.generate({ i }));
+        }
+        return array;
+    }
+}
 class GenerateWeightedCount extends AbstractGenerator {
     static [entityKind] = 'GenerateWeightedCount';
     state;
@@ -131247,7 +131323,6 @@ class HollowGenerator extends AbstractGenerator {
 }
 class GenerateDefault extends AbstractGenerator {
     static [entityKind] = 'GenerateDefault';
-    init() { }
     generate() {
         return this.params.defaultValue;
     }
@@ -131264,7 +131339,7 @@ class GenerateValuesFromArray extends AbstractGenerator {
         if (values.length === 0) {
             throw new Error('Values length equals zero.');
         }
-        if (typeof values[0] === 'object'
+        if (isObject(values[0])
             && !values.every((val) => val.values.length !== 0)) {
             throw new Error('One of weighted values length equals zero.');
         }
@@ -131276,14 +131351,14 @@ class GenerateValuesFromArray extends AbstractGenerator {
             throw new Error('maxRepeatedValuesCount should be greater than zero.');
         }
         let allValuesCount = values.length;
-        if (typeof values[0] === 'object') {
+        if (isObject(values[0])) {
             allValuesCount = values.reduce((acc, currVal) => acc + currVal.values.length, 0);
         }
         if (notNull === true
             && maxRepeatedValuesCount !== undefined
-            && ((typeof values[0] !== 'object' && typeof maxRepeatedValuesCount === 'number'
+            && ((!isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
                 && maxRepeatedValuesCount * values.length < count)
-                || (typeof values[0] === 'object' && typeof maxRepeatedValuesCount === 'number'
+                || (isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
                     && maxRepeatedValuesCount * allValuesCount < count))) {
             throw new Error("Can't fill notNull column with null values.");
         }
@@ -131294,25 +131369,20 @@ class GenerateValuesFromArray extends AbstractGenerator {
                 : obj.count.every((count) => count === 1))))) {
             throw new Error("Can't be greater than 1 if column is unique.");
         }
-        if (isUnique === true && notNull === true && ((typeof values[0] !== 'object' && values.length < count)
-            || (typeof values[0] === 'object' && allValuesCount < count))) {
+        if (isUnique === true && notNull === true && ((!isObject(values[0]) && values.length < count)
+            || (isObject(values[0]) && allValuesCount < count))) {
             // console.log(maxRepeatedValuesCount, values.length, allValuesCount, count)
             throw new Error('There are no enough values to fill unique column.');
         }
     }
     init({ count, seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('Specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+        super.init({ count, seed });
         this.checks({ count });
         let { maxRepeatedValuesCount } = this;
         const { params, isUnique, notNull, weightedCountSeed } = this;
         const values = params.values;
         let valuesWeightedIndices;
-        if (typeof values[0] === 'object') {
+        if (isObject(values[0])) {
             valuesWeightedIndices = getWeightedIndices(values.map((val) => val.weight));
             if (isUnique === true && notNull === true) {
                 let idx, valueIdx, rng = prand.xoroshiro128plus(seed);
@@ -131351,13 +131421,13 @@ class GenerateValuesFromArray extends AbstractGenerator {
         let genIndicesObj;
         let genIndicesObjList;
         if (maxRepeatedValuesCount !== undefined) {
-            if (typeof values[0] !== 'object') {
+            if (!isObject(values[0])) {
                 genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: values.length - 1 });
                 genIndicesObj.genMaxRepeatedValuesCount = genMaxRepeatedValuesCount;
                 genIndicesObj.skipCheck = true;
                 genIndicesObj.init({ count, seed });
             }
-            else if (typeof values[0] === 'object') {
+            else if (isObject(values[0])) {
                 genIndicesObjList = [];
                 for (const obj of values) {
                     const genIndicesObj = new GenerateUniqueInt({ minValue: 0, maxValue: obj.values.length - 1 });
@@ -131452,15 +131522,8 @@ class GenerateNumber extends AbstractGenerator {
     static [entityKind] = 'GenerateNumber';
     state;
     uniqueVersionOfGen = GenerateUniqueNumber;
-    init({ seed }) {
-        if (this.params === undefined)
-            this.params = {};
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         let { minValue, maxValue, precision } = this.params;
         if (precision === undefined) {
             precision = 100;
@@ -131494,8 +131557,6 @@ class GenerateUniqueNumber extends AbstractGenerator {
     state;
     isUnique = true;
     init({ count, seed }) {
-        if (this.params === undefined)
-            this.params = {};
         let { minValue, maxValue, precision } = this.params;
         if (precision === undefined) {
             precision = 100;
@@ -131528,13 +131589,8 @@ class GenerateInt extends AbstractGenerator {
     static [entityKind] = 'GenerateInt';
     state;
     uniqueVersionOfGen = GenerateUniqueInt;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         let { minValue, maxValue } = this.params;
         if (maxValue === undefined) {
             maxValue = 1000;
@@ -131697,7 +131753,8 @@ class GenerateUniqueInt extends AbstractGenerator {
 class GenerateBoolean extends AbstractGenerator {
     static [entityKind] = 'GenerateBoolean';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -131713,7 +131770,8 @@ class GenerateBoolean extends AbstractGenerator {
 class GenerateDate extends AbstractGenerator {
     static [entityKind] = 'GenerateDate';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         let { minDate, maxDate } = this.params;
         const anchorDate = new Date('2024-05-08');
@@ -131754,7 +131812,8 @@ class GenerateDate extends AbstractGenerator {
 class GenerateTime extends AbstractGenerator {
     static [entityKind] = 'GenerateTime';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -131774,7 +131833,8 @@ class GenerateTime extends AbstractGenerator {
 class GenerateTimestamp extends AbstractGenerator {
     static [entityKind] = 'GenerateTimestamp';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -131800,7 +131860,8 @@ class GenerateTimestamp extends AbstractGenerator {
 class GenerateDatetime extends AbstractGenerator {
     static [entityKind] = 'GenerateDatetime';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -131826,7 +131887,8 @@ class GenerateDatetime extends AbstractGenerator {
 class GenerateYear extends AbstractGenerator {
     static [entityKind] = 'GenerateYear';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -131849,12 +131911,14 @@ class GenerateJson extends AbstractGenerator {
     static [entityKind] = 'GenerateJson';
     state;
     init({ count, seed }) {
+        super.init({ count, seed });
         const emailGeneratorObj = new GenerateEmail({});
         emailGeneratorObj.init({ count, seed });
         const nameGeneratorObj = new GenerateFirstName({});
-        nameGeneratorObj.init({ seed });
+        nameGeneratorObj.init({ count, seed });
         const booleanGeneratorObj = new GenerateBoolean({});
         booleanGeneratorObj.init({
+            count,
             seed,
         });
         const salaryGeneratorObj = new GenerateInt({ minValue: 200, maxValue: 4000 });
@@ -131865,7 +131929,7 @@ class GenerateJson extends AbstractGenerator {
         });
         const dateGeneratorObj = new GenerateDate({});
         dateGeneratorObj.dataType = 'string';
-        dateGeneratorObj.init({ seed });
+        dateGeneratorObj.init({ count, seed });
         const visitedCountriesNumberGeneratorObj = new GenerateInt({ minValue: 0, maxValue: 4 });
         visitedCountriesNumberGeneratorObj.init({ count, seed, ...visitedCountriesNumberGeneratorObj.params });
         this.state = {
@@ -131942,13 +132006,8 @@ class GenerateInterval extends AbstractGenerator {
     static [entityKind] = 'GenerateInterval';
     state;
     uniqueVersionOfGen = GenerateUniqueInterval;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -131976,6 +132035,7 @@ class GenerateInterval extends AbstractGenerator {
 class GenerateUniqueInterval extends AbstractGenerator {
     static [entityKind] = 'GenerateUniqueInterval';
     state;
+    isUnique = true;
     init({ count, seed }) {
         const maxUniqueIntervalsNumber = 6 * 13 * 29 * 25 * 61 * 61;
         if (count > maxUniqueIntervalsNumber) {
@@ -132016,13 +132076,8 @@ class GenerateString extends AbstractGenerator {
     static [entityKind] = 'GenerateString';
     state;
     uniqueVersionOfGen = GenerateUniqueString;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132070,18 +132125,44 @@ class GenerateUniqueString extends AbstractGenerator {
         return currStr.slice(0, 4) + uniqueStr + currStr.slice(4);
     }
 }
+class GenerateUUID extends AbstractGenerator {
+    static [entityKind] = 'GenerateUUID';
+    isUnique = true;
+    state;
+    init({ count, seed }) {
+        super.init({ count, seed });
+        const rng = prand.xoroshiro128plus(seed);
+        this.state = { rng };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        // TODO generate uuid using string generator
+        const stringChars = '1234567890abcdef';
+        let idx, currStr;
+        const strLength = 36;
+        // uuid v4
+        const uuidTemplate = '########-####-4###-####-############';
+        currStr = '';
+        for (let i = 0; i < strLength; i++) {
+            [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
+            if (uuidTemplate[i] === '#') {
+                currStr += stringChars[idx];
+                continue;
+            }
+            currStr += uuidTemplate[i];
+        }
+        return currStr;
+    }
+}
 class GenerateFirstName extends AbstractGenerator {
     static [entityKind] = 'GenerateFirstName';
     timeSpent = 0;
     state;
     uniqueVersionOfGen = GenerateUniqueFirstName;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132123,13 +132204,8 @@ class GenerateLastName extends AbstractGenerator {
     static [entityKind] = 'GenerateLastName';
     state;
     uniqueVersionOfGen = GenerateUniqueLastName;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132167,13 +132243,8 @@ class GenerateFullName extends AbstractGenerator {
     static [entityKind] = 'GenerateFullName';
     state;
     uniqueVersionOfGen = GenerateUniqueFullName;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132233,6 +132304,7 @@ class GenerateEmail extends AbstractGenerator {
     timeSpent = 0;
     isUnique = true;
     init({ count, seed }) {
+        super.init({ count, seed });
         const domainsArray = emailDomains;
         const adjectivesArray = adjectives;
         const namesArray = firstNames;
@@ -132266,6 +132338,7 @@ class GeneratePhoneNumber extends AbstractGenerator {
     state;
     isUnique = true;
     init({ count, seed }) {
+        super.init({ count, seed });
         let { generatedDigitsNumbers } = this.params;
         const { prefixes, template } = this.params;
         const rng = prand.xoroshiro128plus(seed);
@@ -132382,13 +132455,8 @@ class GenerateCountry extends AbstractGenerator {
     static [entityKind] = 'GenerateCountry';
     state;
     uniqueVersionOfGen = GenerateUniqueCountry;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132426,7 +132494,8 @@ class GenerateUniqueCountry extends AbstractGenerator {
 class GenerateJobTitle extends AbstractGenerator {
     static [entityKind] = 'GenerateJobTitle';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132443,13 +132512,8 @@ class GenerateStreetAdddress extends AbstractGenerator {
     static [entityKind] = 'GenerateStreetAdddress';
     state;
     uniqueVersionOfGen = GenerateUniqueStreetAdddress;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         const possStreetNames = [firstNames, lastNames];
         this.state = { rng, possStreetNames };
@@ -132470,6 +132534,7 @@ class GenerateStreetAdddress extends AbstractGenerator {
 class GenerateUniqueStreetAdddress extends AbstractGenerator {
     static [entityKind] = 'GenerateUniqueStreetAdddress';
     state;
+    isUnique = true;
     init({ count, seed }) {
         const streetNumberStrs = Array.from({ length: 999 }, (_, i) => String(i + 1));
         const maxUniqueStreetnamesNumber = streetNumberStrs.length * firstNames.length * streetSuffix.length
@@ -132528,13 +132593,8 @@ class GenerateCity extends AbstractGenerator {
     static [entityKind] = 'GenerateCity';
     state;
     uniqueVersionOfGen = GenerateUniqueCity;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132572,13 +132632,8 @@ class GeneratePostcode extends AbstractGenerator {
     static [entityKind] = 'GeneratePostcode';
     state;
     uniqueVersionOfGen = GenerateUniquePostcode;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         const templates = ['#####', '#####-####'];
         this.state = { rng, templates };
@@ -132605,6 +132660,7 @@ class GeneratePostcode extends AbstractGenerator {
 class GenerateUniquePostcode extends AbstractGenerator {
     static [entityKind] = 'GenerateUniquePostcode';
     state;
+    isUnique = true;
     init({ count, seed }) {
         const maxUniquePostcodeNumber = Math.pow(10, 5) + Math.pow(10, 9);
         if (count > maxUniquePostcodeNumber) {
@@ -132658,7 +132714,8 @@ class GenerateUniquePostcode extends AbstractGenerator {
 class GenerateState extends AbstractGenerator {
     static [entityKind] = 'GenerateState';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
     }
@@ -132675,13 +132732,8 @@ class GenerateCompanyName extends AbstractGenerator {
     static [entityKind] = 'GenerateCompanyName';
     state;
     uniqueVersionOfGen = GenerateUniqueCompanyName;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         const templates = [
             { template: '#', placeholdersCount: 1 },
@@ -132722,13 +132774,8 @@ class GenerateCompanyName extends AbstractGenerator {
 class GenerateUniqueCompanyName extends AbstractGenerator {
     static [entityKind] = 'GenerateUniqueCompanyName';
     state;
+    isUnique = true;
     init({ count, seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
         const maxUniqueCompanyNameNumber = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
             + Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
         if (count > maxUniqueCompanyNameNumber) {
@@ -132801,7 +132848,8 @@ class GenerateUniqueCompanyName extends AbstractGenerator {
 class GenerateLoremIpsum extends AbstractGenerator {
     static [entityKind] = 'GenerateLoremIpsum';
     state;
-    init({ seed }) {
+    init({ count, seed }) {
+        super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
         if (this.params.sentencesCount === undefined)
             this.params.sentencesCount = 1;
@@ -132870,25 +132918,20 @@ class GeneratePoint extends AbstractGenerator {
     static [entityKind] = 'GeneratePoint';
     state;
     uniqueVersionOfGen = GenerateUniquePoint;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const xCoordinateGen = new GenerateNumber({
             minValue: this.params.minXValue,
             maxValue: this.params.maxXValue,
             precision: 10,
         });
-        xCoordinateGen.init({ seed });
+        xCoordinateGen.init({ count, seed });
         const yCoordinateGen = new GenerateNumber({
             minValue: this.params.minYValue,
             maxValue: this.params.maxYValue,
             precision: 10,
         });
-        yCoordinateGen.init({ seed });
+        yCoordinateGen.init({ count, seed });
         this.state = { xCoordinateGen, yCoordinateGen };
     }
     generate() {
@@ -132912,6 +132955,7 @@ class GeneratePoint extends AbstractGenerator {
 class GenerateUniquePoint extends AbstractGenerator {
     static [entityKind] = 'GenerateUniquePoint';
     state;
+    isUnique = true;
     init({ count, seed }) {
         const xCoordinateGen = new GenerateUniqueNumber({
             minValue: this.params.minXValue,
@@ -132949,31 +132993,26 @@ class GenerateLine extends AbstractGenerator {
     static [entityKind] = 'GenerateLine';
     state;
     uniqueVersionOfGen = GenerateUniqueLine;
-    init({ seed }) {
-        if (this.params.isUnique !== undefined) {
-            if (this.params.isUnique === false && this.isUnique === true) {
-                throw new Error('specifying non unique generator to unique column.');
-            }
-            this.isUnique = this.params.isUnique;
-        }
+    init({ count, seed }) {
+        super.init({ count, seed });
         const aCoefficientGen = new GenerateNumber({
             minValue: this.params.minAValue,
             maxValue: this.params.maxAValue,
             precision: 10,
         });
-        aCoefficientGen.init({ seed });
+        aCoefficientGen.init({ count, seed });
         const bCoefficientGen = new GenerateNumber({
             minValue: this.params.minBValue,
             maxValue: this.params.maxBValue,
             precision: 10,
         });
-        bCoefficientGen.init({ seed });
+        bCoefficientGen.init({ count, seed });
         const cCoefficientGen = new GenerateNumber({
             minValue: this.params.minCValue,
             maxValue: this.params.maxCValue,
             precision: 10,
         });
-        cCoefficientGen.init({ seed });
+        cCoefficientGen.init({ count, seed });
         this.state = { aCoefficientGen, bCoefficientGen, cCoefficientGen };
     }
     generate() {
@@ -133002,6 +133041,7 @@ class GenerateLine extends AbstractGenerator {
 class GenerateUniqueLine extends AbstractGenerator {
     static [entityKind] = 'GenerateUniqueLine';
     state;
+    isUnique = true;
     init({ count, seed }) {
         const aCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minAValue,
@@ -133050,6 +133090,7 @@ const generatorsFuncs = {
     /**
      * generates same given value each time the generator is called.
      * @param defaultValue - value you want to generate
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133067,6 +133108,7 @@ const generatorsFuncs = {
      * generates values from given array
      * @param values - array of values you want to generate. can be array of weighted values.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133126,6 +133168,7 @@ const generatorsFuncs = {
      * precision equals 10 means that values will be accurate to one tenth (1.2, 34.6);
      * precision equals 100 means that values will be accurate to one hundredth (1.23, 34.67).
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133146,6 +133189,7 @@ const generatorsFuncs = {
      * @param minValue - lower border of range.
      * @param maxValue - upper border of range.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133163,6 +133207,7 @@ const generatorsFuncs = {
     // uniqueInt: createGenerator(GenerateUniqueInt),
     /**
      * generates boolean values(true or false)
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133181,6 +133226,7 @@ const generatorsFuncs = {
      * generates date within given range.
      * @param minDate - lower border of range.
      * @param maxDate - upper border of range.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133197,6 +133243,8 @@ const generatorsFuncs = {
     date: createGenerator(GenerateDate),
     /**
      * generates time in 24 hours style.
+     * @param arraySize - number of elements in each one-dimensional array.
+     *
      * @example
      * ```ts
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
@@ -133212,6 +133260,8 @@ const generatorsFuncs = {
     time: createGenerator(GenerateTime),
     /**
      * generates timestamps.
+     * @param arraySize - number of elements in each one-dimensional array.
+     *
      * @example
      * ```ts
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
@@ -133227,6 +133277,8 @@ const generatorsFuncs = {
     timestamp: createGenerator(GenerateTimestamp),
     /**
      * generates datetime objects.
+     * @param arraySize - number of elements in each one-dimensional array.
+     *
      * @example
      * ```ts
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
@@ -133242,6 +133294,8 @@ const generatorsFuncs = {
     datetime: createGenerator(GenerateDatetime),
     /**
      * generates years.
+     * @param arraySize - number of elements in each one-dimensional array.
+     *
      * @example
      * ```ts
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
@@ -133257,6 +133311,7 @@ const generatorsFuncs = {
     year: createGenerator(GenerateYear),
     /**
      * generates json objects with fixed structure.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * json structure can equal this:
      * ```
@@ -133300,6 +133355,7 @@ const generatorsFuncs = {
      * interval example: "1 years 12 days 5 minutes"
      *
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      * @example
      * ```ts
      * await seed(db, schema, { count: 1000 }).refine((funcs) => ({
@@ -133316,6 +133372,7 @@ const generatorsFuncs = {
     /**
      * generates random strings.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133330,9 +133387,29 @@ const generatorsFuncs = {
      */
     string: createGenerator(GenerateString),
     // uniqueString: createGenerator(GenerateUniqueString),
+    /**
+     * generates v4 UUID strings if arraySize is not specified, or v4 UUID 1D arrays if it is.
+     *
+     * @param arraySize - number of elements in each one-dimensional array.
+     *
+     * @example
+     * ```ts
+     *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
+     *    users: {
+     *      columns: {
+     *        uuid: funcs.uuid({
+     *          arraySize: 4
+     *        })
+     *      },
+     *    },
+     *  }));
+     * ```
+     */
+    uuid: createGenerator(GenerateUUID),
     /**
      * generates person's first names.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133350,6 +133427,7 @@ const generatorsFuncs = {
     /**
      * generates person's last names.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133367,6 +133445,7 @@ const generatorsFuncs = {
     /**
      * generates person's full names.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133383,6 +133462,7 @@ const generatorsFuncs = {
     // uniqueFullName: createGenerator(GenerateUniqueFullName),
     /**
      * generates unique emails.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133398,6 +133478,7 @@ const generatorsFuncs = {
     email: createGenerator(GenerateEmail),
     /**
      * generates unique phone numbers.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @param template - phone number template, where all '#' symbols will be substituted with generated digits.
      * @param prefixes - array of any string you want to be your phone number prefixes.(not compatible with template property)
@@ -133437,6 +133518,7 @@ const generatorsFuncs = {
     /**
      * generates country's names.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133454,6 +133536,7 @@ const generatorsFuncs = {
     /**
      * generates city's names.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133471,6 +133554,7 @@ const generatorsFuncs = {
     /**
      * generates street address.
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133487,6 +133571,7 @@ const generatorsFuncs = {
     // uniqueStreetAddress: createGenerator(GenerateUniqueStreetAdddress),
     /**
      * generates job titles.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133504,6 +133589,7 @@ const generatorsFuncs = {
      * generates postal codes.
      *
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133520,6 +133606,7 @@ const generatorsFuncs = {
     // uniquePostcoe: createGenerator(GenerateUniquePostcode),
     /**
      * generates states of America.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133537,6 +133624,7 @@ const generatorsFuncs = {
      * generates company's names.
      *
      * @param isUnique - property that controls if generated values gonna be unique or not.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133555,6 +133643,7 @@ const generatorsFuncs = {
      * generates 'lorem ipsum' text sentences.
      *
      * @param sentencesCount - number of sentences you want to generate as one generated value(string).
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133576,6 +133665,7 @@ const generatorsFuncs = {
      * @param maxXValue - upper bound of range for x coordinate.
      * @param minYValue - lower bound of range for y coordinate.
      * @param maxYValue - upper bound of range for y coordinate.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133608,6 +133698,7 @@ const generatorsFuncs = {
      * @param maxBValue - upper bound of range for y parameter.
      * @param minCValue - lower bound of range for y parameter.
      * @param maxCValue - upper bound of range for y parameter.
+     * @param arraySize - number of elements in each one-dimensional array.
      *
      * @example
      * ```ts
@@ -133663,15 +133754,20 @@ class SeedService {
     mysqlMaxParametersNumber = 100000;
     //  SQLITE_MAX_VARIABLE_NUMBER, which by default equals to 999 for SQLite versions prior to 3.32.0 (2020-05-22) or 32766 for SQLite versions after 3.32.0.
     sqliteMaxParametersNumber = 32766;
-    generatePossibleGenerators = (connectionType, tables, relations, refinements, options) => {
+    generatePossibleGenerators = (connectionType, tables, relations, tableRelations, refinements, options) => {
         let columnPossibleGenerator;
         let tablePossibleGenerators;
         const customSeed = options?.seed === undefined ? 0 : options.seed;
         // sorting table in order which they will be filled up (tables with foreign keys case)
         // relations = relations.filter(rel => rel.type === "one");
-        const tablesInOutRelations = this.getTablesInOutRelations(relations);
+        const { tablesInOutRelations } = this.getInfoFromRelations(relations);
         const orderedTablesNames = this.getOrderedTablesList(tablesInOutRelations);
         tables = tables.sort((table1, table2) => {
+            const rel = relations.find((rel) => rel.table === table1.name && rel.refTable === table2.name);
+            if (rel?.isCyclic === true) {
+                const reverseRel = relations.find((rel) => rel.table === table2.name && rel.refTable === table1.name);
+                return this.cyclicTablesCompare(table1, table2, rel, reverseRel);
+            }
             const table1Order = orderedTablesNames.indexOf(table1.name), table2Order = orderedTablesNames.indexOf(table2.name);
             return table1Order - table2Order;
         });
@@ -133743,37 +133839,54 @@ class SeedService {
                     columnName: col.name,
                     isUnique: col.isUnique,
                     notNull: col.notNull,
+                    primary: col.primary,
                     generatedIdentityType: col.generatedIdentityType,
                     generator: undefined,
+                    isCyclic: false,
+                    wasDefinedBefore: false,
+                    wasRefined: false,
                 };
                 if (refinements !== undefined
                     && refinements[table.name] !== undefined
                     && refinements[table.name].columns !== undefined
                     && refinements[table.name].columns[col.name] !== undefined) {
                     const genObj = refinements[table.name].columns[col.name];
-                    // for now only GenerateValuesFromArray support notNull property
+                    // TODO: for now only GenerateValuesFromArray support notNull property
                     genObj.notNull = col.notNull;
+                    if (col.dataType === 'array') {
+                        if (col.baseColumn?.dataType === 'array' && col.baseColumn?.columnType === 'array') {
+                            throw new Error("for now you can't specify generators for columns of dimensition greater than 1.");
+                        }
+                        genObj.baseColumnDataType = col.baseColumn?.dataType;
+                    }
                     columnPossibleGenerator.generator = genObj;
+                    columnPossibleGenerator.wasRefined = true;
                 }
                 else if (Object.hasOwn(foreignKeyColumns, col.name)) {
                     // TODO: I might need to assign repeatedValuesCount to column there instead of doing so in generateTablesValues
+                    const cyclicRelation = tableRelations[table.name].find((rel) => rel.isCyclic === true
+                        && rel.columns.includes(col.name));
+                    if (cyclicRelation !== undefined) {
+                        columnPossibleGenerator.isCyclic = true;
+                    }
+                    const predicate = cyclicRelation !== undefined && col.notNull === false;
+                    if (predicate === true) {
+                        columnPossibleGenerator.generator = new GenerateDefault({ defaultValue: null });
+                        columnPossibleGenerator.wasDefinedBefore = true;
+                    }
                     columnPossibleGenerator.generator = new HollowGenerator({});
-                }
-                else if (col.hasDefault && col.default !== undefined) {
-                    columnPossibleGenerator.generator = new GenerateDefault({
-                        defaultValue: col.default,
-                    });
                 } // TODO: rewrite pickGeneratorFor... using new col properties: isUnique and notNull
                 else if (connectionType === 'postgresql') {
-                    columnPossibleGenerator = this.pickGeneratorForPostgresColumn(columnPossibleGenerator, table, col);
+                    columnPossibleGenerator.generator = this.pickGeneratorForPostgresColumn(table, col);
                 }
                 else if (connectionType === 'mysql') {
-                    columnPossibleGenerator = this.pickGeneratorForMysqlColumn(columnPossibleGenerator, table, col);
+                    columnPossibleGenerator.generator = this.pickGeneratorForMysqlColumn(table, col);
                 }
                 else if (connectionType === 'sqlite') {
-                    columnPossibleGenerator = this.pickGeneratorForSqlite(columnPossibleGenerator, table, col);
+                    columnPossibleGenerator.generator = this.pickGeneratorForSqlite(table, col);
                 }
                 if (columnPossibleGenerator.generator === undefined) {
+                    console.log(col);
                     throw new Error(`column with type ${col.columnType} is not supported for now.`);
                 }
                 columnPossibleGenerator.generator.isUnique = col.isUnique;
@@ -133783,6 +133896,27 @@ class SeedService {
         }
         return tablesPossibleGenerators;
     };
+    cyclicTablesCompare = (table1, table2, relation, reverseRelation) => {
+        // TODO: revise
+        const hasTable1NotNullColumns = relation.columns.some((colIName) => table1.columns.find((colJ) => colJ.name === colIName)?.notNull === true);
+        if (reverseRelation !== undefined) {
+            const hasTable2NotNullColumns = reverseRelation.columns.some((colIName) => table2.columns.find((colJ) => colJ.name === colIName)?.notNull === true);
+            if (hasTable1NotNullColumns && hasTable2NotNullColumns) {
+                throw new Error(`The '${table1.name}' and '${table2.name}' tables have not null foreign keys. You can't seed cyclic tables with not null foreign key columns.`);
+            }
+            if (hasTable1NotNullColumns)
+                return 1;
+            else if (hasTable2NotNullColumns)
+                return -1;
+            return 0;
+        }
+        if (hasTable1NotNullColumns) {
+            return 1;
+        }
+        return 0;
+        // if (hasTable1NotNullColumns) return 1;
+        // else if (hasTable2NotNullColumns) return -1;
+    };
     getOrderedTablesList = (tablesInOutRelations) => {
         const leafTablesNames = Object.entries(tablesInOutRelations)
             .filter((tableRel) => tableRel[1].out === 0
@@ -133803,7 +133937,8 @@ class SeedService {
             for (const orderedTableName of orderedTablesNames) {
                 tablesInOutRelations[parent].requiredTableNames.delete(orderedTableName);
             }
-            if (tablesInOutRelations[parent].requiredTableNames.size === 0) {
+            if (tablesInOutRelations[parent].requiredTableNames.size === 0
+                || equalSets(tablesInOutRelations[parent].requiredTableNames, tablesInOutRelations[parent].dependantTableNames)) {
                 orderedTablesNames.push(parent);
             }
             else {
@@ -133815,9 +133950,13 @@ class SeedService {
         }
         return orderedTablesNames;
     };
-    getTablesInOutRelations = (relations) => {
+    getInfoFromRelations = (relations) => {
         const tablesInOutRelations = {};
+        // const cyclicRelations: { [cyclicTableName: string]: Relation & { isCyclic: boolean } } = {};
         for (const rel of relations) {
+            // if (rel.isCyclic) {
+            // 	cyclicRelations[rel.table] = rel;
+            // }
             if (tablesInOutRelations[rel.table] === undefined) {
                 tablesInOutRelations[rel.table] = {
                     out: 0,
@@ -133849,7 +133988,7 @@ class SeedService {
                 tablesInOutRelations[rel.refTable].dependantTableNames.add(rel.table);
             }
         }
-        return tablesInOutRelations;
+        return { tablesInOutRelations };
     };
     getWeightedWithCount = (weightedCount, count, seed) => {
         const gen = new GenerateWeightedCount({});
@@ -133861,15 +134000,18 @@ class SeedService {
         return weightedWithCount;
     };
     // TODO: revise serial part generators
-    pickGeneratorForPostgresColumn = (columnPossibleGenerator, table, col) => {
+    pickGeneratorForPostgresColumn = (table, col) => {
+        let generator;
         // INT ------------------------------------------------------------------------------------------------------------
         if ((col.columnType.includes('serial')
             || col.columnType === 'integer'
             || col.columnType === 'smallint'
             || col.columnType.includes('bigint'))
             && table.primaryKeys.includes(col.name)) {
-            columnPossibleGenerator.generator = new GenerateIntPrimaryKey({});
-            return columnPossibleGenerator;
+            generator = new GenerateIntPrimaryKey({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         let minValue;
         let maxValue;
@@ -133916,111 +134058,167 @@ class SeedService {
         if (col.columnType.includes('int')
             && !col.columnType.includes('interval')
             && !col.columnType.includes('point')) {
-            columnPossibleGenerator.generator = new GenerateInt({
+            generator = new GenerateInt({
                 minValue,
                 maxValue,
             });
-            return columnPossibleGenerator;
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if (col.columnType.includes('serial')) {
-            const genObj = new GenerateIntPrimaryKey({});
-            genObj.maxValue = maxValue;
-            columnPossibleGenerator.generator = genObj;
+            generator = new GenerateIntPrimaryKey({});
+            generator.maxValue = maxValue;
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // NUMBER(real, double, decimal, numeric)
         if (col.columnType === 'real'
             || col.columnType === 'doubleprecision'
             || col.columnType === 'decimal'
             || col.columnType === 'numeric') {
-            columnPossibleGenerator.generator = new GenerateNumber({});
-            return columnPossibleGenerator;
+            generator = new GenerateNumber({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // STRING
         if ((col.columnType === 'text'
             || col.columnType === 'varchar'
             || col.columnType === 'char')
             && table.primaryKeys.includes(col.name)) {
-            columnPossibleGenerator.generator = new GenerateUniqueString({});
-            return columnPossibleGenerator;
+            generator = new GenerateUniqueString({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if ((col.columnType === 'text'
             || col.columnType === 'varchar'
             || col.columnType === 'char')
             && col.name.toLowerCase().includes('name')) {
-            columnPossibleGenerator.generator = new GenerateFirstName({});
-            return columnPossibleGenerator;
+            generator = new GenerateFirstName({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if ((col.columnType === 'text'
             || col.columnType === 'varchar'
             || col.columnType === 'char')
             && col.name.toLowerCase().includes('email')) {
-            columnPossibleGenerator.generator = new GenerateEmail({});
-            return columnPossibleGenerator;
+            generator = new GenerateEmail({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if (col.columnType === 'text'
             || col.columnType === 'varchar'
             || col.columnType === 'char') {
             // console.log(col, table)
-            columnPossibleGenerator.generator = new GenerateString({});
-            return columnPossibleGenerator;
+            generator = new GenerateString({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
+        }
+        // UUID
+        if (col.columnType === 'uuid') {
+            generator = new GenerateUUID({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // BOOLEAN
         if (col.columnType === 'boolean') {
-            columnPossibleGenerator.generator = new GenerateBoolean({});
-            return columnPossibleGenerator;
+            generator = new GenerateBoolean({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // DATE, TIME, TIMESTAMP
         if (col.columnType.includes('date')) {
-            columnPossibleGenerator.generator = new GenerateDate({});
-            return columnPossibleGenerator;
+            generator = new GenerateDate({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if (col.columnType === 'time') {
-            columnPossibleGenerator.generator = new GenerateTime({});
-            return columnPossibleGenerator;
+            generator = new GenerateTime({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if (col.columnType.includes('timestamp')) {
-            columnPossibleGenerator.generator = new GenerateTimestamp({});
-            return columnPossibleGenerator;
+            generator = new GenerateTimestamp({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // JSON, JSONB
         if (col.columnType === 'json' || col.columnType === 'jsonb') {
-            columnPossibleGenerator.generator = new GenerateJson({});
-            return columnPossibleGenerator;
+            generator = new GenerateJson({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // if (col.columnType === "jsonb") {
-        //   columnPossibleGenerator.generator = new GenerateJsonb({});
-        //   return columnPossibleGenerator;
+        //   const generator = new GenerateJsonb({});
+        //   return generator;
         // }
         // ENUM
         if (col.enumValues !== undefined) {
-            columnPossibleGenerator.generator = new GenerateEnum({
+            generator = new GenerateEnum({
                 enumValues: col.enumValues,
             });
-            return columnPossibleGenerator;
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // INTERVAL
         if (col.columnType === 'interval') {
-            columnPossibleGenerator.generator = new GenerateInterval({});
-            return columnPossibleGenerator;
+            generator = new GenerateInterval({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         // POINT, LINE
         if (col.columnType.includes('point')) {
-            columnPossibleGenerator.generator = new GeneratePoint({});
-            return columnPossibleGenerator;
+            generator = new GeneratePoint({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
         }
         if (col.columnType.includes('line')) {
-            columnPossibleGenerator.generator = new GenerateLine({});
-            return columnPossibleGenerator;
+            generator = new GenerateLine({});
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
+        }
+        // ARRAY
+        if (col.columnType.includes('array') && col.baseColumn !== undefined) {
+            const baseColumnGen = this.pickGeneratorForPostgresColumn(table, col.baseColumn);
+            if (baseColumnGen === undefined) {
+                throw new Error(`column with type ${col.baseColumn.columnType} is not supported for now.`);
+            }
+            generator = new GenerateArray({ baseColumnGen, size: col.size });
+            generator.isUnique = col.isUnique;
+            generator.dataType = col.dataType;
+            return generator;
+        }
+        if (col.hasDefault && col.default !== undefined) {
+            generator = new GenerateDefault({
+                defaultValue: col.default,
+            });
+            return generator;
         }
-        return columnPossibleGenerator;
+        return generator;
     };
-    pickGeneratorForMysqlColumn = (columnPossibleGenerator, table, col) => {
+    pickGeneratorForMysqlColumn = (table, col) => {
         // console.log(col);
         // INT ------------------------------------------------------------------------------------------------------------
         if ((col.columnType.includes('serial') || col.columnType.includes('int'))
             && table.primaryKeys.includes(col.name)) {
-            columnPossibleGenerator.generator = new GenerateIntPrimaryKey({});
-            return columnPossibleGenerator;
+            const generator = new GenerateIntPrimaryKey({});
+            return generator;
         }
         let minValue;
         let maxValue;
@@ -134057,24 +134255,24 @@ class SeedService {
             }
         }
         if (col.columnType.includes('int')) {
-            columnPossibleGenerator.generator = new GenerateInt({
+            const generator = new GenerateInt({
                 minValue,
                 maxValue,
             });
-            return columnPossibleGenerator;
+            return generator;
         }
         if (col.columnType.includes('serial')) {
-            const genObj = new GenerateIntPrimaryKey({});
-            genObj.maxValue = maxValue;
-            columnPossibleGenerator.generator = genObj;
+            const generator = new GenerateIntPrimaryKey({});
+            generator.maxValue = maxValue;
+            return generator;
         }
         // NUMBER(real, double, decimal, float)
         if (col.columnType === 'real'
             || col.columnType === 'double'
             || col.columnType === 'decimal'
             || col.columnType === 'float') {
-            columnPossibleGenerator.generator = new GenerateNumber({});
-            return columnPossibleGenerator;
+            const generator = new GenerateNumber({});
+            return generator;
         }
         // STRING
         if ((col.columnType === 'text'
@@ -134084,8 +134282,8 @@ class SeedService {
             || col.columnType.includes('binary')
             || col.columnType.includes('varbinary'))
             && table.primaryKeys.includes(col.name)) {
-            columnPossibleGenerator.generator = new GenerateUniqueString({});
-            return columnPossibleGenerator;
+            const generator = new GenerateUniqueString({});
+            return generator;
         }
         if ((col.columnType === 'text'
             || col.columnType === 'blob'
@@ -134094,8 +134292,8 @@ class SeedService {
             || col.columnType.includes('binary')
             || col.columnType.includes('varbinary'))
             && col.name.toLowerCase().includes('name')) {
-            columnPossibleGenerator.generator = new GenerateFirstName({});
-            return columnPossibleGenerator;
+            const generator = new GenerateFirstName({});
+            return generator;
         }
         if ((col.columnType === 'text'
             || col.columnType === 'blob'
@@ -134104,8 +134302,8 @@ class SeedService {
             || col.columnType.includes('binary')
             || col.columnType.includes('varbinary'))
             && col.name.toLowerCase().includes('email')) {
-            columnPossibleGenerator.generator = new GenerateEmail({});
-            return columnPossibleGenerator;
+            const generator = new GenerateEmail({});
+            return generator;
         }
         if (col.columnType === 'text'
             || col.columnType === 'blob'
@@ -134114,109 +134312,140 @@ class SeedService {
             || col.columnType.includes('binary')
             || col.columnType.includes('varbinary')) {
             // console.log(col, table);
-            columnPossibleGenerator.generator = new GenerateString({});
-            return columnPossibleGenerator;
+            const generator = new GenerateString({});
+            return generator;
         }
         // BOOLEAN
         if (col.columnType === 'boolean') {
-            columnPossibleGenerator.generator = new GenerateBoolean({});
-            return columnPossibleGenerator;
+            const generator = new GenerateBoolean({});
+            return generator;
         }
         // DATE, TIME, TIMESTAMP, DATETIME, YEAR
         if (col.columnType.includes('datetime')) {
-            columnPossibleGenerator.generator = new GenerateDatetime({});
-            return columnPossibleGenerator;
+            const generator = new GenerateDatetime({});
+            return generator;
         }
         if (col.columnType.includes('date')) {
-            columnPossibleGenerator.generator = new GenerateDate({});
-            return columnPossibleGenerator;
+            const generator = new GenerateDate({});
+            return generator;
         }
         if (col.columnType === 'time') {
-            columnPossibleGenerator.generator = new GenerateTime({});
-            return columnPossibleGenerator;
+            const generator = new GenerateTime({});
+            return generator;
         }
         if (col.columnType.includes('timestamp')) {
-            columnPossibleGenerator.generator = new GenerateTimestamp({});
-            return columnPossibleGenerator;
+            const generator = new GenerateTimestamp({});
+            return generator;
         }
         if (col.columnType === 'year') {
-            columnPossibleGenerator.generator = new GenerateYear({});
-            return columnPossibleGenerator;
+            const generator = new GenerateYear({});
+            return generator;
         }
         // JSON
         if (col.columnType === 'json') {
-            columnPossibleGenerator.generator = new GenerateJson({});
-            return columnPossibleGenerator;
+            const generator = new GenerateJson({});
+            return generator;
         }
         // ENUM
         if (col.enumValues !== undefined) {
-            columnPossibleGenerator.generator = new GenerateEnum({
+            const generator = new GenerateEnum({
                 enumValues: col.enumValues,
             });
-            return columnPossibleGenerator;
+            return generator;
         }
-        return columnPossibleGenerator;
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new GenerateDefault({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
     };
-    pickGeneratorForSqlite = (columnPossibleGenerator, table, col) => {
+    pickGeneratorForSqlite = (table, col) => {
         // int section ---------------------------------------------------------------------------------------
         if ((col.columnType === 'integer' || col.columnType === 'numeric')
             && table.primaryKeys.includes(col.name)) {
-            columnPossibleGenerator.generator = new GenerateIntPrimaryKey({});
-            return columnPossibleGenerator;
+            const generator = new GenerateIntPrimaryKey({});
+            return generator;
         }
         if (col.columnType === 'integer'
             || col.columnType === 'numeric'
             || col.columnType === 'bigint') {
-            columnPossibleGenerator.generator = new GenerateInt({});
-            return columnPossibleGenerator;
+            const generator = new GenerateInt({});
+            return generator;
         }
         if (col.columnType === 'boolean') {
-            columnPossibleGenerator.generator = new GenerateBoolean({});
-            return columnPossibleGenerator;
+            const generator = new GenerateBoolean({});
+            return generator;
         }
         // number section ------------------------------------------------------------------------------------
         if (col.columnType === 'real' || col.columnType === 'numeric') {
-            columnPossibleGenerator.generator = new GenerateNumber({});
-            return columnPossibleGenerator;
+            const generator = new GenerateNumber({});
+            return generator;
         }
         // string section ------------------------------------------------------------------------------------
         if ((col.columnType === 'text'
             || col.columnType === 'numeric'
             || col.columnType === 'blob')
             && table.primaryKeys.includes(col.name)) {
-            columnPossibleGenerator.generator = new GenerateUniqueString({});
-            return columnPossibleGenerator;
+            const generator = new GenerateUniqueString({});
+            return generator;
         }
         if ((col.columnType === 'text'
             || col.columnType === 'numeric'
             || col.columnType === 'blob')
             && col.name.toLowerCase().includes('name')) {
-            columnPossibleGenerator.generator = new GenerateFirstName({});
-            return columnPossibleGenerator;
+            const generator = new GenerateFirstName({});
+            return generator;
         }
         if ((col.columnType === 'text'
             || col.columnType === 'numeric'
             || col.columnType === 'blob')
             && col.name.toLowerCase().includes('email')) {
-            columnPossibleGenerator.generator = new GenerateEmail({});
-            return columnPossibleGenerator;
+            const generator = new GenerateEmail({});
+            return generator;
         }
         if (col.columnType === 'text'
             || col.columnType === 'numeric'
             || col.columnType === 'blob'
             || col.columnType === 'blobbuffer') {
-            columnPossibleGenerator.generator = new GenerateString({});
-            return columnPossibleGenerator;
+            const generator = new GenerateString({});
+            return generator;
         }
         if (col.columnType === 'textjson' || col.columnType === 'blobjson') {
-            columnPossibleGenerator.generator = new GenerateJson({});
-            return columnPossibleGenerator;
+            const generator = new GenerateJson({});
+            return generator;
         }
         if (col.columnType === 'timestamp' || col.columnType === 'timestamp_ms') {
-            columnPossibleGenerator.generator = new GenerateTimestamp({});
-            return columnPossibleGenerator;
+            const generator = new GenerateTimestamp({});
+            return generator;
         }
-        return columnPossibleGenerator;
+        if (col.hasDefault && col.default !== undefined) {
+            const generator = new GenerateDefault({
+                defaultValue: col.default,
+            });
+            return generator;
+        }
+        return;
+    };
+    filterCyclicTables = (tablesGenerators) => {
+        const filteredTablesGenerators = tablesGenerators.filter((tableGen) => tableGen.columnsPossibleGenerators.some((columnGen) => columnGen.isCyclic === true && columnGen.wasDefinedBefore === true));
+        const tablesUniqueNotNullColumn = {};
+        for (const [idx, tableGen] of filteredTablesGenerators.entries()) {
+            const uniqueNotNullColName = filteredTablesGenerators[idx].columnsPossibleGenerators.find((colGen) => colGen.primary === true
+                || (colGen.isUnique === true
+                    && colGen.notNull === true))?.columnName;
+            if (uniqueNotNullColName === undefined) {
+                throw new Error(`Table '${tableGen.tableName}' does not have primary or (unique and notNull) column. Can't seed table with cyclic relation.`);
+            }
+            tablesUniqueNotNullColumn[tableGen.tableName] = { uniqueNotNullColName };
+            filteredTablesGenerators[idx].columnsPossibleGenerators = tableGen.columnsPossibleGenerators.filter((colGen) => (colGen.isCyclic === true && colGen.wasDefinedBefore === true) || colGen.columnName === uniqueNotNullColName).map((colGen) => {
+                const newColGen = { ...colGen };
+                newColGen.wasDefinedBefore = false;
+                return newColGen;
+            });
+        }
+        return { filteredTablesGenerators, tablesUniqueNotNullColumn };
     };
     generateTablesValues = async (relations, tablesGenerators, db, schema, options) => {
         // console.time(
@@ -134227,17 +134456,21 @@ class SeedService {
         let columnsGenerators;
         let tableGenerators;
         let tableValues;
-        let tablesValues = [];
+        let tablesValues = options?.tablesValues === undefined ? [] : options.tablesValues;
         let pRNGSeed;
         // relations = relations.filter(rel => rel.type === "one");
         let filteredRelations;
-        let preserveData, insertDataInDb = true;
+        let preserveData, insertDataInDb = true, updateDataInDb = false;
         if (options?.preserveData !== undefined)
             preserveData = options.preserveData;
         if (options?.insertDataInDb !== undefined)
             insertDataInDb = options.insertDataInDb;
+        if (options?.updateDataInDb !== undefined)
+            updateDataInDb = options.updateDataInDb;
+        if (updateDataInDb === true)
+            insertDataInDb = false;
         // TODO: now I'm generating tablesInOutRelations twice, first time in generatePossibleGenerators and second time here. maybe should generate it once instead.
-        const tablesInOutRelations = this.getTablesInOutRelations(relations);
+        const { tablesInOutRelations } = this.getInfoFromRelations(relations);
         for (const table of tablesGenerators) {
             tableCount = table.count === undefined ? options?.count || this.defaultCountForTable : table.count;
             tableGenerators = {};
@@ -134265,10 +134498,11 @@ class SeedService {
                     }
                     for (let colIdx = 0; colIdx < rel.columns.length; colIdx++) {
                         let refColumnValues;
-                        let hasSelfRelation;
+                        let hasSelfRelation = false;
                         let repeatedValuesCount, weightedCountSeed;
                         let genObj;
-                        if (rel.table === rel.refTable) {
+                        if (rel.table === rel.refTable
+                            && tableGenerators[rel.columns[colIdx]]?.wasRefined === false) {
                             const refColName = rel.refColumns[colIdx];
                             pRNGSeed = generateHashFromString(`${table.tableName}.${refColName}`);
                             const refColumnGenerator = {};
@@ -134287,11 +134521,11 @@ class SeedService {
                                 values: refColumnValues,
                             });
                         }
-                        else {
+                        else if (tableGenerators[rel.columns[colIdx]]?.wasDefinedBefore === false
+                            && tableGenerators[rel.columns[colIdx]]?.wasRefined === false) {
                             refColumnValues = tablesValues
                                 .find((val) => val.tableName === rel.refTable)
                                 .rows.map((row) => row[rel.refColumns[colIdx]]);
-                            hasSelfRelation = false;
                             if (table.withFromTable[rel.refTable] !== undefined
                                 && table.withFromTable[rel.refTable].repeatedValuesCount
                                     !== undefined) {
@@ -134304,7 +134538,9 @@ class SeedService {
                             genObj.maxRepeatedValuesCount = repeatedValuesCount;
                         }
                         // console.log(rel.columns[colIdx], tableGenerators)
-                        tableGenerators[rel.columns[colIdx]].generator = genObj;
+                        if (genObj !== undefined) {
+                            tableGenerators[rel.columns[colIdx]].generator = genObj;
+                        }
                         tableGenerators[rel.columns[colIdx]] = {
                             ...tableGenerators[rel.columns[colIdx]],
                             hasSelfRelation,
@@ -134317,6 +134553,8 @@ class SeedService {
                 && tablesInOutRelations[table.tableName]?.in === 0)
                 ? false
                 : true;
+            preserveData = preserveData || (options?.preserveCyclicTablesData === true
+                && table.columnsPossibleGenerators.some((colGen) => colGen.isCyclic === true));
             tableValues = await this.generateColumnsValuesByGenerators({
                 tableGenerators,
                 db,
@@ -134325,6 +134563,10 @@ class SeedService {
                 count: tableCount,
                 preserveData,
                 insertDataInDb,
+                updateDataInDb,
+                uniqueNotNullColName: options?.tablesUniqueNotNullColumn === undefined
+                    ? undefined
+                    : options?.tablesUniqueNotNullColumn[table.tableName]?.uniqueNotNullColName,
             });
             if (preserveData === true) {
                 tablesValues.push({
@@ -134344,10 +134586,13 @@ class SeedService {
         }
         return tablesValues;
     };
-    generateColumnsValuesByGenerators = async ({ tableGenerators, db, schema, tableName, count, preserveData = true, insertDataInDb = true, batchSize = 10000, }) => {
+    generateColumnsValuesByGenerators = async ({ tableGenerators, db, schema, tableName, count, preserveData = true, insertDataInDb = true, updateDataInDb = false, uniqueNotNullColName, batchSize = 10000, }) => {
         if (count === undefined) {
             count = this.defaultCountForTable;
         }
+        if (updateDataInDb === true) {
+            batchSize = 1;
+        }
         let columnGenerator;
         const columnsGenerators = {};
         let generatedValues = [];
@@ -134362,17 +134607,12 @@ class SeedService {
                 count,
                 seed: columnGenerator.pRNGSeed,
             });
-            if (columnsGenerators[columnName].uniqueVersionOfGen !== undefined
-                && columnsGenerators[columnName].isUnique === true) {
-                const uniqueGen = new columnsGenerators[columnName].uniqueVersionOfGen({
-                    ...columnsGenerators[columnName].params,
-                });
-                uniqueGen.init({
-                    count,
-                    seed: columnGenerator.pRNGSeed,
-                });
-                uniqueGen.isUnique = columnsGenerators[columnName].isUnique;
-                uniqueGen.dataType = columnsGenerators[columnName].dataType;
+            const arrayGen = columnsGenerators[columnName].replaceIfArray({ count, seed: columnGenerator.pRNGSeed });
+            if (arrayGen !== undefined) {
+                columnsGenerators[columnName] = arrayGen;
+            }
+            const uniqueGen = columnsGenerators[columnName].replaceIfUnique({ count, seed: columnGenerator.pRNGSeed });
+            if (uniqueGen !== undefined) {
                 columnsGenerators[columnName] = uniqueGen;
             }
         }
@@ -134392,7 +134632,7 @@ class SeedService {
         }
         const maxBatchSize = Math.floor(maxParametersNumber / columnsNumber);
         batchSize = batchSize > maxBatchSize ? maxBatchSize : batchSize;
-        if (insertDataInDb === true
+        if ((insertDataInDb === true || updateDataInDb === true)
             && (db === undefined || schema === undefined || tableName === undefined)) {
             throw new Error('db or schema or tableName is undefined.');
         }
@@ -134408,27 +134648,49 @@ class SeedService {
                 generatedValue = columnsGenerators[columnName].generate({ i });
                 row[columnName] = generatedValue;
             }
-            if (insertDataInDb === true
+            if ((insertDataInDb === true || updateDataInDb === true)
                 && ((i + 1) % batchSize === 0 || i === count - 1)) {
                 if (preserveData === false) {
-                    await this.insertInDb({
-                        generatedValues,
-                        db: db,
-                        schema: schema,
-                        tableName: tableName,
-                        override,
-                    });
+                    if (insertDataInDb === true) {
+                        await this.insertInDb({
+                            generatedValues,
+                            db: db,
+                            schema: schema,
+                            tableName: tableName,
+                            override,
+                        });
+                    }
+                    else if (updateDataInDb === true) {
+                        await this.updateDb({
+                            generatedValues,
+                            db: db,
+                            schema: schema,
+                            tableName: tableName,
+                            uniqueNotNullColName: uniqueNotNullColName,
+                        });
+                    }
                     generatedValues = [];
                 }
                 else {
                     const batchCount = Math.floor(i / batchSize);
-                    await this.insertInDb({
-                        generatedValues: generatedValues.slice(batchSize * batchCount, batchSize * (batchCount + 1)),
-                        db: db,
-                        schema: schema,
-                        tableName: tableName,
-                        override,
-                    });
+                    if (insertDataInDb === true) {
+                        await this.insertInDb({
+                            generatedValues: generatedValues.slice(batchSize * batchCount, batchSize * (batchCount + 1)),
+                            db: db,
+                            schema: schema,
+                            tableName: tableName,
+                            override,
+                        });
+                    }
+                    else if (updateDataInDb === true) {
+                        await this.updateDb({
+                            generatedValues: generatedValues.slice(batchSize * batchCount, batchSize * (batchCount + 1)),
+                            db: db,
+                            schema: schema,
+                            tableName: tableName,
+                            uniqueNotNullColName: uniqueNotNullColName,
+                        });
+                    }
                 }
             }
         }
@@ -134453,6 +134715,21 @@ class SeedService {
                 .values(generatedValues);
         }
     };
+    updateDb = async ({ generatedValues, db, schema, tableName, uniqueNotNullColName, }) => {
+        if (is(db, (PgDatabase))) {
+            const table = schema[tableName];
+            const uniqueNotNullCol = table[uniqueNotNullColName];
+            await db.update(table).set(generatedValues[0]).where(eq(uniqueNotNullCol, generatedValues[0][uniqueNotNullColName]));
+        }
+        else if (is(db, (MySqlDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(generatedValues[0]).where(eq(table[uniqueNotNullColName], generatedValues[0][uniqueNotNullColName]));
+        }
+        else if (is(db, (BaseSQLiteDatabase))) {
+            const table = schema[tableName];
+            await db.update(table).set(generatedValues[0]).where(eq(table[uniqueNotNullColName], generatedValues[0][uniqueNotNullColName]));
+        }
+    };
 }
 var seedService = new SeedService();
 
@@ -134506,6 +134783,7 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
                 hasDefault: col.default === undefined ? false : true,
                 isUnique: col.isUnique === undefined ? false : col.isUnique,
                 notNull: col.notNull,
+                primary: col.primaryKey,
             }));
             tables.push({
                 name: tableName,
@@ -134514,11 +134792,18 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
             });
         }
         relations = drizzleStudioRelations.filter((rel) => rel.schema === schemaName && rel.refSchema === schemaName);
+        const isCyclicRelations = relations.map((reli) => {
+            if (relations.some((relj) => reli.table === relj.refTable && reli.refTable === relj.table)) {
+                return { ...reli, isCyclic: true };
+            }
+            return { ...reli, isCyclic: false };
+        });
         refinements = schemasRefinements !== undefined && schemasRefinements[schemaName] !== undefined
             ? schemasRefinements[schemaName]
             : undefined;
-        const generatedTablesGenerators = seedService.generatePossibleGenerators(sqlDialect, tables, relations, refinements, options);
-        const generatedTables = await seedService.generateTablesValues(relations, generatedTablesGenerators, undefined, undefined, { ...options, preserveData: true, insertDataInDb: false });
+        const generatedTablesGenerators = seedService.generatePossibleGenerators(sqlDialect, tables, isCyclicRelations, {}, // TODO: fix later
+        refinements, options);
+        const generatedTables = await seedService.generateTablesValues(isCyclicRelations, generatedTablesGenerators, undefined, undefined, { ...options, preserveData: true, insertDataInDb: false });
         generatedSchemas[schemaName] = { tables: generatedTables };
     }
     return generatedSchemas;
@@ -134657,7 +134942,7 @@ const resetPostgres = async (db, schema) => {
     const tablesToTruncate = Object.entries(schema).map(([_, table]) => {
         const config = getTableConfig(table);
         config.schema = config.schema === undefined ? 'public' : config.schema;
-        return `${config.schema}.${config.name}`;
+        return `"${config.schema}"."${config.name}"`;
     });
     await db.execute(sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
 };
@@ -134666,9 +134951,13 @@ const filterPgTables = (schema) => {
     return { pgSchema };
 };
 const seedPostgres = async (db, schema, options = {}, refinements) => {
-    const { tables, relations } = getPostgresInfo(schema);
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, refinements, options);
-    await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, options);
+    const { tables, relations, tableRelations } = getPostgresInfo(schema);
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, tableRelations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, schema, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
 const getPostgresInfo = (schema) => {
     let tableConfig;
@@ -134677,6 +134966,7 @@ const getPostgresInfo = (schema) => {
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
     const getDbToTsColumnNamesMap = (table) => {
         let dbToTsColumnNamesMap = {};
         const tableName = getTableName(table);
@@ -134697,10 +134987,14 @@ const getPostgresInfo = (schema) => {
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
             dbToTsColumnNamesMap[col.name] = tsCol;
         }
-        relations.push(...tableConfig.foreignKeys.map((fk) => {
+        // might be empty list
+        const newRelations = tableConfig.foreignKeys.map((fk) => {
             const table = dbToTsTableNamesMap[tableConfig.name];
             const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
             const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
+            if (tableRelations[refTable] === undefined) {
+                tableRelations[refTable] = [];
+            }
             return {
                 table,
                 columns: fk
@@ -134710,27 +135004,94 @@ const getPostgresInfo = (schema) => {
                 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.columnType.replace('Pg', '').toLowerCase(),
+                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;
+        };
+        // console.log(tableConfig.columns);
         tables.push({
             name: dbToTsTableNamesMap[tableConfig.name],
             columns: tableConfig.columns.map((column) => ({
                 name: dbToTsColumnNamesMap[column.name],
                 columnType: column.columnType.replace('Pg', '').toLowerCase(),
                 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]),
         });
     }
-    return { tables, relations };
+    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 };
+};
+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;
 };
 // MySql-----------------------------------------------------------------------------------------------------
 const resetMySql = async (db, schema) => {
@@ -134750,9 +135111,13 @@ const filterMySqlTables = (schema) => {
     return { mySqlSchema };
 };
 const seedMySql = async (db, schema, options = {}, refinements) => {
-    const { tables, relations } = getMySqlInfo(schema);
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
-    await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, options);
+    const { tables, relations, tableRelations } = getMySqlInfo(schema);
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, tableRelations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, schema, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
 const getMySqlInfo = (schema) => {
     let tableConfig;
@@ -134761,6 +135126,7 @@ const getMySqlInfo = (schema) => {
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
     const getDbToTsColumnNamesMap = (table) => {
         let dbToTsColumnNamesMap = {};
         const tableName = getTableName(table);
@@ -134781,10 +135147,13 @@ const getMySqlInfo = (schema) => {
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
             dbToTsColumnNamesMap[col.name] = tsCol;
         }
-        relations.push(...tableConfig.foreignKeys.map((fk) => {
+        const newRelations = tableConfig.foreignKeys.map((fk) => {
             const table = dbToTsTableNamesMap[tableConfig.name];
             const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
             const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
+            if (tableRelations[refTable] === undefined) {
+                tableRelations[refTable] = [];
+            }
             return {
                 table,
                 columns: fk
@@ -134794,8 +135163,14 @@ const getMySqlInfo = (schema) => {
                 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);
         tables.push({
             name: dbToTsTableNamesMap[tableConfig.name],
             columns: tableConfig.columns.map((column) => ({
@@ -134807,13 +135182,23 @@ const getMySqlInfo = (schema) => {
                 enumValues: column.enumValues,
                 isUnique: column.isUnique,
                 notNull: column.notNull,
+                primary: column.primary,
             })),
             primaryKeys: tableConfig.columns
                 .filter((column) => column.primary)
                 .map((column) => dbToTsColumnNamesMap[column.name]),
         });
     }
-    return { tables, relations };
+    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 };
 };
 // Sqlite------------------------------------------------------------------------------------------------------------------------
 const resetSqlite = async (db, schema) => {
@@ -134833,9 +135218,13 @@ const filterSqliteTables = (schema) => {
     return { sqliteSchema };
 };
 const seedSqlite = async (db, schema, options = {}, refinements) => {
-    const { tables, relations } = getSqliteInfo(schema);
-    const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
-    await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, options);
+    const { tables, relations, tableRelations } = getSqliteInfo(schema);
+    const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, tableRelations, refinements, options);
+    const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, { ...options, preserveCyclicTablesData });
+    const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
+    const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, schema, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
 const getSqliteInfo = (schema) => {
     let tableConfig;
@@ -134844,6 +135233,7 @@ const getSqliteInfo = (schema) => {
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
+    const tableRelations = {};
     const getDbToTsColumnNamesMap = (table) => {
         let dbToTsColumnNamesMap = {};
         const tableName = getTableName(table);
@@ -134864,10 +135254,13 @@ const getSqliteInfo = (schema) => {
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
             dbToTsColumnNamesMap[col.name] = tsCol;
         }
-        relations.push(...tableConfig.foreignKeys.map((fk) => {
+        const newRelations = tableConfig.foreignKeys.map((fk) => {
             const table = dbToTsTableNamesMap[tableConfig.name];
             const refTable = dbToTsTableNamesMap[getTableName(fk.reference().foreignTable)];
             const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(fk.reference().foreignTable);
+            if (tableRelations[refTable] === undefined) {
+                tableRelations[refTable] = [];
+            }
             return {
                 table,
                 columns: fk
@@ -134877,8 +135270,14 @@ const getSqliteInfo = (schema) => {
                 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);
         tables.push({
             name: dbToTsTableNamesMap[tableConfig.name],
             columns: tableConfig.columns.map((column) => ({
@@ -134890,14 +135289,24 @@ const getSqliteInfo = (schema) => {
                 enumValues: column.enumValues,
                 isUnique: column.isUnique,
                 notNull: column.notNull,
+                primary: column.primary,
             })),
             primaryKeys: tableConfig.columns
                 .filter((column) => column.primary)
                 .map((column) => dbToTsColumnNamesMap[column.name]),
         });
     }
-    return { tables, relations };
+    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 };
 };
 
-export { firstNames, getGeneratorsFunctions, lastNames, reset, seed, seedForDrizzleStudio };
+export { cityNames as cities, countries, firstNames, getGeneratorsFunctions, lastNames, reset, seed, seedForDrizzleStudio };
 //# sourceMappingURL=index.mjs.map