@libredb/studio 0.9.7

package/src/lib/schema-diff/diff-engine.ts

@@ -0,0 +1,273 @@
+import type { TableSchema, ColumnSchema, IndexSchema, ForeignKeySchema } from '@/lib/types';
+import type { SchemaDiff, TableDiff, ColumnDiff, IndexDiff, ForeignKeyDiff } from './types';
+
+function diffColumns(sourceCols: ColumnSchema[], targetCols: ColumnSchema[]): ColumnDiff[] {
+  const diffs: ColumnDiff[] = [];
+  const sourceMap = new Map(sourceCols.map(c => [c.name, c]));
+  const targetMap = new Map(targetCols.map(c => [c.name, c]));
+
+  // Added columns (in target but not in source)
+  for (const [name, col] of targetMap) {
+    if (!sourceMap.has(name)) {
+      diffs.push({
+        action: 'added',
+        columnName: name,
+        targetType: col.type,
+        targetNullable: col.nullable,
+        targetDefault: col.defaultValue,
+        targetIsPrimary: col.isPrimary,
+        changes: [`Added column "${name}" (${col.type})`],
+      });
+    }
+  }
+
+  // Removed columns (in source but not in target)
+  for (const [name, col] of sourceMap) {
+    if (!targetMap.has(name)) {
+      diffs.push({
+        action: 'removed',
+        columnName: name,
+        sourceType: col.type,
+        sourceNullable: col.nullable,
+        sourceDefault: col.defaultValue,
+        sourceIsPrimary: col.isPrimary,
+        changes: [`Removed column "${name}" (${col.type})`],
+      });
+    }
+  }
+
+  // Modified columns (in both, check for differences)
+  for (const [name, sourceCol] of sourceMap) {
+    const targetCol = targetMap.get(name);
+    if (!targetCol) continue;
+
+    const changes: string[] = [];
+
+    if (sourceCol.type.toLowerCase() !== targetCol.type.toLowerCase()) {
+      changes.push(`Type changed: ${sourceCol.type} → ${targetCol.type}`);
+    }
+    if (sourceCol.nullable !== targetCol.nullable) {
+      changes.push(`Nullable changed: ${sourceCol.nullable} → ${targetCol.nullable}`);
+    }
+    if ((sourceCol.defaultValue || '') !== (targetCol.defaultValue || '')) {
+      changes.push(`Default changed: ${sourceCol.defaultValue || 'none'} → ${targetCol.defaultValue || 'none'}`);
+    }
+    if (sourceCol.isPrimary !== targetCol.isPrimary) {
+      changes.push(`Primary key changed: ${sourceCol.isPrimary} → ${targetCol.isPrimary}`);
+    }
+
+    if (changes.length > 0) {
+      diffs.push({
+        action: 'modified',
+        columnName: name,
+        sourceType: sourceCol.type,
+        targetType: targetCol.type,
+        sourceNullable: sourceCol.nullable,
+        targetNullable: targetCol.nullable,
+        sourceDefault: sourceCol.defaultValue,
+        targetDefault: targetCol.defaultValue,
+        sourceIsPrimary: sourceCol.isPrimary,
+        targetIsPrimary: targetCol.isPrimary,
+        changes,
+      });
+    }
+  }
+
+  return diffs;
+}
+
+function diffIndexes(sourceIndexes: IndexSchema[], targetIndexes: IndexSchema[]): IndexDiff[] {
+  const diffs: IndexDiff[] = [];
+
+  const sourceMap = new Map<string, IndexSchema>();
+  sourceIndexes.forEach(idx => {
+    const key = idx.name || idx.columns.sort().join(',');
+    sourceMap.set(key, idx);
+  });
+
+  const targetMap = new Map<string, IndexSchema>();
+  targetIndexes.forEach(idx => {
+    const key = idx.name || idx.columns.sort().join(',');
+    targetMap.set(key, idx);
+  });
+
+  for (const [key, idx] of targetMap) {
+    if (!sourceMap.has(key)) {
+      diffs.push({
+        action: 'added',
+        indexName: idx.name || key,
+        targetColumns: idx.columns,
+        targetUnique: idx.unique,
+        changes: [`Added index "${idx.name || key}" on (${idx.columns.join(', ')})`],
+      });
+    }
+  }
+
+  for (const [key, idx] of sourceMap) {
+    if (!targetMap.has(key)) {
+      diffs.push({
+        action: 'removed',
+        indexName: idx.name || key,
+        sourceColumns: idx.columns,
+        sourceUnique: idx.unique,
+        changes: [`Removed index "${idx.name || key}"`],
+      });
+    }
+  }
+
+  for (const [key, sourceIdx] of sourceMap) {
+    const targetIdx = targetMap.get(key);
+    if (!targetIdx) continue;
+
+    const changes: string[] = [];
+    const sourceColStr = sourceIdx.columns.sort().join(',');
+    const targetColStr = targetIdx.columns.sort().join(',');
+
+    if (sourceColStr !== targetColStr) {
+      changes.push(`Columns changed: (${sourceIdx.columns.join(', ')}) → (${targetIdx.columns.join(', ')})`);
+    }
+    if (sourceIdx.unique !== targetIdx.unique) {
+      changes.push(`Unique changed: ${sourceIdx.unique} → ${targetIdx.unique}`);
+    }
+
+    if (changes.length > 0) {
+      diffs.push({
+        action: 'modified',
+        indexName: sourceIdx.name || key,
+        sourceColumns: sourceIdx.columns,
+        targetColumns: targetIdx.columns,
+        sourceUnique: sourceIdx.unique,
+        targetUnique: targetIdx.unique,
+        changes,
+      });
+    }
+  }
+
+  return diffs;
+}
+
+function diffForeignKeys(sourceFKs: ForeignKeySchema[], targetFKs: ForeignKeySchema[]): ForeignKeyDiff[] {
+  const diffs: ForeignKeyDiff[] = [];
+
+  const makeKey = (fk: ForeignKeySchema) => `${fk.columnName}→${fk.referencedTable}.${fk.referencedColumn}`;
+
+  const sourceMap = new Map(sourceFKs.map(fk => [makeKey(fk), fk]));
+  const targetMap = new Map(targetFKs.map(fk => [makeKey(fk), fk]));
+
+  for (const [key, fk] of targetMap) {
+    if (!sourceMap.has(key)) {
+      diffs.push({
+        action: 'added',
+        columnName: fk.columnName,
+        targetReferencedTable: fk.referencedTable,
+        targetReferencedColumn: fk.referencedColumn,
+        changes: [`Added FK: ${fk.columnName} → ${fk.referencedTable}(${fk.referencedColumn})`],
+      });
+    }
+  }
+
+  for (const [key, fk] of sourceMap) {
+    if (!targetMap.has(key)) {
+      diffs.push({
+        action: 'removed',
+        columnName: fk.columnName,
+        sourceReferencedTable: fk.referencedTable,
+        sourceReferencedColumn: fk.referencedColumn,
+        changes: [`Removed FK: ${fk.columnName} → ${fk.referencedTable}(${fk.referencedColumn})`],
+      });
+    }
+  }
+
+  return diffs;
+}
+
+export function diffSchemas(source: TableSchema[], target: TableSchema[]): SchemaDiff {
+  const sourceMap = new Map(source.map(t => [t.name, t]));
+  const targetMap = new Map(target.map(t => [t.name, t]));
+
+  const tables: TableDiff[] = [];
+  let added = 0, removed = 0, modified = 0;
+
+  // Added tables
+  for (const [name, table] of targetMap) {
+    if (!sourceMap.has(name)) {
+      tables.push({
+        action: 'added',
+        tableName: name,
+        columns: table.columns.map(c => ({
+          action: 'added' as const,
+          columnName: c.name,
+          targetType: c.type,
+          targetNullable: c.nullable,
+          targetDefault: c.defaultValue,
+          targetIsPrimary: c.isPrimary,
+          changes: [`Added column "${c.name}" (${c.type})`],
+        })),
+        indexes: table.indexes.map(idx => ({
+          action: 'added' as const,
+          indexName: idx.name,
+          targetColumns: idx.columns,
+          targetUnique: idx.unique,
+          changes: [`Added index "${idx.name}"`],
+        })),
+        foreignKeys: (table.foreignKeys || []).map(fk => ({
+          action: 'added' as const,
+          columnName: fk.columnName,
+          targetReferencedTable: fk.referencedTable,
+          targetReferencedColumn: fk.referencedColumn,
+          changes: [`Added FK: ${fk.columnName} → ${fk.referencedTable}(${fk.referencedColumn})`],
+        })),
+      });
+      added++;
+    }
+  }
+
+  // Removed tables
+  for (const [name, table] of sourceMap) {
+    if (!targetMap.has(name)) {
+      tables.push({
+        action: 'removed',
+        tableName: name,
+        columns: table.columns.map(c => ({
+          action: 'removed' as const,
+          columnName: c.name,
+          sourceType: c.type,
+          sourceNullable: c.nullable,
+          sourceDefault: c.defaultValue,
+          sourceIsPrimary: c.isPrimary,
+          changes: [`Removed column "${c.name}"`],
+        })),
+        indexes: [],
+        foreignKeys: [],
+      });
+      removed++;
+    }
+  }
+
+  // Modified tables
+  for (const [name, sourceTable] of sourceMap) {
+    const targetTable = targetMap.get(name);
+    if (!targetTable) continue;
+
+    const columns = diffColumns(sourceTable.columns, targetTable.columns);
+    const indexes = diffIndexes(sourceTable.indexes, targetTable.indexes);
+    const foreignKeys = diffForeignKeys(sourceTable.foreignKeys || [], targetTable.foreignKeys || []);
+
+    if (columns.length > 0 || indexes.length > 0 || foreignKeys.length > 0) {
+      tables.push({
+        action: 'modified',
+        tableName: name,
+        columns,
+        indexes,
+        foreignKeys,
+      });
+      modified++;
+    }
+  }
+
+  return {
+    tables,
+    summary: { added, removed, modified },
+    hasChanges: tables.length > 0,
+  };
+}

