seedForDrizzleStudio() — drizzle-orm Function Reference

Architecture documentation for the seedForDrizzleStudio() function in index.ts from the drizzle-orm codebase.

Function typescript DrizzleSeed SeedOrchestration

Entity Profile

DrizzleSeed→ SeedOrchestration→ seedForDrizzleStudio() — drizzle-orm Function Reference

Dependency Diagram

graph TD
  903eaa25_3406_3535_5165_4f6fb1a8accc["seedForDrizzleStudio()"]
  0fabdd81_61c9_bb7c_7ddf_dde7a6071abc["index.ts"]
  903eaa25_3406_3535_5165_4f6fb1a8accc -->|defined in| 0fabdd81_61c9_bb7c_7ddf_dde7a6071abc
  style 903eaa25_3406_3535_5165_4f6fb1a8accc fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

drizzle-seed/src/index.ts lines 216–299

export async function seedForDrizzleStudio(
	{ sqlDialect, drizzleStudioObject, drizzleStudioRelations, schemasRefinements, options }: {
		sqlDialect: 'postgresql' | 'mysql' | 'sqlite';
		drizzleStudioObject: DrizzleStudioObjectType;
		drizzleStudioRelations: DrizzleStudioRelationType[];
		schemasRefinements?: { [schemaName: string]: RefinementsType };
		options?: { count?: number; seed?: number };
	},
) {
	const generatedSchemas: {
		[schemaName: string]: {
			tables: {
				tableName: string;
				rows: {
					[columnName: string]: string | number | boolean | undefined;
				}[];
			}[];
		};
	} = {};

	let tables: Table[], relations: Relation[], refinements: RefinementsType | undefined;
	drizzleStudioRelations = drizzleStudioRelations.filter((rel) => rel.type === 'one');
	for (const [schemaName, { tables: drizzleStudioTables }] of Object.entries(drizzleStudioObject)) {
		tables = [];
		for (const [tableName, table] of Object.entries(drizzleStudioTables)) {
			const drizzleStudioColumns = Object.values(table.columns);
			const columns = drizzleStudioColumns.map((col) => ({
				name: col.name,
				dataType: 'string',
				columnType: col.type,
				// TODO: revise later
				typeParams: {},
				default: col.default,
				hasDefault: col.default === undefined ? false : true,
				isUnique: col.isUnique === undefined ? false : col.isUnique,
				notNull: col.notNull,
				primary: col.primaryKey,
			}));
			tables.push(
				{
					name: tableName,
					columns,
					primaryKeys: drizzleStudioColumns.filter((col) => col.primaryKey === true).map((col) => col.name),
				},
			);
		}

		relations = drizzleStudioRelations.filter((rel) => rel.schema === schemaName && rel.refSchema === schemaName);
		const isCyclicRelations = relations.map(
			(reli) => {
				if (relations.some((relj) => reli.table === relj.refTable && reli.refTable === relj.table)) {
					return { ...reli, isCyclic: true };
				}
				return { ...reli, isCyclic: false };
			},
		);

		refinements = schemasRefinements !== undefined && schemasRefinements[schemaName] !== undefined
			? schemasRefinements[schemaName]
			: undefined;

		const seedService = new SeedService();

		const generatedTablesGenerators = seedService.generatePossibleGenerators(
			sqlDialect,
			tables,
			isCyclicRelations,
			refinements,
			options,
		);

		const generatedTables = await seedService.generateTablesValues(
			isCyclicRelations,
			generatedTablesGenerators,
			undefined,
			undefined,
			{ ...options, preserveData: true, insertDataInDb: false },
		);

		generatedSchemas[schemaName] = { tables: generatedTables };
	}