drizzle-seed 0.3.2-8e220c4 → 0.3.2-905c951

package/index.cjs

@@ -131216,6 +131216,9 @@ 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());
+};
 
 /* eslint-disable drizzle-internal/require-entity-kind */
 class AbstractGenerator {
@@ -131787,13 +131790,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);
@@ -131806,6 +131816,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() {
@@ -131827,18 +131840,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, '');
     }
 }
@@ -131848,18 +131926,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()
@@ -131875,18 +131981,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()
@@ -133559,6 +133693,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
@@ -133566,7 +133702,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" })
      *      },
      *    },
      *  }));
@@ -133576,6 +133712,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
@@ -133583,7 +133721,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" })
      *      },
      *    },
      *  }));
@@ -133593,6 +133731,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
@@ -133600,7 +133740,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" })
      *      },
      *    },
      *  }));
@@ -134061,7 +134201,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,
 };
@@ -134272,6 +134412,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;
@@ -134332,11 +134473,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
@@ -136145,6 +136299,7 @@ const getSqliteInfo = (sqliteSchema, sqliteTables) => {
     return { tables, relations: isCyclicRelations, tableRelations };
 };
 
+exports.AbstractGenerator = AbstractGenerator;
 exports.SeedService = SeedService;
 exports.cities = cityNames;
 exports.countries = countries;