package/src/lib/schema-diff/migration-generator.ts

@@ -0,0 +1,208 @@
+import type { DatabaseType } from '@/lib/types';
+import type { SchemaDiff, TableDiff, ColumnDiff } from './types';
+
+function escapeIdentifier(name: string, dialect: DatabaseType): string {
+  switch (dialect) {
+    case 'mysql': return `\`${name}\``;
+    case 'mssql': return `[${name.replace(/\]/g, ']]')}]`;
+    case 'oracle':
+    case 'postgres':
+    case 'sqlite':
+    default: return `"${name}"`;
+  }
+}
+
+function generateColumnDef(col: ColumnDiff, dialect: DatabaseType): string {
+  const type = col.targetType || col.sourceType || 'TEXT';
+  const nullable = col.targetNullable === false ? ' NOT NULL' : '';
+  const defaultVal = col.targetDefault ? ` DEFAULT ${col.targetDefault}` : '';
+  return `${escapeIdentifier(col.columnName, dialect)} ${type}${nullable}${defaultVal}`;
+}
+
+function generateCreateTable(table: TableDiff, dialect: DatabaseType): string {
+  const lines: string[] = [];
+  const id = escapeIdentifier(table.tableName, dialect);
+
+  const colDefs = table.columns
+    .filter(c => c.action === 'added')
+    .map(c => `  ${generateColumnDef(c, dialect)}`);
+
+  // Add primary key constraint
+  const pkCols = table.columns.filter(c => c.targetIsPrimary).map(c => escapeIdentifier(c.columnName, dialect));
+
+  lines.push(`CREATE TABLE ${id} (`);
+  lines.push(colDefs.join(',\n'));
+  if (pkCols.length > 0) {
+    lines.push(`,  PRIMARY KEY (${pkCols.join(', ')})`);
+  }
+  lines.push(');');
+
+  // Indexes
+  table.indexes.filter(i => i.action === 'added').forEach(idx => {
+    const unique = idx.targetUnique ? 'UNIQUE ' : '';
+    const cols = (idx.targetColumns || []).map(c => escapeIdentifier(c, dialect)).join(', ');
+    lines.push(`CREATE ${unique}INDEX ${escapeIdentifier(idx.indexName, dialect)} ON ${id} (${cols});`);
+  });
+
+  // Foreign keys
+  table.foreignKeys.filter(fk => fk.action === 'added').forEach(fk => {
+    lines.push(`ALTER TABLE ${id} ADD CONSTRAINT ${escapeIdentifier(`fk_${table.tableName}_${fk.columnName}`, dialect)} FOREIGN KEY (${escapeIdentifier(fk.columnName, dialect)}) REFERENCES ${escapeIdentifier(fk.targetReferencedTable || '', dialect)}(${escapeIdentifier(fk.targetReferencedColumn || '', dialect)});`);
+  });
+
+  return lines.join('\n');
+}
+
+function generateDropTable(table: TableDiff, dialect: DatabaseType): string {
+  return `DROP TABLE IF EXISTS ${escapeIdentifier(table.tableName, dialect)};`;
+}
+
+function generateAlterTable(table: TableDiff, dialect: DatabaseType): string {
+  const lines: string[] = [];
+  const id = escapeIdentifier(table.tableName, dialect);
+
+  lines.push(`-- Alter table: ${table.tableName}`);
+
+  // Added columns
+  table.columns.filter(c => c.action === 'added').forEach(col => {
+    lines.push(`ALTER TABLE ${id} ADD COLUMN ${generateColumnDef(col, dialect)};`);
+  });
+
+  // Removed columns
+  table.columns.filter(c => c.action === 'removed').forEach(col => {
+    if (dialect === 'sqlite') {
+      lines.push(`-- SQLite: Cannot drop column "${col.columnName}" directly. Requires table recreation.`);
+    } else {
+      lines.push(`ALTER TABLE ${id} DROP COLUMN ${escapeIdentifier(col.columnName, dialect)};`);
+    }
+  });
+
+  // Modified columns
+  table.columns.filter(c => c.action === 'modified').forEach(col => {
+    if (dialect === 'sqlite') {
+      lines.push(`-- SQLite: Cannot alter column "${col.columnName}" type directly. Requires table recreation.`);
+    } else if (dialect === 'mysql') {
+      const type = col.targetType || col.sourceType || 'TEXT';
+      const nullable = col.targetNullable === false ? ' NOT NULL' : ' NULL';
+      const defaultVal = col.targetDefault ? ` DEFAULT ${col.targetDefault}` : '';
+      lines.push(`ALTER TABLE ${id} MODIFY COLUMN ${escapeIdentifier(col.columnName, dialect)} ${type}${nullable}${defaultVal};`);
+    } else if (dialect === 'oracle') {
+      const type = col.targetType || col.sourceType || 'VARCHAR2(255)';
+      const nullable = col.targetNullable === false ? ' NOT NULL' : ' NULL';
+      const defaultVal = col.targetDefault ? ` DEFAULT ${col.targetDefault}` : '';
+      lines.push(`ALTER TABLE ${id} MODIFY (${escapeIdentifier(col.columnName, dialect)} ${type}${defaultVal}${nullable});`);
+    } else if (dialect === 'mssql') {
+      const type = col.targetType || col.sourceType || 'NVARCHAR(MAX)';
+      const nullable = col.targetNullable === false ? ' NOT NULL' : ' NULL';
+      lines.push(`ALTER TABLE ${id} ALTER COLUMN ${escapeIdentifier(col.columnName, dialect)} ${type}${nullable};`);
+      if (col.sourceDefault !== col.targetDefault && col.targetDefault) {
+        lines.push(`ALTER TABLE ${id} ADD DEFAULT ${col.targetDefault} FOR ${escapeIdentifier(col.columnName, dialect)};`);
+      }
+    } else {
+      // PostgreSQL
+      if (col.sourceType !== col.targetType) {
+        lines.push(`ALTER TABLE ${id} ALTER COLUMN ${escapeIdentifier(col.columnName, dialect)} TYPE ${col.targetType};`);
+      }
+      if (col.sourceNullable !== col.targetNullable) {
+        if (col.targetNullable) {
+          lines.push(`ALTER TABLE ${id} ALTER COLUMN ${escapeIdentifier(col.columnName, dialect)} DROP NOT NULL;`);
+        } else {
+          lines.push(`ALTER TABLE ${id} ALTER COLUMN ${escapeIdentifier(col.columnName, dialect)} SET NOT NULL;`);
+        }
+      }
+      if (col.sourceDefault !== col.targetDefault) {
+        if (col.targetDefault) {
+          lines.push(`ALTER TABLE ${id} ALTER COLUMN ${escapeIdentifier(col.columnName, dialect)} SET DEFAULT ${col.targetDefault};`);
+        } else {
+          lines.push(`ALTER TABLE ${id} ALTER COLUMN ${escapeIdentifier(col.columnName, dialect)} DROP DEFAULT;`);
+        }
+      }
+    }
+  });
+
+  // Added indexes
+  table.indexes.filter(i => i.action === 'added').forEach(idx => {
+    const unique = idx.targetUnique ? 'UNIQUE ' : '';
+    const cols = (idx.targetColumns || []).map(c => escapeIdentifier(c, dialect)).join(', ');
+    lines.push(`CREATE ${unique}INDEX ${escapeIdentifier(idx.indexName, dialect)} ON ${id} (${cols});`);
+  });
+
+  // Removed indexes
+  table.indexes.filter(i => i.action === 'removed').forEach(idx => {
+    if (dialect === 'mysql') {
+      lines.push(`DROP INDEX ${escapeIdentifier(idx.indexName, dialect)} ON ${id};`);
+    } else {
+      lines.push(`DROP INDEX IF EXISTS ${escapeIdentifier(idx.indexName, dialect)};`);
+    }
+  });
+
+  // Added foreign keys
+  table.foreignKeys.filter(fk => fk.action === 'added').forEach(fk => {
+    const constraintName = escapeIdentifier(`fk_${table.tableName}_${fk.columnName}`, dialect);
+    lines.push(`ALTER TABLE ${id} ADD CONSTRAINT ${constraintName} FOREIGN KEY (${escapeIdentifier(fk.columnName, dialect)}) REFERENCES ${escapeIdentifier(fk.targetReferencedTable || '', dialect)}(${escapeIdentifier(fk.targetReferencedColumn || '', dialect)});`);
+  });
+
+  // Removed foreign keys
+  table.foreignKeys.filter(fk => fk.action === 'removed').forEach(fk => {
+    const constraintName = escapeIdentifier(`fk_${table.tableName}_${fk.columnName}`, dialect);
+    if (dialect === 'mysql') {
+      lines.push(`ALTER TABLE ${id} DROP FOREIGN KEY ${constraintName};`);
+    } else if (dialect === 'sqlite') {
+      lines.push(`-- SQLite: Cannot drop foreign key directly. Requires table recreation.`);
+    } else {
+      lines.push(`ALTER TABLE ${id} DROP CONSTRAINT IF EXISTS ${constraintName};`);
+    }
+  });
+
+  return lines.join('\n');
+}
+
+export function generateMigrationSQL(diff: SchemaDiff, dialect: DatabaseType): string {
+  if (!diff.hasChanges) {
+    return '-- No schema changes detected.';
+  }
+
+  const sections: string[] = [];
+  sections.push(`-- Migration generated at ${new Date().toISOString()}`);
+  sections.push(`-- Dialect: ${dialect}`);
+  sections.push(`-- Changes: ${diff.summary.added} added, ${diff.summary.removed} removed, ${diff.summary.modified} modified`);
+  sections.push('');
+
+  if (dialect !== 'sqlite') {
+    sections.push('BEGIN;');
+    sections.push('');
+  }
+
+  // Drop tables first (reverse dependency order)
+  const droppedTables = diff.tables.filter(t => t.action === 'removed');
+  if (droppedTables.length > 0) {
+    sections.push('-- Drop removed tables');
+    droppedTables.forEach(t => sections.push(generateDropTable(t, dialect)));
+    sections.push('');
+  }
+
+  // Create new tables
+  const addedTables = diff.tables.filter(t => t.action === 'added');
+  if (addedTables.length > 0) {
+    sections.push('-- Create new tables');
+    addedTables.forEach(t => {
+      sections.push(generateCreateTable(t, dialect));
+      sections.push('');
+    });
+  }
+
+  // Alter existing tables
+  const modifiedTables = diff.tables.filter(t => t.action === 'modified');
+  if (modifiedTables.length > 0) {
+    sections.push('-- Modify existing tables');
+    modifiedTables.forEach(t => {
+      sections.push(generateAlterTable(t, dialect));
+      sections.push('');
+    });
+  }
+
+  if (dialect !== 'sqlite') {
+    sections.push('COMMIT;');
+  }
+
+  return sections.join('\n');
+}

