drizzle-seed 0.1.2 → 0.1.3-e14a5a2

package/services/SeedService.d.cts

@@ -6,8 +6,9 @@ import { PgDatabase } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 import type { GeneratePossibleGeneratorsColumnType, RefinementsType, TableGeneratorsType } from '../types/seedService.js';
-import type { Column, Prettify, Relation, Table } from '../types/tables.js';
+import type { Column, Prettify, Relation, RelationWithReferences, Table } from '../types/tables.js';
 import type { AbstractGenerator } from './GeneratorsWrappers.js';
+import { GenerateBoolean, GenerateDate, GenerateDatetime, GenerateDefault, GenerateEmail, GenerateEnum, GenerateFirstName, GenerateInt, GenerateIntPrimaryKey, GenerateJson, GenerateNumber, GenerateString, GenerateTime, GenerateTimestamp, GenerateUniqueString, GenerateYear } from './GeneratorsWrappers.js';
 declare class SeedService {
     static readonly [entityKind]: string;
     private defaultCountForTable;
@@ -15,7 +16,11 @@ declare class SeedService {
     private postgresMaxParametersNumber;
     private mysqlMaxParametersNumber;
     private sqliteMaxParametersNumber;
-    generatePossibleGenerators: (connectionType: "postgresql" | "mysql" | "sqlite", tables: Table[], relations: Relation[], refinements?: RefinementsType, options?: {
+    generatePossibleGenerators: (connectionType: "postgresql" | "mysql" | "sqlite", tables: Table[], relations: (Relation & {
+        isCyclic: boolean;
+    })[], tableRelations: {
+        [tableName: string]: RelationWithReferences[];
+    }, refinements?: RefinementsType, options?: {
         count?: number;
         seed?: number;
     }) => {
@@ -33,56 +38,84 @@ declare class SeedService {
         };
         columnsPossibleGenerators: GeneratePossibleGeneratorsColumnType[];
     }[];
-    getOrderedTablesList: (tablesInOutRelations: ReturnType<typeof this.getTablesInOutRelations>) => string[];
-    getTablesInOutRelations: (relations: Relation[]) => {
-        [tableName: string]: {
-            out: number;
-            in: number;
-            selfRelation: boolean;
-            selfRelCount: number;
-            requiredTableNames: Set<string>;
-            dependantTableNames: Set<string>;
+    cyclicTablesCompare: (table1: Table, table2: Table, relation: Relation & {
+        isCyclic: boolean;
+    }, reverseRelation: (Relation & {
+        isCyclic: boolean;
+    }) | undefined) => 1 | 0 | -1;
+    getOrderedTablesList: (tablesInOutRelations: ReturnType<typeof this.getInfoFromRelations>["tablesInOutRelations"]) => string[];
+    getInfoFromRelations: (relations: (Relation & {
+        isCyclic: boolean;
+    })[]) => {
+        tablesInOutRelations: {
+            [tableName: string]: {
+                out: number;
+                in: number;
+                selfRelation: boolean;
+                selfRelCount: number;
+                requiredTableNames: Set<string>;
+                dependantTableNames: Set<string>;
+            };
         };
     };
     getWeightedWithCount: (weightedCount: {
         weight: number;
         count: number | number[];
     }[], count: number, seed: number) => number;
-    pickGeneratorForPostgresColumn: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
-    };
-    pickGeneratorForMysqlColumn: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
-    };
-    pickGeneratorForSqlite: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
+    pickGeneratorForPostgresColumn: (table: Table, col: Column) => AbstractGenerator<any> | undefined;
+    pickGeneratorForMysqlColumn: (table: Table, col: Column) => GenerateDefault | GenerateIntPrimaryKey | GenerateNumber | GenerateInt | GenerateBoolean | GenerateDate | GenerateTime | GenerateTimestamp | GenerateDatetime | GenerateYear | GenerateJson | GenerateEmail | GenerateFirstName | GenerateEnum | GenerateString | GenerateUniqueString | undefined;
+    pickGeneratorForSqlite: (table: Table, col: Column) => GenerateDefault | GenerateIntPrimaryKey | GenerateNumber | GenerateInt | GenerateBoolean | GenerateTimestamp | GenerateJson | GenerateEmail | GenerateFirstName | GenerateString | GenerateUniqueString | undefined;
+    filterCyclicTables: (tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>) => {
+        filteredTablesGenerators: {
+            tableName: string;
+            count?: number | undefined;
+            withCount?: number | undefined;
+            withFromTable: {
+                [withFromTableName: string]: {
+                    repeatedValuesCount: number | {
+                        weight: number;
+                        count: number | number[];
+                    }[];
+                    weightedCountSeed?: number;
+                };
+            };
+            columnsPossibleGenerators: GeneratePossibleGeneratorsColumnType[];
+        }[];
+        tablesUniqueNotNullColumn: {
+            [tableName: string]: {
+                uniqueNotNullColName: string;
+            };
+        };
     };
-    generateTablesValues: (relations: Relation[], tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>, db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>, schema?: {
+    generateTablesValues: (relations: (Relation & {
+        isCyclic: boolean;
+    })[], tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>, db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>, schema?: {
         [key: string]: PgTable | MySqlTable | SQLiteTable;
     }, options?: {
         count?: number;
         seed?: number;
         preserveData?: boolean;
+        preserveCyclicTablesData?: boolean;
         insertDataInDb?: boolean;
+        updateDataInDb?: boolean;
+        tablesValues?: {
+            tableName: string;
+            rows: {
+                [columnName: string]: string | number | boolean | undefined;
+            }[];
+        }[];
+        tablesUniqueNotNullColumn?: {
+            [tableName: string]: {
+                uniqueNotNullColName: string;
+            };
+        };
     }) => Promise<{
         tableName: string;
         rows: {
             [columnName: string]: string | number | boolean | undefined;
         }[];
     }[]>;
-    generateColumnsValuesByGenerators: ({ tableGenerators, db, schema, tableName, count, preserveData, insertDataInDb, batchSize, }: {
+    generateColumnsValuesByGenerators: ({ tableGenerators, db, schema, tableName, count, preserveData, insertDataInDb, updateDataInDb, uniqueNotNullColName, batchSize, }: {
         tableGenerators: Prettify<TableGeneratorsType>;
         db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
         schema?: {
@@ -92,6 +125,8 @@ declare class SeedService {
         count?: number;
         preserveData?: boolean;
         insertDataInDb?: boolean;
+        updateDataInDb?: boolean;
+        uniqueNotNullColName?: string;
         batchSize?: number;
     }) => Promise<{
         [columnName: string]: string | number | boolean | undefined;
@@ -100,13 +135,24 @@ declare class SeedService {
         generatedValues: {
             [columnName: string]: number | string | boolean | undefined;
         }[];
-        db: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
+        db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
         schema: {
             [key: string]: PgTable | MySqlTable | SQLiteTable;
         };
         tableName: string;
         override: boolean;
     }) => Promise<any>;
+    updateDb: ({ generatedValues, db, schema, tableName, uniqueNotNullColName, }: {
+        generatedValues: {
+            [columnName: string]: number | string | boolean | undefined;
+        }[];
+        db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
+        schema: {
+            [key: string]: PgTable | MySqlTable | SQLiteTable;
+        };
+        tableName: string;
+        uniqueNotNullColName: string;
+    }) => Promise<void>;
 }
 declare const _default: SeedService;
 export default _default;

package/services/SeedService.d.mts

@@ -6,8 +6,9 @@ import { PgDatabase } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 import type { GeneratePossibleGeneratorsColumnType, RefinementsType, TableGeneratorsType } from '../types/seedService.js';
-import type { Column, Prettify, Relation, Table } from '../types/tables.js';
+import type { Column, Prettify, Relation, RelationWithReferences, Table } from '../types/tables.js';
 import type { AbstractGenerator } from './GeneratorsWrappers.js';
+import { GenerateBoolean, GenerateDate, GenerateDatetime, GenerateDefault, GenerateEmail, GenerateEnum, GenerateFirstName, GenerateInt, GenerateIntPrimaryKey, GenerateJson, GenerateNumber, GenerateString, GenerateTime, GenerateTimestamp, GenerateUniqueString, GenerateYear } from './GeneratorsWrappers.js';
 declare class SeedService {
     static readonly [entityKind]: string;
     private defaultCountForTable;
@@ -15,7 +16,11 @@ declare class SeedService {
     private postgresMaxParametersNumber;
     private mysqlMaxParametersNumber;
     private sqliteMaxParametersNumber;
-    generatePossibleGenerators: (connectionType: "postgresql" | "mysql" | "sqlite", tables: Table[], relations: Relation[], refinements?: RefinementsType, options?: {
+    generatePossibleGenerators: (connectionType: "postgresql" | "mysql" | "sqlite", tables: Table[], relations: (Relation & {
+        isCyclic: boolean;
+    })[], tableRelations: {
+        [tableName: string]: RelationWithReferences[];
+    }, refinements?: RefinementsType, options?: {
         count?: number;
         seed?: number;
     }) => {
@@ -33,56 +38,84 @@ declare class SeedService {
         };
         columnsPossibleGenerators: GeneratePossibleGeneratorsColumnType[];
     }[];
-    getOrderedTablesList: (tablesInOutRelations: ReturnType<typeof this.getTablesInOutRelations>) => string[];
-    getTablesInOutRelations: (relations: Relation[]) => {
-        [tableName: string]: {
-            out: number;
-            in: number;
-            selfRelation: boolean;
-            selfRelCount: number;
-            requiredTableNames: Set<string>;
-            dependantTableNames: Set<string>;
+    cyclicTablesCompare: (table1: Table, table2: Table, relation: Relation & {
+        isCyclic: boolean;
+    }, reverseRelation: (Relation & {
+        isCyclic: boolean;
+    }) | undefined) => 1 | 0 | -1;
+    getOrderedTablesList: (tablesInOutRelations: ReturnType<typeof this.getInfoFromRelations>["tablesInOutRelations"]) => string[];
+    getInfoFromRelations: (relations: (Relation & {
+        isCyclic: boolean;
+    })[]) => {
+        tablesInOutRelations: {
+            [tableName: string]: {
+                out: number;
+                in: number;
+                selfRelation: boolean;
+                selfRelCount: number;
+                requiredTableNames: Set<string>;
+                dependantTableNames: Set<string>;
+            };
         };
     };
     getWeightedWithCount: (weightedCount: {
         weight: number;
         count: number | number[];
     }[], count: number, seed: number) => number;
-    pickGeneratorForPostgresColumn: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
-    };
-    pickGeneratorForMysqlColumn: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
-    };
-    pickGeneratorForSqlite: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
+    pickGeneratorForPostgresColumn: (table: Table, col: Column) => AbstractGenerator<any> | undefined;
+    pickGeneratorForMysqlColumn: (table: Table, col: Column) => GenerateDefault | GenerateIntPrimaryKey | GenerateNumber | GenerateInt | GenerateBoolean | GenerateDate | GenerateTime | GenerateTimestamp | GenerateDatetime | GenerateYear | GenerateJson | GenerateEmail | GenerateFirstName | GenerateEnum | GenerateString | GenerateUniqueString | undefined;
+    pickGeneratorForSqlite: (table: Table, col: Column) => GenerateDefault | GenerateIntPrimaryKey | GenerateNumber | GenerateInt | GenerateBoolean | GenerateTimestamp | GenerateJson | GenerateEmail | GenerateFirstName | GenerateString | GenerateUniqueString | undefined;
+    filterCyclicTables: (tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>) => {
+        filteredTablesGenerators: {
+            tableName: string;
+            count?: number | undefined;
+            withCount?: number | undefined;
+            withFromTable: {
+                [withFromTableName: string]: {
+                    repeatedValuesCount: number | {
+                        weight: number;
+                        count: number | number[];
+                    }[];
+                    weightedCountSeed?: number;
+                };
+            };
+            columnsPossibleGenerators: GeneratePossibleGeneratorsColumnType[];
+        }[];
+        tablesUniqueNotNullColumn: {
+            [tableName: string]: {
+                uniqueNotNullColName: string;
+            };
+        };
     };
-    generateTablesValues: (relations: Relation[], tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>, db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>, schema?: {
+    generateTablesValues: (relations: (Relation & {
+        isCyclic: boolean;
+    })[], tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>, db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>, schema?: {
         [key: string]: PgTable | MySqlTable | SQLiteTable;
     }, options?: {
         count?: number;
         seed?: number;
         preserveData?: boolean;
+        preserveCyclicTablesData?: boolean;
         insertDataInDb?: boolean;
+        updateDataInDb?: boolean;
+        tablesValues?: {
+            tableName: string;
+            rows: {
+                [columnName: string]: string | number | boolean | undefined;
+            }[];
+        }[];
+        tablesUniqueNotNullColumn?: {
+            [tableName: string]: {
+                uniqueNotNullColName: string;
+            };
+        };
     }) => Promise<{
         tableName: string;
         rows: {
             [columnName: string]: string | number | boolean | undefined;
         }[];
     }[]>;
-    generateColumnsValuesByGenerators: ({ tableGenerators, db, schema, tableName, count, preserveData, insertDataInDb, batchSize, }: {
+    generateColumnsValuesByGenerators: ({ tableGenerators, db, schema, tableName, count, preserveData, insertDataInDb, updateDataInDb, uniqueNotNullColName, batchSize, }: {
         tableGenerators: Prettify<TableGeneratorsType>;
         db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
         schema?: {
@@ -92,6 +125,8 @@ declare class SeedService {
         count?: number;
         preserveData?: boolean;
         insertDataInDb?: boolean;
+        updateDataInDb?: boolean;
+        uniqueNotNullColName?: string;
         batchSize?: number;
     }) => Promise<{
         [columnName: string]: string | number | boolean | undefined;
@@ -100,13 +135,24 @@ declare class SeedService {
         generatedValues: {
             [columnName: string]: number | string | boolean | undefined;
         }[];
-        db: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
+        db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
         schema: {
             [key: string]: PgTable | MySqlTable | SQLiteTable;
         };
         tableName: string;
         override: boolean;
     }) => Promise<any>;
+    updateDb: ({ generatedValues, db, schema, tableName, uniqueNotNullColName, }: {
+        generatedValues: {
+            [columnName: string]: number | string | boolean | undefined;
+        }[];
+        db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
+        schema: {
+            [key: string]: PgTable | MySqlTable | SQLiteTable;
+        };
+        tableName: string;
+        uniqueNotNullColName: string;
+    }) => Promise<void>;
 }
 declare const _default: SeedService;
 export default _default;

package/services/SeedService.d.ts

@@ -6,8 +6,9 @@ import { PgDatabase } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 import type { GeneratePossibleGeneratorsColumnType, RefinementsType, TableGeneratorsType } from '../types/seedService.js';
-import type { Column, Prettify, Relation, Table } from '../types/tables.js';
+import type { Column, Prettify, Relation, RelationWithReferences, Table } from '../types/tables.js';
 import type { AbstractGenerator } from './GeneratorsWrappers.js';
+import { GenerateBoolean, GenerateDate, GenerateDatetime, GenerateDefault, GenerateEmail, GenerateEnum, GenerateFirstName, GenerateInt, GenerateIntPrimaryKey, GenerateJson, GenerateNumber, GenerateString, GenerateTime, GenerateTimestamp, GenerateUniqueString, GenerateYear } from './GeneratorsWrappers.js';
 declare class SeedService {
     static readonly [entityKind]: string;
     private defaultCountForTable;
@@ -15,7 +16,11 @@ declare class SeedService {
     private postgresMaxParametersNumber;
     private mysqlMaxParametersNumber;
     private sqliteMaxParametersNumber;
-    generatePossibleGenerators: (connectionType: "postgresql" | "mysql" | "sqlite", tables: Table[], relations: Relation[], refinements?: RefinementsType, options?: {
+    generatePossibleGenerators: (connectionType: "postgresql" | "mysql" | "sqlite", tables: Table[], relations: (Relation & {
+        isCyclic: boolean;
+    })[], tableRelations: {
+        [tableName: string]: RelationWithReferences[];
+    }, refinements?: RefinementsType, options?: {
         count?: number;
         seed?: number;
     }) => {
@@ -33,56 +38,84 @@ declare class SeedService {
         };
         columnsPossibleGenerators: GeneratePossibleGeneratorsColumnType[];
     }[];
-    getOrderedTablesList: (tablesInOutRelations: ReturnType<typeof this.getTablesInOutRelations>) => string[];
-    getTablesInOutRelations: (relations: Relation[]) => {
-        [tableName: string]: {
-            out: number;
-            in: number;
-            selfRelation: boolean;
-            selfRelCount: number;
-            requiredTableNames: Set<string>;
-            dependantTableNames: Set<string>;
+    cyclicTablesCompare: (table1: Table, table2: Table, relation: Relation & {
+        isCyclic: boolean;
+    }, reverseRelation: (Relation & {
+        isCyclic: boolean;
+    }) | undefined) => 1 | 0 | -1;
+    getOrderedTablesList: (tablesInOutRelations: ReturnType<typeof this.getInfoFromRelations>["tablesInOutRelations"]) => string[];
+    getInfoFromRelations: (relations: (Relation & {
+        isCyclic: boolean;
+    })[]) => {
+        tablesInOutRelations: {
+            [tableName: string]: {
+                out: number;
+                in: number;
+                selfRelation: boolean;
+                selfRelCount: number;
+                requiredTableNames: Set<string>;
+                dependantTableNames: Set<string>;
+            };
         };
     };
     getWeightedWithCount: (weightedCount: {
         weight: number;
         count: number | number[];
     }[], count: number, seed: number) => number;
-    pickGeneratorForPostgresColumn: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
-    };
-    pickGeneratorForMysqlColumn: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
-    };
-    pickGeneratorForSqlite: (columnPossibleGenerator: Prettify<GeneratePossibleGeneratorsColumnType>, table: Table, col: Column) => {
-        columnName: string;
-        generator: AbstractGenerator<any> | undefined;
-        isUnique: boolean;
-        notNull: boolean;
-        generatedIdentityType?: "always" | "byDefault" | undefined;
+    pickGeneratorForPostgresColumn: (table: Table, col: Column) => AbstractGenerator<any> | undefined;
+    pickGeneratorForMysqlColumn: (table: Table, col: Column) => GenerateDefault | GenerateIntPrimaryKey | GenerateNumber | GenerateInt | GenerateBoolean | GenerateDate | GenerateTime | GenerateTimestamp | GenerateDatetime | GenerateYear | GenerateJson | GenerateEmail | GenerateFirstName | GenerateEnum | GenerateString | GenerateUniqueString | undefined;
+    pickGeneratorForSqlite: (table: Table, col: Column) => GenerateDefault | GenerateIntPrimaryKey | GenerateNumber | GenerateInt | GenerateBoolean | GenerateTimestamp | GenerateJson | GenerateEmail | GenerateFirstName | GenerateString | GenerateUniqueString | undefined;
+    filterCyclicTables: (tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>) => {
+        filteredTablesGenerators: {
+            tableName: string;
+            count?: number | undefined;
+            withCount?: number | undefined;
+            withFromTable: {
+                [withFromTableName: string]: {
+                    repeatedValuesCount: number | {
+                        weight: number;
+                        count: number | number[];
+                    }[];
+                    weightedCountSeed?: number;
+                };
+            };
+            columnsPossibleGenerators: GeneratePossibleGeneratorsColumnType[];
+        }[];
+        tablesUniqueNotNullColumn: {
+            [tableName: string]: {
+                uniqueNotNullColName: string;
+            };
+        };
     };
-    generateTablesValues: (relations: Relation[], tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>, db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>, schema?: {
+    generateTablesValues: (relations: (Relation & {
+        isCyclic: boolean;
+    })[], tablesGenerators: ReturnType<typeof this.generatePossibleGenerators>, db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>, schema?: {
         [key: string]: PgTable | MySqlTable | SQLiteTable;
     }, options?: {
         count?: number;
         seed?: number;
         preserveData?: boolean;
+        preserveCyclicTablesData?: boolean;
         insertDataInDb?: boolean;
+        updateDataInDb?: boolean;
+        tablesValues?: {
+            tableName: string;
+            rows: {
+                [columnName: string]: string | number | boolean | undefined;
+            }[];
+        }[];
+        tablesUniqueNotNullColumn?: {
+            [tableName: string]: {
+                uniqueNotNullColName: string;
+            };
+        };
     }) => Promise<{
         tableName: string;
         rows: {
             [columnName: string]: string | number | boolean | undefined;
         }[];
     }[]>;
-    generateColumnsValuesByGenerators: ({ tableGenerators, db, schema, tableName, count, preserveData, insertDataInDb, batchSize, }: {
+    generateColumnsValuesByGenerators: ({ tableGenerators, db, schema, tableName, count, preserveData, insertDataInDb, updateDataInDb, uniqueNotNullColName, batchSize, }: {
         tableGenerators: Prettify<TableGeneratorsType>;
         db?: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
         schema?: {
@@ -92,6 +125,8 @@ declare class SeedService {
         count?: number;
         preserveData?: boolean;
         insertDataInDb?: boolean;
+        updateDataInDb?: boolean;
+        uniqueNotNullColName?: string;
         batchSize?: number;
     }) => Promise<{
         [columnName: string]: string | number | boolean | undefined;
@@ -100,13 +135,24 @@ declare class SeedService {
         generatedValues: {
             [columnName: string]: number | string | boolean | undefined;
         }[];
-        db: PgDatabase<any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
+        db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
         schema: {
             [key: string]: PgTable | MySqlTable | SQLiteTable;
         };
         tableName: string;
         override: boolean;
     }) => Promise<any>;
+    updateDb: ({ generatedValues, db, schema, tableName, uniqueNotNullColName, }: {
+        generatedValues: {
+            [columnName: string]: number | string | boolean | undefined;
+        }[];
+        db: PgDatabase<any, any> | MySqlDatabase<any, any> | BaseSQLiteDatabase<any, any>;
+        schema: {
+            [key: string]: PgTable | MySqlTable | SQLiteTable;
+        };
+        tableName: string;
+        uniqueNotNullColName: string;
+    }) => Promise<void>;
 }
 declare const _default: SeedService;
 export default _default;

package/services/utils.d.cts

@@ -18,3 +18,5 @@ export declare const fillTemplate: ({ template, placeholdersCount, values, defau
     values: string[];
     defaultValue?: string;
 }) => string;
+export declare const isObject: (value: any) => boolean;
+export declare const equalSets: (set1: Set<any>, set2: Set<any>) => boolean;

package/services/utils.d.mts

@@ -18,3 +18,5 @@ export declare const fillTemplate: ({ template, placeholdersCount, values, defau
     values: string[];
     defaultValue?: string;
 }) => string;
+export declare const isObject: (value: any) => boolean;
+export declare const equalSets: (set1: Set<any>, set2: Set<any>) => boolean;

package/services/utils.d.ts

@@ -18,3 +18,5 @@ export declare const fillTemplate: ({ template, placeholdersCount, values, defau
     values: string[];
     defaultValue?: string;
 }) => string;
+export declare const isObject: (value: any) => boolean;
+export declare const equalSets: (set1: Set<any>, set2: Set<any>) => boolean;

package/types/seedService.d.cts

@@ -12,7 +12,11 @@ export type GeneratePossibleGeneratorsColumnType = {
     generator: AbstractGenerator<any> | undefined;
     isUnique: boolean;
     notNull: boolean;
+    primary: boolean;
     generatedIdentityType?: 'always' | 'byDefault' | undefined;
+    wasRefined: boolean;
+    wasDefinedBefore: boolean;
+    isCyclic: boolean;
 };
 export type GeneratePossibleGeneratorsTableType = Prettify<{
     tableName: string;

package/types/seedService.d.mts

@@ -12,7 +12,11 @@ export type GeneratePossibleGeneratorsColumnType = {
     generator: AbstractGenerator<any> | undefined;
     isUnique: boolean;
     notNull: boolean;
+    primary: boolean;
     generatedIdentityType?: 'always' | 'byDefault' | undefined;
+    wasRefined: boolean;
+    wasDefinedBefore: boolean;
+    isCyclic: boolean;
 };
 export type GeneratePossibleGeneratorsTableType = Prettify<{
     tableName: string;

package/types/seedService.d.ts

@@ -12,7 +12,11 @@ export type GeneratePossibleGeneratorsColumnType = {
     generator: AbstractGenerator<any> | undefined;
     isUnique: boolean;
     notNull: boolean;
+    primary: boolean;
     generatedIdentityType?: 'always' | 'byDefault' | undefined;
+    wasRefined: boolean;
+    wasDefinedBefore: boolean;
+    isCyclic: boolean;
 };
 export type GeneratePossibleGeneratorsTableType = Prettify<{
     tableName: string;

package/types/tables.d.cts

@@ -2,12 +2,15 @@ export type Column = {
     name: string;
     dataType: string;
     columnType: string;
+    size?: number;
     default?: any;
     hasDefault: boolean;
     enumValues?: string[];
     isUnique: boolean;
     notNull: boolean;
+    primary: boolean;
     generatedIdentityType?: 'always' | 'byDefault' | undefined;
+    baseColumn?: Omit<Column, 'generatedIdentityType'>;
 };
 export type Table = {
     name: string;
@@ -20,6 +23,10 @@ export type Relation = {
     refTable: string;
     refColumns: string[];
 };
+export type RelationWithReferences = Relation & {
+    isCyclic?: boolean;
+    refTableRels: RelationWithReferences[];
+};
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};

package/types/tables.d.mts

@@ -2,12 +2,15 @@ export type Column = {
     name: string;
     dataType: string;
     columnType: string;
+    size?: number;
     default?: any;
     hasDefault: boolean;
     enumValues?: string[];
     isUnique: boolean;
     notNull: boolean;
+    primary: boolean;
     generatedIdentityType?: 'always' | 'byDefault' | undefined;
+    baseColumn?: Omit<Column, 'generatedIdentityType'>;
 };
 export type Table = {
     name: string;
@@ -20,6 +23,10 @@ export type Relation = {
     refTable: string;
     refColumns: string[];
 };
+export type RelationWithReferences = Relation & {
+    isCyclic?: boolean;
+    refTableRels: RelationWithReferences[];
+};
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};