@deterministic-code/migraters 0.0.4 → 0.0.5

package/typescript/{dialects/sqlserver/src/sqlserver-dialect.ts → providers/sqlserver/src/sqlserver-provider.ts}

@@ -1,8 +1,9 @@
 import type { Request as MssqlRequest } from 'mssql';
+import type { IDatasourceProvider, ProviderLogId } from '../../../src/abstractions/datasource-provider.ts';
 import type { MigrationClient, MigrationSqlParam } from '../../../src/migration-client.ts';
 import { interopDefault } from '../../../src/infrastructure/interop-default.ts';
 import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
-import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
+import { sqlRun } from '../../sql/sql-run.ts';
 
 const [migratesDdl, migrateLogsDdl] = await Promise.all([
   readSqlTemplate('sqlserver', 'migrates'),
@@ -23,7 +24,7 @@ const bindMssql = (
   });
 };
 
-export class SqlServerDialect extends SqlDialectBase {
+export class SqlServerProvider implements IDatasourceProvider {
   readonly name = 'sqlserver' as const;
   readonly connectionEnvironmentVariables = ['MSSQL_URL', 'DATABASE_URL'] as const;
   readonly migratesDdl = migratesDdl;
@@ -41,6 +42,12 @@ export class SqlServerDialect extends SqlDialectBase {
     return `OFFSET 0 ROWS FETCH NEXT ${n} ROWS ONLY`;
   }
 
+  async prerequisiteError(_connection: string): Promise<string | null> {
+    return null;
+  }
+
+  async prepareSetup(_connection: string): Promise<void> {}
+
   async createDatabaseIfMissing(connection: string): Promise<void> {
     const match = /(?:^|;)Database=([^;]+)/i.exec(connection);
     const name = match?.[1]?.trim();
@@ -100,4 +107,32 @@ export class SqlServerDialect extends SqlDialectBase {
       },
     };
   }
+
+  setup(connection: string): Promise<void> {
+    return sqlRun.setup(this, connection);
+  }
+
+  applied(connection: string): Promise<Map<string, string | null>> {
+    return sqlRun.applied(this, connection);
+  }
+
+  migrateUp(connection: string, name: string, body: string, checksum: string): Promise<void> {
+    return sqlRun.migrateUp(this, connection, name, body, checksum);
+  }
+
+  migrateDown(connection: string, name: string, body: string): Promise<void> {
+    return sqlRun.migrateDown(this, connection, name, body);
+  }
+
+  log(
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId> {
+    return sqlRun.log(this, connection, id, name, direction, status, durationMs, error);
+  }
 }

package/typescript/src/abstractions/datasource-provider.ts

@@ -0,0 +1,26 @@
+import type { SqlDialect } from '../sql.ts';
+
+export type ProviderLogId = string | number | bigint;
+
+export interface IDatasourceProvider {
+  readonly name: SqlDialect;
+  prepareSetup(connection: string): Promise<void>;
+  createDatabaseIfMissing(connection: string): Promise<void>;
+  setup(connection: string): Promise<void>;
+  applied(connection: string): Promise<Map<string, string | null>>;
+  migrateUp(connection: string, name: string, body: string, checksum: string): Promise<void>;
+  migrateDown(connection: string, name: string, body: string): Promise<void>;
+  log(
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId>;
+}
+
+/** @deprecated Use IDatasourceProvider. */
+export type IDialect = IDatasourceProvider;
+export type ISqlDialect = IDatasourceProvider;

package/typescript/src/abstractions/sql-dialect-factory.ts

@@ -1,21 +1,21 @@
 import { normalizeDialect, type SqlDialect } from '../sql.ts';
-import type { ISqlDialect } from './sql-dialect.ts';
+import type { IDatasourceProvider } from './datasource-provider.ts';
 
 const VALID = 'sqlite, mysql, postgres, sqlserver, oracle';
 
 export class SqlDialectFactory {
-  private readonly byName: Map<SqlDialect, ISqlDialect>;
+  private readonly byName: Map<SqlDialect, IDatasourceProvider>;
 
-  constructor(dialects: readonly ISqlDialect[]) {
-    this.byName = new Map(dialects.map((d) => [d.name, d]));
+  constructor(providers: readonly IDatasourceProvider[]) {
+    this.byName = new Map(providers.map((d) => [d.name, d]));
   }
 
-  tryGet(raw: string): ISqlDialect | undefined {
+  tryGet(raw: string): IDatasourceProvider | undefined {
     const key = normalizeDialect(raw);
     return key ? this.byName.get(key) : undefined;
   }
 
-  get(raw: string): ISqlDialect {
+  get(raw: string): IDatasourceProvider {
     const dialect = this.tryGet(raw);
     if (!dialect) {
       throw new Error(`Unknown SQL dialect "${raw}". Valid: ${VALID}.`);
@@ -23,7 +23,7 @@ export class SqlDialectFactory {
     return dialect;
   }
 
-  all(): readonly ISqlDialect[] {
+  all(): readonly IDatasourceProvider[] {
     return [...this.byName.values()];
   }
 }

package/typescript/src/abstractions/sql-dialect.ts

@@ -1,18 +1 @@
-import type { MigrationClient } from '../migration-client.ts';
-import type { SqlDialect } from '../sql.ts';
-
-export interface ISqlDialect {
-  readonly name: SqlDialect;
-  readonly connectionEnvironmentVariables: readonly string[];
-  readonly migratesDdl: string;
-  readonly migrateLogsDdl: string;
-  readonly usesLastInsertRowid: boolean;
-  quoteIdent(ident: string): string;
-  nowExpr(): string;
-  limitClause(n: number): string;
-  translatePlaceholders(sql: string): string;
-  prerequisiteError(connection: string): Promise<string | null>;
-  prepareSetup(connection: string): Promise<void>;
-  createDatabaseIfMissing(connection: string): Promise<void>;
-  createClient(connection: string): Promise<MigrationClient>;
-}
+export type { IDatasourceProvider, IDialect, ISqlDialect } from './datasource-provider.ts';

package/typescript/src/cli.ts

@@ -1,5 +1,5 @@
 import { connectionResolver, defaultDialectFactory } from './infrastructure/default-factory.ts';
-import type { ISqlDialect } from './abstractions/sql-dialect.ts';
+import type { IDatasourceProvider } from './abstractions/datasource-provider.ts';
 import { cliSpec } from './cli-spec.ts';
 import { fillTemplate, loadMessage } from './infrastructure/message-templates.ts';
 
@@ -9,7 +9,7 @@ const missingConnectionTpl = await loadMessage('errors/missing-connection');
 
 export { missingProviderMsg };
 
-export const requireDialect = (provider: string | null): ISqlDialect => {
+export const requireDialect = (provider: string | null): IDatasourceProvider => {
   if (!provider) {
     process.stderr.write(missingProviderMsg);
     process.exit(2);
@@ -22,12 +22,14 @@ export const requireDialect = (provider: string | null): ISqlDialect => {
   return dialect;
 };
 
-export const requireConnection = (dialect: ISqlDialect, fromFlag: string | null): string => {
-  const connection = connectionResolver.resolve(dialect, fromFlag);
+export const requireConnection = (dialect: IDatasourceProvider, fromFlag: string | null): string => {
+  const connection = connectionResolver.resolve(dialect.name, fromFlag);
   if (!connection) {
     process.stderr.write(
       fillTemplate(missingConnectionTpl, {
-        envVars: dialect.connectionEnvironmentVariables.join(cliSpec.env_var_list_separator),
+        envVars: (cliSpec.connection_environment[dialect.name] ?? []).join(
+          cliSpec.env_var_list_separator,
+        ),
       }),
     );
     process.exit(2);

package/typescript/src/datasource-migrate.ts

@@ -1,12 +1,8 @@
 import { createHash } from 'node:crypto';
 import { readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { defaultDialectFactory } from './infrastructure/default-factory.ts';
-import { splitOnGo } from './infrastructure/split-on-go.ts';
 import { fillTemplate, loadMessage } from './infrastructure/message-templates.ts';
-import type { ISqlDialect } from './abstractions/sql-dialect.ts';
-import type { MigrationClient, MigrationRowValue } from './migration-client.ts';
-import type { SqlDialect } from './sql.ts';
+import type { IDatasourceProvider } from './abstractions/datasource-provider.ts';
 
 export { normalizeDialect } from './sql.ts';
 export type {
@@ -15,6 +11,7 @@ export type {
   MigrationSqlParam,
   SqliteRawDatabase,
 } from './migration-client.ts';
+export type { IDatasourceProvider, ProviderLogId } from './abstractions/datasource-provider.ts';
 export { applyMysqlDdlViaTextProtocol } from './infrastructure/mysql-text-protocol.ts';
 
 /** One discovered migration: its up script and the rollback sibling when present. */
@@ -51,7 +48,7 @@ export async function discoverMigrations({
   migratePath: string;
   dialect: string;
 }): Promise<MigrationDescriptor[]> {
-  requireDialect(dialect);
+  void dialect;
   let st;
   try {
     st = await stat(migratePath);
@@ -86,15 +83,17 @@ export function checksum(text: string): string {
 }
 
 export async function applyOneUp({
-  client,
+  provider,
+  connection,
   migrations,
   env = process.env,
 }: {
-  client: MigrationClient;
+  provider: IDatasourceProvider;
+  connection: string;
   migrations: MigrationDescriptor[];
   env?: NodeJS.ProcessEnv;
 }): Promise<{ applied: boolean; name: string | null }> {
-  const applied = await appliedRecords(client);
+  const applied = await provider.applied(connection);
   await assertNoChecksumDrift({ migrations, applied, env });
   const next = migrations.find((m) => !applied.has(m.name));
   if (!next) return { applied: false, name: null };
@@ -102,49 +101,33 @@ export async function applyOneUp({
   const sqlText = await readFile(next.upPath, 'utf8');
   const sum = checksum(sqlText);
 
-  const logId = await insertLogStarted(client, next.name, 'up');
+  const logId = await provider.log(connection, null, next.name, 'up', null, 0, null);
   const startedAt = Date.now();
 
   try {
-    await client.transaction(async () => {
-      const stmts = splitOnGo(await readFile(next.upPath, 'utf8'));
-      for (const stmt of stmts) {
-        await client.exec(stmt);
-      }
-      await insertMigrate(client, next.name, sum);
-    });
+    await provider.migrateUp(connection, next.name, sqlText, sum);
   } catch (e) {
     const err = e as Error;
-    await updateLogTerminal({
-      client,
-      id: logId,
-      status: 'error',
-      durationMs: Date.now() - startedAt,
-      errorMessage: String(err?.message ?? e),
-    });
+    await provider.log(connection, logId, next.name, 'up', 'error', Date.now() - startedAt, String(err?.message ?? e));
     throw e;
   }
 
-  await updateLogTerminal({
-    client,
-    id: logId,
-    status: 'success',
-    durationMs: Date.now() - startedAt,
-    errorMessage: null,
-  });
+  await provider.log(connection, logId, next.name, 'up', 'success', Date.now() - startedAt, null);
   return { applied: true, name: next.name };
 }
 
 export async function applyOneDown({
-  client,
+  provider,
+  connection,
   migrations,
   env = process.env,
 }: {
-  client: MigrationClient;
+  provider: IDatasourceProvider;
+  connection: string;
   migrations: MigrationDescriptor[];
   env?: NodeJS.ProcessEnv;
 }): Promise<{ rolledBack: boolean; name: string | null }> {
-  const applied = await appliedRecords(client);
+  const applied = await provider.applied(connection);
   await assertNoChecksumDrift({ migrations, applied, env });
   if (applied.size === 0) return { rolledBack: false, name: null };
 
@@ -159,56 +142,29 @@ export async function applyOneDown({
   }
   const downPath = lastApplied.downPath;
 
-  const logId = await insertLogStarted(client, lastApplied.name, 'down');
+  const logId = await provider.log(connection, null, lastApplied.name, 'down', null, 0, null);
   const startedAt = Date.now();
 
   try {
-    await client.transaction(async () => {
-      const stmts = splitOnGo(await readFile(downPath, 'utf8'));
-      for (const stmt of stmts) {
-        await client.exec(stmt);
-      }
-      await deleteMigrate(client, lastApplied.name);
-    });
+    await provider.migrateDown(connection, lastApplied.name, await readFile(downPath, 'utf8'));
   } catch (e) {
     const err = e as Error;
-    await updateLogTerminal({
-      client,
-      id: logId,
-      status: 'error',
-      durationMs: Date.now() - startedAt,
-      errorMessage: String(err?.message ?? e),
-    });
+    await provider.log(
+      connection,
+      logId,
+      lastApplied.name,
+      'down',
+      'error',
+      Date.now() - startedAt,
+      String(err?.message ?? e),
+    );
     throw e;
   }
 
-  await updateLogTerminal({
-    client,
-    id: logId,
-    status: 'success',
-    durationMs: Date.now() - startedAt,
-    errorMessage: null,
-  });
+  await provider.log(connection, logId, lastApplied.name, 'down', 'success', Date.now() - startedAt, null);
   return { rolledBack: true, name: lastApplied.name };
 }
 
-function dialectOf(client: MigrationClient): ISqlDialect {
-  return defaultDialectFactory.get(client.dialect);
-}
-
-async function appliedRecords(client: MigrationClient): Promise<Map<string, string | null>> {
-  const d = dialectOf(client);
-  const q = (ident: string) => d.quoteIdent(ident);
-  const rows = await client.query(
-    `SELECT ${q('name')} AS name, ${q('checksum')} AS checksum FROM ${q('migrates')}`,
-  );
-  return new Map(
-    rows.map(
-      (r) => [r.name ?? r.NAME, r.checksum ?? r.CHECKSUM ?? null] as [string, string | null],
-    ),
-  );
-}
-
 async function assertNoChecksumDrift({
   migrations,
   applied,
@@ -239,76 +195,3 @@ async function assertNoChecksumDrift({
     .join('\n');
   throw new Error(fillTemplate(checksumDriftTpl, { lines }).trimEnd());
 }
-
-async function insertMigrate(client: MigrationClient, name: string, sum: string): Promise<void> {
-  const d = dialectOf(client);
-  const t = d.quoteIdent('migrates');
-  await client.run(
-    `INSERT INTO ${t} (${d.quoteIdent('name')}, ${d.quoteIdent('checksum')}) VALUES (?, ?)`,
-    [name, sum],
-  );
-}
-
-async function deleteMigrate(client: MigrationClient, name: string): Promise<void> {
-  const d = dialectOf(client);
-  const t = d.quoteIdent('migrates');
-  await client.run(`DELETE FROM ${t} WHERE ${d.quoteIdent('name')} = ?`, [name]);
-}
-
-async function insertLogStarted(
-  client: MigrationClient,
-  name: string,
-  direction: string,
-): Promise<MigrationRowValue> {
-  const d = dialectOf(client);
-  const t = d.quoteIdent('migrate_logs');
-  if (d.usesLastInsertRowid) {
-    const stmt = `INSERT INTO ${t} (${d.quoteIdent('migrate_name')}, ${d.quoteIdent('direction')}, ${d.quoteIdent('status')}) VALUES (?, ?, 'started')`;
-    const db = client._raw;
-    if (db) {
-      const info = db.prepare(stmt).run(name, direction);
-      return info.lastInsertRowid;
-    }
-    await client.run(stmt, [name, direction]);
-    const rows = await client.query(
-      `SELECT ${d.quoteIdent('id')} AS id FROM ${t} WHERE ${d.quoteIdent('migrate_name')} = ? AND ${d.quoteIdent('direction')} = ? ORDER BY id DESC ${d.limitClause(1)}`,
-      [name, direction],
-    );
-    return rows[0]?.id;
-  }
-  await client.run(
-    `INSERT INTO ${t} (${d.quoteIdent('migrate_name')}, ${d.quoteIdent('direction')}, ${d.quoteIdent('status')}) VALUES (?, ?, 'started')`,
-    [name, direction],
-  );
-  const rows = await client.query(
-    `SELECT ${d.quoteIdent('id')} AS id FROM ${t} WHERE ${d.quoteIdent('migrate_name')} = ? AND ${d.quoteIdent('direction')} = ? ORDER BY ${d.quoteIdent('id')} DESC ${d.limitClause(1)}`,
-    [name, direction],
-  );
-  return rows[0]?.id ?? rows[0]?.ID;
-}
-
-async function updateLogTerminal({
-  client,
-  id,
-  status,
-  durationMs,
-  errorMessage,
-}: {
-  client: MigrationClient;
-  id: MigrationRowValue;
-  status: string;
-  durationMs: number;
-  errorMessage: string | null;
-}): Promise<void> {
-  const d = dialectOf(client);
-  const t = d.quoteIdent('migrate_logs');
-  const setNow = d.nowExpr();
-  await client.run(
-    `UPDATE ${t} SET ${d.quoteIdent('status')} = ?, ${d.quoteIdent('finished_at')} = ${setNow}, ${d.quoteIdent('duration_ms')} = ?, ${d.quoteIdent('error_message')} = ?, ${d.quoteIdent('updated')} = ${setNow} WHERE ${d.quoteIdent('id')} = ?`,
-    [status, durationMs, errorMessage, id],
-  );
-}
-
-function requireDialect(dialect: string): SqlDialect {
-  return defaultDialectFactory.get(dialect).name;
-}

package/typescript/src/index.ts

@@ -7,6 +7,12 @@ export type {
   SetupArg,
   UpArg,
 } from './abstractions/migrater.ts';
+export type {
+  IDatasourceProvider,
+  IDialect,
+  ISqlDialect,
+  ProviderLogId,
+} from './abstractions/datasource-provider.ts';
 export { getMigrater, Migrater } from './migrater.ts';
 export {
   fillHelpTemplate,

package/typescript/src/infrastructure/connection-resolver.ts

@@ -1,18 +1,18 @@
-import type { ISqlDialect } from '../abstractions/sql-dialect.ts';
+import { cliSpec } from '../cli-spec.ts';
 
 export class ConnectionResolver {
   constructor(private readonly env: NodeJS.ProcessEnv = process.env) {}
 
-  fromEnvironment(dialect: ISqlDialect): string | null {
-    for (const name of dialect.connectionEnvironmentVariables) {
+  fromEnvironment(provider: string): string | null {
+    for (const name of cliSpec.connection_environment[provider] ?? []) {
       const value = this.env[name];
       if (value) return value;
     }
     return null;
   }
 
-  resolve(dialect: ISqlDialect, fromFlag: string | null): string | null {
+  resolve(provider: string, fromFlag: string | null): string | null {
     if (fromFlag) return fromFlag;
-    return this.fromEnvironment(dialect);
+    return this.fromEnvironment(provider);
   }
 }

package/typescript/src/infrastructure/default-factory.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { defaultDialectFactory } from './default-factory.ts';
+import { parseProviders } from './migraters-config.ts';
 
 describe('defaultDialectFactory', () => {
   it('registers every dialect name and alias', () => {
@@ -27,4 +28,20 @@ describe('defaultDialectFactory', () => {
     expect(defaultDialectFactory.tryGet('nope')).toBeUndefined();
     expect(() => defaultDialectFactory.get('nope')).toThrow(/Unknown SQL dialect/);
   });
+
+  it('reads the providers list migrate-init writes', () => {
+    expect(
+      parseProviders(
+        `language: typescript
+providers:
+  - name: sqlite
+    location: typescript/providers/sqlite/src/index.ts
+  - name: postgres
+    location: typescript/providers/postgres/src/index.ts
+binDir: typescript/dist/src/bin
+`,
+      ).map((p) => p.name),
+    ).toEqual(['sqlite', 'postgres']);
+    expect(parseProviders('language: rust\nproviders: []\nbinDir: rust/target/debug\n')).toEqual([]);
+  });
 });

package/typescript/src/infrastructure/default-factory.ts

@@ -1,41 +1,44 @@
 import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { isAbsolute, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { SqlDialectFactory } from '../abstractions/sql-dialect-factory.ts';
-import type { ISqlDialect } from '../abstractions/sql-dialect.ts';
+import type { IDatasourceProvider } from '../abstractions/datasource-provider.ts';
 import { ConnectionResolver } from './connection-resolver.ts';
+import { enabledProviders } from './migraters-config.ts';
 
-const DIALECT_PACKAGES = [
-  'sqlite',
-  'postgres',
-  'mysql',
-  'sqlserver',
-  'oracle',
-] as const;
-
-const dialectEntry = (name: string): string => {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const ext = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
-  return join(here, '..', '..', 'dialects', name, 'src', `index${ext}`);
+const loadModule = async (
+  location: string,
+  configDir: string,
+): Promise<IDatasourceProvider> => {
+  const relative = isAbsolute(location) ? location : resolve(configDir, location);
+  const stripped = location.startsWith('typescript/')
+    ? resolve(configDir, location.slice('typescript/'.length))
+    : relative;
+  const file = existsSync(relative) ? relative : stripped;
+  const specifier = existsSync(file) ? pathToFileURL(file).href : location;
+  const mod = (await import(specifier)) as {
+    provider?: () => IDatasourceProvider;
+    createProvider?: () => IDatasourceProvider;
+  };
+  const create = mod.provider ?? mod.createProvider;
+  if (typeof create !== 'function') throw new Error(location);
+  return create();
 };
 
-const loadInstalledDialects = async (): Promise<ISqlDialect[]> => {
-  const loaded: ISqlDialect[] = [];
-  for (const name of DIALECT_PACKAGES) {
-    const file = dialectEntry(name);
-    if (!existsSync(file)) continue;
+const loadInstalledProviders = async (): Promise<IDatasourceProvider[]> => {
+  const { configDir, entries } = enabledProviders();
+  const loaded: IDatasourceProvider[] = [];
+  for (const entry of entries) {
     try {
-      const mod = (await import(pathToFileURL(file).href)) as { createDialect?: () => ISqlDialect };
-      if (typeof mod.createDialect === 'function') {
-        loaded.push(mod.createDialect());
-      }
-    } catch {
-      // Dialect is compiled and drivers are installed by migrate-init.
+      loaded.push(await loadModule(entry.location, configDir));
+    } catch (err) {
+      if (err instanceof Error && err.message === entry.name) throw err;
+      throw new Error(entry.name, { cause: err });
     }
   }
   return loaded;
 };
 
-export const defaultDialectFactory = new SqlDialectFactory(await loadInstalledDialects());
+export const defaultDialectFactory = new SqlDialectFactory(await loadInstalledProviders());
 
 export const connectionResolver = new ConnectionResolver();

package/typescript/src/infrastructure/migraters-config.ts

@@ -0,0 +1,53 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export const CONFIG_NAME = '.migraters.yaml';
+
+export type ProviderEntry = { name: string; location: string };
+
+export const findConfigPath = (start: string): string | undefined => {
+  let dir = resolve(start);
+  while (true) {
+    const candidate = join(dir, CONFIG_NAME);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+};
+
+export const parseProviders = (raw: string): ProviderEntry[] => {
+  const entries: ProviderEntry[] = [];
+  let inProviders = false;
+  let name: string | undefined;
+  for (const line of raw.split('\n')) {
+    const trimmed = line.replace(/\r$/, '');
+    if (!inProviders) {
+      if (trimmed.trim() === 'providers:') inProviders = true;
+      continue;
+    }
+    const item = trimmed.trim();
+    if (item.startsWith('- name:')) {
+      name = item.slice('- name:'.length).trim();
+      continue;
+    }
+    if (item.startsWith('location:') && name) {
+      const location = item.slice('location:'.length).trim();
+      if (name.length > 0 && location.length > 0) entries.push({ name, location });
+      name = undefined;
+      continue;
+    }
+    if (item.length === 0) continue;
+    if (item.startsWith('- ')) continue;
+    break;
+  }
+  return entries;
+};
+
+export const enabledProviders = (
+  start = process.cwd(),
+): { configDir: string; entries: ProviderEntry[] } => {
+  const path = findConfigPath(start);
+  if (!path) return { configDir: start, entries: [] };
+  return { configDir: dirname(path), entries: parseProviders(readFileSync(path, 'utf8')) };
+};