@sebspark/spanner-migrate 0.2.0 → 1.0.0

package/README.md

@@ -14,110 +14,196 @@ yarn add -D @sebspark/spanner-migrate
 
 ---
 
-## CLI Usage
+## CLI Commands
 
-Run `spanner-migrate` from your project root. If no command is provided, the help message is displayed.
+`spanner-migrate` provides several commands for managing database migrations in Google Spanner.
 
-```zsh
-spanner-migrate [command] [options]
-```
+### Initialize Configuration
 
-### Commands
+```sh
+spanner-migrate init
+```
 
-#### `init`
-Initialize a Spanner migration configuration file (`.spanner-migrate.config.json`).
+Initializes a `.spanner-migrate.config.json` file by prompting for:
+- Spanner instance name
+- One or more database configurations
+- Optional Google Cloud project name
 
-**Usage:**
+### Create a Migration
 
-```zsh
-spanner-migrate init
+```sh
+spanner-migrate create <description ...> [--database <name>]
+spanner-migrate create add users table
+spanner-migrate create --database=mydb add users table
 ```
 
-**Prompts:**
-- `Enter the path for your migrations`: Directory for migration files (default: `./migrations`).
-- `Enter Spanner instance name`: The name of the Spanner instance.
-- `Enter Spanner database name`: The name of the Spanner database.
-- `Enter Google Cloud project name`: (Optional) The Google Cloud project name.
+Creates a new migration file with the specified description.
 
----
+- If `--database` (`-d`) is provided, it uses the specified database.
+- If multiple databases exist and none is specified, the user is prompted to select one.
+- The filename is generated from the description (`<timestamp>_add_users_table.sql`).
 
-#### `create <description>`
-Create a new migration file.
+### Apply Migrations
 
-**Usage:**
+```sh
+spanner-migrate up
+spanner-migrate up --database <name>
+spanner-migrate up --database <name> --max <n>
+```
 
-```zsh
-spanner-migrate create add users table
+Applies pending migrations.
+
+- If **no** `--database` and `--max` are provided, applies all migrations to all databases.
+- If `--database` (`-d`) is provided, applies migrations only to that database.
+- If `--max` (`-m`) is provided, limits the number of migrations applied (requires `--database`).
+- `--max` must be an integer greater than 0.
+
+### Roll Back Last Migration
+
+```sh
+spanner-migrate down
+spanner-migrate down --database <name>
 ```
 
-**Result:**
+Rolls back the last applied migration.
+
+- If a **single** database exists, it is automatically selected.
+- If multiple databases exist, `--database` is **required**.
+- The specified `--database` must exist.
+
+### Show Migration Status
 
-Example:
+```sh
+spanner-migrate status
+spanner-migrate status --database <name>
+```
+
+Displays migration status.
 
-`./migrations/20250120145638000_create_table_users.sql`
+- If `--database` is specified, shows status for that database.
+- If no `--database` is provided, shows status for all configured databases.
 
-```sql
--- Created: 2025-01-20T14:56:38.000Z
--- Description: create table users
+### Help
 
----- UP ----
+```sh
+spanner-migrate --help
+spanner-migrate <command> --help
+```
 
+Displays help for the CLI or a specific command.
 
+---
 
----- DOWN ----
+## Programmatic Usage
 
+In addition to the CLI, `spanner-migrate` can be used as a Node.js module to manage migrations programmatically.
 
+### Importing
 
+```typescript
+import { init, create, up, down, status } from '@sebspark/spanner-migrate'
 ```
 
-#### `up`
-Apply pending migrations
+### Initializing Configuration
 
-**Usage:**
+```typescript
+import { init, type Config } from '@sebspark/spanner-migrate'
 
-```zsh
-spanner-migrate up
+const config: Config = {
+  instance: {
+    name: 'my-instance',
+    databases: [
+      { name: 'mydb', migrationsPath: './migrations' },
+    ],
+  },
+  projectId: 'my-gcp-project',
+}
+
+await init(config, '.spanner-migrate.config.json')
 ```
 
-If you don't want to apply all pending migrations, use the `--max` or `-m` flag
+Writes the given configuration to a `.spanner-migrate.config.json` file.
 
-```zsh
-spanner migrate up --max 1
+### Creating a Migration
+
+```typescript
+import { create, type DatabaseConfig } from '@sebspark/spanner-migrate'
+
+const databaseConfig: DatabaseConfig = {
+  name: 'mydb',
+  migrationsPath: './migrations',
+}
+
+await create(databaseConfig, 'add users table')
 ```
 
-#### `down`
-Rollback one migration
+Creates a new migration file for the specified database.
 
-**Usage:**
+### Applying Migrations
 
-```zsh
-spanner-migrate down
+```typescript
+import { up, type Config, type DatabaseConfig } from '@sebspark/spanner-migrate'
+
+// Load configuration
+const config: Config = /* Load from file or define inline */
+
+// Apply all migrations to all databases
+await up(config)
+
+// Apply all migrations to a specific database
+const databaseConfig: DatabaseConfig = config.instance.databases[0]
+await up(config, databaseConfig)
+
+// Apply up to 5 migrations to a specific database
+await up(config, databaseConfig, 5)
 ```
 
-#### `status`
-Check migration status
+- Applies pending migrations.
+- If a database is specified, only applies migrations to that database.
+- If `max` is specified, applies at most `max` migrations.
 
-**Usage:**
+### Rolling Back Migrations
 