package/src/lib/schema-diff/types.ts

@@ -0,0 +1,55 @@
+export type DiffAction = 'added' | 'removed' | 'modified';
+
+export interface ColumnDiff {
+  action: DiffAction;
+  columnName: string;
+  sourceType?: string;
+  targetType?: string;
+  sourceNullable?: boolean;
+  targetNullable?: boolean;
+  sourceDefault?: string;
+  targetDefault?: string;
+  sourceIsPrimary?: boolean;
+  targetIsPrimary?: boolean;
+  changes: string[];
+}
+
+export interface IndexDiff {
+  action: DiffAction;
+  indexName: string;
+  sourceColumns?: string[];
+  targetColumns?: string[];
+  sourceUnique?: boolean;
+  targetUnique?: boolean;
+  changes: string[];
+}
+
+export interface ForeignKeyDiff {
+  action: DiffAction;
+  columnName: string;
+  sourceReferencedTable?: string;
+  targetReferencedTable?: string;
+  sourceReferencedColumn?: string;
+  targetReferencedColumn?: string;
+  changes: string[];
+}
+
+export interface TableDiff {
+  action: DiffAction;
+  tableName: string;
+  columns: ColumnDiff[];
+  indexes: IndexDiff[];
+  foreignKeys: ForeignKeyDiff[];
+}
+
+export interface DiffSummary {
+  added: number;
+  removed: number;
+  modified: number;
+}
+
+export interface SchemaDiff {
+  tables: TableDiff[];
+  summary: DiffSummary;
+  hasChanges: boolean;
+}

