@libredb/studio 0.9.7 → 0.9.13

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

@@ -1,273 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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,
-    }));
-}