drizzle-seed 0.2.1 → 0.3.0

package/index.cjs

@@ -134254,6 +134254,7 @@ class SeedService {
             const table1Order = orderedTablesNames.indexOf(table1.name), table2Order = orderedTablesNames.indexOf(table2.name);
             return table1Order - table2Order;
         });
+        const tableNamesSet = new Set(tables.map((table) => table.name));
         const tablesPossibleGenerators = tables.map((table) => ({
             tableName: table.name,
             columnsPossibleGenerators: [],
@@ -134284,8 +134285,10 @@ class SeedService {
                         if (!tablesInOutRelations[table.name]?.dependantTableNames.has(fkTableName)) {
                             const reason = tablesInOutRelations[table.name]?.selfRelation === true
                                 ? `"${table.name}" table has self reference`
-                                : `"${fkTableName}" table doesn't have reference to "${table.name}" table`;
-                            throw new Error(`${reason}. you can't specify "${fkTableName}" as parameter in ${table.name}.with object.`);
+                                : `"${fkTableName}" table doesn't have a reference to "${table.name}" table or`
+                                    + `\nyou didn't include your one-to-many relation in the seed function schema`;
+                            throw new Error(`${reason}.` + `\nYou can't specify "${fkTableName}" as parameter in ${table.name}.with object.`
+                                + `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-using-with-option`);
                         }
                         idx = tablesPossibleGenerators.findIndex((table) => table.tableName === fkTableName);
                         if (idx !== -1) {
@@ -134353,15 +134356,23 @@ class SeedService {
                     if (cyclicRelation !== undefined) {
                         columnPossibleGenerator.isCyclic = true;
                     }
-                    if (foreignKeyColumns[col.name]?.table === undefined && col.notNull === true) {
-                        throw new Error(`Column '${col.name}' has no null contraint, and you didn't specify a table for foreign key on column '${col.name}' in '${table.name}' table. You should pass  `);
+                    if ((foreignKeyColumns[col.name]?.table === undefined || !tableNamesSet.has(foreignKeyColumns[col.name].table))
+                        && col.notNull === true) {
+                        throw new Error(`Column '${col.name}' has not null contraint,`
+                            + `\nand you didn't specify a table for foreign key on column '${col.name}' in '${table.name}' table.`
+                            + `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-with-partially-exposed-tables#example-1`);
                     }
-                    const predicate = (cyclicRelation !== undefined || foreignKeyColumns[col.name]?.table === undefined)
+                    const predicate = (cyclicRelation !== undefined
+                        || (foreignKeyColumns[col.name]?.table === undefined
+                            || !tableNamesSet.has(foreignKeyColumns[col.name].table)))
                         && col.notNull === false;
                     if (predicate === true) {
-                        if (foreignKeyColumns[col.name]?.table === undefined && col.notNull === false) {
+                        if ((foreignKeyColumns[col.name]?.table === undefined
+                            || !tableNamesSet.has(foreignKeyColumns[col.name].table)) && col.notNull === false) {
                             console.warn(`Column '${col.name}' in '${table.name}' table will be filled with Null values`
-                                + `\nbecause you specified neither a table for foreign key on column '${col.name}' nor a function for '${col.name}' column in refinements.`);
+                                + `\nbecause you specified neither a table for foreign key on column '${col.name}'`
+                                + `\nnor a function for '${col.name}' column in refinements.`
+                                + `\n\nFor more details, check this: https://orm.drizzle.team/docs/guides/seeding-with-partially-exposed-tables#example-2`);
                         }
                         columnPossibleGenerator.generator = new generatorsMap.GenerateDefault[0]({ defaultValue: null });
                         columnPossibleGenerator.wasDefinedBefore = true;
@@ -135442,16 +135453,13 @@ const seedFunc = async (db, schema, options = {}, refinements) => {
         version = Number(options?.version);
     }
     if (drizzleOrm.is(db, (pgCore.PgDatabase))) {
-        const { pgSchema } = filterPgTables(schema);
-        await seedPostgres(db, pgSchema, { ...options, version }, refinements);
+        await seedPostgres(db, schema, { ...options, version }, refinements);
     }
     else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
-        const { mySqlSchema } = filterMySqlTables(schema);
-        await seedMySql(db, mySqlSchema, { ...options, version }, refinements);
+        await seedMySql(db, schema, { ...options, version }, refinements);
     }
     else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
-        const { sqliteSchema } = filterSqliteTables(schema);
-        await seedSqlite(db, sqliteSchema, { ...options, version }, refinements);
+        await seedSqlite(db, schema, { ...options, version }, refinements);
     }
     else {
         throw new Error('The drizzle-seed package currently supports only PostgreSQL, MySQL, and SQLite databases. Please ensure your database is one of these supported types');
@@ -135500,21 +135508,21 @@ const seedFunc = async (db, schema, options = {}, refinements) => {
  */
 async function reset(db, schema) {
     if (drizzleOrm.is(db, (pgCore.PgDatabase))) {
-        const { pgSchema } = filterPgTables(schema);
-        if (Object.entries(pgSchema).length > 0) {
-            await resetPostgres(db, pgSchema);
+        const { pgTables } = filterPgSchema(schema);
+        if (Object.entries(pgTables).length > 0) {
+            await resetPostgres(db, pgTables);
         }
     }
     else if (drizzleOrm.is(db, (mysqlCore.MySqlDatabase))) {
-        const { mySqlSchema } = filterMySqlTables(schema);
-        if (Object.entries(mySqlSchema).length > 0) {
-            await resetMySql(db, mySqlSchema);
+        const { mysqlTables } = filterMysqlTables(schema);
+        if (Object.entries(mysqlTables).length > 0) {
+            await resetMySql(db, mysqlTables);
         }
     }
     else if (drizzleOrm.is(db, (sqliteCore.BaseSQLiteDatabase))) {
-        const { sqliteSchema } = filterSqliteTables(schema);
-        if (Object.entries(sqliteSchema).length > 0) {
-            await resetSqlite(db, sqliteSchema);
+        const { sqliteTables } = filterSqliteTables(schema);
+        if (Object.entries(sqliteTables).length > 0) {
+            await resetSqlite(db, sqliteTables);
         }
     }
     else {
@@ -135522,32 +135530,34 @@ async function reset(db, schema) {
     }
 }
 // Postgres-----------------------------------------------------------------------------------------------------------
-const resetPostgres = async (db, schema) => {
-    const tablesToTruncate = Object.entries(schema).map(([_, table]) => {
+const resetPostgres = async (db, pgTables) => {
+    const tablesToTruncate = Object.entries(pgTables).map(([_, table]) => {
         const config = pgCore.getTableConfig(table);
         config.schema = config.schema === undefined ? 'public' : config.schema;
         return `"${config.schema}"."${config.name}"`;
     });
     await db.execute(drizzleOrm.sql.raw(`truncate ${tablesToTruncate.join(',')} cascade;`));
 };
-const filterPgTables = (schema) => {
-    const pgSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], pgCore.PgTable)));
-    return { pgSchema };
+const filterPgSchema = (schema) => {
+    const pgSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], pgCore.PgTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const pgTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], pgCore.PgTable)));
+    return { pgSchema, pgTables };
 };
 const seedPostgres = async (db, schema, options = {}, refinements) => {
     const seedService = new SeedService();
-    const { tables, relations } = getPostgresInfo(schema);
+    const { pgSchema, pgTables } = filterPgSchema(schema);
+    const { tables, relations } = getPostgresInfo(pgSchema, pgTables);
     const generatedTablesGenerators = seedService.generatePossibleGenerators('postgresql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, { ...options, preserveCyclicTablesData });
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, pgTables, { ...options, preserveCyclicTablesData });
     const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, schema, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, pgTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getPostgresInfo = (schema) => {
+const getPostgresInfo = (pgSchema, pgTables) => {
     let tableConfig;
     let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(schema).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(pgTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
@@ -135566,7 +135576,48 @@ const getPostgresInfo = (schema) => {
         dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
         return dbToTsColumnNamesMap;
     };
-    for (const table of Object.values(schema)) {
+    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
+        const schemaConfig = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.createTableRelationsHelpers);
+        const relations = [];
+        for (const table of Object.values(schemaConfig.tables)) {
+            if (table.relations !== undefined) {
+                for (const drizzleRel of Object.values(table.relations)) {
+                    if (drizzleOrm.is(drizzleRel, drizzleOrm.One)) {
+                        const tableConfig = pgCore.getTableConfig(drizzleRel.sourceTable);
+                        const tableDbSchema = tableConfig.schema ?? 'public';
+                        const tableDbName = tableConfig.name;
+                        const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
+                        const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
+                        const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
+                            ?? [];
+                        const refTableConfig = pgCore.getTableConfig(drizzleRel.referencedTable);
+                        const refTableDbSchema = refTableConfig.schema ?? 'public';
+                        const refTableDbName = refTableConfig.name;
+                        const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
+                            ?? refTableDbName;
+                        const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
+                        const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
+                            ?? [];
+                        if (tableRelations[refTableTsName] === undefined) {
+                            tableRelations[refTableTsName] = [];
+                        }
+                        const relation = {
+                            table: tableTsName,
+                            columns,
+                            refTable: refTableTsName,
+                            refColumns,
+                            refTableRels: tableRelations[refTableTsName],
+                            type: 'one',
+                        };
+                        relations.push(relation);
+                        tableRelations[tableTsName].push(relation);
+                    }
+                }
+            }
+        }
+        return relations;
+    };
+    for (const table of Object.values(pgTables)) {
         tableConfig = pgCore.getTableConfig(table);
         dbToTsColumnNamesMap = {};
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
@@ -135673,6 +135724,8 @@ const getPostgresInfo = (schema) => {
                 .map((column) => dbToTsColumnNamesMap[column.name]),
         });
     }
+    const transformedDrizzleRelations = transformFromDrizzleRelation(pgSchema, getDbToTsColumnNamesMap, tableRelations);
+    relations.push(...transformedDrizzleRelations);
     const isCyclicRelations = relations.map((relI) => {
         // if (relations.some((relj) => relI.table === relj.refTable && relI.refTable === relj.table)) {
         const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
@@ -135727,24 +135780,26 @@ const resetMySql = async (db, schema) => {
     }
     await db.execute(drizzleOrm.sql.raw('SET FOREIGN_KEY_CHECKS = 1;'));
 };
-const filterMySqlTables = (schema) => {
-    const mySqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable)));
-    return { mySqlSchema };
+const filterMysqlTables = (schema) => {
+    const mysqlSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const mysqlTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], mysqlCore.MySqlTable)));
+    return { mysqlSchema, mysqlTables };
 };
 const seedMySql = async (db, schema, options = {}, refinements) => {
-    const { tables, relations } = getMySqlInfo(schema);
+    const { mysqlSchema, mysqlTables } = filterMysqlTables(schema);
+    const { tables, relations } = getMySqlInfo(mysqlSchema, mysqlTables);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('mysql', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, { ...options, preserveCyclicTablesData });
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, mysqlTables, { ...options, preserveCyclicTablesData });
     const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, schema, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, mysqlTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getMySqlInfo = (schema) => {
+const getMySqlInfo = (mysqlSchema, mysqlTables) => {
     let tableConfig;
     let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(schema).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(mysqlTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
@@ -135763,7 +135818,48 @@ const getMySqlInfo = (schema) => {
         dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
         return dbToTsColumnNamesMap;
     };
-    for (const table of Object.values(schema)) {
+    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
+        const schemaConfig = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.createTableRelationsHelpers);
+        const relations = [];
+        for (const table of Object.values(schemaConfig.tables)) {
+            if (table.relations !== undefined) {
+                for (const drizzleRel of Object.values(table.relations)) {
+                    if (drizzleOrm.is(drizzleRel, drizzleOrm.One)) {
+                        const tableConfig = mysqlCore.getTableConfig(drizzleRel.sourceTable);
+                        const tableDbSchema = tableConfig.schema ?? 'public';
+                        const tableDbName = tableConfig.name;
+                        const tableTsName = schemaConfig.tableNamesMap[`${tableDbSchema}.${tableDbName}`] ?? tableDbName;
+                        const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
+                        const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
+                            ?? [];
+                        const refTableConfig = mysqlCore.getTableConfig(drizzleRel.referencedTable);
+                        const refTableDbSchema = refTableConfig.schema ?? 'public';
+                        const refTableDbName = refTableConfig.name;
+                        const refTableTsName = schemaConfig.tableNamesMap[`${refTableDbSchema}.${refTableDbName}`]
+                            ?? refTableDbName;
+                        const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
+                        const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
+                            ?? [];
+                        if (tableRelations[refTableTsName] === undefined) {
+                            tableRelations[refTableTsName] = [];
+                        }
+                        const relation = {
+                            table: tableTsName,
+                            columns,
+                            refTable: refTableTsName,
+                            refColumns,
+                            refTableRels: tableRelations[refTableTsName],
+                            type: 'one',
+                        };
+                        relations.push(relation);
+                        tableRelations[tableTsName].push(relation);
+                    }
+                }
+            }
+        }
+        return relations;
+    };
+    for (const table of Object.values(mysqlTables)) {
         tableConfig = mysqlCore.getTableConfig(table);
         dbToTsColumnNamesMap = {};
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
@@ -135836,6 +135932,8 @@ const getMySqlInfo = (schema) => {
                 .map((column) => dbToTsColumnNamesMap[column.name]),
         });
     }
+    const transformedDrizzleRelations = transformFromDrizzleRelation(mysqlSchema, getDbToTsColumnNamesMap, tableRelations);
+    relations.push(...transformedDrizzleRelations);
     const isCyclicRelations = relations.map((relI) => {
         const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
         if (isRelationCyclic(relI)) {
@@ -135861,23 +135959,25 @@ const resetSqlite = async (db, schema) => {
     await db.run(drizzleOrm.sql.raw('PRAGMA foreign_keys = ON'));
 };
 const filterSqliteTables = (schema) => {
-    const sqliteSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], sqliteCore.SQLiteTable)));
-    return { sqliteSchema };
+    const sqliteSchema = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], sqliteCore.SQLiteTable) || drizzleOrm.is(keyValue[1], drizzleOrm.Relations)));
+    const sqliteTables = Object.fromEntries(Object.entries(schema).filter((keyValue) => drizzleOrm.is(keyValue[1], sqliteCore.SQLiteTable)));
+    return { sqliteSchema, sqliteTables };
 };
 const seedSqlite = async (db, schema, options = {}, refinements) => {
-    const { tables, relations } = getSqliteInfo(schema);
+    const { sqliteSchema, sqliteTables } = filterSqliteTables(schema);
+    const { tables, relations } = getSqliteInfo(sqliteSchema, sqliteTables);
     const seedService = new SeedService();
     const generatedTablesGenerators = seedService.generatePossibleGenerators('sqlite', tables, relations, refinements, options);
     const preserveCyclicTablesData = relations.some((rel) => rel.isCyclic === true);
-    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, schema, { ...options, preserveCyclicTablesData });
+    const tablesValues = await seedService.generateTablesValues(relations, generatedTablesGenerators, db, sqliteTables, { ...options, preserveCyclicTablesData });
     const { filteredTablesGenerators, tablesUniqueNotNullColumn } = seedService.filterCyclicTables(generatedTablesGenerators);
     const updateDataInDb = filteredTablesGenerators.length === 0 ? false : true;
