fromDatabase() — drizzle-orm Function Reference

Source Code

drizzle-kit/src/serializer/gelSerializer.ts lines 954–1535

export const fromDatabase = async (
	db: DB,
	tablesFilter: (table: string) => boolean = () => true,
	schemaFilters: string[],
	entities?: {
		roles: boolean | {
			provider?: string | undefined;
			include?: string[] | undefined;
			exclude?: string[] | undefined;
		};
	},
	progressCallback?: (
		stage: IntrospectStage,
		count: number,
		status: IntrospectStatus,
	) => void,
	tsSchema?: GelSchemaInternal,
): Promise<GelSchemaInternal> => {
	const result: Record<string, Table> = {};
	// const views: Record<string, View> = {};
	const policies: Record<string, Policy> = {};
	const internals: GelKitInternals = { tables: {} };

	const where = schemaFilters.map((t) => `n.nspname = '${t}'`).join(' or ');

	const allTables = await db.query<{ table_schema: string; table_name: string; type: string; rls_enabled: boolean }>(
		`SELECT 
    n.nspname::text AS table_schema, 
    c.relname::text AS table_name, 
    CASE 
        WHEN c.relkind = 'r' THEN 'table'
        WHEN c.relkind = 'v' THEN 'view'
        WHEN c.relkind = 'm' THEN 'materialized_view'
    END AS type,
	c.relrowsecurity AS rls_enabled
FROM 
    pg_catalog.pg_class c
JOIN 
    pg_catalog.pg_namespace n ON n.oid::text = c.relnamespace::text
WHERE 
	c.relkind IN ('r', 'v', 'm') 
    ${where === '' ? '' : ` AND ${where}`};`,
	);

	const schemas = new Set(allTables.map((it) => it.table_schema));

	const allSchemas = await db.query<{
		table_schema: string;
	}>(`select s.nspname::text as table_schema
  from pg_catalog.pg_namespace s
  join pg_catalog.pg_user u on u.usesysid::text = s.nspowner::text
  where nspname not in ('information_schema', 'pg_catalog', 'public')
        and nspname::text not like 'pg_toast%'
        and nspname::text not like 'pg_temp_%'
  order by 1;`);

	allSchemas.forEach((item) => {
		if (schemaFilters.includes(item.table_schema)) {
			schemas.add(item.table_schema);
		}
	});

	let columnsCount = 0;
	let indexesCount = 0;
	let foreignKeysCount = 0;
	let tableCount = 0;

	const sequencesToReturn: Record<string, Sequence> = {};

	const all = allTables
		.filter((it) => it.type === 'table')
		.map((row) => {
			return new Promise(async (res, rej) => {
				const tableName = row.table_name as string;
				if (!tablesFilter(tableName)) return res('');
				tableCount += 1;
				const tableSchema = row.table_schema;

				try {
					const columnToReturn: Record<string, Column> = {};
					const indexToReturn: Record<string, Index> = {};