drizzle-seed 0.4.0-dd6ee88 → 0.4.0-e6bdce6

package/index.mjs

@@ -37,16 +37,6 @@ const isRelationCyclic = (startRel) => {
     }
     return false;
 };
-const generateHashFromString = (s) => {
-    let hash = 0;
-    // p and m are prime numbers
-    const p = 53;
-    const m = 28871271685163;
-    for (let i = 0; i < s.length; i++) {
-        hash += ((s.codePointAt(i) || 0) * Math.pow(p, i)) % m;
-    }
-    return hash;
-};
 const equalSets = (set1, set2) => {
     return set1.size === set2.size && [...set1].every((si) => set2.has(si));
 };
@@ -114,7 +104,7 @@ const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRela
     }
     return relations;
 };
-const getSchemaInfo = (drizzleTablesAndRelations, drizzleTables, mapTable) => {
+const getSchemaInfo = (drizzleTablesAndRelations, drizzleTables, mapColumns) => {
     let tableConfig;
     let dbToTsColumnNamesMap;
     const dbToTsTableNamesMap = Object.fromEntries(Object.entries(drizzleTables).map(([key, value]) => [getTableName(value), key]));
@@ -165,8 +155,25 @@ const getSchemaInfo = (drizzleTablesAndRelations, drizzleTables, mapTable) => {
             tableRelations[dbToTsTableNamesMap[tableConfig.name]] = [];
         }
         tableRelations[dbToTsTableNamesMap[tableConfig.name]].push(...newRelations);
-        // console.log(tableConfig.columns);
-        tables.push(mapTable(tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap));
+        const stringsSet = [];
+        const uniqueConstraints = [];
+        for (const uniCon of tableConfig.uniqueConstraints) {
+            const uniConColumns = uniCon.columns.map((col) => dbToTsColumnNamesMap[col.name]);
+            const uniConColumnsStr = JSON.stringify(uniConColumns);
+            if (!stringsSet.includes(uniConColumnsStr)) {
+                stringsSet.push(uniConColumnsStr);
+                uniqueConstraints.push(uniConColumns);
+            }
+        }
+        const mappedTable = {
+            name: dbToTsTableNamesMap[tableConfig.name],
+            uniqueConstraints,
+            primaryKeys: tableConfig.columns
+                .filter((column) => column.primary)
+                .map((column) => dbToTsColumnNamesMap[column.name]),
+            columns: mapColumns(tableConfig, dbToTsColumnNamesMap),
+        };
+        tables.push(mappedTable);
     }
     const transformedDrizzleRelations = transformFromDrizzleRelation(drizzleTablesAndRelations, getDbToTsColumnNamesMap, tableRelations);
     relations.push(...transformedDrizzleRelations);
@@ -131448,10 +131455,12 @@ const isObject = (value) => {
 class AbstractGenerator {
     static entityKind = 'AbstractGenerator';
     static version = 1;
+    isGeneratorUnique = false;
     isUnique = false;
     notNull = false;
     // param for generators which have a unique version of themselves
     uniqueVersionOfGen;
+    maxUniqueCount = -1;
     dataType;
     timeSpent;
     //
@@ -131463,6 +131472,7 @@ class AbstractGenerator {
     weightedCountSeed;
     maxRepeatedValuesCount;
     typeParams = {};
+    uniqueKey;
     params;
     constructor(params) {
         this.params = params === undefined ? {} : params;
@@ -131485,9 +131495,13 @@ class AbstractGenerator {
         const constructor = this.constructor;
         return constructor.entityKind;
     }
+    getMaxUniqueCount() {
+        // override if you need to initialize this.maxUniqueCount after constructor
+        return this.maxUniqueCount;
+    }
     replaceIfUnique() {
         this.updateParams();
-        if (this.uniqueVersionOfGen !== undefined
+        if ((this.uniqueVersionOfGen !== undefined)
             && this.isUnique === true) {
             const uniqueGen = new this.uniqueVersionOfGen({
                 ...this.params,
@@ -131518,6 +131532,20 @@ class AbstractGenerator {
     }
 }
 // Generators Classes -----------------------------------------------------------------------------------------------------------------------
+class GenerateHashFromString extends AbstractGenerator {
+    static entityKind = 'GenerateHashFromString';
+    init() { }
+    generate({ input }) {
+        let hash = 0;
+        // p and m are prime numbers
+        const p = 53;
+        const m = 28871271685163;
+        for (let i = 0; i < input.length; i++) {
+            hash += ((input.codePointAt(i) || 0) * Math.pow(p, i)) % m;
+        }
+        return hash;
+    }
+}
 class GenerateArray extends AbstractGenerator {
     static entityKind = 'GenerateArray';
     arraySize = 10;
@@ -131577,6 +131605,23 @@ class GenerateValuesFromArray extends AbstractGenerator {
     static entityKind = 'GenerateValuesFromArray';
     state;
     timeSpent = 0;
+    maxUniqueCount;
+    allValuesCount = 0; // TODO rewrite generator
+    constructor(params) {
+        super(params);
+        this.allValuesCount = this.params.values.length;
+        if (isObject(this.params.values[0])) {
+            this.allValuesCount = this.params.values.reduce((acc, currVal) => acc + currVal.values.length, 0);
+        }
+        this.maxUniqueCount = this.allValuesCount;
+    }
+    getMaxUniqueCount() {
+        this.allValuesCount = this.params.values.length;
+        if (isObject(this.params.values[0])) {
+            this.allValuesCount = this.params.values.reduce((acc, currVal) => acc + currVal.values.length, 0);
+        }
+        return this.allValuesCount;
+    }
     checks({ count }) {
         const { values } = this.params;
         const { maxRepeatedValuesCount, notNull, isUnique } = this;
@@ -131594,16 +131639,13 @@ class GenerateValuesFromArray extends AbstractGenerator {
                 : obj.count.every((count) => count > 0))))) {
             throw new Error('maxRepeatedValuesCount should be greater than zero.');
         }
-        let allValuesCount = values.length;
-        if (isObject(values[0])) {
-            allValuesCount = values.reduce((acc, currVal) => acc + currVal.values.length, 0);
-        }
         if (notNull === true
             && maxRepeatedValuesCount !== undefined
             && ((!isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
                 && maxRepeatedValuesCount * values.length < count)
                 || (isObject(values[0]) && typeof maxRepeatedValuesCount === 'number'
-                    && maxRepeatedValuesCount * allValuesCount < count))) {
+                    // eslint-disable-next-line unicorn/consistent-destructuring
+                    && maxRepeatedValuesCount * this.allValuesCount < count))) {
             throw new Error("Can't fill notNull column with null values.");
         }
         if (isUnique === true && maxRepeatedValuesCount !== undefined && ((typeof maxRepeatedValuesCount === 'number' && maxRepeatedValuesCount > 1)
@@ -131614,7 +131656,8 @@ class GenerateValuesFromArray extends AbstractGenerator {
             throw new Error("Can't be greater than 1 if column is unique.");
         }
         if (isUnique === true && notNull === true && ((!isObject(values[0]) && values.length < count)
-            || (isObject(values[0]) && allValuesCount < count))) {
+            // eslint-disable-next-line unicorn/consistent-destructuring
+            || (isObject(values[0]) && this.allValuesCount < count))) {
             // console.log(maxRepeatedValuesCount, values.length, allValuesCount, count)
             throw new Error('There are no enough values to fill unique column.');
         }
@@ -131750,6 +131793,8 @@ class GenerateSelfRelationsValuesFromArray extends AbstractGenerator {
 class GenerateIntPrimaryKey extends AbstractGenerator {
     static entityKind = 'GenerateIntPrimaryKey';
     maxValue;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
+    isGeneratorUnique = true;
     init({ count }) {
         if (this.maxValue !== undefined && count > this.maxValue) {
             throw new Error('count exceeds max number for this column type.');
@@ -131800,14 +131845,39 @@ class GenerateNumber extends AbstractGenerator {
 class GenerateUniqueNumber extends AbstractGenerator {
     static entityKind = 'GenerateUniqueNumber';
     state;
-    isUnique = true;
-    init({ count, seed }) {
+    precision;
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        let { minValue, maxValue } = this.params;
+        const { precision } = this.params;
+        this.precision = precision ?? 100;
+        if (maxValue === undefined) {
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return;
+        }
+        else {
+            maxValue *= this.precision;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        else {
+            minValue *= this.precision;
+        }
+        this.maxUniqueCount = maxValue - minValue + 1;
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
         let { minValue, maxValue, precision } = this.params;
         if (precision === undefined) {
             precision = 100;
         }
         if (maxValue === undefined) {
-            maxValue = count * precision;
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return this.maxUniqueCount;
         }
         else {
             maxValue *= precision;
@@ -131818,9 +131888,26 @@ class GenerateUniqueNumber extends AbstractGenerator {
         else {
             minValue *= precision;
         }
+        this.maxUniqueCount = maxValue - minValue + 1;
+        return this.maxUniqueCount;
+    }
+    init({ count, seed }) {
+        let { minValue, maxValue } = this.params;
+        if (maxValue === undefined) {
+            maxValue = count * this.precision;
+        }
+        else {
+            maxValue *= this.precision;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        else {
+            minValue *= this.precision;
+        }
         const genUniqueIntObj = new GenerateUniqueInt({ minValue, maxValue });
         genUniqueIntObj.init({ count, seed });
-        this.state = { genUniqueIntObj, minValue, maxValue, precision };
+        this.state = { genUniqueIntObj, minValue, maxValue, precision: this.precision };
     }
     generate() {
         if (this.state === undefined) {
@@ -131875,8 +131962,48 @@ class GenerateUniqueInt extends AbstractGenerator {
     genMaxRepeatedValuesCount;
     skipCheck = false;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
     timeSpent = 0;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        let minValue = this.params.minValue, maxValue = this.params.maxValue;
+        if (maxValue === undefined) {
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+            maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+            this.maxUniqueCount = Number(maxValue - minValue) + 1;
+        }
+        else if (typeof minValue === 'bigint' && typeof maxValue === 'bigint') {
+            this.maxUniqueCount = Number(maxValue - minValue) + 1;
+        }
+        else
+            this.maxUniqueCount = Number(Number(maxValue) - Number(minValue)) + 1; // error should be triggered in init method
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        let minValue = this.params.minValue, maxValue = this.params.maxValue;
+        if (maxValue === undefined) {
+            this.maxUniqueCount = Number.POSITIVE_INFINITY;
+            return this.maxUniqueCount;
+        }
+        if (minValue === undefined) {
+            minValue = -maxValue;
+        }
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
+            maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
+        }
+        this.maxUniqueCount = Number(maxValue - minValue) + 1;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         const rng = prand.xoroshiro128plus(seed);
         let { minValue, maxValue } = this.params;
@@ -132306,11 +132433,10 @@ class GenerateInterval extends AbstractGenerator {
         return interval;
     }
 }
-// has a newer version
 class GenerateUniqueInterval extends AbstractGenerator {
     static 'entityKind' = 'GenerateUniqueInterval';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
     config = {
         year: {
             from: 0,
@@ -132337,6 +132463,47 @@ class GenerateUniqueInterval extends AbstractGenerator {
             to: 60,
         },
     };
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+        let fieldsToGenerate = allFields;
+        if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+            const tokens = this.params.fields.split(' to ');
+            const endIdx = allFields.indexOf(tokens[1]);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        else if (this.params.fields !== undefined) {
+            const endIdx = allFields.indexOf(this.params.fields);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        this.maxUniqueCount = 1;
+        for (const field of fieldsToGenerate) {
+            const from = this.config[field].from, to = this.config[field].to;
+            this.maxUniqueCount *= from - to + 1;
+        }
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
+        let fieldsToGenerate = allFields;
+        if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
+            const tokens = this.params.fields.split(' to ');
+            const endIdx = allFields.indexOf(tokens[1]);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        else if (this.params.fields !== undefined) {
+            const endIdx = allFields.indexOf(this.params.fields);
+            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+        }
+        this.maxUniqueCount = 1;
+        for (const field of fieldsToGenerate) {
+            const from = this.config[field].from, to = this.config[field].to;
+            this.maxUniqueCount *= from - to + 1;
+        }
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
         let fieldsToGenerate = allFields;
@@ -132414,7 +132581,11 @@ class GenerateString extends AbstractGenerator {
 class GenerateUniqueString extends AbstractGenerator {
     static entityKind = 'GenerateUniqueString';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
+    getMaxUniqueCount() {
+        return Number.POSITIVE_INFINITY;
+    }
     init({ seed }) {
         const rng = prand.xoroshiro128plus(seed);
         this.state = { rng };
@@ -132443,8 +132614,12 @@ class GenerateUniqueString extends AbstractGenerator {
 }
 class GenerateUUID extends AbstractGenerator {
     static entityKind = 'GenerateUUID';
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
     state;
+    getMaxUniqueCount() {
+        return Number.POSITIVE_INFINITY;
+    }
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
@@ -132499,9 +132674,16 @@ class GenerateFirstName extends AbstractGenerator {
 class GenerateUniqueFirstName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueFirstName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = firstNames.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = firstNames.length;
+        return firstNames.length;
+    }
     init({ count, seed }) {
-        if (count > firstNames.length) {
+        if (count > this.getMaxUniqueCount()) {
             throw new Error('count exceeds max number of unique first names.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$5) {
@@ -132545,9 +132727,16 @@ class GenerateLastName extends AbstractGenerator {
 class GenerateUniqueLastName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueLastName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = lastNames.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = lastNames.length;
+        return lastNames.length;
+    }
     init({ count, seed }) {
-        if (count > lastNames.length) {
+        if (count > this.getMaxUniqueCount()) {
             throw new Error('count exceeds max number of unique last names.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$3) {
@@ -132594,13 +132783,19 @@ class GenerateFullName extends AbstractGenerator {
 class GenerateUniqueFullName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueFullName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
     timeSpent = 0;
+    maxUniqueCount = firstNames.length * lastNames.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = firstNames.length * lastNames.length;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         const t0 = new Date();
-        const maxUniqueFullNamesNumber = firstNames.length * lastNames.length;
-        if (count > maxUniqueFullNamesNumber) {
-            throw new RangeError(`count exceeds max number of unique full names(${maxUniqueFullNamesNumber}).`);
+        if (count > this.getMaxUniqueCount()) {
+            throw new RangeError(`count exceeds max number of unique full names(${this.getMaxUniqueCount()}).`);
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxStringLength$5 + maxStringLength$3 + 1)) {
             throw new Error(`You can't use full name generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxStringLength$5 + maxStringLength$3 + 1}.`);
@@ -132635,13 +132830,17 @@ class GenerateEmail extends AbstractGenerator {
     static entityKind = 'GenerateEmail';
     state;
     timeSpent = 0;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = adjectives.length * firstNames.length * emailDomains.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = adjectives.length * firstNames.length * emailDomains.length;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         super.init({ count, seed });
-        const domainsArray = emailDomains;
-        const adjectivesArray = adjectives;
-        const namesArray = firstNames;
-        const maxUniqueEmailsNumber = adjectivesArray.length * namesArray.length * domainsArray.length;
+        const maxUniqueEmailsNumber = adjectives.length * firstNames.length * emailDomains.length;
         if (count > maxUniqueEmailsNumber) {
             throw new RangeError(`count exceeds max number of unique emails(${maxUniqueEmailsNumber}).`);
         }
@@ -132649,7 +132848,7 @@ class GenerateEmail extends AbstractGenerator {
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxEmailLength) {
             throw new Error(`You can't use email generator with a db column length restriction of ${this.typeParams?.length}. Set the maximum string length to at least ${maxEmailLength}.`);
         }
-        const arraysToGenerateFrom = [adjectivesArray, namesArray, domainsArray];
+        const arraysToGenerateFrom = [adjectives, firstNames, emailDomains];
         const genIndicesObj = new GenerateUniqueInt({
             minValue: 0,
             maxValue: maxUniqueEmailsNumber - 1,
@@ -132673,20 +132872,75 @@ class GenerateEmail extends AbstractGenerator {
 class GeneratePhoneNumber extends AbstractGenerator {
     static entityKind = 'GeneratePhoneNumber';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        const { template } = this.params;
+        if (template === undefined) {
+            const { generatedDigitsNumbers } = this.prepareWithoutTemplate();
+            this.maxUniqueCount = generatedDigitsNumbers.reduce((a, b) => a + Math.pow(10, b), 0);
+        }
+        else {
+            const { placeholdersCount } = this.prepareWithTemplate();
+            this.maxUniqueCount = Math.pow(10, placeholdersCount);
+        }
+    }
+    prepareWithTemplate() {
+        const { template } = this.params;
+        const iterArray = [...template.matchAll(/#/g)];
+        const placeholdersCount = iterArray.length;
+        return { placeholdersCount };
+    }
+    prepareWithoutTemplate() {
+        let { generatedDigitsNumbers, prefixes } = this.params;
+        if (prefixes === undefined || prefixes.length === 0) {
+            prefixes = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
+            generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
+                // tokens = ["380","99","9"] =
+                // = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
+                const tokens = phoneInfo.split(',');
+                const operatorPrefixLength = tokens[1].replaceAll(' ', '').length;
+                return Number(tokens[2]) - operatorPrefixLength;
+            });
+        }
+        else {
+            if (typeof generatedDigitsNumbers === 'number') {
+                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(generatedDigitsNumbers);
+            }
+            else if (generatedDigitsNumbers === undefined
+                || generatedDigitsNumbers.length === 0) {
+                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(7);
+            }
+        }
+        return { prefixes, generatedDigitsNumbers };
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        const { template } = this.params;
+        if (template === undefined) {
+            const { generatedDigitsNumbers } = this.prepareWithoutTemplate();
+            this.maxUniqueCount = generatedDigitsNumbers.reduce((a, b) => a + Math.pow(10, b), 0);
+            return this.maxUniqueCount;
+        }
+        else {
+            const { placeholdersCount } = this.prepareWithTemplate();
+            this.maxUniqueCount = Math.pow(10, placeholdersCount);
+            return this.maxUniqueCount;
+        }
+    }
     init({ count, seed }) {
         super.init({ count, seed });
-        let { generatedDigitsNumbers } = this.params;
-        const { prefixes, template } = this.params;
+        const { template } = this.params;
         const rng = prand.xoroshiro128plus(seed);
         if (template !== undefined) {
             if (this.typeParams?.length !== undefined && this.typeParams?.length < template.length) {
                 throw new Error(`Length of phone number template is shorter than db column length restriction: ${this.typeParams?.length}. 
 					Set the maximum string length to at least ${template.length}.`);
             }
-            const iterArray = [...template.matchAll(/#/g)];
-            const placeholdersCount = iterArray.length;
-            const maxUniquePhoneNumbersCount = Math.pow(10, placeholdersCount);
+            const { placeholdersCount } = this.prepareWithTemplate();
+            const maxUniquePhoneNumbersCount = this.getMaxUniqueCount();
             if (maxUniquePhoneNumbersCount < count) {
                 throw new RangeError(`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`);
             }
@@ -132703,27 +132957,8 @@ class GeneratePhoneNumber extends AbstractGenerator {
             this.state = { rng, placeholdersCount, generatorsMap, prefixesArray, generatedDigitsNumbers, phoneNumbersSet };
             return;
         }
-        let prefixesArray;
-        if (prefixes === undefined || prefixes.length === 0) {
-            prefixesArray = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
-            generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
-                // tokens = ["380","99","9"] =
-                // = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
-                const tokens = phoneInfo.split(',');
-                const operatorPrefixLength = tokens[1].replaceAll(' ', '').length;
-                return Number(tokens[2]) - operatorPrefixLength;
-            });
-        }
-        else {
-            prefixesArray = prefixes;
-            if (typeof generatedDigitsNumbers === 'number') {
-                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(generatedDigitsNumbers);
-            }
-            else if (generatedDigitsNumbers === undefined
-                || generatedDigitsNumbers.length === 0) {
-                generatedDigitsNumbers = Array.from({ length: prefixes.length }).fill(7);
-            }
-        }
+        const { generatedDigitsNumbers, prefixes } = this.prepareWithoutTemplate();
+        const prefixesArray = [...prefixes];
         const maxPrefixLength = Math.max(...prefixesArray.map((prefix) => prefix.length));
         const maxGeneratedDigits = Math.max(...generatedDigitsNumbers);
         if (this.typeParams?.length !== undefined && this.typeParams?.length < (maxPrefixLength + maxGeneratedDigits)) {
@@ -132732,7 +132967,7 @@ class GeneratePhoneNumber extends AbstractGenerator {
         if (new Set(prefixesArray).size !== prefixesArray.length) {
             throw new Error('prefixes are not unique.');
         }
-        const maxUniquePhoneNumbersCount = generatedDigitsNumbers.reduce((a, b) => a + Math.pow(10, b), 0);
+        const maxUniquePhoneNumbersCount = this.getMaxUniqueCount();
         if (maxUniquePhoneNumbersCount < count) {
             throw new RangeError(`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`);
         }
@@ -132822,9 +133057,16 @@ class GenerateCountry extends AbstractGenerator {
 class GenerateUniqueCountry extends AbstractGenerator {
     static entityKind = 'GenerateUniqueCountry';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = countries.length;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount !== undefined)
+            return this.maxUniqueCount;
+        this.maxUniqueCount = countries.length;
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
-        if (count > countries.length) {
+        if (count > this.getMaxUniqueCount()) {
             throw new Error('count exceeds max number of unique countries.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$7) {
@@ -132893,11 +133135,17 @@ class GenerateStreetAddress extends AbstractGenerator {
 class GenerateUniqueStreetAddress extends AbstractGenerator {
     static entityKind = 'GenerateUniqueStreetAddress';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    streetNumbersCount = 999;
+    maxUniqueCount = this.streetNumbersCount * (firstNames.length + lastNames.length)
+        * streetSuffix.length;
+    getMaxUniqueCount() {
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
-        const streetNumberStrs = Array.from({ length: 999 }, (_, i) => String(i + 1));
-        const maxUniqueStreetnamesNumber = streetNumberStrs.length * firstNames.length * streetSuffix.length
-            + streetNumberStrs.length * firstNames.length * streetSuffix.length;
+        const streetNumberStrs = Array.from({ length: this.streetNumbersCount }, (_, i) => String(i + 1));
+        const maxUniqueStreetnamesNumber = streetNumberStrs.length * (firstNames.length + lastNames.length)
+            * streetSuffix.length;
         if (count > maxUniqueStreetnamesNumber) {
             throw new RangeError(`count exceeds max number of unique street names(${maxUniqueStreetnamesNumber}).`);
         }
@@ -132922,7 +133170,7 @@ class GenerateUniqueStreetAddress extends AbstractGenerator {
                     minValue: 0,
                     maxValue: streetNumberStrs.length * lastNames.length * streetSuffix.length - 1,
                 }),
-                maxUniqueStreetNamesNumber: streetNumberStrs.length * firstNames.length * streetSuffix.length,
+                maxUniqueStreetNamesNumber: streetNumberStrs.length * lastNames.length * streetSuffix.length,
                 count: 0,
                 arraysToChooseFrom: [streetNumberStrs, lastNames, streetSuffix],
             },
@@ -132976,9 +133224,10 @@ class GenerateCity extends AbstractGenerator {
 class GenerateUniqueCity extends AbstractGenerator {
     static entityKind = 'GenerateUniqueCity';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = cityNames.length;
     init({ count, seed }) {
-        if (count > cityNames.length) {
+        if (count > this.maxUniqueCount) {
             throw new Error('count exceeds max number of unique cities.');
         }
         if (this.typeParams?.length !== undefined && this.typeParams?.length < maxStringLength$9) {
@@ -133033,11 +133282,11 @@ class GeneratePostcode extends AbstractGenerator {
 class GenerateUniquePostcode extends AbstractGenerator {
     static entityKind = 'GenerateUniquePostcode';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = Math.pow(10, 5) + Math.pow(10, 9);
     init({ count, seed }) {
-        const maxUniquePostcodeNumber = Math.pow(10, 5) + Math.pow(10, 9);
-        if (count > maxUniquePostcodeNumber) {
-            throw new RangeError(`count exceeds max number of unique postcodes(${maxUniquePostcodeNumber}).`);
+        if (count > this.maxUniqueCount) {
+            throw new RangeError(`count exceeds max number of unique postcodes(${this.maxUniqueCount}).`);
         }
         const rng = prand.xoroshiro128plus(seed);
         const templates = [
@@ -133159,12 +133408,12 @@ class GenerateCompanyName extends AbstractGenerator {
 class GenerateUniqueCompanyName extends AbstractGenerator {
     static entityKind = 'GenerateUniqueCompanyName';
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
+        + Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
     init({ count, seed }) {
-        const maxUniqueCompanyNameNumber = lastNames.length * companyNameSuffixes.length + Math.pow(lastNames.length, 2)
-            + Math.pow(lastNames.length, 2) + Math.pow(lastNames.length, 3);
-        if (count > maxUniqueCompanyNameNumber) {
-            throw new RangeError(`count exceeds max number of unique company names(${maxUniqueCompanyNameNumber}).`);
+        if (count > this.maxUniqueCount) {
+            throw new RangeError(`count exceeds max number of unique company names(${this.maxUniqueCount}).`);
         }
         // max( { template: '#', placeholdersCount: 1 }, { template: '#, # and #', placeholdersCount: 3 } )
         const maxCompanyNameLength = Math.max(maxStringLength$3 + maxStringLength$8 + 1, 3 * maxStringLength$3 + 7);
@@ -133350,22 +133599,29 @@ class GeneratePoint extends AbstractGenerator {
 class GenerateUniquePoint extends AbstractGenerator {
     static entityKind = 'GenerateUniquePoint';
     state;
-    isUnique = true;
-    init({ count, seed }) {
-        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique points.
-        const xCoordinateGen = new GenerateUniqueNumber({
+    isGeneratorUnique = true;
+    xCoordinateGen;
+    yCoordinateGen;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
+        this.xCoordinateGen = new GenerateUniqueNumber({
             minValue: this.params.minXValue,
             maxValue: this.params.maxXValue,
             precision: 10,
         });
-        xCoordinateGen.init({ count, seed });
-        const yCoordinateGen = new GenerateUniqueNumber({
+        this.yCoordinateGen = new GenerateUniqueNumber({
             minValue: this.params.minYValue,
             maxValue: this.params.maxYValue,
             precision: 10,
         });
-        yCoordinateGen.init({ count, seed });
-        this.state = { xCoordinateGen, yCoordinateGen };
+        this.maxUniqueCount = Math.min(this.xCoordinateGen.maxUniqueCount, this.yCoordinateGen.maxUniqueCount);
+    }
+    init({ count, seed }) {
+        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique points.
+        this.xCoordinateGen.init({ count, seed });
+        this.yCoordinateGen.init({ count, seed });
+        this.state = { xCoordinateGen: this.xCoordinateGen, yCoordinateGen: this.yCoordinateGen };
     }
     generate() {
         if (this.state === undefined) {
@@ -133437,28 +133693,40 @@ class GenerateLine extends AbstractGenerator {
 class GenerateUniqueLine extends AbstractGenerator {
     static entityKind = 'GenerateUniqueLine';
     state;
-    isUnique = true;
-    init({ count, seed }) {
-        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique triplets(liens).
-        const aCoefficientGen = new GenerateUniqueNumber({
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    aCoefficientGen;
+    bCoefficientGen;
+    cCoefficientGen;
+    constructor(params) {
+        super(params);
+        this.aCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minAValue,
             maxValue: this.params.maxAValue,
             precision: 10,
         });
-        aCoefficientGen.init({ count, seed });
-        const bCoefficientGen = new GenerateUniqueNumber({
+        this.bCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minBValue,
             maxValue: this.params.maxBValue,
             precision: 10,
         });
-        bCoefficientGen.init({ count, seed });
-        const cCoefficientGen = new GenerateUniqueNumber({
+        this.cCoefficientGen = new GenerateUniqueNumber({
             minValue: this.params.minCValue,
             maxValue: this.params.maxCValue,
             precision: 10,
         });
-        cCoefficientGen.init({ count, seed });
-        this.state = { aCoefficientGen, bCoefficientGen, cCoefficientGen };
+        this.maxUniqueCount = Math.min(this.aCoefficientGen.maxUniqueCount, this.bCoefficientGen.maxUniqueCount, this.cCoefficientGen.maxUniqueCount);
+    }
+    init({ count, seed }) {
+        // TODO: rewrite the unique generator to use fastCartesianProduct for generating unique triplets(liens).
+        this.aCoefficientGen.init({ count, seed });
+        this.bCoefficientGen.init({ count, seed });
+        this.cCoefficientGen.init({ count, seed });
+        this.state = {
+            aCoefficientGen: this.aCoefficientGen,
+            bCoefficientGen: this.bCoefficientGen,
+            cCoefficientGen: this.cCoefficientGen,
+        };
     }
     generate() {
         if (this.state === undefined) {
@@ -133516,7 +133784,15 @@ class GenerateUniqueBitString extends AbstractGenerator {
     static entityKind = 'GenerateUniqueBitString';
     dimensions = 11;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount >= 0)
+            return this.maxUniqueCount;
+        this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
+        this.maxUniqueCount = Math.pow(2, this.dimensions);
+        // TODO revise: will work incorrect with this.dimensions > 53, due to node js number limitations
+        return this.maxUniqueCount;
+    }
     init({ count, seed }) {
         this.dimensions = this.params.dimensions ?? this.typeParams?.length ?? this.dimensions;
         let intGen;
@@ -133587,18 +133863,35 @@ class GenerateInet extends AbstractGenerator {
         }
     }
 }
-// TODO: add defaults to js doc
 class GenerateUniqueInet extends AbstractGenerator {
     static entityKind = 'GenerateUniqueInet';
     ipAddress = 'ipv4';
     includeCidr = true;
     delimiter = '.';
     state;
-    isUnique = true;
-    init({ count, seed }) {
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
         this.ipAddress = this.params.ipAddress ?? this.ipAddress;
-        this.delimiter = this.ipAddress === 'ipv4' ? '.' : ':';
         this.includeCidr = this.params.includeCidr ?? this.includeCidr;
+        if (this.ipAddress === 'ipv4') {
+            this.maxUniqueCount = 256 ** 4;
+            if (this.includeCidr) {
+                this.maxUniqueCount *= 33;
+            }
+        }
+        else {
+            // this.ipAddress === 'ipv6'
+            // TODO revise: this.maxUniqueCount can exceed Number.MAX_SAFE_INTEGER
+            this.maxUniqueCount = 65535 ** 8;
+            if (this.includeCidr) {
+                this.maxUniqueCount *= 129;
+            }
+        }
+    }
+    init({ count, seed }) {
+        this.delimiter = this.ipAddress === 'ipv4' ? '.' : ':';
         // maxValue - number of combinations for cartesian product: {0…255} × {0…255} × {0…255} × {0…255} × {0…32}
         // where pattern for ipv4 ip is {0–255}.{0–255}.{0–255}.{0–255}[/{0–32}?]
         // or number of combinations for cartesian product: {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…65535} × {0…128}
@@ -133714,11 +134007,42 @@ class GenerateUniqueGeometry extends AbstractGenerator {
     srid = 4326;
     decimalPlaces = 6;
     state;
-    isUnique = true;
-    init({ count, seed }) {
+    isGeneratorUnique = true;
+    maxUniqueCount;
+    constructor(params) {
+        super(params);
         this.type = this.params.type ?? this.type;
         this.srid = this.params.srid ?? this.srid;
         this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
+        let minXValue, maxXValue, minYValue, maxYValue, denominator;
+        if (this.type === 'point') {
+            if (this.srid === 4326) {
+                // Degrees (latitude / longitude)
+                denominator = 10 ** this.decimalPlaces;
+                minXValue = -180 * denominator;
+                maxXValue = 180 * denominator;
+                minYValue = -90 * denominator;
+                maxYValue = 90 * denominator;
+            }
+            else {
+                // this.srid === 3857
+                // Meters (projected X / Y)
+                denominator = 1;
+                minXValue = -20026376;
+                maxXValue = 20026376;
+                minYValue = -20048966;
+                maxYValue = 20048966;
+            }
+        }
+        else {
+            // error should be triggered in init method
+            this.maxUniqueCount = -1;
+            return;
+        }
+        // TODO revise: can lose accuracy due to exceeding Number.MAX_SAFE_INTEGER
+        this.maxUniqueCount = Number(BigInt(maxXValue - minXValue + 1) * BigInt(maxYValue - minYValue + 1));
+    }
+    init({ count, seed }) {
         let minXValue, maxXValue, minYValue, maxYValue, denominator;
         if (this.type === 'point') {
             if (this.srid === 4326) {
@@ -133825,11 +134149,10 @@ class GenerateUniqueVector extends AbstractGenerator {
     maxValue = 1000;
     decimalPlaces = 2;
     state;
-    isUnique = true;
-    init({ count, seed }) {
-        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+    isGeneratorUnique = true;
+    constructor(params) {
+        super(params);
         this.decimalPlaces = this.params.decimalPlaces ?? this.decimalPlaces;
-        const denominator = 10 ** this.decimalPlaces;
         this.minValue = this.params.minValue ?? this.minValue;
         this.maxValue = this.params.maxValue ?? this.maxValue;
         if (this.minValue > this.maxValue) {
@@ -133839,6 +134162,18 @@ class GenerateUniqueVector extends AbstractGenerator {
         if (this.decimalPlaces < 0) {
             throw new Error(`decimalPlaces value must be greater than or equal to zero.`);
         }
+    }
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount >= 0)
+            return this.maxUniqueCount;
+        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+        const denominator = 10 ** this.decimalPlaces;
+        this.maxUniqueCount = (this.maxValue * denominator - this.minValue * denominator + 1) ** this.dimensions;
+        return this.maxUniqueCount;
+    }
+    init({ count, seed }) {
+        this.dimensions = this.params.dimensions ?? this.typeParams.length ?? this.dimensions;
+        const denominator = 10 ** this.decimalPlaces;
         if (abs(BigInt(this.minValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER
             || abs(BigInt(this.maxValue) * BigInt(denominator)) > Number.MAX_SAFE_INTEGER) {
             console.warn(`vector generator: minValue or maxValue multiplied by 10^decimalPlaces exceeds Number.MAX_SAFE_INTEGER (2^53 -1).\n`
@@ -133874,13 +134209,80 @@ class GenerateUniqueVector extends AbstractGenerator {
         return vector;
     }
 }
+class GenerateCompositeUniqueKey extends AbstractGenerator {
+    static entityKind = 'GenerateCompositeUniqueKey';
+    columnGenerators = [];
+    isInitialized = false;
+    state;
+    addGenerator(columnName, generator) {
+        this.columnGenerators.push({ columnName, generator });
+    }
+    init({ count, seed }) {
+        if (this.isInitialized)
+            return;
+        if (this.columnGenerators.length === 0) {
+            throw new Error(`composite unique key generator has no generators to work with.`);
+        }
+        let countPerGen = Math.ceil(count ** (1 / this.columnGenerators.length));
+        // const gensMaxUniqueCount: { columnName: string; count: number; maxUniqueCount: number }[] = [];
+        for (const colGen of this.columnGenerators) {
+            colGen.maxUniqueCount = colGen.generator.getMaxUniqueCount();
+        }
+        this.columnGenerators.sort((a, b) => a.maxUniqueCount - b.maxUniqueCount);
+        let currCount = count;
+        let canGenerate = false;
+        for (const [idx, colGen] of this.columnGenerators.entries()) {
+            if (colGen.maxUniqueCount < countPerGen) {
+                colGen.count = colGen.maxUniqueCount;
+                currCount /= colGen.count;
+                countPerGen = Math.ceil(currCount ** (1 / (this.columnGenerators.length - idx - 1)));
+                canGenerate = false;
+            }
+            else {
+                colGen.count = countPerGen;
+                canGenerate = true;
+            }
+        }
+        if (!canGenerate) {
+            const colGensCountInfo = this.columnGenerators.map((colGen) => `generator:${colGen.generator.getEntityKind()};count:${colGen.count}`).join('\n');
+            throw new Error(`There are no enough unique values in each generator to generate ${count} values; \n${colGensCountInfo}`);
+        }
+        const sets = [];
+        for (const colGen of this.columnGenerators) {
+            colGen.generator.init({ count: colGen.count, seed });
+            const setI = [];
+            for (let i = 0; i < countPerGen; i++) {
+                setI.push(colGen.generator.generate({ i }));
+            }
+            sets.push(setI);
+        }
+        this.state = { sets, currI: -1, currValue: {} };
+        this.isInitialized = true;
+    }
+    generate({ i, columnName }) {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        if (i > this.state.currI) {
+            const rowI = fastCartesianProduct(this.state.sets, i);
+            const newCurrValue = {};
+            for (const [idx, colGen] of this.columnGenerators.entries()) {
+                newCurrValue[colGen.columnName] = rowI[idx];
+            }
+            this.state.currValue = newCurrValue;
+            this.state.currI = i;
+        }
+        return this.state.currValue[columnName];
+    }
+}
 
 /* eslint-disable drizzle-internal/require-entity-kind */
 class GenerateUniqueIntervalV2 extends AbstractGenerator {
     static 'entityKind' = 'GenerateUniqueInterval';
     static version = 2;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxUniqueCount;
     config = {
         year: {
             from: 0,
@@ -133907,29 +134309,33 @@ class GenerateUniqueIntervalV2 extends AbstractGenerator {
             to: 59,
         },
     };
-    init({ count, seed }) {
+    fieldsToGenerate;
+    constructor(params) {
+        super(params);
         const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
-        let fieldsToGenerate = allFields;
+        this.fieldsToGenerate = allFields;
         if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
             const tokens = this.params.fields.split(' to ');
             const endIdx = allFields.indexOf(tokens[1]);
-            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+            this.fieldsToGenerate = allFields.slice(0, endIdx + 1);
         }
         else if (this.params.fields !== undefined) {
             const endIdx = allFields.indexOf(this.params.fields);
-            fieldsToGenerate = allFields.slice(0, endIdx + 1);
+            this.fieldsToGenerate = allFields.slice(0, endIdx + 1);
         }
-        let maxUniqueIntervalsNumber = 1;
-        for (const field of fieldsToGenerate) {
+        this.maxUniqueCount = 1;
+        for (const field of this.fieldsToGenerate) {
             const from = this.config[field].from, to = this.config[field].to;
-            maxUniqueIntervalsNumber *= from - to + 1;
+            this.maxUniqueCount *= from - to + 1;
         }
-        if (count > maxUniqueIntervalsNumber) {
-            throw new RangeError(`count exceeds max number of unique intervals(${maxUniqueIntervalsNumber})`);
+    }
+    init({ count, seed }) {
+        if (count > this.maxUniqueCount) {
+            throw new RangeError(`count exceeds max number of unique intervals(${this.maxUniqueCount})`);
         }
         const rng = prand.xoroshiro128plus(seed);
         const intervalSet = new Set();
-        this.state = { rng, fieldsToGenerate, intervalSet };
+        this.state = { rng, fieldsToGenerate: this.fieldsToGenerate, intervalSet };
     }
     generate() {
         if (this.state === undefined) {
@@ -133951,6 +134357,7 @@ class GenerateUniqueIntervalV2 extends AbstractGenerator {
         return interval;
     }
 }
+// TODO need to rework this generator
 class GenerateStringV2 extends AbstractGenerator {
     static 'entityKind' = 'GenerateString';
     static version = 2;
@@ -133992,21 +134399,27 @@ class GenerateUniqueStringV2 extends AbstractGenerator {
     static 'entityKind' = 'GenerateUniqueString';
     static version = 2;
     state;
-    isUnique = true;
+    isGeneratorUnique = true;
+    maxStringLength = 20;
+    minStringLength = 7;
+    getMaxUniqueCount() {
+        if (this.maxUniqueCount >= 0)
+            return this.maxUniqueCount;
+        this.maxStringLength = this.typeParams?.length ?? this.maxStringLength;
+        this.maxUniqueCount = Number.parseInt('f'.repeat(this.maxStringLength), 16);
+        return this.maxUniqueCount;
+    }
     init({ seed, count }) {
         const rng = prand.xoroshiro128plus(seed);
-        let minStringLength = 7;
-        let maxStringLength = 20;
         // TODO: revise later
-        if (this.typeParams?.length !== undefined) {
-            maxStringLength = this.typeParams?.length;
-            if (maxStringLength === 1 || maxStringLength < minStringLength)
-                minStringLength = maxStringLength;
+        this.maxStringLength = this.typeParams?.length ?? this.maxStringLength;
+        if (this.maxStringLength === 1 || this.maxStringLength < this.minStringLength) {
+            this.minStringLength = this.maxStringLength;
         }
-        if (maxStringLength < count.toString(16).length) {
-            throw new Error(`You can't generate ${count} unique strings, with a maximum string length of ${maxStringLength}.`);
+        if (count > this.getMaxUniqueCount()) {
+            throw new Error(`You can't generate ${count} unique strings, with a maximum string length of ${this.maxStringLength}.`);
         }
-        this.state = { rng, minStringLength, maxStringLength };
+        this.state = { rng, minStringLength: this.minStringLength, maxStringLength: this.maxStringLength };
     }
     generate({ i }) {
         if (this.state === undefined) {
@@ -134029,6 +134442,25 @@ class GenerateUniqueStringV2 extends AbstractGenerator {
     }
 }
 
+/* eslint-disable drizzle-internal/require-entity-kind */
+class GenerateHashFromStringV3 extends AbstractGenerator {
+    static entityKind = 'GenerateHashFromString';
+    static version = 3;
+    init() { }
+    generate({ input }) {
+        let hash = 0n;
+        // p and m are prime numbers
+        const p = 53n;
+        const m = 28871271685163n; // < 2^53
+        let power = 1n; // will track p^i, where i is character index
+        for (const ch of input) {
+            hash = (hash + (BigInt(ch.codePointAt(0) || 0) * power)) % m;
+            power = (power * p) % m;
+        }
+        return Number(hash);
+    }
+}
+
 function createGenerator(generatorConstructor) {
     return (...args) => {
         let params = args[0];
@@ -134824,7 +135256,14 @@ const generatorsFuncs = {
 const generatorsFuncsV2 = {
     ...generatorsFuncs,
 };
+({
+    ...generatorsFuncs,
+});
 const generatorsMap = {
+    GenerateHashFromString: [
+        GenerateHashFromString,
+        GenerateHashFromStringV3,
+    ],
     HollowGenerator: [
         HollowGenerator,
     ],
@@ -135002,6 +135441,9 @@ const generatorsMap = {
     GenerateUniqueVector: [
         GenerateUniqueVector,
     ],
+    GenerateCompositeUniqueKey: [
+        GenerateCompositeUniqueKey,
+    ],
 };
 
 // TODO: revise serial part generators
@@ -135220,7 +135662,7 @@ const selectGeneratorForCockroachColumn = (table, col) => {
     return generator;
 };
 
-const latestVersion = 2;
+const latestVersion = 3;
 
 const selectGeneratorForMssqlColumn = (table, col) => {
     const pickGenerator = (table, col) => {
@@ -136069,6 +136511,7 @@ class SeedService {
     sqliteMaxParametersNumber = 32766;
     mssqlMaxParametersNumber = 2100;
     version;
+    hashFromStringGenerator;
     generatePossibleGenerators = (connectionType, tables, relations, refinements, options) => {
         let columnPossibleGenerator;
         let tablePossibleGenerators;
@@ -136077,6 +136520,7 @@ class SeedService {
         if (Number.isNaN(this.version) || this.version < 1 || this.version > latestVersion) {
             throw new Error(`Version should be in range [1, ${latestVersion}].`);
         }
+        this.hashFromStringGenerator = this.selectVersionOfGenerator(new generatorsMap.GenerateHashFromString[0]());
         // sorting table in order which they will be filled up (tables with foreign keys case)
         const { tablesInOutRelations } = this.getInfoFromRelations(relations);
         const orderedTablesNames = this.getOrderedTablesList(tablesInOutRelations);
@@ -136096,6 +136540,7 @@ class SeedService {
             withFromTable: {},
         }));
         for (const [i, table] of tables.entries()) {
+            const compositeUniqueKeyGenMap = {};
             // get foreignKey columns relations
             const foreignKeyColumns = {};
             for (const rel of relations
@@ -136137,7 +136582,7 @@ class SeedService {
                                 const weightedRepeatedValuesCount = refinements[table.name]
                                     .with[fkTableName];
                                 weightedCountSeed = customSeed
-                                    + generateHashFromString(`${table.name}.${fkTableName}`);
+                                    + this.hashFromStringGenerator.generate({ input: `${table.name}.${fkTableName}` });
                                 newTableWithCount = this.getWeightedWithCount(weightedRepeatedValuesCount, (tablesPossibleGenerators[i].withCount
                                     || tablesPossibleGenerators[i].count), weightedCountSeed);
                             }
@@ -136173,6 +136618,18 @@ class SeedService {
                     && refinements[table.name].columns !== undefined
                     && refinements[table.name].columns[col.name] !== undefined) {
                     const genObj = refinements[table.name].columns[col.name];
+                    if (genObj === false) {
+                        if (col.notNull === true && col.hasDefault === false) {
+                            throw new Error(`You cannot set the '${col.name}' column in the '${table.name}' table to false in your refinements.`
+                                + `\nDoing so will result in a null value being inserted into the '${col.name}' column,`
+                                + `\nwhich will cause an error because the column has a not null constraint and no default value.`);
+                        }
+                        // Generating undefined as a value for a column and then inserting it via drizzle-orm
+                        // will result in the value not being inserted into that column.
+                        columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: undefined });
+                        columnPossibleGenerator.wasRefined = true;
+                        continue;
+                    }
                     if (col.columnType.match(/\[\w*]/g) !== null) {
                         if ((col.baseColumn?.dataType === 'array' && col.baseColumn.columnType.match(/\[\w*]/g) !== null)
                             // studio case
@@ -136244,16 +136701,66 @@ class SeedService {
                     columnPossibleGenerator.generator = arrayGen;
                 }
                 columnPossibleGenerator.generator.isUnique = col.isUnique;
+                // composite unique keys handling
+                let compositeKeyColumnNames = table.uniqueConstraints.filter((colNames) => colNames.includes(col.name));
+                if (compositeKeyColumnNames.some((colNames) => colNames.length === 1)) {
+                    // composite unique key contains only one column, therefore it equals to just unique column
+                    columnPossibleGenerator.generator.isUnique = true;
+                }
+                // removing column from composite unique keys if current column is unique
+                if (columnPossibleGenerator.generator.isUnique && compositeKeyColumnNames.length > 0) {
+                    const newUniqueConstraints = [];
+                    for (const colNames of table.uniqueConstraints) {
+                        if (colNames.includes(col.name)) {
+                            const newColNames = colNames.filter((colName) => colName !== col.name);
+                            if (newColNames.length === 0)
+                                continue;
+                            newUniqueConstraints.push(newColNames);
+                        }
+                        else {
+                            newUniqueConstraints.push(colNames);
+                        }
+                    }
+                    table.uniqueConstraints = newUniqueConstraints;
+                }
+                compositeKeyColumnNames = table.uniqueConstraints.filter((colNames) => colNames.includes(col.name));
+                if (compositeKeyColumnNames.length > 1) {
+                    throw new Error('Currently, multiple composite unique keys that share the same column are not supported.');
+                }
+                // to handle composite unique key generation, I will need a unique generator for each column in the composite key
+                if (compositeKeyColumnNames.length === 1) {
+                    if (columnPossibleGenerator.generator.params.isUnique === false) {
+                        throw new Error(`To handle the composite unique key on columns: ${compositeKeyColumnNames[0]}, `
+                            + `column: ${col.name} should either be assigned a generator with isUnique set to true, or have isUnique omitted.`);
+                    }
+                    columnPossibleGenerator.generator.params.isUnique = true;
+                }
                 const uniqueGen = columnPossibleGenerator.generator.replaceIfUnique();
                 if (uniqueGen !== undefined) {
                     columnPossibleGenerator.generator = uniqueGen;
                 }
+                if (compositeKeyColumnNames.length === 1 && !columnPossibleGenerator.generator.isGeneratorUnique
+                    && !(columnPossibleGenerator.generator.getEntityKind() === 'GenerateValuesFromArray')) {
+                    throw new Error(`To handle the composite unique key on columns: ${compositeKeyColumnNames[0]}, `
+                        + `column: ${col.name} should be assigned a generator with its own unique version.`);
+                }
                 // selecting version of generator
                 columnPossibleGenerator.generator = this.selectVersionOfGenerator(columnPossibleGenerator.generator);
                 // TODO: for now only GenerateValuesFromArray support notNull property
                 columnPossibleGenerator.generator.notNull = col.notNull;
                 columnPossibleGenerator.generator.dataType = col.dataType;
-                // columnPossibleGenerator.generator.stringLength = col.typeParams.length;
+                // assigning composite key generator
+                if (compositeKeyColumnNames.length === 1) {
+                    const key = compositeKeyColumnNames[0].join('_');
+                    if (compositeUniqueKeyGenMap[key] === undefined) {
+                        let compositeUniqueKeyGen = new generatorsMap.GenerateCompositeUniqueKey[0]();
+                        compositeUniqueKeyGen.uniqueKey = key;
+                        compositeUniqueKeyGen = this.selectVersionOfGenerator(compositeUniqueKeyGen);
+                        compositeUniqueKeyGenMap[key] = compositeUniqueKeyGen;
+                    }
+                    compositeUniqueKeyGenMap[key].addGenerator(col.name, columnPossibleGenerator.generator);
+                    columnPossibleGenerator.generator = compositeUniqueKeyGenMap[key];
+                }
                 tablePossibleGenerators.columnsPossibleGenerators.push(columnPossibleGenerator);
             }
         }
@@ -136282,6 +136789,7 @@ class SeedService {
         newGenerator.dataType = generator.dataType;
         // newGenerator.stringLength = generator.stringLength;
         newGenerator.typeParams = generator.typeParams ?? newGenerator.typeParams;
+        newGenerator.uniqueKey = generator.uniqueKey;
         return newGenerator;
     };
     cyclicTablesCompare = (table1, table2, relation, reverseRelation) => {
@@ -136442,8 +136950,13 @@ class SeedService {
                 const columnRelations = filteredRelations.filter((rel) => rel.columns.includes(col.columnName));
                 pRNGSeed = (columnRelations.length !== 0
                     && columnRelations[0].columns.length >= 2)
-                    ? (customSeed + generateHashFromString(`${columnRelations[0].table}.${columnRelations[0].columns.join('_')}`))
-                    : (customSeed + generateHashFromString(`${table.tableName}.${col.columnName}`));
+                    ? (customSeed
+                        + this.hashFromStringGenerator.generate({
+                            input: `${columnRelations[0].table}.${columnRelations[0].columns.join('_')}`,
+                        }))
+                    : col.generator?.uniqueKey === undefined
+                        ? (customSeed + this.hashFromStringGenerator.generate({ input: `${table.tableName}.${col.columnName}` }))
+                        : (customSeed + this.hashFromStringGenerator.generate({ input: col.generator.uniqueKey }));
                 tableGenerators[col.columnName] = {
                     pRNGSeed,
                     ...col,
@@ -136465,7 +136978,9 @@ class SeedService {
                         if (rel.table === rel.refTable
                             && tableGenerators[rel.columns[colIdx]]?.wasRefined === false) {
                             const refColName = rel.refColumns[colIdx];
-                            pRNGSeed = generateHashFromString(`${table.tableName}.${refColName}`);
+                            pRNGSeed = this.hashFromStringGenerator.generate({
+                                input: `${table.tableName}.${refColName}`,
+                            });
                             const refColumnGenerator = {};
                             refColumnGenerator[refColName] = {
                                 ...tableGenerators[refColName],
@@ -136614,11 +137129,7 @@ class SeedService {
             row = {};
             generatedValues.push(row);
             for (const columnName of Object.keys(columnsGenerators)) {
-                // generatedValue = columnsGenerators[columnName].next().value as
-                //   | string
-                //   | number
-                //   | boolean;
-                generatedValue = columnsGenerators[columnName].generate({ i });
+                generatedValue = columnsGenerators[columnName].generate({ i, columnName });
                 row[columnName] = generatedValue;
             }
             if ((insertDataInDb === true || updateDataInDb === true)
@@ -136765,7 +137276,7 @@ const filterCockroachSchema = (schema) => {
 const seedCockroach = async (db, schema, options = {}, refinements) => {
     const seedService = new SeedService();
     const { cockroachSchema, cockroachTables } = filterCockroachSchema(schema);
-    const { tables, relations } = getSchemaInfo(cockroachSchema, cockroachTables, mapCockroachTable);
+    const { tables, relations } = getSchemaInfo(cockroachSchema, cockroachTables, mapCockroachColumns);
     const generatedTablesGenerators = seedService.generatePossibleGenerators('cockroach', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
     const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, cockroachTables, { ...options, preserveCyclicTablesData });
@@ -136773,7 +137284,7 @@ const seedCockroach = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, cockroachTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const mapCockroachTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+const mapCockroachColumns = (tableConfig, dbToTsColumnNamesMap) => {
     const getAllBaseColumns = (baseColumn) => {
         const baseColumnResult = {
             name: baseColumn.name,
@@ -136825,30 +137336,24 @@ const mapCockroachTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMa
         }
         return typeParams;
     };
-    // console.log(tableConfig.columns);
-    return {
-        name: dbToTsTableNamesMap[tableConfig.name],
-        columns: tableConfig.columns.map((column) => ({
-            name: dbToTsColumnNamesMap[column.name],
-            columnType: column.getSQLType(),
-            typeParams: getTypeParams(column.getSQLType()),
-            dataType: column.dataType.split(' ')[0],
-            size: column.length,
-            hasDefault: column.hasDefault,
-            default: column.default,
-            enumValues: column.enumValues,
-            isUnique: column.isUnique,
-            notNull: column.notNull,
-            primary: column.primary,
-            generatedIdentityType: column.generatedIdentity?.type,
-            baseColumn: (column.baseColumn === undefined)
-                ? undefined
-                : getAllBaseColumns(column.baseColumn),
-        })),
-        primaryKeys: tableConfig.columns
-            .filter((column) => column.primary)
-            .map((column) => dbToTsColumnNamesMap[column.name]),
-    };
+    const mappedColumns = tableConfig.columns.map((column) => ({
+        name: dbToTsColumnNamesMap[column.name],
+        columnType: column.getSQLType(),
+        typeParams: getTypeParams(column.getSQLType()),
+        dataType: column.dataType.split(' ')[0],
+        size: column.length,
+        hasDefault: column.hasDefault,
+        default: column.default,
+        enumValues: column.enumValues,
+        isUnique: column.isUnique,
+        notNull: column.notNull,
+        primary: column.primary,
+        generatedIdentityType: column.generatedIdentity?.type,
+        baseColumn: (column.baseColumn === undefined)
+            ? undefined
+            : getAllBaseColumns(column.baseColumn),
+    }));
+    return mappedColumns;
 };
 
 // MySql-----------------------------------------------------------------------------------------------------
@@ -136937,7 +137442,7 @@ const filterMsSqlTables = (schema) => {
 };
 const seedMsSql = async (db, schema, options = {}, refinements) => {
     const { mssqlSchema, mssqlTables } = filterMsSqlTables(schema);
-    const { tables, relations } = getSchemaInfo(mssqlSchema, mssqlTables, mapMsSqlTable);
+    const { tables, relations } = getSchemaInfo(mssqlSchema, mssqlTables, mapMsSqlColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mssql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -136946,7 +137451,7 @@ const seedMsSql = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mssqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const mapMsSqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+const mapMsSqlColumns = (tableConfig, dbToTsColumnNamesMap) => {
     // TODO: rewrite
     const getTypeParams = (sqlType) => {
         // get type params and set only type
@@ -136971,25 +137476,20 @@ const mapMsSqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) =
         }
         return typeParams;
     };
-    return {
-        name: dbToTsTableNamesMap[tableConfig.name],
-        columns: tableConfig.columns.map((column) => ({
-            name: dbToTsColumnNamesMap[column.name],
-            columnType: column.getSQLType(),
-            typeParams: getTypeParams(column.getSQLType()),
-            dataType: column.dataType.split(' ')[0],
-            hasDefault: column.hasDefault,
-            default: column.default,
-            enumValues: column.enumValues,
-            isUnique: column.isUnique,
-            notNull: column.notNull,
-            primary: column.primary,
-            identity: column.identity ? true : false,
-        })),
-        primaryKeys: tableConfig.columns
-            .filter((column) => column.primary)
-            .map((column) => dbToTsColumnNamesMap[column.name]),
-    };
+    const mappedColumns = tableConfig.columns.map((column) => ({
+        name: dbToTsColumnNamesMap[column.name],
+        columnType: column.getSQLType(),
+        typeParams: getTypeParams(column.getSQLType()),
+        dataType: column.dataType.split(' ')[0],
+        hasDefault: column.hasDefault,
+        default: column.default,
+        enumValues: column.enumValues,
+        isUnique: column.isUnique,
+        notNull: column.notNull,
+        primary: column.primary,
+        identity: column.identity ? true : false,
+    }));
+    return mappedColumns;
 };
 
 // MySql-----------------------------------------------------------------------------------------------------
@@ -137012,7 +137512,7 @@ const filterMysqlTables = (schema) => {
 };
 const seedMySql = async (db, schema, options = {}, refinements) => {
     const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
-    const { tables, relations } = getSchemaInfo(mysqlSchema, mysqlTables, mapMySqlTable);
+    const { tables, relations } = getSchemaInfo(mysqlSchema, mysqlTables, mapMySqlColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137021,7 +137521,7 @@ const seedMySql = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mysqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const mapMySqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+const mapMySqlColumns = (tableConfig, dbToTsColumnNamesMap) => {
     const getTypeParams = (sqlType) => {
         // get type params and set only type
         const typeParams = {};
@@ -137046,24 +137546,19 @@ const mapMySqlTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) =
         }
         return typeParams;
     };
-    return {
-        name: dbToTsTableNamesMap[tableConfig.name],
-        columns: tableConfig.columns.map((column) => ({
-            name: dbToTsColumnNamesMap[column.name],
-            columnType: column.getSQLType(),
-            typeParams: getTypeParams(column.getSQLType()),
-            dataType: column.dataType.split(' ')[0],
-            hasDefault: column.hasDefault,
-            default: column.default,
-            enumValues: column.enumValues,
-            isUnique: column.isUnique,
-            notNull: column.notNull,
-            primary: column.primary,
-        })),
-        primaryKeys: tableConfig.columns
-            .filter((column) => column.primary)
-            .map((column) => dbToTsColumnNamesMap[column.name]),
-    };
+    const mappedColumns = tableConfig.columns.map((column) => ({
+        name: dbToTsColumnNamesMap[column.name],
+        columnType: column.getSQLType(),
+        typeParams: getTypeParams(column.getSQLType()),
+        dataType: column.dataType.split(' ')[0],
+        hasDefault: column.hasDefault,
+        default: column.default,
+        enumValues: column.enumValues,
+        isUnique: column.isUnique,
+        notNull: column.notNull,
+        primary: column.primary,
+    }));
+    return mappedColumns;
 };
 
 // Postgres-----------------------------------------------------------------------------------------------------------
@@ -137083,7 +137578,7 @@ const filterPgSchema = (schema) => {
 const seedPostgres = async (db, schema, options = {}, refinements) => {
     const seedService = new SeedService();
     const { pgSchema, pgTables } = filterPgSchema(schema);
-    const { tables, relations } = getSchemaInfo(pgSchema, pgTables, mapPgTable);
+    const { tables, relations } = getSchemaInfo(pgSchema, pgTables, mapPgColumns);
     // const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
     const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137092,7 +137587,7 @@ const seedPostgres = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, pgTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const mapPgTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+const mapPgColumns = (tableConfig, dbToTsColumnNamesMap) => {
     const getAllBaseColumns = (baseColumn) => {
         const baseColumnResult = {
             name: baseColumn.name,
@@ -137145,29 +137640,24 @@ const mapPgTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
         }
         return typeParams;
     };
-    return {
-        name: dbToTsTableNamesMap[tableConfig.name],
-        columns: tableConfig.columns.map((column) => ({
-            name: dbToTsColumnNamesMap[column.name],
-            columnType: column.getSQLType(),
-            typeParams: getTypeParams(column.getSQLType()),
-            dataType: column.dataType.split(' ')[0],
-            size: column.length,
-            hasDefault: column.hasDefault,
-            default: column.default,
-            enumValues: column.enumValues,
-            isUnique: column.isUnique,
-            notNull: column.notNull,
-            primary: column.primary,
-            generatedIdentityType: column.generatedIdentity?.type,
-            baseColumn: (column.baseColumn === undefined)
-                ? undefined
-                : getAllBaseColumns(column.baseColumn),
-        })),
-        primaryKeys: tableConfig.columns
-            .filter((column) => column.primary)
-            .map((column) => dbToTsColumnNamesMap[column.name]),
-    };
+    const mappedColumns = tableConfig.columns.map((column) => ({
+        name: dbToTsColumnNamesMap[column.name],
+        columnType: column.getSQLType(),
+        typeParams: getTypeParams(column.getSQLType()),
+        dataType: column.dataType.split(' ')[0],
+        size: column.length,
+        hasDefault: column.hasDefault,
+        default: column.default,
+        enumValues: column.enumValues,
+        isUnique: column.isUnique,
+        notNull: column.notNull,
+        primary: column.primary,
+        generatedIdentityType: column.generatedIdentity?.type,
+        baseColumn: (column.baseColumn === undefined)
+            ? undefined
+            : getAllBaseColumns(column.baseColumn),
+    }));
+    return mappedColumns;
 };
 
 // SingleStore-----------------------------------------------------------------------------------------------------
@@ -137190,7 +137680,7 @@ const filterSingleStoreTables = (schema) => {
 };
 const seedSingleStore = async (db, schema, options = {}, refinements) => {
     const { singleStoreSchema, singleStoreTables } = filterSingleStoreTables(schema);
-    const { tables, relations } = getSchemaInfo(singleStoreSchema, singleStoreTables, mapSingleStoreTable);
+    const { tables, relations } = getSchemaInfo(singleStoreSchema, singleStoreTables, mapSingleStoreColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('singlestore', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137199,7 +137689,7 @@ const seedSingleStore = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, singleStoreTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const mapSingleStoreTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+const mapSingleStoreColumns = (tableConfig, dbToTsColumnNamesMap) => {
     const getTypeParams = (sqlType) => {
         // get type params and set only type
         const typeParams = {};
@@ -137215,6 +137705,7 @@ const mapSingleStoreTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNames
         }
         else if (sqlType.startsWith('char')
             || sqlType.startsWith('varchar')
+            || sqlType.startsWith('text')
             || sqlType.startsWith('binary')
             || sqlType.startsWith('varbinary')) {
             const match = sqlType.match(/\((\d+)\)/);
@@ -137231,24 +137722,19 @@ const mapSingleStoreTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNames
         }
         return typeParams;
     };
-    return {
-        name: dbToTsTableNamesMap[tableConfig.name],
-        columns: tableConfig.columns.map((column) => ({
-            name: dbToTsColumnNamesMap[column.name],
-            columnType: column.getSQLType(),
-            typeParams: getTypeParams(column.getSQLType()),
-            dataType: column.dataType.split(' ')[0],
-            hasDefault: column.hasDefault,
-            default: column.default,
-            enumValues: column.enumValues,
-            isUnique: column.isUnique,
-            notNull: column.notNull,
-            primary: column.primary,
-        })),
-        primaryKeys: tableConfig.columns
-            .filter((column) => column.primary)
-            .map((column) => dbToTsColumnNamesMap[column.name]),
-    };
+    const mappedColumns = tableConfig.columns.map((column) => ({
+        name: dbToTsColumnNamesMap[column.name],
+        columnType: column.getSQLType(),
+        typeParams: getTypeParams(column.getSQLType()),
+        dataType: column.dataType.split(' ')[0],
+        hasDefault: column.hasDefault,
+        default: column.default,
+        enumValues: column.enumValues,
+        isUnique: column.isUnique,
+        notNull: column.notNull,
+        primary: column.primary,
+    }));
+    return mappedColumns;
 };
 
 // Sqlite------------------------------------------------------------------------------------------------------------------------
@@ -137271,7 +137757,7 @@ const filterSqliteTables = (schema) => {
 };
 const seedSqlite = async (db, schema, options = {}, refinements) => {
     const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
-    const { tables, relations } = getSchemaInfo(sqliteSchema, sqliteTables, mapSqliteTable);
+    const { tables, relations } = getSchemaInfo(sqliteSchema, sqliteTables, mapSqliteColumns);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
@@ -137280,7 +137766,7 @@ const seedSqlite = async (db, schema, options = {}, refinements) => {
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
     await seedService.generateTablesValues(relations, filteredTablesGenerators, db, sqliteTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const mapSqliteTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap) => {
+const mapSqliteColumns = (tableConfig, dbToTsColumnNamesMap) => {
     const getTypeParams = (sqlType) => {
         // get type params and set only type
         const typeParams = {};
@@ -137301,24 +137787,19 @@ const mapSqliteTable = (tableConfig, dbToTsTableNamesMap, dbToTsColumnNamesMap)
         }
         return typeParams;
     };
-    return {
-        name: dbToTsTableNamesMap[tableConfig.name],
-        columns: tableConfig.columns.map((column) => ({
-            name: dbToTsColumnNamesMap[column.name],
-            columnType: column.getSQLType(),
-            typeParams: getTypeParams(column.getSQLType()),
-            dataType: column.dataType.split(' ')[0],
-            hasDefault: column.hasDefault,
-            default: column.default,
-            enumValues: column.enumValues,
-            isUnique: column.isUnique,
-            notNull: column.notNull,
-            primary: column.primary,
-        })),
-        primaryKeys: tableConfig.columns
-            .filter((column) => column.primary)
-            .map((column) => dbToTsColumnNamesMap[column.name]),
-    };
+    const mappedColumns = tableConfig.columns.map((column) => ({
+        name: dbToTsColumnNamesMap[column.name],
+        columnType: column.getSQLType(),
+        typeParams: getTypeParams(column.getSQLType()),
+        dataType: column.dataType.split(' ')[0],
+        hasDefault: column.hasDefault,
+        default: column.default,
+        enumValues: column.enumValues,
+        isUnique: column.isUnique,
+        notNull: column.notNull,
+        primary: column.primary,
+    }));
+    return mappedColumns;
 };
 
 /* eslint-disable drizzle-internal/require-entity-kind */
@@ -137382,6 +137863,7 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
                 name: tableName,
                 columns,
                 primaryKeys: drizzleStudioColumns.filter((col) => col.primaryKey === true).map((col) => col.name),
+                uniqueConstraints: [], // TODO change later
             });
         }
         relations = drizzleStudioRelations.filter((rel) => rel.schema === schemaName && rel.refSchema === schemaName);