drizzle-seed 0.3.2-97009ae → 0.3.2-b5a9650

package/index.mjs

@@ -1,6 +1,6 @@
-import { is, entityKind, eq, sql, Relations, getTableName, extractTablesRelationalConfig, createTableRelationsHelpers, One } from 'drizzle-orm';
+import { is, entityKind, sql, eq, Relations, getTableName, extractTablesRelationalConfig, createTableRelationsHelpers, One } 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 { PgSmallInt, PgInteger, PgBigInt53, PgBigInt64, PgSmallSerial, PgSerial, PgBigSerial53, PgBigSerial64, PgDatabase, getTableConfig, PgTable } from 'drizzle-orm/pg-core';
 import { BaseSQLiteDatabase, SQLiteTable, getTableConfig as getTableConfig$2 } from 'drizzle-orm/sqlite-core';
 import prand from 'pure-rand';
 
@@ -131214,6 +131214,20 @@ const isObject = (value) => {
 const equalSets = (set1, set2) => {
     return set1.size === set2.size && [...set1].every((si) => set2.has(si));
 };
+const isValidDate = (date) => {
+    return !Number.isNaN(date.getTime());
+};
+const intMax = (args) => args.reduce((m, e) => e > m ? e : m);
+const isPostgresColumnIntLike = (column) => {
+    return is(column, PgSmallInt)
+        || is(column, PgInteger)
+        || is(column, PgBigInt53)
+        || is(column, PgBigInt64)
+        || is(column, PgSmallSerial)
+        || is(column, PgSerial)
+        || is(column, PgBigSerial53)
+        || is(column, PgBigSerial64);
+};
 
 /* eslint-disable drizzle-internal/require-entity-kind */
 class AbstractGenerator {
@@ -131785,13 +131799,20 @@ class GenerateDate extends AbstractGenerator {
         const rng = prand.xoroshiro128plus(seed);
         let { minDate, maxDate } = this.params;
         const anchorDate = new Date('2024-05-08');
+        // 4 years in milliseconds
         const deltaMilliseconds = 4 * 31536000000;
         if (typeof minDate === 'string') {
             minDate = new Date(minDate);
         }
+        if (typeof minDate === 'object' && !isValidDate(minDate)) {
+            throw new Error('Invalid Date was provided for the minDate parameter.');
+        }
         if (typeof maxDate === 'string') {
             maxDate = new Date(maxDate);
         }
+        if (typeof maxDate === 'object' && !isValidDate(maxDate)) {
+            throw new Error('Invalid Date was provided for the maxDate parameter.');
+        }
         if (minDate === undefined) {
             if (maxDate === undefined) {
                 minDate = new Date(anchorDate.getTime() - deltaMilliseconds);
@@ -131804,6 +131825,9 @@ class GenerateDate extends AbstractGenerator {
         if (maxDate === undefined) {
             maxDate = new Date(minDate.getTime() + (2 * deltaMilliseconds));
         }
+        if (minDate > maxDate) {
+            throw new Error(`The minDate parameter must be less than or equal to the maxDate parameter.`);
+        }
         this.state = { rng, minDate, maxDate };
     }
     generate() {
@@ -131825,18 +131849,83 @@ class GenerateTime extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        this.state = { rng };
+        let { minTime, maxTime } = this.params;
+        if (minTime === undefined && maxTime === undefined) {
+            // TODO: maybe need to change in major version release
+            // This is required to ensure that this generator remains deterministic when used without minTime, maxTime parameters.
+            const oneDayInMilliseconds = 86400000;
+            minTime = new Date(new Date('2024-05-08T12:00:00.000Z').getTime() - oneDayInMilliseconds);
+            maxTime = new Date(new Date('2024-05-08T12:00:00.000Z').getTime() + oneDayInMilliseconds);
+            this.state = { rng, minTime, maxTime };
+            return;
+        }
+        if (minTime === undefined) {
+            if (maxTime === undefined) {
+                minTime = '00:00:00.000Z';
+                maxTime = '23:59:59.999Z';
+            }
+            else {
+                minTime = '00:00:00.000Z';
+            }
+        }
+        if (maxTime === undefined) {
+            maxTime = '23:59:59.999Z';
+            new Date().toISOString();
+        }
+        const anchorDate = new Date('2024-05-08');
+        const anchorDateString0 = anchorDate.toISOString().replace(/T\d{2}:\d{2}:\d{2}.\d{3}Z/, '');
+        if (typeof minTime === 'string') {
+            // const timeMatch0 = minTime.match(/^\d{2}:\d{2}:\d{2}.\d{1,3}Z?$/);
+            const timeMatch1 = minTime.match(/^\d{2}:\d{2}:\d{2}Z?$/);
+            const timeMatch2 = minTime.match(/^\d{2}:\d{2}Z?$/);
+            if (
+            // timeMatch0 === null
+            timeMatch1 === null
+                && timeMatch2 === null) {
+                throw new Error(`You're using the wrong format for the minTime parameter.`
+                    + `\nPlease use one of these formats: 'HH:mm:ss', 'HH:mm' (with or without a trailing 'Z')`);
+            }
+            minTime = minTime.at(-1) === 'Z' ? minTime : minTime + 'Z';
+            minTime = new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}.\d{3}Z/, minTime));
+        }
+        if (typeof minTime === 'object') {
+            if (!isValidDate(minTime)) {
+                throw new Error('Invalid Date was provided for the minTime parameter.');
+            }
+            minTime = new Date(minTime.toISOString().replace(/\d{4}-\d{2}-\d{2}/, anchorDateString0));
+        }
+        if (typeof maxTime === 'string') {
+            // const timeMatch0 = maxTime.match(/^\d{2}:\d{2}:\d{2}.\d{1,3}Z?$/);
+            const timeMatch1 = maxTime.match(/^\d{2}:\d{2}:\d{2}Z?$/);
+            const timeMatch2 = maxTime.match(/^\d{2}:\d{2}Z?$/);
+            if (
+            // timeMatch0 === null
+            timeMatch1 === null
+                && timeMatch2 === null) {
+                throw new Error(`You're using the wrong format for the maxTime parameter.`
+                    + `\nPlease use one of these formats: 'HH:mm:ss', 'HH:mm' (with or without a trailing 'Z').`);
+            }
+            maxTime = maxTime.at(-1) === 'Z' ? maxTime : maxTime + 'Z';
+            maxTime = new Date(anchorDate.toISOString().replace(/\d{2}:\d{2}:\d{2}.\d{3}Z/, maxTime));
+        }
+        if (typeof maxTime === 'object') {
+            if (!isValidDate(maxTime)) {
+                throw new Error('Invalid Date was provided for the maxTime parameter.');
+            }
+            maxTime = new Date(maxTime.toISOString().replace(/\d{4}-\d{2}-\d{2}/, anchorDateString0));
+        }
+        if (minTime > maxTime) {
+            throw new Error(`The minTime parameter must be less than or equal to the maxTime parameter.`);
+        }
+        this.state = { rng, minTime, maxTime };
     }
     generate() {
         if (this.state === undefined) {
             throw new Error('state is not defined.');
         }
-        const anchorDateTime = new Date('2024-05-08T12:00:00.000Z');
-        const oneDayInMilliseconds = 86400000;
-        let date = new Date();
         let milliseconds;
-        [milliseconds, this.state.rng] = prand.uniformIntDistribution(-oneDayInMilliseconds, oneDayInMilliseconds, this.state.rng);
-        date = new Date(date.setTime(anchorDateTime.getTime() + milliseconds));
+        [milliseconds, this.state.rng] = prand.uniformIntDistribution(this.state.minTime.getTime(), this.state.maxTime.getTime(), this.state.rng);
+        const date = new Date(milliseconds);
         return date.toISOString().replace(/(\d{4}-\d{2}-\d{2}T)|(\.\d{3}Z)/g, '');
     }
 }
@@ -131846,18 +131935,46 @@ class GenerateTimestamp extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        this.state = { rng };
+        let { minTimestamp, maxTimestamp } = this.params;
+        const anchorDate = new Date('2024-05-08');
+        // 2 years in milliseconds
+        const deltaMilliseconds = 2 * 31536000000;
+        if (typeof minTimestamp === 'string') {
+            minTimestamp = new Date(minTimestamp);
+        }
+        if (typeof minTimestamp === 'object' && !isValidDate(minTimestamp)) {
+            throw new Error('Invalid Date was provided for the minTimestamp parameter.');
+        }
+        if (typeof maxTimestamp === 'string') {
+            maxTimestamp = new Date(maxTimestamp);
+        }
+        if (typeof maxTimestamp === 'object' && !isValidDate(maxTimestamp)) {
+            throw new Error('Invalid Date was provided for the maxTimestamp parameter.');
+        }
+        if (minTimestamp === undefined) {
+            if (maxTimestamp === undefined) {
+                minTimestamp = new Date(anchorDate.getTime() - deltaMilliseconds);
+                maxTimestamp = new Date(anchorDate.getTime() + deltaMilliseconds);
+            }
+            else {
+                minTimestamp = new Date(maxTimestamp.getTime() - (2 * deltaMilliseconds));
+            }
+        }
+        if (maxTimestamp === undefined) {
+            maxTimestamp = new Date(minTimestamp.getTime() + (2 * deltaMilliseconds));
+        }
+        if (minTimestamp > maxTimestamp) {
+            throw new Error(`The minTimestamp parameter must be less than or equal to the maxTimestamp parameter.`);
+        }
+        this.state = { rng, minTimestamp, maxTimestamp };
     }
     generate() {
         if (this.state === undefined) {
             throw new Error('state is not defined.');
         }
-        const anchorTimestamp = new Date('2024-05-08');
-        const twoYearsInMilliseconds = 2 * 31536000000;
-        let date = new Date();
         let milliseconds;
-        [milliseconds, this.state.rng] = prand.uniformIntDistribution(-twoYearsInMilliseconds, twoYearsInMilliseconds, this.state.rng);
-        date = new Date(date.setTime(anchorTimestamp.getTime() + milliseconds));
+        [milliseconds, this.state.rng] = prand.uniformIntDistribution(this.state.minTimestamp.getTime(), this.state.maxTimestamp.getTime(), this.state.rng);
+        const date = new Date(milliseconds);
         if (this.dataType === 'string') {
             return date
                 .toISOString()
@@ -131873,18 +131990,46 @@ class GenerateDatetime extends AbstractGenerator {
     init({ count, seed }) {
         super.init({ count, seed });
         const rng = prand.xoroshiro128plus(seed);
-        this.state = { rng };
+        let { minDatetime, maxDatetime } = this.params;
+        const anchorDate = new Date('2024-05-08');
+        // 2 years in milliseconds
+        const deltaMilliseconds = 2 * 31536000000;
+        if (typeof minDatetime === 'string') {
+            minDatetime = new Date(minDatetime);
+        }
+        if (typeof minDatetime === 'object' && !isValidDate(minDatetime)) {
+            throw new Error('Invalid Date was provided for the minDatetime parameter.');
+        }
+        if (typeof maxDatetime === 'string') {
+            maxDatetime = new Date(maxDatetime);
+        }
+        if (typeof maxDatetime === 'object' && !isValidDate(maxDatetime)) {
+            throw new Error('Invalid Date was provided for the maxDatetime parameter.');
+        }
+        if (minDatetime === undefined) {
+            if (maxDatetime === undefined) {
+                minDatetime = new Date(anchorDate.getTime() - deltaMilliseconds);
+                maxDatetime = new Date(anchorDate.getTime() + deltaMilliseconds);
+            }
+            else {
+                minDatetime = new Date(maxDatetime.getTime() - (2 * deltaMilliseconds));
+            }
+        }
+        if (maxDatetime === undefined) {
+            maxDatetime = new Date(minDatetime.getTime() + (2 * deltaMilliseconds));
+        }
+        if (minDatetime > maxDatetime) {
+            throw new Error(`The minDatetime parameter must be less than or equal to the maxDatetime parameter.`);
+        }
+        this.state = { rng, minDatetime, maxDatetime };
     }
     generate() {
         if (this.state === undefined) {
             throw new Error('state is not defined.');
         }
-        const anchorDate = new Date('2024-05-08');
-        const twoYearsInMilliseconds = 2 * 31536000000;
-        let date = new Date();
         let milliseconds;
-        [milliseconds, this.state.rng] = prand.uniformIntDistribution(-twoYearsInMilliseconds, twoYearsInMilliseconds, this.state.rng);
-        date = new Date(date.setTime(anchorDate.getTime() + milliseconds));
+        [milliseconds, this.state.rng] = prand.uniformIntDistribution(this.state.minDatetime.getTime(), this.state.maxDatetime.getTime(), this.state.rng);
+        const date = new Date(milliseconds);
         if (this.dataType === 'string') {
             return date
                 .toISOString()
@@ -133557,6 +133702,8 @@ const generatorsFuncs = {
     date: createGenerator(GenerateDate),
     /**
      * generates time in 24 hours style.
+     * @param minTime - lower border of range.
+     * @param maxTime - upper border of range.
      * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
      *
      * @example
@@ -133564,7 +133711,7 @@ const generatorsFuncs = {
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
      *    users: {
      *      columns: {
-     *        birthTime: funcs.time()
+     *        birthTime: funcs.time({ minTime: "11:12:13.141", maxTime: "15:16:17.181" })
      *      },
      *    },
      *  }));
@@ -133574,6 +133721,8 @@ const generatorsFuncs = {
     time: createGenerator(GenerateTime),
     /**
      * generates timestamps.
+     * @param minTimestamp - lower border of range.
+     * @param maxTimestamp - upper border of range.
      * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
      *
      * @example
@@ -133581,7 +133730,7 @@ const generatorsFuncs = {
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
      *    orders: {
      *      columns: {
-     *        shippedDate: funcs.timestamp()
+     *        shippedDate: funcs.timestamp({ minTimestamp: "2025-03-07T11:12:13.141", maxTimestamp: "2025-03-08T15:16:17.181" })
      *      },
      *    },
      *  }));
@@ -133591,6 +133740,8 @@ const generatorsFuncs = {
     timestamp: createGenerator(GenerateTimestamp),
     /**
      * generates datetime objects.
+     * @param minDatetime - lower border of range.
+     * @param maxDatetime - upper border of range.
      * @param arraySize - number of elements in each one-dimensional array. (If specified, arrays will be generated.)
      *
      * @example
@@ -133598,7 +133749,7 @@ const generatorsFuncs = {
      *  await seed(db, schema, { count: 1000 }).refine((funcs) => ({
      *    orders: {
      *      columns: {
-     *        shippedDate: funcs.datetime()
+     *        shippedDate: funcs.datetime({ minDatetime: "2025-03-07T11:12:13.141", maxDatetime: "2025-03-08T15:16:17.181" })
      *      },
      *    },
      *  }));
@@ -134059,7 +134210,7 @@ const generatorsFuncs = {
      */
     weightedRandom: createGenerator(WeightedRandomGenerator),
 };
-// so far, version changes don’t affect generator parameters.
+// so far, version changes don’t change generator parameters.
 const generatorsFuncsV2 = {
     ...generatorsFuncs,
 };
@@ -134270,6 +134421,7 @@ class SeedService {
                     };
                 }
             }
+            // handling refinements (count, with)
             if (refinements !== undefined && refinements[table.name] !== undefined) {
                 if (refinements[table.name].count !== undefined) {
                     tablesPossibleGenerators[i].count = refinements[table.name].count;
@@ -134330,11 +134482,24 @@ class SeedService {
                     wasDefinedBefore: false,
                     wasRefined: false,
                 };
+                // handling refinements (columnGenerator)
                 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];
+                    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
@@ -134646,8 +134811,8 @@ class SeedService {
             // NUMBER(real, double, decimal, numeric)
             if (col.columnType === 'real'
                 || col.columnType === 'double precision'
-                || col.columnType.match(/^decimal(\(\d+,? *\d*\))?$/) !== null
-                || col.columnType.match(/^numeric(\(\d+,? *\d*\))?$/) !== null) {
+                || col.columnType.match(/^decimal(\(\d{1,6}(, ?-?\d{0,5})?\))?$/) !== null
+                || col.columnType.match(/^numeric(\(\d{1,6}(, ?-?\d{0,5})?\))?$/) !== null) {
                 if (col.typeParams.precision !== undefined) {
                     const precision = col.typeParams.precision;
                     const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
@@ -134823,8 +134988,8 @@ class SeedService {
             if (col.columnType === 'real'
                 || col.columnType === 'double'
                 || col.columnType === 'float'
-                || col.columnType.match(/^decimal(\(\d+,? *\d*\))?$/) !== null
-                || col.columnType.match(/^numeric(\(\d+,? *\d*\))?$/) !== null) {
+                || col.columnType.startsWith('decimal')
+                || col.columnType.startsWith('numeric')) {
                 if (col.typeParams.precision !== undefined) {
                     const precision = col.typeParams.precision;
                     const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
@@ -134842,40 +135007,40 @@ class SeedService {
             // STRING
             if ((col.columnType === 'text'
                 || col.columnType === 'blob'
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^binary(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varbinary(\(\d+\))?$/) !== null)
+                || col.columnType.startsWith('char')
+                || col.columnType.startsWith('varchar')
+                || col.columnType.startsWith('binary')
+                || col.columnType.startsWith('varbinary'))
                 && table.primaryKeys.includes(col.name)) {
                 const generator = new generatorsMap.GenerateUniqueString[0]();
                 return generator;
             }
             if ((col.columnType === 'text'
                 || col.columnType === 'blob'
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^binary(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varbinary(\(\d+\))?$/) !== null)
+                || col.columnType.startsWith('char')
+                || col.columnType.startsWith('varchar')
+                || col.columnType.startsWith('binary')
+                || col.columnType.startsWith('varbinary'))
                 && col.name.toLowerCase().includes('name')) {
                 const generator = new generatorsMap.GenerateFirstName[0]();
                 return generator;
             }
             if ((col.columnType === 'text'
                 || col.columnType === 'blob'
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^binary(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varbinary(\(\d+\))?$/) !== null)
+                || col.columnType.startsWith('char')
+                || col.columnType.startsWith('varchar')
+                || col.columnType.startsWith('binary')
+                || col.columnType.startsWith('varbinary'))
                 && col.name.toLowerCase().includes('email')) {
                 const generator = new generatorsMap.GenerateEmail[0]();
                 return generator;
             }
             if (col.columnType === 'text'
                 || col.columnType === 'blob'
-                || col.columnType.match(/^char(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varchar(\(\d+\))?$/) !== null
-                || col.columnType.match(/^binary(\(\d+\))?$/) !== null
-                || col.columnType.match(/^varbinary(\(\d+\))?$/) !== null) {
+                || col.columnType.startsWith('char')
+                || col.columnType.startsWith('varchar')
+                || col.columnType.startsWith('binary')
+                || col.columnType.startsWith('varbinary')) {
                 const generator = new generatorsMap.GenerateString[0]();
                 return generator;
             }
@@ -134885,7 +135050,7 @@ class SeedService {
                 return generator;
             }
             // DATE, TIME, TIMESTAMP, DATETIME, YEAR
-            if (col.columnType.match(/^datetime(\(\d\))?$/) !== null) {
+            if (col.columnType.startsWith('datetime')) {
                 const generator = new generatorsMap.GenerateDatetime[0]();
                 return generator;
             }
@@ -134897,7 +135062,7 @@ class SeedService {
                 const generator = new generatorsMap.GenerateTime[0]();
                 return generator;
             }
-            if (col.columnType.match(/^timestamp(\(\d\))?$/) !== null) {
+            if (col.columnType.startsWith('timestamp')) {
                 const generator = new generatorsMap.GenerateTimestamp[0]();
                 return generator;
             }
@@ -134950,8 +135115,8 @@ class SeedService {
                 return generator;
             }
             // number section ------------------------------------------------------------------------------------
-            if (col.columnType.match(/^real(\(\d+,? *\d*\))?$/) !== null
-                || col.columnType.match(/^numeric(\(\d+,? *\d*\))?$/) !== null) {
+            if (col.columnType.startsWith('real')
+                || col.columnType.startsWith('numeric')) {
                 if (col.typeParams.precision !== undefined) {
                     const precision = col.typeParams.precision;
                     const scale = col.typeParams.scale === undefined ? 0 : col.typeParams.scale;
@@ -135068,7 +135233,8 @@ class SeedService {
                 };
             }
             // get values to generate columns with foreign key
-            // if table posts contains foreign key to table users, then rel.table === 'posts' and rel.refTable === 'users', because table posts has reference to table users.
+            // if table posts contains foreign key to table users, then rel.table === 'posts' and rel.refTable === 'users',
+            // because table posts has reference to table users.
             if (filteredRelations.length !== 0) {
                 for (const rel of filteredRelations) {
                     if (table.withFromTable[rel.refTable] !== undefined
@@ -135185,9 +135351,6 @@ class SeedService {
             columnsNumber += 1;
             columnGenerator = tableGenerators[columnName];
             override = tableGenerators[columnName]?.generatedIdentityType === 'always' ? true : override;
-            if (tableName === 'evaluations' && columnName === 'gameId') {
-                console.log();
-            }
             columnsGenerators[columnName] = columnGenerator.generator;
             columnsGenerators[columnName].init({
                 count,
@@ -135202,6 +135365,25 @@ class SeedService {
             // 	columnsGenerators[columnName] = uniqueGen;
             // }
         }
+        // sequence updates will only be performed for PostgreSQL, since MySQL and SQLite already update their sequences correctly on their own.
+        const columnsToUpdateSeq = new Map();
+        if (count > 0 && is(db, PgDatabase) && schema !== undefined && tableName !== undefined
+            && schema[tableName] !== undefined) {
+            const tableConfig = getTableConfig(schema[tableName]);
+            for (const column of tableConfig.columns) {
+                // TODO should I filter only primary key columns?
+                // should I filter column by dataType or by column drizzle type?
+                // column.dataType === 'number' || column.dataType === 'bigint'
+                if (isPostgresColumnIntLike(column)) {
+                    columnsToUpdateSeq.set(column.name, {
+                        schemaName: tableConfig.schema,
+                        tableName: tableConfig.name,
+                        columnName: column.name,
+                        valueToUpdate: undefined,
+                    });
+                }
+            }
+        }
         let maxParametersNumber;
         if (is(db, (PgDatabase))) {
             // @ts-ignore
@@ -135233,6 +135415,12 @@ class SeedService {
                 //   | boolean;
                 generatedValue = columnsGenerators[columnName].generate({ i });
                 row[columnName] = generatedValue;
+                const colToUpdateSeq = columnsToUpdateSeq.get(columnName);
+                if (columnsToUpdateSeq.size !== 0 && colToUpdateSeq !== undefined) {
+                    colToUpdateSeq.valueToUpdate = colToUpdateSeq?.valueToUpdate === undefined
+                        ? generatedValue
+                        : intMax([colToUpdateSeq.valueToUpdate, generatedValue]);
+                }
             }
             if ((insertDataInDb === true || updateDataInDb === true)
                 && ((i + 1) % batchSize === 0 || i === count - 1)) {
@@ -135279,9 +135467,28 @@ class SeedService {
                     }
                 }
             }
+            const columnsToUpdateSeqFiltered = [...columnsToUpdateSeq.values()].filter((col) => col.valueToUpdate !== undefined);
+            if (i === count - 1
+                && columnsToUpdateSeqFiltered.length !== 0 && db !== undefined) {
+                for (const columnConfig of columnsToUpdateSeq.values()) {
+                    if (columnConfig) {
+                        await this.updateColumnSequence({ db, columnConfig });
+                    }
+                }
+            }
         }
         return preserveData === true ? generatedValues : [];
     };
+    updateColumnSequence = async ({ db, columnConfig: { schemaName, tableName, columnName, valueToUpdate } }) => {
+        if (is(db, PgDatabase)) {
+            const fullTableName = schemaName ? `"${schemaName}"."${tableName}"` : `"${tableName}"`;
+            const rawQuery = `SELECT setval(pg_get_serial_sequence('${fullTableName}', '${columnName}'), ${(valueToUpdate ?? 'null').toString()}, true);`;
+            await db.execute(sql.raw(rawQuery));
+        }
+        // mysql updates auto_increment or serial column by itself
+        // sqlite updates autoincrement  column by itself
+        return;
+    };
     insertInDb = async ({ generatedValues, db, schema, tableName, override, }) => {
         if (is(db, (PgDatabase))) {
             const query = db.insert(schema[tableName]);
@@ -135420,7 +135627,7 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
  * // seeding with count and seed specified
  * await seed(db, schema, { count: 100000, seed: 1 });
  *
- * //seeding using refine
+ * // seeding using refine
  * await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  *   users: {
  *     columns: {
@@ -135441,6 +135648,17 @@ async function seedForDrizzleStudio({ sqlDialect, drizzleStudioObject, drizzleSt
  *   },
  * }));
  *
+ * // seeding while ignoring column
+ * await seed(db, schema).refine((funcs) => ({
+ *   users: {
+ *     count: 5,
+ *     columns: {
+ *       name: funcs.fullName(),
+ *       photo: false, // the photo column will not be seeded, allowing the database to use its default value.
+ *     },
+ *   },
+ * }));
+ *
  * ```
  */
 function seed(db, schema, options) {
@@ -136146,5 +136364,5 @@ const getSqliteInfo = (sqliteSchema, sqliteTables) => {
     return { tables, relations: isCyclicRelations, tableRelations };
 };
 
-export { SeedService, cityNames as cities, countries, firstNames, getGeneratorsFunctions, lastNames, reset, seed, seedForDrizzleStudio };
+export { AbstractGenerator, SeedService, cityNames as cities, countries, firstNames, getGeneratorsFunctions, lastNames, reset, seed, seedForDrizzleStudio };
 //# sourceMappingURL=index.mjs.map