@deterministic-code/migraters 0.0.2 → 0.0.3

package/typescript/dialects/sqlserver/src/sqlserver-dialect.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const mssql = vi.hoisted(() => {
+  const state = {
+    failRollback: false,
+    closed: false,
+    batches: [] as string[],
+    queries: [] as string[],
+    inputs: [] as { name: string; value: unknown }[],
+  };
+  const request = () => ({
+    input(name: string, value: unknown) {
+      state.inputs.push({ name, value });
+    },
+    async query(sql: string) {
+      state.queries.push(sql);
+      if (sql.includes('empty')) return {};
+      return { recordset: [{ n: 1 }] };
+    },
+    async batch(sql: string) {
+      state.batches.push(sql);
+    },
+  });
+  const transaction = () => ({
+    async begin() {},
+    async commit() {},
+    async rollback() {
+      if (state.failRollback) throw new Error('rollback failed');
+    },
+  });
+  const pool = {
+    request,
+    transaction,
+    async close() {
+      state.closed = true;
+    },
+  };
+  return {
+    state,
+    connect: async () => pool,
+  };
+});
+
+vi.mock('mssql', () => ({ default: { connect: mssql.connect } }));
+
+import { SqlServerDialect } from './sqlserver-dialect.ts';
+
+const dialect = new SqlServerDialect();
+
+describe('SqlServerDialect', () => {
+  afterEach(() => {
+    mssql.state.failRollback = false;
+    mssql.state.closed = false;
+    mssql.state.batches = [];
+    mssql.state.queries = [];
+    mssql.state.inputs = [];
+  });
+
+  it('registers as sqlserver with bracket quotes, SYSUTCDATETIME, and OFFSET/FETCH', async () => {
+    expect(dialect.name).toBe('sqlserver');
+    expect([...dialect.connectionEnvironmentVariables]).toEqual(['MSSQL_URL', 'DATABASE_URL']);
+    expect(dialect.quoteIdent('t')).toBe('[t]');
+    expect(dialect.nowExpr()).toBe('SYSUTCDATETIME()');
+    expect(dialect.limitClause(4)).toBe('OFFSET 0 ROWS FETCH NEXT 4 ROWS ONLY');
+    expect(dialect.migratesDdl).toMatch(/migrates/i);
+    expect(dialect.migrateLogsDdl).toMatch(/migrate_logs/i);
+    expect(await dialect.prerequisiteError('mssql://x')).toBeNull();
+    await dialect.prepareSetup('mssql://x');
+  });
+
+  it('createDatabaseIfMissing creates the database unless it is master', async () => {
+    await dialect.createDatabaseIfMissing(
+      'Server=sqlserver,1433;User Id=sa;Password=x;Database=proof',
+    );
+    expect(mssql.state.batches[0]).toContain('CREATE DATABASE [proof]');
+    await dialect.createDatabaseIfMissing(
+      'Server=sqlserver,1433;User Id=sa;Password=x;Database=master',
+    );
+  });
+
+  it('createClient binds ? as @pN and handles empty recordsets', async () => {
+    const client = await dialect.createClient('Server=localhost');
+    expect(client.dialect).toBe('sqlserver');
+    await client.exec('CREATE TABLE t (id INT)');
+    expect(mssql.state.batches).toContain('CREATE TABLE t (id INT)');
+    expect(await client.query('SELECT ?', [7])).toEqual([{ n: 1 }]);
+    expect(mssql.state.queries).toContain('SELECT @p0');
+    expect(mssql.state.inputs).toContainEqual({ name: 'p0', value: 7 });
+    expect(await client.query('empty')).toEqual([]);
+    await client.run('UPDATE t SET x = ?', [8]);
+    expect(await client.transaction(async () => 'ok')).toBe('ok');
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx');
+      }),
+    ).rejects.toThrow('tx');
+    mssql.state.failRollback = true;
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx2');
+      }),
+    ).rejects.toThrow('tx2');
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    await client.close();
+    expect(mssql.state.closed).toBe(true);
+  });
+});

package/typescript/dialects/sqlserver/src/sqlserver-dialect.ts

