drizzle-seed 0.4.0-08e4e66 → 0.4.0-0ec754e

package/generators/Generators.d.cts

@@ -31,14 +31,22 @@ export declare abstract class AbstractGenerator<T = {}> {
     }): void;
     updateParams(): void;
     abstract generate(params: {
-        i: number;
+        i?: number;
         columnName?: string;
+        input?: string;
     }): number | string | boolean | unknown | undefined | void;
     getEntityKind(): string;
     getMaxUniqueCount(): number;
     replaceIfUnique(): AbstractGenerator<T> | undefined;
     replaceIfArray(): GenerateArray | undefined;
 }
+export declare class GenerateHashFromString extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    init(): void;
+    generate({ input }: {
+        input: string;
+    }): number;
+}
 export declare class GenerateArray extends AbstractGenerator<{
     baseColumnGen: AbstractGenerator<any>;
     size?: number;

package/generators/Generators.d.mts

@@ -31,14 +31,22 @@ export declare abstract class AbstractGenerator<T = {}> {
     }): void;
     updateParams(): void;
     abstract generate(params: {
-        i: number;
+        i?: number;
         columnName?: string;
+        input?: string;
     }): number | string | boolean | unknown | undefined | void;
     getEntityKind(): string;
     getMaxUniqueCount(): number;
     replaceIfUnique(): AbstractGenerator<T> | undefined;
     replaceIfArray(): GenerateArray | undefined;
 }
+export declare class GenerateHashFromString extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    init(): void;
+    generate({ input }: {
+        input: string;
+    }): number;
+}
 export declare class GenerateArray extends AbstractGenerator<{
     baseColumnGen: AbstractGenerator<any>;
     size?: number;

package/generators/Generators.d.ts

@@ -31,14 +31,22 @@ export declare abstract class AbstractGenerator<T = {}> {
     }): void;
     updateParams(): void;
     abstract generate(params: {
-        i: number;
+        i?: number;
         columnName?: string;
+        input?: string;
     }): number | string | boolean | unknown | undefined | void;
     getEntityKind(): string;
     getMaxUniqueCount(): number;
     replaceIfUnique(): AbstractGenerator<T> | undefined;
     replaceIfArray(): GenerateArray | undefined;
 }
+export declare class GenerateHashFromString extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    init(): void;
+    generate({ input }: {
+        input: string;
+    }): number;
+}
 export declare class GenerateArray extends AbstractGenerator<{
     baseColumnGen: AbstractGenerator<any>;
     size?: number;

package/generators/apiVersion.d.cts

@@ -1 +1 @@
-export declare const latestVersion = 2;
+export declare const latestVersion = 3;

package/generators/apiVersion.d.mts

@@ -1 +1 @@
-export declare const latestVersion = 2;
+export declare const latestVersion = 3;

package/generators/apiVersion.d.ts

@@ -1 +1 @@
-export declare const latestVersion = 2;
+export declare const latestVersion = 3;

package/generators/versioning/v3.d.cts

@@ -0,0 +1,10 @@
+import { AbstractGenerator } from '../Generators.js';
+export declare class GenerateHashFromStringV3 extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    static readonly version: number;
+    init(): void;
+    generate({ input }: {
+        i: number;
+        input: string;
+    }): number;
+}

package/generators/versioning/v3.d.mts

@@ -0,0 +1,10 @@
+import { AbstractGenerator } from '../Generators.js';
+export declare class GenerateHashFromStringV3 extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    static readonly version: number;
+    init(): void;
+    generate({ input }: {
+        i: number;
+        input: string;
+    }): number;
+}

package/generators/versioning/v3.d.ts

@@ -0,0 +1,10 @@
+import { AbstractGenerator } from '../Generators.js';
+export declare class GenerateHashFromStringV3 extends AbstractGenerator<{}> {
+    static readonly entityKind: string;
+    static readonly version: number;
+    init(): void;
+    generate({ input }: {
+        i: number;
+        input: string;
+    }): number;
+}

package/index.cjs

@@ -39,16 +39,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));
 };
@@ -131544,6 +131534,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;
@@ -134440,6 +134444,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];
@@ -135235,7 +135258,14 @@ const generatorsFuncs = {
 const generatorsFuncsV2 = {
     ...generatorsFuncs,
 };
+({
+    ...generatorsFuncs,
+});
 const generatorsMap = {
+    GenerateHashFromString: [
+        GenerateHashFromString,
+        GenerateHashFromStringV3,
+    ],
     HollowGenerator: [
         HollowGenerator,
     ],
@@ -135634,7 +135664,7 @@ const selectGeneratorForCockroachColumn = (table, col) => {
     return generator;
 };
 
-const latestVersion = 2;
+const latestVersion = 3;
 
 const selectGeneratorForMssqlColumn = (table, col) => {
     const pickGenerator = (table, col) => {
@@ -136483,6 +136513,7 @@ class SeedService {
     sqliteMaxParametersNumber = 32766;
     mssqlMaxParametersNumber = 2100;
     version;
+    hashFromStringGenerator;
     generatePossibleGenerators = (connectionType, tables, relations, refinements, options) => {
         let columnPossibleGenerator;
         let tablePossibleGenerators;
@@ -136491,6 +136522,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);
@@ -136552,7 +136584,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);
                             }
@@ -136588,6 +136620,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
@@ -136909,10 +136953,12 @@ class SeedService {
                 pRNGSeed = (columnRelations.length !== 0
                     && columnRelations[0].columns.length >= 2)
                     ? (customSeed
-                        + generateHashFromString(`${columnRelations[0].table}.${columnRelations[0].columns.join('_')}`))
+                        + this.hashFromStringGenerator.generate({
+                            input: `${columnRelations[0].table}.${columnRelations[0].columns.join('_')}`,
+                        }))
                     : col.generator?.uniqueKey === undefined
-                        ? (customSeed + generateHashFromString(`${table.tableName}.${col.columnName}`))
-                        : (customSeed + generateHashFromString(col.generator.uniqueKey));
+                        ? (customSeed + this.hashFromStringGenerator.generate({ input: `${table.tableName}.${col.columnName}` }))
+                        : (customSeed + this.hashFromStringGenerator.generate({ input: col.generator.uniqueKey }));
                 tableGenerators[col.columnName] = {
                     pRNGSeed,
                     ...col,
@@ -136934,7 +136980,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],