drizzle-seed 1.0.0-beta.2-58a4521 → 1.0.0-beta.2-278d7e6

package/index.mjs

@@ -1,6 +1,6 @@
-import { getTableName, is, getColumnTable, Column, entityKind, sql, eq } from 'drizzle-orm';
+import { is, getTableName, getColumnTable, Column, entityKind, sql, eq } from 'drizzle-orm';
 import { MySqlTable, getTableConfig as getTableConfig$2, MySqlDatabase } from 'drizzle-orm/mysql-core';
-import { PgTable, getTableConfig as getTableConfig$1, PgDatabase } from 'drizzle-orm/pg-core';
+import { PgSmallInt, PgInteger, PgBigInt53, PgBigInt64, PgSmallSerial, PgSerial, PgBigSerial53, PgBigSerial64, PgTable, getTableConfig as getTableConfig$1, PgDatabase } from 'drizzle-orm/pg-core';
 import { SQLiteTable, getTableConfig as getTableConfig$3, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 import { MsSqlTable, getTableConfig as getTableConfig$5, MsSqlDatabase } from 'drizzle-orm/mssql-core';
 import { CockroachTable, getTableConfig as getTableConfig$4, CockroachDatabase } from 'drizzle-orm/cockroach-core';
@@ -40,6 +40,17 @@ const isRelationCyclic = (startRel) => {
 const equalSets = (set1, set2) => {
     return set1.size === set2.size && [...set1].every((si) => set2.has(si));
 };
+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);
+};
 
 const getTableConfig = (table) => {
     if (is(table, PgTable))
@@ -131429,6 +131440,9 @@ const isObject = (value) => {
         return true;
     return false;
 };
+const isValidDate = (date) => {
+    return !Number.isNaN(date.getTime());
+};
 // const main = () => {
 // 	console.time('range');
 // 	const range = new OrderedBigintRange(BigInt(-10), BigInt(10), BigInt(1));
@@ -132147,13 +132161,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);
@@ -132166,6 +132187,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() {
@@ -132187,18 +132211,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, '');
     }
 }
@@ -132208,18 +132297,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()
@@ -132235,18 +132352,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()
@@ -134461,6 +134606,49 @@ class GenerateHashFromStringV3 extends AbstractGenerator {
     }
 }
 
+/* eslint-disable drizzle-internal/require-entity-kind */
+class GenerateUUIDV4 extends AbstractGenerator {
+    static entityKind = 'GenerateUUID';
+    static version = 4;
+    isGeneratorUnique = true;
+    maxUniqueCount = Number.POSITIVE_INFINITY;
+    state;
+    getMaxUniqueCount() {
+        return Number.POSITIVE_INFINITY;
+    }
+    init({ count, seed }) {
+        super.init({ count, seed });
+        const rng = prand.xoroshiro128plus(seed);
+        this.state = { rng };
+    }
+    generate() {
+        if (this.state === undefined) {
+            throw new Error('state is not defined.');
+        }
+        // TODO generate uuid using string generator
+        const stringChars = '1234567890abcdef';
+        let idx, currStr;
+        const strLength = 36;
+        // uuid v4
+        const uuidTemplate = '########-####-4###-N###-############';
+        currStr = '';
+        for (let i = 0; i < strLength; i++) {
+            [idx, this.state.rng] = prand.uniformIntDistribution(0, stringChars.length - 1, this.state.rng);
+            if (uuidTemplate[i] === '#') {
+                currStr += stringChars[idx];
+                continue;
+            }
+            // used this pr -> https://github.com/drizzle-team/drizzle-orm/pull/4503
+            if (uuidTemplate[i] === 'N') {
+                currStr += '89ab'[idx % 4];
+                continue;
+            }
+            currStr += uuidTemplate[i];
+        }
+        return currStr;
+    }
+}
+
 function createGenerator(generatorConstructor) {
     return (...args) => {
         let params = args[0];
@@ -134626,6 +134814,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
@@ -134633,7 +134823,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" })
      *      },
      *    },
      *  }));
@@ -134643,6 +134833,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
@@ -134650,7 +134842,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" })
      *      },
      *    },
      *  }));
@@ -134660,6 +134852,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
@@ -134667,7 +134861,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" })
      *      },
      *    },
      *  }));
@@ -135252,13 +135446,16 @@ const generatorsFuncs = {
      */
     vector: createGenerator(GenerateVector),
 };
-// so far, version changes don’t affect generator parameters.
+// so far, version changes don’t change generator parameters.
 const generatorsFuncsV2 = {
     ...generatorsFuncs,
 };
 ({
     ...generatorsFuncs,
 });
+({
+    ...generatorsFuncs,
+});
 const generatorsMap = {
     GenerateHashFromString: [
         GenerateHashFromString,
@@ -135332,6 +135529,7 @@ const generatorsMap = {
     ],
     GenerateUUID: [
         GenerateUUID,
+        GenerateUUIDV4,
     ],
     GenerateFirstName: [
         GenerateFirstName,
@@ -135662,7 +135860,7 @@ const selectGeneratorForCockroachColumn = (table, col) => {
     return generator;
 };
 
-const latestVersion = 3;
+const latestVersion = 4;
 
 const selectGeneratorForMssqlColumn = (table, col) => {
     const pickGenerator = (table, col) => {
@@ -136552,6 +136750,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;
@@ -136613,6 +136812,7 @@ class SeedService {
                     wasDefinedBefore: false,
                     wasRefined: false,
                 };
+                // handling refinements (columnGenerator)
                 if (refinements !== undefined
                     && refinements[table.name] !== undefined
                     && refinements[table.name].columns !== undefined
@@ -136625,7 +136825,7 @@ class SeedService {
                                 + `\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.
+                        // will result in null of default value being inserted into that column.
                         columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: undefined });
                         columnPossibleGenerator.wasRefined = true;
                         continue;
@@ -136963,7 +137163,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
@@ -137101,6 +137302,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$1(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
@@ -137131,6 +137351,12 @@ class SeedService {
             for (const columnName of Object.keys(columnsGenerators)) {
                 generatedValue = columnsGenerators[columnName].generate({ i, columnName });
                 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)) {
@@ -137177,9 +137403,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]);
@@ -137905,7 +138150,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: {
@@ -137926,6 +138171,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) {
@@ -137997,6 +138253,10 @@ const seedFunc = async (db, schema, options = {}, refinements) => {
  * @example
  * ```ts
  * await reset(db, schema);
+ *
+ * // Alternatively, you can provide an object containing your tables
+ * // as the `schema` parameter when calling `reset`.
+ * await reset(db, { users });
  * ```
  */
 async function reset(db, schema) {