@@ -0,0 +1,103 @@
+import type { Request as MssqlRequest } from 'mssql';
+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';
+
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+  readSqlTemplate('sqlserver', 'migrates'),
+  readSqlTemplate('sqlserver', 'migrate_logs'),
+]);
+
+const bindMssql = (
+  req: Pick<MssqlRequest, 'input'>,
+  sql: string,
+  params: MigrationSqlParam[],
+): string => {
+  let n = 0;
+  return sql.replace(/\?/g, () => {
+    const name = `p${n}`;
+    req.input(name, params[n]);
+    n++;
+    return `@${name}`;
+  });
+};
+
+export class SqlServerDialect extends SqlDialectBase {
+  readonly name = 'sqlserver' as const;
+  readonly connectionEnvironmentVariables = ['MSSQL_URL', 'DATABASE_URL'] as const;
+  readonly migratesDdl = migratesDdl;
+  readonly migrateLogsDdl = migrateLogsDdl;
+
+  quoteIdent(ident: string): string {
+    return `[${ident}]`;
+  }
+
+  nowExpr(): string {
+    return 'SYSUTCDATETIME()';
+  }
+
+  limitClause(n: number): string {
+    return `OFFSET 0 ROWS FETCH NEXT ${n} ROWS ONLY`;
+  }
+
+  async createDatabaseIfMissing(connection: string): Promise<void> {
+    const match = /(?:^|;)Database=([^;]+)/i.exec(connection);
+    const name = match?.[1]?.trim();
+    if (!name || /^master$/i.test(name)) return;
+    const admin = connection.replace(/(^|;)Database=[^;]*/i, '$1Database=master');
+    const { default: mssql } = await import('mssql');
+    const pool = await mssql.connect(admin);
+    try {
+      await pool.request().batch(
+        `IF DB_ID(N'${name.replaceAll("'", "''")}') IS NULL CREATE DATABASE [${name.replaceAll(']', ']]')}];`,
+      );
+    } finally {
+      await pool.close();
+    }
+  }
+
+  async createClient(connection: string): Promise<MigrationClient> {
+    const mssql = interopDefault(await import('mssql'));
+    const pool = await mssql.connect(connection);
+    return {
+      dialect: 'sqlserver',
+      async exec(sql) {
+        await pool.request().batch(sql);
+      },
+      async query(sql, params = []) {
+        const req = pool.request();
+        const translated = bindMssql(req, sql, params);
+        const r = await req.query(translated);
+        return r.recordset ?? [];
+      },
+      async run(sql, params = []) {
+        const req = pool.request();
+        const translated = bindMssql(req, sql, params);
+        await req.query(translated);
+      },
+      async transaction(fn) {
+        const tx = pool.transaction();
+        await tx.begin();
+        try {
+          const r = await fn();
+          await tx.commit();
+          return r;
+        } catch (e) {
+          try {
+            await tx.rollback();
+          } catch (rollbackErr) {
+            console.warn(
+              'sqlserver rollback failed after transaction error; original error rethrown',
+              rollbackErr,
+            );
+          }
+          throw e;
+        }
+      },
+      async close() {
+        await pool.close();
+      },
+    };
+  }
+}

package/typescript/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@deterministic-code/migraters-typescript",
+  "version": "0.0.1",
+  "private": true,
+  "description": "TypeScript migrate runner for deterministic-code.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "migrate-up": "./dist/src/bin/migrate-up.js",
+    "migrate-down": "./dist/src/bin/migrate-down.js",
+    "migrate-setup": "./dist/src/bin/migrate-setup.js",
+    "migrate-create": "./dist/src/bin/migrate-create.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "dialects",
+    "cli.yaml",
+    "bundle.yaml",
+    "tsconfig.build.json"
+  ],
+  "scripts": {
+    "build": "rm -rf dist.tmp && tsc -p tsconfig.build.json --outDir dist.tmp && cp -R ../shared/templates dist.tmp/templates && cp ../cli.yaml dist.tmp/cli.yaml && rm -rf dist && mv dist.tmp dist",
+    "typecheck": "tsc -p tsconfig.src.json --noEmit",
+    "test": "npm run build && node ../orchestrator/dist/migrate-init.js --language typescript --all && vitest run --coverage",
+    "test:coverage": "vitest run --coverage",
+    "generate:help": "node --experimental-strip-types src/generate-help.ts",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "typescript": "^5.8.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "prettier": "^3.9.6",
+    "vitest": "^3.2.4"
+  }
+}

package/typescript/src/abstractions/migrater.ts

