Function extractRelations

drizzle-kit/src/serializer/studio.ts:515–584

(
	tablesConfig: {
		tables: TablesRelationalConfig;
		tableNamesMap: Record<string, string>;
	},
	casing?: CasingType,
)

};

export const extractRelations = (
	tablesConfig: {
		tables: TablesRelationalConfig;
		tableNamesMap: Record<string, string>;
	},
	casing?: CasingType,
): Relation[] => {
	const relations = Object.values(tablesConfig.tables)
		.map((it) =>
			Object.entries(it.relations).map(([name, relation]) => {
				try {
					const normalized = normalizeRelation(
						tablesConfig.tables,
						tablesConfig.tableNamesMap,
						relation,
					);
					const rel = relation;
					const refTableName = rel.referencedTableName;
					const refTable = rel.referencedTable;
					const fields = normalized.fields
						.map((it) => getColumnCasing(it, casing))
						.flat();
					const refColumns = normalized.references
						.map((it) => getColumnCasing(it, casing))
						.flat();

					let refSchema: string | undefined;
					if (is(refTable, PgTable)) {
						refSchema = pgTableConfig(refTable).schema;
					} else if (is(refTable, MySqlTable)) {
						refSchema = mysqlTableConfig(refTable).schema;
					} else if (is(refTable, SQLiteTable)) {
						refSchema = undefined;
					} else if (is(refTable, SingleStoreTable)) {
						refSchema = singlestoreTableConfig(refTable).schema;
					} else {
						throw new Error('unsupported dialect');
					}

					let type: 'one' | 'many';
					if (is(rel, One)) {
						type = 'one';
					} else if (is(rel, Many)) {
						type = 'many';
					} else {
						throw new Error('unsupported relation type');
					}

					return {
						name,
						type,
						table: it.dbName,
						schema: it.schema || 'public',
						columns: fields,
						refTable: refTableName,
						refSchema: refSchema || 'public',
						refColumns: refColumns,
					};