-```zsh
-spanner-migrate status
+```typescript
+import { up, type Config, type DatabaseConfig } from '@sebspark/spanner-migrate'
+
+const config: Config = /* Load from file */
+const databaseConfig: DatabaseConfig = config.instance.databases[0]
+
+// Roll back the last applied migration
+await down(config, databaseConfig)
 ```
-Displays an overview of applied and peding migrations
 
-```text
-Migrations
+- Rolls back the last applied migration for the specified database.
+- Requires a database to be specified.
+
+### Checking Migration Status
+
+```typescript
+import { up, type Config, type DatabaseConfig } from '@sebspark/spanner-migrate'
 
-Applied
---------------------------------------------------------------------------------
-20250122080434866_add_users_table
-20250122080444982_add_index_on_users
+const config: Config = /* Load from file */
 
-New
---------------------------------------------------------------------------------
-20250122080444982_add_index_on_users
+// Check status for all databases
+const migrationStatus = await status(config)
+console.log(migrationStatus)
+
+// Check status for a specific database
+const databaseConfig = config.instance.databases[0]
+const migrationStatusSingle = await status(config, [databaseConfig])
+console.log(migrationStatusSingle)
 ```
 
----
+- Displays applied and pending migrations for one or more databases.
+- If a specific database is provided, only its status is shown.
+
+## Running on Spanner Emulator
+
+If you want to test your migrations against a Spanner Emulator, you will need to set:
+
+```typescript
+process.env.SPANNER_EMULATOR_HOST = 'localhost:<port>'
+```
 
 ## License
 

package/dist/{chunk-Z3ZLNDVO.mjs → chunk-SZDH364K.mjs}

@@ -38,7 +38,7 @@ var applyDown = async (db) => {
     json: true
   };
   const [rows] = await db.run(req);
-  const lastMigration = rows == null ? void 0 : rows[0];
+  const lastMigration = rows?.[0];
   if (!lastMigration) {
     throw new Error("No migrations found to roll back.");
   }
@@ -100,12 +100,12 @@ var SQL_CREATE_TABLE_MIGRATIONS = `
     down STRING(1024)
   ) PRIMARY KEY (id)
 `;
