bunsql-native-migrate 0.4.0 → 0.4.1

package/src/api/pending.ts

@@ -1,4 +1,4 @@
-import { listFiles, MIGRATION_EXTENSIONS } from "../core/fs.js";
+import { listMigrationFiles } from "../core/fs.js";
 import { log } from "../core/console.js";
 import { MigrationNotFoundError } from "./options.js";
 
@@ -29,7 +29,7 @@ export async function assertTargetOptions(
     throw new Error(`Invalid ${command} options: "to" and "steps" cannot be combined`);
   }
   if (target !== undefined) {
-    assertTargetInFiles(await listFiles(listDir, MIGRATION_EXTENSIONS), target);
+    assertTargetInFiles(await listMigrationFiles(listDir), target);
   }
 }
 

package/src/api/status.ts

@@ -1,4 +1,4 @@
-import { listFiles, MIGRATION_EXTENSIONS, resolveListDir } from "../core/fs.js";
+import { listMigrationFiles, resolveListDir } from "../core/fs.js";
 import type { MigrateOptions, MigrateStatusResult } from "./options.js";
 import { runWithDriver } from "./run-with-driver.js";
 import { ensureTrackingTable } from "./tracking-table.js";
@@ -9,7 +9,7 @@ export async function migrateStatus(options: MigrateOptions = {}): Promise<Migra
   return runWithDriver(options, async (driver) => {
     await ensureTrackingTable(driver);
 
-    const files = await listFiles(listDir, MIGRATION_EXTENSIONS);
+    const files = await listMigrationFiles(listDir);
     const executed = await driver.listExecuted();
     const appliedNames = new Set(executed.map((entry) => entry.name));
 

package/src/api/tracking-table.ts

@@ -13,3 +13,14 @@ export async function listExecutedForPlan(driver: MigrationDriver): Promise<Exec
   }
   return driver.listExecuted();
 }
+
+export async function loadExecutedHistory(
+  driver: MigrationDriver,
+  dryRun: boolean,
+): Promise<ExecutedMigration[]> {
+  if (dryRun) {
+    return listExecutedForPlan(driver);
+  }
+  await ensureTrackingTable(driver);
+  return driver.listExecuted();
+}

package/src/api/up.ts

@@ -1,5 +1,4 @@
-import path from "node:path";
-import { checksumFile, listFiles, MIGRATION_EXTENSIONS, resolveListDir } from "../core/fs.js";
+import { checksumFiles, listMigrationFiles, resolveListDir } from "../core/fs.js";
 import { log } from "../core/console.js";
 import { formatDuration } from "../core/duration.js";
 import { type MigrateUpOptions, type MigrateUpResult, ChecksumDriftError } from "./options.js";
@@ -8,7 +7,7 @@ import { runMigrationStep } from "./run-step.js";
 import { loadMigration } from "./load-migration.js";
 import { resolvePendingToTarget } from "./pending.js";
 import { resolveLockTimeout, withMigrationLock } from "./lock.js";