@@ -0,0 +1,13 @@
+export type SetupArg = { connection: string; migrationsPath: string };
+export type UpArg = { connection: string; migrationsPath: string; one?: boolean };
+export type DownArg = { connection: string; migrationsPath: string };
+export type CreateArg = { name: string; migrationsPath: string };
+export type CreateResponse = { upName: string; downName: string };
+
+export interface IMigrater {
+  readonly name: string;
+  setup(args: SetupArg): Promise<void>;
+  up(args: UpArg): Promise<string[]>;
+  down(args: DownArg): Promise<string | null>;
+  create(args: CreateArg): Promise<CreateResponse>;
+}

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

@@ -0,0 +1,38 @@
+import type { SqlDialect } from '../sql.ts';
+import type { ISqlDialect } from './sql-dialect.ts';
+
+export abstract class SqlDialectBase implements ISqlDialect {
+  abstract readonly name: SqlDialect;
+  abstract readonly connectionEnvironmentVariables: readonly string[];
+  abstract readonly migratesDdl: string;
+  abstract readonly migrateLogsDdl: string;
+  readonly usesLastInsertRowid: boolean = false;
+
+  quoteIdent(ident: string): string {
+    return `"${ident}"`;
+  }
+
+  nowExpr(): string {
+    return 'CURRENT_TIMESTAMP';
+  }
+
+  limitClause(n: number): string {
+    return `LIMIT ${n}`;
+  }
+
+  translatePlaceholders(sql: string): string {
+    return sql;
+  }
+
+  async prerequisiteError(_connection: string): Promise<string | null> {
+    return null;
+  }
+
+  async prepareSetup(_connection: string): Promise<void> {}
+
+  async createDatabaseIfMissing(_connection: string): Promise<void> {}
+
+  abstract createClient(
+    connection: string,
+  ): Promise<import('../migration-client.ts').MigrationClient>;
+}

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

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

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

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

package/typescript/src/bin/migrate-create.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Scaffolds a new <NNNN>_<name>_{up,down}.sql pair in the migrations directory. Numbering is max(1-4-digit prefix in dir)+1; legacy timestamp prefixes are ignored.
+
+import { missingProviderMsg, requireDialect, takeFlag } from '../cli.ts';
+import { isMigrationName } from '../create-sequence.ts';
+import { fillTemplate, loadMessage } from '../infrastructure/message-templates.ts';
+import { loadHelp, Migrater } from '../index.ts';
+
+const [HELP_TEXT, unknownArgTpl, missingNameMsg, invalidNameTpl, createdTpl] = await Promise.all([
+  loadHelp('migrate-create'),
+  loadMessage('errors/unknown-arg'),
+  loadMessage('errors/missing-name'),
+  loadMessage('errors/invalid-name'),
+  loadMessage('status/created'),
+]);
+
+const parseArgs = (argv: string[]) => {
+  const args: {
+    provider: string | null;
+    name: string | null;
+    migrationsPath: string | null;
+  } = { provider: null, name: null, migrationsPath: null };
+  const rest = argv.slice(2);
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i] as string;
+    if (a === '-h' || a === '--help') {
+      process.stderr.write(HELP_TEXT);
+      process.exit(0);
+    }
+    let taken;
+    if ((taken = takeFlag(rest, i, a, '--provider'))) {
+      args.provider = taken.value;
+      i = taken.next;
+    } else if ((taken = takeFlag(rest, i, a, '--name'))) {
+      args.name = taken.value;
+      i = taken.next;
+    } else if (
+      (taken = takeFlag(rest, i, a, '--migrations-path')) ||
+      (taken = takeFlag(rest, i, a, '--migrate-path'))
+    ) {
+      args.migrationsPath = taken.value;
+      i = taken.next;
+    } else {
+      process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
+      process.exit(2);
+    }
+  }
+  return args;
+};
+
+const main = async () => {
+  const args = parseArgs(process.argv);
+  if (!args.provider) {
+    process.stderr.write(missingProviderMsg);
+    process.exit(2);
+  }
+  const dialect = requireDialect(args.provider);
+  if (!args.name) {
+    process.stderr.write(missingNameMsg);
+    process.exit(2);
+  }
+  if (!isMigrationName(args.name)) {
+    process.stderr.write(fillTemplate(invalidNameTpl, { name: args.name }));
+    process.exit(2);
+  }
+
+  const migrationsPath = args.migrationsPath ?? `./sql/${dialect.name}/migrations`;
+  const { upName, downName } = await new Migrater(dialect).create({
+    name: args.name,
+    migrationsPath,
+  });
+  process.stdout.write(fillTemplate(createdTpl, { file: upName }));
+  process.stdout.write(fillTemplate(createdTpl, { file: downName }));
+};
+
+main().catch((e: unknown) => {
+  const err = e as Error;
+  process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+  process.exit(1);
+});