-var ensureMigrationTable = async (database) => {
-  const [rows] = await database.run(SQL_SELECT_TABLE_MIGRATIONS);
+var ensureMigrationTable = async (db) => {
+  const [rows] = await db.run(SQL_SELECT_TABLE_MIGRATIONS);
   if (rows.length) return;
   console.log("Creating migration table");
   try {
-    await database.updateSchema(SQL_CREATE_TABLE_MIGRATIONS);
+    await db.updateSchema(SQL_CREATE_TABLE_MIGRATIONS);
   } catch (err) {
     console.error("Failed to create migrations table");
     throw err;
@@ -168,22 +168,17 @@ var getMigration = async (path, id) => {
     );
   }
 };
-var getDescription = (text) => {
-  var _a, _b;
-  return ((_b = (_a = text == null ? void 0 : text.match(/^--\s*Description:\s*(.+)$/m)) == null ? void 0 : _a[1]) == null ? void 0 : _b.trim()) || "";
-};
+var getDescription = (text) => text?.match(/^--\s*Description:\s*(.+)$/m)?.[1]?.trim() || "";
 var getSql = (text, direction) => {
-  var _a, _b;
   const rx = {
     up: /---- UP ----\n([\s\S]*?)\n---- DOWN ----/,
     down: /---- DOWN ----\n([\s\S]*)$/
   };
-  return (_b = (_a = text == null ? void 0 : text.match(rx[direction])) == null ? void 0 : _a[1]) == null ? void 0 : _b.replace(/--.*$/gm, "").trim();
+  return text?.match(rx[direction])?.[1]?.replace(/--.*$/gm, "").trim();
 };
 var getNewMigrations = (applied, files) => {
   const sortedFiles = files.sort();
   for (let ix = 0; ix < applied.length; ix++) {
-    console.log(sortedFiles[ix], applied[ix].id);
     if (sortedFiles[ix] !== applied[ix].id) {
       throw new Error(
         `Mismatch between applied migrations and files. Found '${sortedFiles[ix]}' but expected '${applied[ix].id}' at position ${ix}.`
@@ -191,7 +186,6 @@ var getNewMigrations = (applied, files) => {
     }
   }
   const newMigrations = sortedFiles.slice(applied.length);
-  console.log(`Found ${newMigrations.length} new migrations.`);
   return newMigrations;
 };
 var createMigration = async (path, description) => {
@@ -242,42 +236,74 @@ var init = async (config, configPath) => {
 var create = async (config, description) => {
   await createMigration(config.migrationsPath, description);
 };
-var up = async (config, max = 1e3) => {
-  const db = getDb(config);
-  await ensureMigrationTable(db);
-  const appliedMigrations = await getAppliedMigrations(db);
-  const migrationFiles = await getMigrationFiles(config.migrationsPath);
-  const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
-  console.log(`Found ${newMigrations.length} new migrations.`);
-  console.log(newMigrations.map((mig) => `	${mig}`).join("\n"));
-  for (const id of newMigrations.slice(0, max)) {
-    const migration = await getMigration(config.migrationsPath, id);
-    await applyUp(db, migration);
+var up = async (config, database, max) => {
+  if (max && !database) {
+    throw new Error("Max number of migrations requires specifying a database");
+  }
+  const databases = database ? [database] : config.instance.databases;
+  for (const databaseConfig of databases) {
+    const path = {
+      projectId: config.projectId,
+      instanceName: config.instance.name,
+      databaseName: databaseConfig.name
+    };
+    const db = getDb(path);
+    await ensureMigrationTable(db);
+    const appliedMigrations = await getAppliedMigrations(db);
+    const migrationFiles = await getMigrationFiles(
+      databaseConfig.migrationsPath
+    );
+    const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
+    console.log(`Found ${newMigrations.length} new migrations.`);
+    console.log(newMigrations.map((mig) => `	${mig}`).join("\n"));
+    const newMigrationsToApply = max ? newMigrations.slice(0, max) : newMigrations;
+    for (const id of newMigrationsToApply) {
+      const migration = await getMigration(databaseConfig.migrationsPath, id);
+      await applyUp(db, migration);
+    }
   }
 };
-var down = async (config) => {
-  const db = getDb(config);
+var down = async (config, database) => {
+  const path = {
+    projectId: config.projectId,
+    instanceName: config.instance.name,
+    databaseName: database.name
+  };
+  const db = getDb(path);
   await ensureMigrationTable(db);
   await applyDown(db);
 };
-var status = async (config) => {
-  const db = getDb(config);
-  await ensureMigrationTable(db);
-  const appliedMigrations = await getAppliedMigrations(db);
-  const migrationFiles = await getMigrationFiles(config.migrationsPath);
-  const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
-  return [
-    "Migrations",
-    "",
-    "Applied",
-    "--------------------------------------------------------------------------------",
-    `${appliedMigrations.map((m) => m.id).join("\n")}
+var status = async (config, databases) => {
+  const statuses = [];
+  for (const databaseConfig of databases || config.instance.databases) {
+    const path = {
+      projectId: config.projectId,
+      instanceName: config.instance.name,
+      databaseName: databaseConfig.name
+    };
+    const db = getDb(path);
+    await ensureMigrationTable(db);
+    const appliedMigrations = await getAppliedMigrations(db);
+    const migrationFiles = await getMigrationFiles(
+      databaseConfig.migrationsPath
+    );
+    const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
+    statuses.push(
+      [
+        `Migrations [${databaseConfig.name}]`,
+        "",
+        "Applied",
+        "--------------------------------------------------------------------------------",
+        `${appliedMigrations.map((m) => m.id).join("\n")}
 `,
-    "New",
-    "--------------------------------------------------------------------------------",
-    `${newMigrations.join("\n")}
+        "New",
+        "--------------------------------------------------------------------------------",
+        `${newMigrations.join("\n")}
 `
-  ].join("\n");
+      ].join("\n")
+    );
+  }
+  return statuses.join("\n\n");
 };
 
 export {

package/dist/cli.js

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = require("path");
-var import_input = __toESM(require("@inquirer/input"));
+var import_prompts = require("@inquirer/prompts");
 var import_yargs = __toESM(require("yargs"));
 var import_helpers = require("yargs/helpers");
 
@@ -70,7 +70,7 @@ var applyDown = async (db) => {
     json: true
   };
   const [rows] = await db.run(req);
-  const lastMigration = rows == null ? void 0 : rows[0];
+  const lastMigration = rows?.[0];
   if (!lastMigration) {
     throw new Error("No migrations found to roll back.");
   }
@@ -132,12 +132,12 @@ var SQL_CREATE_TABLE_MIGRATIONS = `
     down STRING(1024)
   ) PRIMARY KEY (id)
 `;
-var ensureMigrationTable = async (database) => {
-  const [rows] = await database.run(SQL_SELECT_TABLE_MIGRATIONS);
+var ensureMigrationTable = async (db) => {
+  const [rows] = await db.run(SQL_SELECT_TABLE_MIGRATIONS);
   if (rows.length) return;
   console.log("Creating migration table");
   try {
-    await database.updateSchema(SQL_CREATE_TABLE_MIGRATIONS);
+    await db.updateSchema(SQL_CREATE_TABLE_MIGRATIONS);
   } catch (err) {
     console.error("Failed to create migrations table");
     throw err;
@@ -200,22 +200,17 @@ var getMigration = async (path, id) => {
     );
   }
 };
-var getDescription = (text) => {
-  var _a, _b;
-  return ((_b = (_a = text == null ? void 0 : text.match(/^--\s*Description:\s*(.+)$/m)) == null ? void 0 : _a[1]) == null ? void 0 : _b.trim()) || "";
-};
+var getDescription = (text) => text?.match(/^--\s*Description:\s*(.+)$/m)?.[1]?.trim() || "";
 var getSql = (text, direction) => {
-  var _a, _b;
   const rx = {
     up: /---- UP ----\n([\s\S]*?)\n---- DOWN ----/,
     down: /---- DOWN ----\n([\s\S]*)$/
   };
-  return (_b = (_a = text == null ? void 0 : text.match(rx[direction])) == null ? void 0 : _a[1]) == null ? void 0 : _b.replace(/--.*$/gm, "").trim();
+  return text?.match(rx[direction])?.[1]?.replace(/--.*$/gm, "").trim();
 };
 var getNewMigrations = (applied, files) => {
   const sortedFiles = files.sort();
   for (let ix = 0; ix < applied.length; ix++) {
-    console.log(sortedFiles[ix], applied[ix].id);
     if (sortedFiles[ix] !== applied[ix].id) {
       throw new Error(
         `Mismatch between applied migrations and files. Found '${sortedFiles[ix]}' but expected '${applied[ix].id}' at position ${ix}.`
@@ -223,7 +218,6 @@ var getNewMigrations = (applied, files) => {
     }
   }
   const newMigrations = sortedFiles.slice(applied.length);
-  console.log(`Found ${newMigrations.length} new migrations.`);
   return newMigrations;
 };
 var createMigration = async (path, description) => {
@@ -274,86 +268,116 @@ var init = async (config, configPath) => {
 var create = async (config, description) => {
   await createMigration(config.migrationsPath, description);
 };
-var up = async (config, max = 1e3) => {
-  const db = getDb(config);
-  await ensureMigrationTable(db);
-  const appliedMigrations = await getAppliedMigrations(db);
-  const migrationFiles = await getMigrationFiles(config.migrationsPath);
-  const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
-  console.log(`Found ${newMigrations.length} new migrations.`);
-  console.log(newMigrations.map((mig) => `	${mig}`).join("\n"));
-  for (const id of newMigrations.slice(0, max)) {
-    const migration = await getMigration(config.migrationsPath, id);
-    await applyUp(db, migration);
+var up = async (config, database, max) => {
+  if (max && !database) {
+    throw new Error("Max number of migrations requires specifying a database");
+  }
+  const databases = database ? [database] : config.instance.databases;
+  for (const databaseConfig of databases) {
+    const path = {
+      projectId: config.projectId,
+      instanceName: config.instance.name,
+      databaseName: databaseConfig.name
+    };
+    const db = getDb(path);
+    await ensureMigrationTable(db);
+    const appliedMigrations = await getAppliedMigrations(db);
+    const migrationFiles = await getMigrationFiles(
+      databaseConfig.migrationsPath
+    );
+    const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
+    console.log(`Found ${newMigrations.length} new migrations.`);
+    console.log(newMigrations.map((mig) => `	${mig}`).join("\n"));
+    const newMigrationsToApply = max ? newMigrations.slice(0, max) : newMigrations;
+    for (const id of newMigrationsToApply) {
+      const migration = await getMigration(databaseConfig.migrationsPath, id);
+      await applyUp(db, migration);
+    }
   }
 };
-var down = async (config) => {
-  const db = getDb(config);
+var down = async (config, database) => {
+  const path = {
+    projectId: config.projectId,
+    instanceName: config.instance.name,
+    databaseName: database.name
+  };
+  const db = getDb(path);
   await ensureMigrationTable(db);
   await applyDown(db);
 };
-var status = async (config) => {
-  const db = getDb(config);
-  await ensureMigrationTable(db);
-  const appliedMigrations = await getAppliedMigrations(db);
-  const migrationFiles = await getMigrationFiles(config.migrationsPath);
-  const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
-  return [
-    "Migrations",
-    "",
-    "Applied",
-    "--------------------------------------------------------------------------------",
-    `${appliedMigrations.map((m) => m.id).join("\n")}
+var status = async (config, databases) => {
+  const statuses = [];
+  for (const databaseConfig of databases || config.instance.databases) {
+    const path = {
+      projectId: config.projectId,
+      instanceName: config.instance.name,
+      databaseName: databaseConfig.name
+    };
+    const db = getDb(path);
+    await ensureMigrationTable(db);
+    const appliedMigrations = await getAppliedMigrations(db);
+    const migrationFiles = await getMigrationFiles(
+      databaseConfig.migrationsPath
+    );
+    const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
+    statuses.push(
+      [
+        `Migrations [${databaseConfig.name}]`,
+        "",
+        "Applied",
+        "--------------------------------------------------------------------------------",
+        `${appliedMigrations.map((m) => m.id).join("\n")}
 `,
-    "New",
-    "--------------------------------------------------------------------------------",
-    `${newMigrations.join("\n")}
+        "New",
+        "--------------------------------------------------------------------------------",
+        `${newMigrations.join("\n")}
 `
-  ].join("\n");
+      ].join("\n")
+    );
+  }
+  return statuses.join("\n\n");
 };
 
 // src/cli.ts
 var CONFIG_FILE = "./.spanner-migrate.config.json";
-async function loadConfig() {
-  try {
-    const configContent = await import_promises2.default.readFile(CONFIG_FILE, "utf8");
-    return JSON.parse(configContent);
-  } catch {
-    console.error('Config file not found. Run "spanner-migrate init" first.');
-    process.exit(1);
-  }
-}
 (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName("spanner-migrate").usage("$0 <command>").command(
   "init",
   "Initialize a .spanner-migrate.config.json file",
   async () => {
-    const migrationsPath = await (0, import_input.default)({
-      message: "Enter the path for your migrations",
-      required: true,
-      default: "./migrations"
-    });
-    const instanceName = await (0, import_input.default)({
+    const instanceName = await (0, import_prompts.input)({
       message: "Enter Spanner instance name",
       required: true
     });
-    const databaseName = await (0, import_input.default)({
-      message: "Enter Spanner database name",
-      required: true
-    });
-    const projectId = await (0, import_input.default)({
+    const databases = [
+      await getDatabaseConfig(true)
+    ];
+    while (true) {
+      const dbConfig = await getDatabaseConfig(false);
+      if (!dbConfig) break;
+      databases.push(dbConfig);
+    }
+    const projectId = await (0, import_prompts.input)({
       message: "Enter Google Cloud project name",
       required: false
     });
-    const config = { instanceName, databaseName, migrationsPath };
+    const config = {
+      instance: {
+        name: instanceName,
+        databases
+      }
+    };
     if (projectId) config.projectId = projectId;
     await init(config, CONFIG_FILE);
-    console.log(`Configuration written to ${CONFIG_FILE}`);
   }
 ).command(
   "create <description ...>",
   "Create a new migration file",
   (yargs2) => {
-    yargs2.positional("description", {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Database name"
+    }).positional("description", {
       type: "string",
       describe: "Description of the migration",
       demandOption: true
@@ -362,33 +386,157 @@ async function loadConfig() {
   async (args) => {
     const config = await loadConfig();
     const fullDescription = args.description.join(" ");
-    await create(config, fullDescription);
+    let databaseConfig;
+    if (args.database) {
+      databaseConfig = config.instance.databases.find(
+        (db) => db.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+    } else {
+      if (config.instance.databases.length === 1) {
+        databaseConfig = config.instance.databases[0];
+      } else {
+        databaseConfig = await (0, import_prompts.select)({
+          message: "Select database",
+          choices: config.instance.databases.map((dbConfig) => ({
+            name: dbConfig.name,
+            value: dbConfig
+          }))
+        });
+      }
+    }
+    if (!databaseConfig) throw new Error("No database config found");
+    await create(databaseConfig, fullDescription);
     console.log(
-      `Migration file created: '${(0, import_node_path2.join)(config.migrationsPath, args.description.join("_"))}.sql'`
+      `Migration file created: '${(0, import_node_path2.join)(databaseConfig.migrationsPath, args.description.join("_"))}.sql'`
     );
   }
 ).command(
   "up",
   "Apply migrations",
   (yargs2) => {
-    yargs2.option("max", {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Database name",
+      requiresArg: false
+    }).option("max", {
       alias: "m",
       type: "number",
-      describe: "Maximum number of migrations to apply",
-      default: 1e3
+      describe: "Maximum number of migrations to apply (requires --database)",
+      requiresArg: false
     });
   },
   async (args) => {
     const config = await loadConfig();
-    await up(config, args.max);
+    if (args.max !== void 0) {
+      if (!args.database) {
+        throw new Error("The --max option requires a specified --database");
+      }
+      if (!Number.isInteger(args.max) || args.max <= 0) {
+        throw new Error("The --max option must be an integer greater than 0");
+      }
+    }
+    if (args.database) {
+      const databaseConfig = config.instance.databases.find(
+        (db) => db.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+      if (args.max !== void 0) {
+        await up(config, databaseConfig, args.max);
+      } else {
+        await up(config, databaseConfig);
+      }
+    } else {
+      await up(config);
+    }
     console.log("Migrations applied successfully.");
   }
-).command("down", "Roll back the last applied migration", {}, async () => {
-  const config = await loadConfig();
-  await down(config);
-  console.log("Last migration rolled back successfully.");
-}).command("status", "Show the migration status", {}, async () => {
-  const config = await loadConfig();
-  const migrationStatus = await status(config);
-  console.log(migrationStatus);
-}).demandCommand().help().parse();
+).command(
+  "down",
+  "Roll back the last applied migration",
+  (yargs2) => {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Specify the database to roll back (required if multiple databases exist)"
+    });
+  },
+  async (args) => {
+    const config = await loadConfig();
+    let databaseConfig;
+    if (args.database) {
+      databaseConfig = config.instance.databases.find(
+        (dbConfig) => dbConfig.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+    } else if (config.instance.databases.length === 1) {
+      databaseConfig = config.instance.databases[0];
+    } else {
+      throw new Error(
+        "Multiple databases detected. Use --database to specify which one to roll back."
+      );
+    }
+    if (!databaseConfig) throw new Error("No database config found");
+    await down(config, databaseConfig);
+    console.log("Last migration rolled back successfully.");
+  }
+).command(
+  "status",
+  "Show the migration status",
+  (yargs2) => {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Specify a database to check status (optional, runs on all databases if omitted)"
+    });
+  },
+  async (args) => {
+    const config = await loadConfig();
+    let migrationStatus;
+    if (args.database) {
+      const databaseConfig = config.instance.databases.find(
+        (db) => db.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+      migrationStatus = await status(config, [databaseConfig]);
+    } else {
+      migrationStatus = await status(config);
+    }
+    console.log(migrationStatus);
+  }
+).demandCommand().help().parse();
+async function loadConfig() {
+  try {
+    const configContent = await import_promises2.default.readFile(CONFIG_FILE, "utf8");
+    return JSON.parse(configContent);
+  } catch {
+    console.error('Config file not found. Run "spanner-migrate init" first.');
+    process.exit(1);
+  }
+}
+var getDatabaseConfig = async (required) => {
+  const message = required ? "Enter Spanner database name" : "Enter another Spanner database name [Enter to continue]";
+  const name = await (0, import_prompts.input)({
+    message,
+    required
+  });
+  if (!name) return;
+  const migrationsPath = await (0, import_prompts.input)({
+    message: "Enter the path for your migrations",
+    required: true,
+    default: `./migrations/${name}`
+  });
+  return {
+    name,
+    migrationsPath
+  };
+};

package/dist/cli.mjs

@@ -5,55 +5,53 @@ import {
   init,
   status,
   up
-} from "./chunk-Z3ZLNDVO.mjs";
+} from "./chunk-SZDH364K.mjs";
 
 // src/cli.ts
 import fs from "node:fs/promises";
 import { join } from "node:path";
-import input from "@inquirer/input";
+import { input, select } from "@inquirer/prompts";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 var CONFIG_FILE = "./.spanner-migrate.config.json";
-async function loadConfig() {
-  try {
-    const configContent = await fs.readFile(CONFIG_FILE, "utf8");
-    return JSON.parse(configContent);
-  } catch {
-    console.error('Config file not found. Run "spanner-migrate init" first.');
-    process.exit(1);
-  }
-}
 yargs(hideBin(process.argv)).scriptName("spanner-migrate").usage("$0 <command>").command(
   "init",
   "Initialize a .spanner-migrate.config.json file",
   async () => {
-    const migrationsPath = await input({
-      message: "Enter the path for your migrations",
-      required: true,
-      default: "./migrations"
-    });
     const instanceName = await input({
       message: "Enter Spanner instance name",
       required: true
     });
-    const databaseName = await input({
-      message: "Enter Spanner database name",
-      required: true
-    });
+    const databases = [
+      await getDatabaseConfig(true)
+    ];
+    while (true) {
+      const dbConfig = await getDatabaseConfig(false);
+      if (!dbConfig) break;
+      databases.push(dbConfig);
+    }
     const projectId = await input({
       message: "Enter Google Cloud project name",
       required: false
     });
-    const config = { instanceName, databaseName, migrationsPath };
+    const config = {
+      instance: {
+        name: instanceName,
+        databases
+      }
+    };
     if (projectId) config.projectId = projectId;
     await init(config, CONFIG_FILE);
-    console.log(`Configuration written to ${CONFIG_FILE}`);
   }
 ).command(
   "create <description ...>",
   "Create a new migration file",
   (yargs2) => {
-    yargs2.positional("description", {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Database name"
+    }).positional("description", {
       type: "string",
       describe: "Description of the migration",
       demandOption: true
@@ -62,33 +60,157 @@ yargs(hideBin(process.argv)).scriptName("spanner-migrate").usage("$0 <command>")
   async (args) => {
     const config = await loadConfig();
     const fullDescription = args.description.join(" ");
-    await create(config, fullDescription);
+    let databaseConfig;
+    if (args.database) {
+      databaseConfig = config.instance.databases.find(
+        (db) => db.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+    } else {
+      if (config.instance.databases.length === 1) {
+        databaseConfig = config.instance.databases[0];
+      } else {
+        databaseConfig = await select({
+          message: "Select database",
+          choices: config.instance.databases.map((dbConfig) => ({
+            name: dbConfig.name,
+            value: dbConfig
+          }))
+        });
+      }
+    }
+    if (!databaseConfig) throw new Error("No database config found");
+    await create(databaseConfig, fullDescription);
     console.log(
-      `Migration file created: '${join(config.migrationsPath, args.description.join("_"))}.sql'`
+      `Migration file created: '${join(databaseConfig.migrationsPath, args.description.join("_"))}.sql'`
     );
   }
 ).command(
   "up",
   "Apply migrations",
   (yargs2) => {
-    yargs2.option("max", {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Database name",
+      requiresArg: false
+    }).option("max", {
       alias: "m",
       type: "number",
-      describe: "Maximum number of migrations to apply",
-      default: 1e3
+      describe: "Maximum number of migrations to apply (requires --database)",
+      requiresArg: false
     });
   },
   async (args) => {
     const config = await loadConfig();
-    await up(config, args.max);
+    if (args.max !== void 0) {
+      if (!args.database) {
+        throw new Error("The --max option requires a specified --database");
+      }
+      if (!Number.isInteger(args.max) || args.max <= 0) {
+        throw new Error("The --max option must be an integer greater than 0");
+      }
+    }
+    if (args.database) {
+      const databaseConfig = config.instance.databases.find(
+        (db) => db.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+      if (args.max !== void 0) {
+        await up(config, databaseConfig, args.max);
+      } else {
+        await up(config, databaseConfig);
+      }
+    } else {
+      await up(config);
+    }
     console.log("Migrations applied successfully.");
   }
-).command("down", "Roll back the last applied migration", {}, async () => {
-  const config = await loadConfig();
-  await down(config);
-  console.log("Last migration rolled back successfully.");
-}).command("status", "Show the migration status", {}, async () => {
-  const config = await loadConfig();
-  const migrationStatus = await status(config);
-  console.log(migrationStatus);
-}).demandCommand().help().parse();
+).command(
+  "down",
+  "Roll back the last applied migration",
+  (yargs2) => {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Specify the database to roll back (required if multiple databases exist)"
+    });
+  },
+  async (args) => {
+    const config = await loadConfig();
+    let databaseConfig;
+    if (args.database) {
+      databaseConfig = config.instance.databases.find(
+        (dbConfig) => dbConfig.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+    } else if (config.instance.databases.length === 1) {
+      databaseConfig = config.instance.databases[0];
+    } else {
+      throw new Error(
+        "Multiple databases detected. Use --database to specify which one to roll back."
+      );
+    }
+    if (!databaseConfig) throw new Error("No database config found");
+    await down(config, databaseConfig);
+    console.log("Last migration rolled back successfully.");
+  }
+).command(
+  "status",
+  "Show the migration status",
+  (yargs2) => {
+    yargs2.option("database", {
+      alias: "d",
+      type: "string",
+      describe: "Specify a database to check status (optional, runs on all databases if omitted)"
+    });
+  },
+  async (args) => {
+    const config = await loadConfig();
+    let migrationStatus;
+    if (args.database) {
+      const databaseConfig = config.instance.databases.find(
+        (db) => db.name === args.database
+      );
+      if (!databaseConfig) {
+        throw new Error(`Unknown database name "${args.database}"`);
+      }
+      migrationStatus = await status(config, [databaseConfig]);
+    } else {
+      migrationStatus = await status(config);
+    }
+    console.log(migrationStatus);
+  }
+).demandCommand().help().parse();
+async function loadConfig() {
+  try {
+    const configContent = await fs.readFile(CONFIG_FILE, "utf8");
+    return JSON.parse(configContent);
+  } catch {
+    console.error('Config file not found. Run "spanner-migrate init" first.');
+    process.exit(1);
+  }
+}
+var getDatabaseConfig = async (required) => {
+  const message = required ? "Enter Spanner database name" : "Enter another Spanner database name [Enter to continue]";
+  const name = await input({
+    message,
+    required
+  });
+  if (!name) return;
+  const migrationsPath = await input({
+    message: "Enter the path for your migrations",
+    required: true,
+    default: `./migrations/${name}`
+  });
+  return {
+    name,
+    migrationsPath
+  };
+};

package/dist/index.d.mts

@@ -1,14 +1,20 @@
-type Config = {
+type DatabaseConfig = {
+    name: string;
     migrationsPath: string;
-    instanceName: string;
-    databaseName: string;
+};
+type InstanceConfig = {
+    name: string;
+    databases: DatabaseConfig[];
+};
+type Config = {
+    instance: InstanceConfig;
     projectId?: string;
 };
 
 declare const init: (config: Config, configPath: string) => Promise<void>;
-declare const create: (config: Config, description: string) => Promise<void>;
-declare const up: (config: Config, max?: number) => Promise<void>;
-declare const down: (config: Config) => Promise<void>;
-declare const status: (config: Config) => Promise<string>;
+declare const create: (config: DatabaseConfig, description: string) => Promise<void>;
+declare const up: (config: Config, database?: DatabaseConfig, max?: number) => Promise<void>;
+declare const down: (config: Config, database: DatabaseConfig) => Promise<void>;
+declare const status: (config: Config, databases?: DatabaseConfig[]) => Promise<string>;
 
 export { create, down, init, status, up };

package/dist/index.d.ts

@@ -1,14 +1,20 @@
-type Config = {
+type DatabaseConfig = {
+    name: string;
     migrationsPath: string;
-    instanceName: string;
-    databaseName: string;
+};
+type InstanceConfig = {
+    name: string;
+    databases: DatabaseConfig[];
+};
+type Config = {
+    instance: InstanceConfig;
     projectId?: string;
 };
 
 declare const init: (config: Config, configPath: string) => Promise<void>;
-declare const create: (config: Config, description: string) => Promise<void>;
-declare const up: (config: Config, max?: number) => Promise<void>;
-declare const down: (config: Config) => Promise<void>;
-declare const status: (config: Config) => Promise<string>;
+declare const create: (config: DatabaseConfig, description: string) => Promise<void>;
+declare const up: (config: Config, database?: DatabaseConfig, max?: number) => Promise<void>;
+declare const down: (config: Config, database: DatabaseConfig) => Promise<void>;
+declare const status: (config: Config, databases?: DatabaseConfig[]) => Promise<string>;
 
 export { create, down, init, status, up };

package/dist/index.js

@@ -66,7 +66,7 @@ var applyDown = async (db) => {
     json: true
   };
   const [rows] = await db.run(req);
-  const lastMigration = rows == null ? void 0 : rows[0];
+  const lastMigration = rows?.[0];
   if (!lastMigration) {
     throw new Error("No migrations found to roll back.");
   }
@@ -128,12 +128,12 @@ var SQL_CREATE_TABLE_MIGRATIONS = `
     down STRING(1024)
   ) PRIMARY KEY (id)
 `;
-var ensureMigrationTable = async (database) => {
-  const [rows] = await database.run(SQL_SELECT_TABLE_MIGRATIONS);
+var ensureMigrationTable = async (db) => {
+  const [rows] = await db.run(SQL_SELECT_TABLE_MIGRATIONS);
   if (rows.length) return;
   console.log("Creating migration table");
   try {
-    await database.updateSchema(SQL_CREATE_TABLE_MIGRATIONS);
+    await db.updateSchema(SQL_CREATE_TABLE_MIGRATIONS);
   } catch (err) {
     console.error("Failed to create migrations table");
     throw err;
@@ -196,22 +196,17 @@ var getMigration = async (path, id) => {
     );
   }
 };
-var getDescription = (text) => {
-  var _a, _b;
-  return ((_b = (_a = text == null ? void 0 : text.match(/^--\s*Description:\s*(.+)$/m)) == null ? void 0 : _a[1]) == null ? void 0 : _b.trim()) || "";
-};
+var getDescription = (text) => text?.match(/^--\s*Description:\s*(.+)$/m)?.[1]?.trim() || "";
 var getSql = (text, direction) => {
-  var _a, _b;
   const rx = {
     up: /---- UP ----\n([\s\S]*?)\n---- DOWN ----/,
     down: /---- DOWN ----\n([\s\S]*)$/
   };
-  return (_b = (_a = text == null ? void 0 : text.match(rx[direction])) == null ? void 0 : _a[1]) == null ? void 0 : _b.replace(/--.*$/gm, "").trim();
+  return text?.match(rx[direction])?.[1]?.replace(/--.*$/gm, "").trim();
 };
 var getNewMigrations = (applied, files) => {
   const sortedFiles = files.sort();
   for (let ix = 0; ix < applied.length; ix++) {
-    console.log(sortedFiles[ix], applied[ix].id);
     if (sortedFiles[ix] !== applied[ix].id) {
       throw new Error(
         `Mismatch between applied migrations and files. Found '${sortedFiles[ix]}' but expected '${applied[ix].id}' at position ${ix}.`
@@ -219,7 +214,6 @@ var getNewMigrations = (applied, files) => {
     }
   }
   const newMigrations = sortedFiles.slice(applied.length);
-  console.log(`Found ${newMigrations.length} new migrations.`);
   return newMigrations;
 };
 var createMigration = async (path, description) => {
@@ -270,42 +264,74 @@ var init = async (config, configPath) => {
 var create = async (config, description) => {
   await createMigration(config.migrationsPath, description);
 };
-var up = async (config, max = 1e3) => {
-  const db = getDb(config);
-  await ensureMigrationTable(db);
-  const appliedMigrations = await getAppliedMigrations(db);
-  const migrationFiles = await getMigrationFiles(config.migrationsPath);
-  const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
-  console.log(`Found ${newMigrations.length} new migrations.`);
-  console.log(newMigrations.map((mig) => `	${mig}`).join("\n"));
-  for (const id of newMigrations.slice(0, max)) {
-    const migration = await getMigration(config.migrationsPath, id);
-    await applyUp(db, migration);
+var up = async (config, database, max) => {
+  if (max && !database) {
+    throw new Error("Max number of migrations requires specifying a database");
+  }
+  const databases = database ? [database] : config.instance.databases;
+  for (const databaseConfig of databases) {
+    const path = {
+      projectId: config.projectId,
+      instanceName: config.instance.name,
+      databaseName: databaseConfig.name
+    };
+    const db = getDb(path);
+    await ensureMigrationTable(db);
+    const appliedMigrations = await getAppliedMigrations(db);
+    const migrationFiles = await getMigrationFiles(
+      databaseConfig.migrationsPath
+    );
+    const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
+    console.log(`Found ${newMigrations.length} new migrations.`);
+    console.log(newMigrations.map((mig) => `	${mig}`).join("\n"));
+    const newMigrationsToApply = max ? newMigrations.slice(0, max) : newMigrations;
+    for (const id of newMigrationsToApply) {
+      const migration = await getMigration(databaseConfig.migrationsPath, id);
+      await applyUp(db, migration);
+    }
   }
 };
-var down = async (config) => {
-  const db = getDb(config);
+var down = async (config, database) => {
+  const path = {
+    projectId: config.projectId,
+    instanceName: config.instance.name,
+    databaseName: database.name
+  };
+  const db = getDb(path);
   await ensureMigrationTable(db);
   await applyDown(db);
 };
-var status = async (config) => {
-  const db = getDb(config);
-  await ensureMigrationTable(db);
-  const appliedMigrations = await getAppliedMigrations(db);
-  const migrationFiles = await getMigrationFiles(config.migrationsPath);
-  const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
-  return [
-    "Migrations",
-    "",
-    "Applied",
-    "--------------------------------------------------------------------------------",
-    `${appliedMigrations.map((m) => m.id).join("\n")}
+var status = async (config, databases) => {
+  const statuses = [];
+  for (const databaseConfig of databases || config.instance.databases) {
+    const path = {
+      projectId: config.projectId,
+      instanceName: config.instance.name,
+      databaseName: databaseConfig.name
+    };
+    const db = getDb(path);
+    await ensureMigrationTable(db);
+    const appliedMigrations = await getAppliedMigrations(db);
+    const migrationFiles = await getMigrationFiles(
+      databaseConfig.migrationsPath
+    );
+    const newMigrations = getNewMigrations(appliedMigrations, migrationFiles);
+    statuses.push(
+      [
+        `Migrations [${databaseConfig.name}]`,
+        "",
+        "Applied",
+        "--------------------------------------------------------------------------------",
+        `${appliedMigrations.map((m) => m.id).join("\n")}
 `,
-    "New",
-    "--------------------------------------------------------------------------------",
-    `${newMigrations.join("\n")}
+        "New",
+        "--------------------------------------------------------------------------------",
+        `${newMigrations.join("\n")}
 `
-  ].join("\n");
+      ].join("\n")
+    );
+  }
+  return statuses.join("\n\n");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -4,7 +4,7 @@ import {
   init,
   status,
   up
-} from "./chunk-Z3ZLNDVO.mjs";
+} from "./chunk-SZDH364K.mjs";
 export {
   create,
   down,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/spanner-migrate",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -14,24 +14,29 @@
     "dev": "tsc --watch --noEmit",
     "lint": "biome check .",
     "test": "jest --config jest.config.ts --passWithNoTests --coverage",
-    "test:e2e": "jest --config jest.e2e.config.ts",
+    "test:e2e": "jest --config jest.e2e.config.ts --runInBand",
     "typecheck": "tsc --noEmit "
   },
   "devDependencies": {
-    "@google-cloud/spanner": "^7.17.1",
+    "@google-cloud/spanner": "7.18.1",
+    "@sebspark/cli-tester": "*",
     "@sebspark/spanner-mock": "*",
-    "@types/jest": "^29.5.14",
-    "@types/yargs": "^17.0.33",
-    "jest": "^29.7.0",
-    "testcontainers": "^10.16.0",
-    "ts-jest": "^29.2.5",
+    "@types/jest": "29.5.14",
+    "@types/yargs": "17.0.33",
+    "jest": "29.7.0",
+    "testcontainers": "10.18.0",
+    "ts-jest": "29.2.6",
     "tsconfig": "*"
   },
   "peerDependencies": {
     "@google-cloud/spanner": "*"
   },
   "dependencies": {
-    "@inquirer/input": "4.1.3",
+    "@inquirer/prompts": "7.3.2",
+    "@jest/globals": "29.7.0",
+    "@types/node": "20.17.17",
+    "typescript": "5.7.3",
+    "vitest": "3.0.7",
     "yargs": "17.7.2"
   }
 }