-import { ensureTrackingTable, listExecutedForPlan } from "./tracking-table.js";
+import { loadExecutedHistory } from "./tracking-table.js";
 
 export async function migrateUp(options: MigrateUpOptions = {}): Promise<MigrateUpResult> {
   const listDir = resolveListDir(options.listDir);
@@ -17,22 +16,10 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
   const lockTimeout = resolveLockTimeout(options.lockTimeout);
 
   return runWithDriver(options, async (driver) => {
-    if (!dryRun) {
-      await ensureTrackingTable(driver);
-    }
-
     const run = async (): Promise<MigrateUpResult> => {
-      const allFiles = await listFiles(listDir, MIGRATION_EXTENSIONS);
-
-      const checksums = new Map(
-        await Promise.all(
-          allFiles.map(
-            async (file) => [file, await checksumFile(path.join(listDir, file))] as const,
-          ),
-        ),
-      );
-
-      const executed = dryRun ? await listExecutedForPlan(driver) : await driver.listExecuted();
+      const allFiles = await listMigrationFiles(listDir);
+      const checksums = await checksumFiles(listDir, allFiles);
+      const executed = await loadExecutedHistory(driver, dryRun);
       const executedByName = new Map(executed.map((entry) => [entry.name, entry]));
 
       for (const [file, checksum] of checksums) {
@@ -81,7 +68,9 @@ export async function migrateUp(options: MigrateUpOptions = {}): Promise<Migrate
 
       for (const file of pending) {
         const checksum = checksums.get(file);
-        if (!checksum) continue;
+        if (checksum === undefined) {
+          throw new Error(`checksum for ${file} was not computed`);
+        }
         try {
           const { up } = await loadMigration(listDir, file);
           if (up === null) {

package/src/cli/exit-codes.ts

@@ -0,0 +1,31 @@
+import {
+  ChecksumDriftError,
+  InvalidMigrationNameError,
+  MigrationLockError,
+} from "../api/options.js";
+import { InvalidIdentifierError } from "../core/identifiers.js";
+import { InvalidConfigError } from "../core/config.js";
+
+export const EXIT_SUCCESS = 0;
+export const EXIT_GENERIC = 1;
+export const EXIT_PENDING = 2;
+export const EXIT_CHECKSUM_DRIFT = 3;
+export const EXIT_LOCK_TIMEOUT = 4;
+export const EXIT_USAGE = 5;
+
+export function exitCodeForError(error: unknown): number {
+  if (error instanceof ChecksumDriftError) {
+    return EXIT_CHECKSUM_DRIFT;
+  }
+  if (error instanceof MigrationLockError) {
+    return EXIT_LOCK_TIMEOUT;
+  }
+  if (
+    error instanceof InvalidIdentifierError ||
+    error instanceof InvalidConfigError ||
+    error instanceof InvalidMigrationNameError
+  ) {
+    return EXIT_USAGE;
+  }
+  return EXIT_GENERIC;
+}

package/src/cli/main.ts

@@ -9,20 +9,25 @@ import { createMigrationCommand, type MigrationLang } from "../api/create.js";
 import { initMigrations } from "../api/init.js";
 import { markMigrationsApplied } from "../api/mark.js";
 import { resolveSecondsOption } from "../core/duration.js";
+import { loadProjectConfig, InvalidConfigError } from "../core/config.js";
 import {
   ChecksumDriftError,
   DatabaseWaitTimeoutError,
+  InvalidMigrationNameError,
+  MigrationFileMissingError,
   MigrationLockError,
   MigrationNotFoundError,
 } from "../api/options.js";
 import { InvalidIdentifierError } from "../core/identifiers.js";
 import { log } from "../core/console.js";
+import { EXIT_PENDING, EXIT_SUCCESS, EXIT_USAGE, exitCodeForError } from "./exit-codes.js";
 
 interface CliArgs {
   command: string | undefined;
   positional: string[];
   url?: string | undefined;
   dir?: string | undefined;
+  config?: string | undefined;
   git: boolean;
   lang?: MigrationLang | undefined;
   to?: string | undefined;
@@ -37,7 +42,7 @@ interface CliArgs {
   version: boolean;
 }
 
-type FlagKey = Exclude<keyof CliArgs, "command" | "positional" | "help" | "version">;
+type FlagKey = Exclude<keyof CliArgs, "command" | "positional" | "help" | "version" | "config">;
 
 const FLAG_NAMES: Record<FlagKey, string> = {
   url: "--url",
@@ -74,7 +79,7 @@ const COMMAND_SPECS: Record<string, CommandSpec> = {
     positionalLimit: 1,
   },
   init: { flags: new Set(["dir", "lang"]), positionalLimit: 0 },
-  install: { flags: new Set(["url", "dir", "wait", "table", "schema"]), positionalLimit: 0 },
+  install: { flags: new Set(["url", "wait", "table", "schema"]), positionalLimit: 0 },
   create: { flags: new Set(["dir", "lang", "git"]), positionalLimit: 1 },
   mark: { flags: new Set(["url", "dir", "wait", "table", "schema", "all"]), positionalLimit: 1 },
   status: {
@@ -91,7 +96,7 @@ function rejectDisallowedFlags(command: string, args: CliArgs): void {
   const [extra] = args.positional.slice(spec.positionalLimit);
   if (extra !== undefined) {
     log({ text: `Unexpected argument for ${command}: ${extra}`, type: "error" });
-    usage(1);
+    usage(EXIT_USAGE);
   }
   for (const flag of Object.keys(FLAG_NAMES) as FlagKey[]) {
     const value = args[flag];
@@ -99,7 +104,7 @@ function rejectDisallowedFlags(command: string, args: CliArgs): void {
       continue;
     }
     log({ text: `${command} does not support ${FLAG_NAMES[flag]}.`, type: "error" });
-    usage(1);
+    usage(EXIT_USAGE);
   }
 }
 
@@ -111,14 +116,41 @@ function parseSecondsValue(flag: string, value: string | undefined): number {
       text: `Invalid ${flag}: ${value ?? "(missing)"} (expected a non-negative integer of seconds)`,
       type: "error",
     });
-    usage(1);
+    usage(EXIT_USAGE);
   }
 }
 
+function parseStepsArg(stepsArg: string): number {
+  try {
+    return parseSteps(Number(stepsArg));
+  } catch {
+    log({
+      text: `Invalid step count: ${stepsArg} (expected a positive integer)`,
+      type: "error",
+    });
+    usage(EXIT_USAGE);
+  }
+}
+
+function requireFlagValue(
+  argv: string[],
+  index: number,
+  flag: string,
+  description: string,
+): string {
+  const value = argv[index];
+  if (value !== undefined && value !== "" && !value.startsWith("-")) {
+    return value;
+  }
+  log({ text: `${flag} requires ${description}`, type: "error" });
+  usage(EXIT_USAGE);
+}
+
 function parseArgs(argv: string[]): CliArgs {
   const positional: string[] = [];
   let url: string | undefined;
   let dir: string | undefined;
+  let config: string | undefined;
   let git = false;
   let lang: MigrationLang | undefined;
   let to: string | undefined;
@@ -134,13 +166,11 @@ function parseArgs(argv: string[]): CliArgs {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]!;
     if (arg === "--url") {
-      url = argv[++i];
-      if (url === undefined) {
-        log({ text: "--url requires a database URL", type: "error" });
-        usage(1);
-      }
+      url = requireFlagValue(argv, ++i, "--url", "a database URL");
     } else if (arg === "--dir") {
-      dir = argv[++i];
+      dir = requireFlagValue(argv, ++i, "--dir", "a migrations directory path");
+    } else if (arg === "--config") {
+      config = requireFlagValue(argv, ++i, "--config", "a config file path");
     } else if (arg === "--git") {
       git = true;
     } else if (arg === "--lang") {
@@ -150,31 +180,19 @@ function parseArgs(argv: string[]): CliArgs {
           text: `Unknown --lang value: ${value ?? "(missing)"} (expected js or ts)`,
           type: "error",
         });
-        usage(1);
+        usage(EXIT_USAGE);
       }
       lang = value;
     } else if (arg === "--to") {
-      to = argv[++i];
-      if (to === undefined) {
-        log({ text: "--to requires a migration file name", type: "error" });
-        usage(1);
-      }
+      to = requireFlagValue(argv, ++i, "--to", "a migration file name");
     } else if (arg === "--lock-timeout") {
       lockTimeout = parseSecondsValue("--lock-timeout", argv[++i]);
     } else if (arg === "--wait") {
       wait = parseSecondsValue("--wait", argv[++i]);
     } else if (arg === "--table") {
-      table = argv[++i];
-      if (table === undefined) {
-        log({ text: "--table requires a tracking table name", type: "error" });
-        usage(1);
-      }
+      table = requireFlagValue(argv, ++i, "--table", "a tracking table name");
     } else if (arg === "--schema") {
-      schema = argv[++i];
-      if (schema === undefined) {
-        log({ text: "--schema requires a postgres schema name", type: "error" });
-        usage(1);
-      }
+      schema = requireFlagValue(argv, ++i, "--schema", "a postgres schema name");
     } else if (arg === "--all") {
       all = true;
     } else if (arg === "--dry-run") {
@@ -186,6 +204,10 @@ function parseArgs(argv: string[]): CliArgs {
     } else if (arg === "--version") {
       version = true;
     } else {
+      if (arg === "") {
+        log({ text: "Empty argument is not allowed", type: "error" });
+        usage(EXIT_USAGE);
+      }
       positional.push(arg);
     }
   }
@@ -194,6 +216,7 @@ function parseArgs(argv: string[]): CliArgs {
     positional,
     url,
     dir,
+    config,
     git,
     lang,
     to,
@@ -211,7 +234,7 @@ function parseArgs(argv: string[]): CliArgs {
 
 function usage(exitCode: number): never {
   log({
-    text: "Usage: bunsql-native-migrate <init|up|down [n]|redo [n]|install|create [name]|mark [name]|status|version> [--url <url>] [--dir <migrations-dir>] [--to <name>] [--lock-timeout <seconds>] [--wait <seconds>] [--table <name>] [--schema <name>] [--dry-run] [--all] [--lang <js|ts>] [--git] [--strict] [--version] [--help]",
+    text: "Usage: bunsql-native-migrate <init|up|down [n]|redo [n]|install|create [name]|mark [name]|status|version> [--url <url>] [--dir <migrations-dir>] [--config <path>] [--to <name>] [--lock-timeout <seconds>] [--wait <seconds>] [--table <name>] [--schema <name>] [--dry-run] [--all] [--lang <js|ts>] [--git] [--strict] [--version] [--help]",
     type: "info",
   });
   process.exit(exitCode);
@@ -223,33 +246,45 @@ async function printVersion(): Promise<void> {
 }
 
 const args = parseArgs(process.argv.slice(2));
-const urlOptions = args.url !== undefined ? { databaseUrl: args.url } : {};
-const waitOptions = args.wait !== undefined && args.wait > 0 ? { waitTimeout: args.wait } : {};
-const listDirOptions = args.dir ? { listDir: args.dir } : {};
-const tableOptions = {
-  ...(args.table !== undefined ? { tableName: args.table } : {}),
-  ...(args.schema !== undefined ? { schema: args.schema } : {}),
-};
-const connectOptions = {
-  ...urlOptions,
-  ...listDirOptions,
-  ...tableOptions,
-  ...waitOptions,
-};
 
 if (args.help) {
-  usage(0);
+  usage(EXIT_SUCCESS);
 }
 
 if (args.version) {
   await printVersion();
-  process.exit(0);
+  process.exit(EXIT_SUCCESS);
+}
+
+if (args.command !== undefined) {
+  rejectDisallowedFlags(args.command, args);
 }
 
 try {
-  if (args.command !== undefined) {
-    rejectDisallowedFlags(args.command, args);
-  }
+  const config = args.command === "version" ? {} : await loadProjectConfig(args.config);
+
+  const databaseUrl = args.url ?? config.databaseUrl;
+  const listDir = args.dir ?? config.listDir;
+  const tableName = args.table ?? config.tableName;
+  const schema = args.schema ?? config.schema;
+  const lang = args.lang ?? config.lang;
+  const lockTimeout = args.lockTimeout ?? config.lockTimeout;
+  const waitTimeout = args.wait ?? config.waitTimeout;
+
+  const urlOptions = databaseUrl !== undefined ? { databaseUrl } : {};
+  const waitOptions = waitTimeout !== undefined && waitTimeout > 0 ? { waitTimeout } : {};
+  const listDirOptions = listDir !== undefined ? { listDir } : {};
+  const tableOptions = {
+    ...(tableName !== undefined ? { tableName } : {}),
+    ...(schema !== undefined ? { schema } : {}),
+  };
+  const connectOptions = {
+    ...urlOptions,
+    ...listDirOptions,
+    ...tableOptions,
+    ...waitOptions,
+  };
+
   switch (args.command) {
     case "version": {
       await printVersion();
@@ -258,8 +293,8 @@ try {
     case "up": {
       const { applied, planned } = await migrateUp({
         ...connectOptions,
-        ...(args.to ? { to: args.to } : {}),
-        ...(args.lockTimeout !== undefined ? { lockTimeout: args.lockTimeout } : {}),
+        ...(args.to !== undefined ? { to: args.to } : {}),
+        ...(lockTimeout !== undefined ? { lockTimeout } : {}),
         ...(args.dryRun ? { dryRun: true } : {}),
       });
       if (planned !== undefined && planned.length > 0) {
@@ -274,28 +309,20 @@ try {
       const [stepsArg] = args.positional;
       if (args.all && stepsArg !== undefined) {
         log({ text: "Use either --all or a number of steps, not both.", type: "error" });
-        usage(1);
+        usage(EXIT_USAGE);
       }
       if (args.to !== undefined && (args.all || stepsArg !== undefined)) {
         log({
           text: "Use either --to, --all, or a number of steps, not more than one of them.",
           type: "error",
         });
-        usage(1);
+        usage(EXIT_USAGE);
       }
       let steps: number | "all" = 1;
       if (args.all) {
         steps = "all";
       } else if (stepsArg !== undefined) {
-        try {
-          steps = parseSteps(Number(stepsArg));
-        } catch {
-          log({
-            text: `Invalid step count: ${stepsArg} (expected a positive integer)`,
-            type: "error",
-          });
-          usage(1);
-        }
+        steps = parseStepsArg(stepsArg);
       }
       const { reverted, planned } = await migrateDown({
         ...connectOptions,
@@ -314,25 +341,17 @@ try {
       const [stepsArg] = args.positional;
       if (stepsArg !== undefined && args.to !== undefined) {
         log({ text: "Use either --to or a step count, not both.", type: "error" });
-        usage(1);
+        usage(EXIT_USAGE);
       }
       let steps: number | undefined;
       if (stepsArg !== undefined) {
-        try {
-          steps = parseSteps(Number(stepsArg));
-        } catch {
-          log({
-            text: `Invalid step count: ${stepsArg} (expected a positive integer)`,
-            type: "error",
-          });
-          usage(1);
-        }
+        steps = parseStepsArg(stepsArg);
       }
       const { reverted } = await migrateRedo({
         ...connectOptions,
         ...(steps !== undefined ? { steps } : {}),
         ...(args.to !== undefined ? { to: args.to } : {}),
-        ...(args.lockTimeout !== undefined ? { lockTimeout: args.lockTimeout } : {}),
+        ...(lockTimeout !== undefined ? { lockTimeout } : {}),
       });
       if (reverted.length > 0) {
         log({ text: `Redid ${reverted.length} migration(s).`, type: "success" });
@@ -342,7 +361,7 @@ try {
     case "init": {
       await initMigrations({
         ...listDirOptions,
-        ...(args.lang !== undefined ? { lang: args.lang } : {}),
+        ...(lang !== undefined ? { lang } : {}),
       });
       break;
     }
@@ -353,8 +372,8 @@ try {
     case "create": {
       const [name] = args.positional;
       await createMigrationCommand({
-        ...(name ? { name } : {}),
-        ...(args.lang ? { lang: args.lang } : {}),
+        ...(name !== undefined ? { name } : {}),
+        ...(lang !== undefined ? { lang } : {}),
         git: args.git,
         ...listDirOptions,
       });
@@ -364,11 +383,11 @@ try {
       const [name] = args.positional;
       if (args.all && name !== undefined) {
         log({ text: "Use either --all or a migration file name, not both.", type: "error" });
-        usage(1);
+        usage(EXIT_USAGE);
       }
       if (!args.all && name === undefined) {
         log({ text: "mark requires a migration file name or --all.", type: "error" });
-        usage(1);
+        usage(EXIT_USAGE);
       }
       const { marked } = await markMigrationsApplied({
         ...connectOptions,
@@ -390,24 +409,27 @@ try {
       log({ text: `${applied.length} applied, ${pending.length} pending`, type: "info" });
       if (args.strict && pending.length > 0) {
         log({ text: `Strict mode: ${pending.length} pending migration(s).`, type: "warn" });
-        process.exit(1);
+        process.exit(EXIT_PENDING);
       }
       break;
     }
     default:
-      usage(1);
+      usage(EXIT_USAGE);
   }
 } catch (error) {
   if (
     error instanceof ChecksumDriftError ||
     error instanceof MigrationNotFoundError ||
+    error instanceof MigrationFileMissingError ||
     error instanceof MigrationLockError ||
     error instanceof DatabaseWaitTimeoutError ||
-    error instanceof InvalidIdentifierError
+    error instanceof InvalidIdentifierError ||
+    error instanceof InvalidConfigError ||
+    error instanceof InvalidMigrationNameError
   ) {
     log({ text: error.message, type: "error" });
   } else {
     log({ text: "Migration command failed", type: "error", error });
   }
-  process.exit(1);
+  process.exit(exitCodeForError(error));
 }

package/src/core/config.ts

@@ -0,0 +1,131 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { type MigrationLang } from "../api/create.js";
+
+export interface ProjectConfig {
+  databaseUrl?: string;
+  listDir?: string;
+  tableName?: string;
+  schema?: string;
+  lang?: MigrationLang;
+  lockTimeout?: number;
+  waitTimeout?: number;
+}
+
+const CONFIG_FILE_NAMES = ["bunsql-migrate.config.ts", "bunsql-migrate.config.js"];
+
+type ConfigKeyType = "string" | "lang" | "seconds";
+
+const CONFIG_KEYS: Record<string, ConfigKeyType> = {
+  databaseUrl: "string",
+  listDir: "string",
+  tableName: "string",
+  schema: "string",
+  lang: "lang",
+  lockTimeout: "seconds",
+  waitTimeout: "seconds",
+};
+
+export class InvalidConfigError extends Error {
+  readonly configPath: string;
+
+  constructor(configPath: string, detail: string) {
+    super(`${configPath}: ${detail}`);
+    this.name = "InvalidConfigError";
+    this.configPath = configPath;
+  }
+}
+
+function resolveConfigPath(override?: string): string | null {
+  if (override !== undefined) {
+    const resolved = path.resolve(override);
+    if (!existsSync(resolved)) {
+      throw new InvalidConfigError(override, "config file not found");
+    }
+    return resolved;
+  }
+  for (const name of CONFIG_FILE_NAMES) {
+    const candidate = path.resolve(name);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function importConfig(filePath: string): Promise<Record<string, unknown>> {
+  let moduleNamespace: Record<string, unknown>;
+  try {
+    moduleNamespace = (await import(pathToFileURL(filePath).href)) as Record<string, unknown>;
+  } catch (error) {
+    throw new InvalidConfigError(
+      filePath,
+      `could not load the config file — ${errorMessage(error)}`,
+    );
+  }
+  const exported =
+    moduleNamespace["default"] !== undefined ? moduleNamespace["default"] : moduleNamespace;
+  if (typeof exported !== "object" || exported === null || Array.isArray(exported)) {
+    throw new InvalidConfigError(filePath, "must export a config object");
+  }
+  return exported as Record<string, unknown>;
+}
+
+function quoteKeys(keys: string[]): string {
+  return keys.map((key) => `"${key}"`).join(", ");
+}
+
+function validateConfig(filePath: string, raw: Record<string, unknown>): ProjectConfig {
+  const unknownKeys = Object.keys(raw).filter((key) => !(key in CONFIG_KEYS));
+  if (unknownKeys.length > 0) {
+    const label = unknownKeys.length > 1 ? "unknown config keys" : "unknown config key";
+    throw new InvalidConfigError(filePath, `${label} ${quoteKeys(unknownKeys)}`);
+  }
+
+  const problems: string[] = [];
+  const config: Record<string, string | number> = {};
+  for (const [key, kind] of Object.entries(CONFIG_KEYS)) {
+    const value = raw[key];
+    if (value === undefined) {
+      continue;
+    }
+    if (kind === "string") {
+      if (typeof value === "string") {
+        config[key] = value;
+      } else {
+        problems.push(`expected a string for "${key}"`);
+      }
+      continue;
+    }
+    if (kind === "lang") {
+      if (value === "js" || value === "ts") {
+        config[key] = value;
+      } else {
+        problems.push(`expected "js" or "ts" for "${key}"`);
+      }
+      continue;
+    }
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+      config[key] = value;
+    } else {
+      problems.push(`expected a non-negative integer for "${key}"`);
+    }
+  }
+  if (problems.length > 0) {
+    throw new InvalidConfigError(filePath, problems.join("; "));
+  }
+  return config as ProjectConfig;
+}
+
+export async function loadProjectConfig(configPath?: string): Promise<ProjectConfig> {
+  const filePath = resolveConfigPath(configPath);
+  if (filePath === null) {
+    return {};
+  }
+  return validateConfig(filePath, await importConfig(filePath));
+}

package/src/core/console.ts

@@ -15,8 +15,11 @@ interface LogOptions {
 
 function formatError(error: unknown): void {
   if (error instanceof Error) {
+    if (error.stack) {
+      console.log(error.stack);
+      return;
+    }
     console.log(error.message);
-    if (error.stack) console.log(error.stack);
     return;
   }
   if (typeof error !== "object" || error === null) {

package/src/core/env.ts

@@ -5,3 +5,7 @@ export function getDatabaseUrl(override?: string): string {
   }
   return url;
 }
+
+export function getMigrationListDir(): string | undefined {
+  return process.env["MIGRATION_LIST_DIR"];
+}