package/typescript/src/bin/migrate-down.ts

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// Rolls back the most recently applied migration (one step). DESTRUCTIVE: refuses to proceed unless the user types confirm on stdin, or passes --confirm.
+
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { missingProviderMsg, requireConnection, requireDialect, takeFlag } from '../cli.ts';
+import { fillTemplate, loadMessage } from '../infrastructure/message-templates.ts';
+import { loadHelp, Migrater } from '../index.ts';
+
+const [
+  HELP_TEXT,
+  unknownArgTpl,
+  destructiveHeaderTpl,
+  confirmTtyRequiredMsg,
+  confirmPromptTpl,
+  confirmTokenMismatchMsg,
+  noRollbackMsg,
+  rolledBackTpl,
+] = await Promise.all([
+  loadHelp('migrate-down'),
+  loadMessage('errors/unknown-arg'),
+  loadMessage('down/destructive-header'),
+  loadMessage('down/confirm-tty-required'),
+  loadMessage('down/confirm-prompt'),
+  loadMessage('down/confirm-token-mismatch'),
+  loadMessage('status/no-rollback'),
+  loadMessage('status/rolled-back'),
+]);
+
+const parseArgs = (argv: string[]) => {
+  const args: {
+    provider: string | null;
+    migratePath: string | null;
+    migrateRoot: string | null;
+    connection: string | null;
+    confirm: boolean;
+  } = {
+    provider: null,
+    migratePath: null,
+    migrateRoot: null,
+    connection: null,
+    confirm: false,
+  };
+  const rest = argv.slice(2);
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i] as string;
+    if (a === '-h' || a === '--help') {
+      process.stderr.write(HELP_TEXT);
+      process.exit(0);
+    }
+    let taken;
+    if ((taken = takeFlag(rest, i, a, '--provider'))) {
+      args.provider = taken.value;
+      i = taken.next;
+    } else if (
+      (taken = takeFlag(rest, i, a, '--migrations-path')) ||
+      (taken = takeFlag(rest, i, a, '--migrate-path'))
+    ) {
+      args.migratePath = taken.value;
+      i = taken.next;
+    } else if (
+      (taken = takeFlag(rest, i, a, '--migrations-root')) ||
+      (taken = takeFlag(rest, i, a, '--migrate-root'))
+    ) {
+      args.migrateRoot = taken.value;
+      i = taken.next;
+    } else if ((taken = takeFlag(rest, i, a, '--connection'))) {
+      args.connection = taken.value;
+      i = taken.next;
+    } else if (a === '--confirm') {
+      args.confirm = true;
+    } else {
+      process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
+      process.exit(2);
+    }
+  }
+  return args;
+};
+
+const resolveMigratePath = (
+  args: { migratePath: string | null; migrateRoot: string | null },
+  dialect: string,
+): string => {
+  if (args.migratePath) return args.migratePath;
+  const root = args.migrateRoot ?? 'sql';
+  return `${root}/${dialect}/migrations`;
+};
+
+const promptConfirmation = async (): Promise<boolean> => {
+  if (!process.stdin.isTTY) {
+    process.stderr.write(confirmTtyRequiredMsg);
+    process.exit(2);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(confirmPromptTpl);
+    return answer.trim() === 'confirm';
+  } finally {
+    rl.close();
+  }
+};
+
+const main = async () => {
+  const args = parseArgs(process.argv);
+  if (!args.provider) {
+    process.stderr.write(missingProviderMsg);
+    process.exit(2);
+  }
+  const dialect = requireDialect(args.provider);
+  const connection = requireConnection(dialect, args.connection);
+
+  const missing = await dialect.prerequisiteError(connection);
+  if (missing !== null) {
+    process.stderr.write(`${missing}\n`);
+    process.exit(2);
+  }
+
+  process.stderr.write(fillTemplate(destructiveHeaderTpl, { dialect: dialect.name }));
+
+  if (!args.confirm) {
+    const ok = await promptConfirmation();
+    if (!ok) {
+      process.stderr.write(confirmTokenMismatchMsg);
+      process.exit(2);
+    }
+  }
+
+  const migratePath = resolve(resolveMigratePath(args, dialect.name));
+  const name = await new Migrater(dialect).down({
+    connection,
+    migrationsPath: migratePath,
+  });
+  if (name == null) process.stdout.write(noRollbackMsg);
+  else process.stdout.write(fillTemplate(rolledBackTpl, { name }));
+};
+
+main().catch((e: unknown) => {
+  const err = e as Error;
+  process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+  process.exit(1);
+});