-    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, schema, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
+    await seedService.generateTablesValues(relations, filteredTablesGenerators, db, sqliteTables, { ...options, tablesValues, updateDataInDb, tablesUniqueNotNullColumn });
 };
-const getSqliteInfo = (schema) => {
+const getSqliteInfo = (sqliteSchema, sqliteTables) => {
     let tableConfig;
     let dbToTsColumnNamesMap;
-    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(schema).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
+    const dbToTsTableNamesMap = Object.fromEntries(Object.entries(sqliteTables).map(([key, value]) => [drizzleOrm.getTableName(value), key]));
     const tables = [];
     const relations = [];
     const dbToTsColumnNamesMapGlobal = {};
@@ -135896,7 +135996,47 @@ const getSqliteInfo = (schema) => {
         dbToTsColumnNamesMapGlobal[tableName] = dbToTsColumnNamesMap;
         return dbToTsColumnNamesMap;
     };
-    for (const table of Object.values(schema)) {
+    const transformFromDrizzleRelation = (schema, getDbToTsColumnNamesMap, tableRelations) => {
+        const schemaConfig = drizzleOrm.extractTablesRelationalConfig(schema, drizzleOrm.createTableRelationsHelpers);
+        const relations = [];
+        for (const table of Object.values(schemaConfig.tables)) {
+            if (table.relations !== undefined) {
+                for (const drizzleRel of Object.values(table.relations)) {
+                    if (drizzleOrm.is(drizzleRel, drizzleOrm.One)) {
+                        const tableConfig = sqliteCore.getTableConfig(drizzleRel.sourceTable);
+                        const tableDbName = tableConfig.name;
+                        // TODO: tableNamesMap: have {public.customer: 'customer'} structure in sqlite
+                        const tableTsName = schemaConfig.tableNamesMap[`public.${tableDbName}`] ?? tableDbName;
+                        const dbToTsColumnNamesMap = getDbToTsColumnNamesMap(drizzleRel.sourceTable);
+                        const columns = drizzleRel.config?.fields.map((field) => dbToTsColumnNamesMap[field.name])
+                            ?? [];
+                        const refTableConfig = sqliteCore.getTableConfig(drizzleRel.referencedTable);
+                        const refTableDbName = refTableConfig.name;
+                        const refTableTsName = schemaConfig.tableNamesMap[`public.${refTableDbName}`]
+                            ?? refTableDbName;
+                        const dbToTsColumnNamesMapForRefTable = getDbToTsColumnNamesMap(drizzleRel.referencedTable);
+                        const refColumns = drizzleRel.config?.references.map((ref) => dbToTsColumnNamesMapForRefTable[ref.name])
+                            ?? [];
+                        if (tableRelations[refTableTsName] === undefined) {
+                            tableRelations[refTableTsName] = [];
+                        }
+                        const relation = {
+                            table: tableTsName,
+                            columns,
+                            refTable: refTableTsName,
+                            refColumns,
+                            refTableRels: tableRelations[refTableTsName],
+                            type: 'one',
+                        };
+                        relations.push(relation);
+                        tableRelations[tableTsName].push(relation);
+                    }
+                }
+            }
+        }
+        return relations;
+    };
+    for (const table of Object.values(sqliteTables)) {
         tableConfig = sqliteCore.getTableConfig(table);
         dbToTsColumnNamesMap = {};
         for (const [tsCol, col] of Object.entries(tableConfig.columns[0].table)) {
@@ -135965,6 +136105,8 @@ const getSqliteInfo = (schema) => {
                 .map((column) => dbToTsColumnNamesMap[column.name]),
         });
     }
+    const transformedDrizzleRelations = transformFromDrizzleRelation(sqliteSchema, getDbToTsColumnNamesMap, tableRelations);
+    relations.push(...transformedDrizzleRelations);
     const isCyclicRelations = relations.map((relI) => {
         const tableRel = tableRelations[relI.table].find((relJ) => relJ.refTable === relI.refTable);
         if (isRelationCyclic(relI)) {