package/src/lib/seed/config-loader.ts

@@ -0,0 +1,79 @@
+import { readFile } from 'fs/promises';
+import { parse as parseYAML } from 'yaml';
+import { SeedConfigSchema, type SeedConfig } from './types';
+import { logger } from '@/lib/logger';
+
+const DEFAULT_PATH = '/app/config/seed-connections.yaml';
+
+let cachedConfig: SeedConfig | null = null;
+let cachedAt = 0;
+let cacheIsNull = false;
+
+function getCacheTTL(): number {
+  const raw = Number(process.env.SEED_CACHE_TTL_MS);
+  return Number.isFinite(raw) ? raw : 60_000;
+}
+
+function getConfigPath(): string {
+  return process.env.SEED_CONFIG_PATH || DEFAULT_PATH;
+}
+
+export function resetCache(): void {
+  cachedConfig = null;
+  cachedAt = 0;
+  cacheIsNull = false;
+}
+
+export async function loadConfig(): Promise<SeedConfig | null> {
+  const now = Date.now();
+  const ttl = getCacheTTL();
+
+  if ((cachedConfig || cacheIsNull) && now - cachedAt < ttl) {
+    return cachedConfig;
+  }
+
+  const configPath = getConfigPath();
+
+  let raw: string;
+  try {
+    raw = await readFile(configPath, 'utf-8');
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      logger.warn('Seed config file not found, seed connections disabled', {
+        route: 'seed/config-loader',
+        path: configPath,
+      });
+      cachedConfig = null;
+      cacheIsNull = true;
+      cachedAt = now;
+      return null;
+    }
+    throw err;
+  }
+
+  const isJSON = configPath.endsWith('.json');
+  let parsed: unknown;
+  try {
+    parsed = isJSON ? JSON.parse(raw) : parseYAML(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse seed config at ${configPath}: ${err}`);
+  }
+
+  const result = SeedConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ');
+    throw new Error(`Invalid seed config: ${issues}`);
+  }
+
+  cachedConfig = result.data;
+  cachedAt = now;
+  cacheIsNull = false;
+
+  logger.info('Seed config loaded', {
+    route: 'seed/config-loader',
+    connectionCount: result.data.connections.length,
+  });
+
+  return cachedConfig;
+}

package/src/lib/seed/connection-filter.ts

@@ -0,0 +1,49 @@
+import type { SSLConfig } from '@/lib/types';
+import type { SeedConnection, SeedDefaults, ManagedConnection } from './types';
+
+export function mergeDefaults(
+  conn: SeedConnection,
+  defaults: SeedDefaults | undefined,
+): SeedConnection {
+  if (!defaults) return conn;
+  return {
+    ...conn,
+    managed: conn.managed ?? defaults.managed,
+    environment: conn.environment ?? defaults.environment,
+    ssl: conn.ssl ?? defaults.ssl,
+  };
+}
+
+function rolesMatch(connectionRoles: string[], userRoles: string[]): boolean {
+  if (connectionRoles.includes('*')) return true;
+  return connectionRoles.some((r) => userRoles.includes(r));
+}
+
+export function filterByRoles(
+  connections: SeedConnection[],
+  userRoles: string[],
+): ManagedConnection[] {
+  return connections
+    .filter((conn) => rolesMatch(conn.roles, userRoles))
+    .map((conn) => ({
+      id: `seed:${conn.id}`,
+      name: conn.name,
+      type: conn.type,
+      host: conn.host,
+      port: conn.port,
+      database: conn.database,
+      user: conn.user,
+      password: conn.password,
+      connectionString: conn.connectionString,
+      environment: conn.environment,
+      group: conn.group,
+      color: conn.color,
+      ssl: conn.ssl as SSLConfig | undefined,
+      serviceName: conn.serviceName,
+      instanceName: conn.instanceName,
+      createdAt: new Date(),
+      managed: conn.managed ?? true,
+      roles: conn.roles,
+      seedId: conn.id,
+    }));
+}