package/typescript/src/bin/migrate-setup.ts

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// Idempotent migrate-setup — creates the migrates + migrate_logs tracking tables per dialect.
+
+import { missingProviderMsg, requireConnection, requireDialect, takeFlag } from '../cli.ts';
+import { createDatabase } from '../create-database.ts';
+import { fillTemplate, loadMessage } from '../infrastructure/message-templates.ts';
+import { loadHelp, Migrater } from '../index.ts';
+
+const [HELP_TEXT, unknownArgTpl, setupCompleteTpl] = await Promise.all([
+  loadHelp('migrate-setup'),
+  loadMessage('errors/unknown-arg'),
+  loadMessage('setup-complete'),
+]);
+
+const parseArgs = (argv: string[]) => {
+  const args: {
+    provider: string | null;
+    connection: string | null;
+    migrationsPath: string | null;
+    andUp: boolean;
+    createDatabase: boolean;
+  } = {
+    provider: null,
+    connection: null,
+    migrationsPath: null,
+    andUp: false,
+    createDatabase: false,
+  };
+  const rest = argv.slice(2);
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i] as string;
+    if (a === '-h' || a === '--help') {
+      process.stderr.write(HELP_TEXT);
+      process.exit(0);
+    }
+    if (a === '--and-up') {
+      args.andUp = true;
+      continue;
+    }
+    if (a === '--create-database') {
+      args.createDatabase = true;
+      continue;
+    }
+    let taken;
+    if ((taken = takeFlag(rest, i, a, '--provider'))) {
+      args.provider = taken.value;
+      i = taken.next;
+    } else if ((taken = takeFlag(rest, i, a, '--connection'))) {
+      args.connection = taken.value;
+      i = taken.next;
+    } else if (
+      (taken = takeFlag(rest, i, a, '--migrations-path')) ||
+      (taken = takeFlag(rest, i, a, '--migrate-path'))
+    ) {
+      args.migrationsPath = taken.value;
+      i = taken.next;
+    } else {
+      process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
+      process.exit(2);
+    }
+  }
+  return args;
+};
+
+const main = async () => {
+  const args = parseArgs(process.argv);
+  if (!args.provider) {
+    process.stderr.write(missingProviderMsg);
+    process.exit(2);
+  }
+  const dialect = requireDialect(args.provider);
+  const connection = requireConnection(dialect, args.connection);
+
+  const migrationsPath = args.migrationsPath ?? `./sql/${dialect.name}/migrations`;
+  if (args.createDatabase) await createDatabase(dialect.name, connection);
+  const migrater = new Migrater(dialect);
+  await migrater.setup({ connection, migrationsPath });
+  process.stdout.write(
+    fillTemplate(setupCompleteTpl, {
+      dialect: dialect.name,
+      migrationsPath,
+      createExample: `  migrate-create --provider ${dialect.name} --name add_users`,
+      upExample: `  migrate-up --provider ${dialect.name} --connection ${connection}`,
+    }),
+  );
+
+  if (args.andUp) {
+    const names = await migrater.up({ connection, migrationsPath });
+    const [noPendingMsg, noMorePendingMsg, appliedTpl] = await Promise.all([
+      loadMessage('status/no-pending'),
+      loadMessage('status/no-more-pending'),
+      loadMessage('status/applied'),
+    ]);
+    if (names.length === 0) process.stdout.write(noPendingMsg);
+    else {
+      for (const name of names) process.stdout.write(fillTemplate(appliedTpl, { name }));
+      process.stdout.write(noMorePendingMsg);
+    }
+  }
+};
+
+main().catch((e: unknown) => {
+  const err = e as Error;
+  process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+  process.exit(1);
+});