@pikku/migrator-sql 0.12.2 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pikku/migrator-sql
 
+## 0.12.4
+
+### Patch Changes
+
+- 7262b4c: `db generate` now creates a referenced table before the one referencing it
+
+## 0.12.3
+
+### Patch Changes
+
+- b2e038b: Rename `@pikku/sql-migrator` to `@pikku/migrator-sql`, so a future migrator for
+  another store sorts beside it rather than under a second prefix. The package has
+  never been published under either name, so nothing depends on the old one.
+
 ## 0.12.2
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -10,4 +10,4 @@
  */
 export { migrate, baselineMigrations, pendingMigrations, MigrationDriftError, MIGRATION_TRACKING_TABLE, type MigrationExecutor, type MigrateResult, type AppliedMigration, } from './sql-migrator.js';
 export { assertSnakeCaseIdentifiers, findCamelCaseIdentifiers, stripSqlComments, CamelCaseIdentifierError, type CamelCaseIdentifier, } from './migration-identifiers.js';
-export { splitStatements, bareTableName, tableCreationSql, } from './schema-sql.js';
+export { splitStatements, bareTableName, tableCreationSql, tablesInSourceOrder, } from './schema-sql.js';

package/dist/src/index.js

@@ -10,4 +10,4 @@
  */
 export { migrate, baselineMigrations, pendingMigrations, MigrationDriftError, MIGRATION_TRACKING_TABLE, } from './sql-migrator.js';
 export { assertSnakeCaseIdentifiers, findCamelCaseIdentifiers, stripSqlComments, CamelCaseIdentifierError, } from './migration-identifiers.js';
-export { splitStatements, bareTableName, tableCreationSql, } from './schema-sql.js';
+export { splitStatements, bareTableName, tableCreationSql, tablesInSourceOrder, } from './schema-sql.js';

package/dist/src/schema-sql.d.ts

@@ -41,3 +41,14 @@ export declare function bareTableName(name: string): string;
  * expected to fall back rather than emit nothing.
  */
 export declare function tableCreationSql(sql: string, table: string): string[];
+/**
+ * `tables`, in the order `sql` creates them.
+ *
+ * A diff hands its missing tables back in whatever order it walked them, which
+ * is usually alphabetical and is never the order they can be created in: a
+ * table that references another has to come after it, and `channel_subscriptions`
+ * sorts before `channels`. The source's own SQL already has a workable order —
+ * it was applied in it — so that is the order used, with anything the source
+ * does not visibly create left at the end for the caller to render its own way.
+ */
+export declare function tablesInSourceOrder(sql: string, tables: string[]): string[];

package/dist/src/schema-sql.js

@@ -133,3 +133,27 @@ export function tableCreationSql(sql, table) {
     // and their presence says the table came from somewhere this cannot read.
     return creates ? statements : [];
 }
+/**
+ * `tables`, in the order `sql` creates them.
+ *
+ * A diff hands its missing tables back in whatever order it walked them, which
+ * is usually alphabetical and is never the order they can be created in: a
+ * table that references another has to come after it, and `channel_subscriptions`
+ * sorts before `channels`. The source's own SQL already has a workable order —
+ * it was applied in it — so that is the order used, with anything the source
+ * does not visibly create left at the end for the caller to render its own way.
+ */
+export function tablesInSourceOrder(sql, tables) {
+    const position = new Map();
+    let index = 0;
+    for (const statement of splitStatements(sql)) {
+        const create = CREATE_TABLE.exec(statement);
+        if (create) {
+            const name = bareTableName(create[1]);
+            if (!position.has(name))
+                position.set(name, index++);
+        }
+    }
+    const rank = (table) => position.get(bareTableName(table)) ?? Number.MAX_SAFE_INTEGER;
+    return [...tables].sort((a, b) => rank(a) - rank(b));
+}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/migration-identifiers.ts","../src/schema-sql.ts","../src/sql-migrator.ts","../src/postgres/index.ts","../src/postgres/postgres-migrator.ts","../src/sqlite/index.ts","../src/sqlite/sqlite-migrator.ts","../src/sqlite/sqlite-runtime-bun.ts","../src/sqlite/sqlite-runtime-node.ts","../src/sqlite/sqlite-runtime.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/migrator-sql",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "The SQL migration applier shared by the Pikku CLI and the standalone runtime",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -30,4 +30,4 @@
     "./sqlite": "./dist/src/sqlite/index.js",
     "./postgres": "./dist/src/postgres/index.js"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+/**
+ * The SQL migration applier, and nothing that knows where it is running.
+ *
+ * Two programs apply the same migrations to the same database: `pikku db
+ * migrate` from a checkout, and a shipped standalone bundle from a machine that
+ * has no checkout. They have to agree on the bookkeeping table, the hash, and
+ * the file order, because the second runs against a database the first has
+ * already written to — a second implementation that differs in any of the three
+ * reports every migration the other applied as drifted.
+ */
+export {
+  migrate,
+  baselineMigrations,
+  pendingMigrations,
+  MigrationDriftError,
+  MIGRATION_TRACKING_TABLE,
+  type MigrationExecutor,
+  type MigrateResult,
+  type AppliedMigration,
+} from './sql-migrator.js'
+
+export {
+  assertSnakeCaseIdentifiers,
+  findCamelCaseIdentifiers,
+  stripSqlComments,
+  CamelCaseIdentifierError,
+  type CamelCaseIdentifier,
+} from './migration-identifiers.js'
+
+export {
+  splitStatements,
+  bareTableName,
+  tableCreationSql,
+  tablesInSourceOrder,
+} from './schema-sql.js'

package/src/migration-identifiers.test.ts

@@ -0,0 +1,142 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  assertSnakeCaseIdentifiers,
+  CamelCaseIdentifierError,
+  findCamelCaseIdentifiers,
+} from './migration-identifiers.js'
+
+test('a snake_case migration declares nothing to complain about', () => {
+  const sql = `CREATE TABLE animal (
+  id TEXT NOT NULL PRIMARY KEY,
+  price_cents INTEGER NOT NULL,
+  weight NUMERIC(10,2),
+  status TEXT CHECK (status IN ('for_sale','sold')) DEFAULT 'for_sale',
+  created_at DATE NOT NULL,
+  CONSTRAINT animal_price_positive CHECK (price_cents > 0),
+  FOREIGN KEY (id) REFERENCES owner (id)
+);
+CREATE INDEX animal_status_idx ON animal (status);`
+
+  assert.deepEqual(findCamelCaseIdentifiers('0001-animal.sql', sql), [])
+})
+
+test('a camelCase column is reported with its snake_case name', () => {
+  const sql = 'CREATE TABLE animal (id TEXT PRIMARY KEY, priceCents INTEGER);'
+
+  assert.deepEqual(findCamelCaseIdentifiers('0001-animal.sql', sql), [
+    {
+      file: '0001-animal.sql',
+      table: 'animal',
+      column: 'priceCents',
+      suggestion: 'price_cents',
+    },
+  ])
+})
+
+test('the Better Auth schema quoting style passes as written', () => {
+  const sql =
+    'create table "user" ("id" text not null primary key, "email_verified" integer not null, "created_at" date not null);'
+
+  assert.deepEqual(findCamelCaseIdentifiers('0001-better-auth.sql', sql), [])
+})
+
+test('quoting a camelCase column does not exempt it', () => {
+  const sql = 'create table "user" ("id" text, "emailVerified" integer);'
+
+  assert.deepEqual(findCamelCaseIdentifiers('0001-better-auth.sql', sql), [
+    {
+      file: '0001-better-auth.sql',
+      table: 'user',
+      column: 'emailVerified',
+      suggestion: 'email_verified',
+    },
+  ])
+})
+
+test('a camelCase table name is reported on its own', () => {
+  const sql = 'CREATE TABLE animalSale (id TEXT PRIMARY KEY);'
+
+  assert.deepEqual(findCamelCaseIdentifiers('0001-sales.sql', sql), [
+    {
+      file: '0001-sales.sql',
+      table: 'animalSale',
+      column: null,
+      suggestion: 'animal_sale',
+    },
+  ])
+})
+
+test('camelCase inside comments and string literals is not a declaration', () => {
+  const sql = `-- priceCents used to live here; renamed for CamelCasePlugin
+/* the createdAt column is a date,
+   not a datetime */
+CREATE TABLE animal (
+  id TEXT PRIMARY KEY, -- was animalId
+  status TEXT NOT NULL DEFAULT 'forSale'
+);`
+
+  assert.deepEqual(findCamelCaseIdentifiers('0001-animal.sql', sql), [])
+})
+
+test('ALTER TABLE ADD COLUMN is a declaration too', () => {
+  const sql = `ALTER TABLE animal ADD COLUMN soldAt DATE;
+ALTER TABLE "animal" ADD priceCents INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE animal ADD COLUMN IF NOT EXISTS ownerId TEXT;`
+
+  assert.deepEqual(
+    findCamelCaseIdentifiers('0002-animal.sql', sql).map((o) => o.column),
+    ['soldAt', 'priceCents', 'ownerId']
+  )
+})
+
+test('an ALTER that adds a constraint declares no column', () => {
+  const sql = `ALTER TABLE animal ADD CONSTRAINT animalPriceCheck CHECK (price_cents > 0);
+ALTER TABLE animal ADD PRIMARY KEY (id);
+ALTER TABLE animal RENAME TO beast;`
+
+  assert.deepEqual(findCamelCaseIdentifiers('0003-animal.sql', sql), [])
+})
+
+test('every offender across every file is reported at once', () => {
+  const migrations = [
+    {
+      name: '0001-animal.sql',
+      sql: 'CREATE TABLE animal (id TEXT, priceCents INTEGER, soldAt DATE);',
+    },
+    {
+      name: '0002-owner.sql',
+      sql: 'ALTER TABLE owner ADD COLUMN displayName TEXT;',
+    },
+  ]
+
+  try {
+    assertSnakeCaseIdentifiers(migrations)
+    assert.fail('expected a CamelCaseIdentifierError')
+  } catch (error) {
+    assert.ok(error instanceof CamelCaseIdentifierError)
+    assert.deepEqual(
+      error.offenders.map((o) => `${o.file}:${o.table}.${o.column}`),
+      [
+        '0001-animal.sql:animal.priceCents',
+        '0001-animal.sql:animal.soldAt',
+        '0002-owner.sql:owner.displayName',
+      ]
+    )
+    assert.match(error.message, /priceCents {2}→ {2}price_cents/)
+    assert.match(error.message, /displayName {2}→ {2}display_name/)
+    assert.match(error.message, /replay your dev\ndatabase from scratch/)
+  }
+})
+
+test('a clean set of migrations passes the assertion', () => {
+  assert.doesNotThrow(() =>
+    assertSnakeCaseIdentifiers([
+      {
+        name: '0001-animal.sql',
+        sql: 'CREATE TABLE animal (price_cents INT);',
+      },
+    ])
+  )
+})

package/src/migration-identifiers.ts

@@ -0,0 +1,321 @@
+/**
+ * Catching camelCase columns at migrate time, before they can half-work.
+ *
+ * Pikku's Kysely runs with `CamelCasePlugin`, so `priceCents` in TypeScript is
+ * `price_cents` in SQL and nothing else. A migration that declares the column
+ * *as* `priceCents` is not merely unconventional — it is broken in the one way
+ * that hides itself: `.selectAll()` compiles to `SELECT *` and never names an
+ * identifier, so the table reads back perfectly, while the first query that
+ * names the column (`.select(['animal.priceCents'])`) asks for `price_cents`
+ * and gets `no such column`. The usual conclusion is that the plugin is broken,
+ * and the usual response is a raw `sql` template or a retreat to `.selectAll()`
+ * — both of which keep the real cause alive.
+ *
+ * There is no exception to escape. Even the Better Auth schema `db generate`
+ * writes is snake_case (`email_verified`, `user_id`), because Better Auth is
+ * handed the app's own Kysely and its camelCase field names compile the same
+ * way everyone else's do.
+ */
+
+import { splitStatements } from './schema-sql.js'
+
+/** A camelCase identifier a migration declares, and what it should have said. */
+export interface CamelCaseIdentifier {
+  file: string
+  table: string
+  /** `null` when the table name itself is the offender. */
+  column: string | null
+  suggestion: string
+}
+
+export class CamelCaseIdentifierError extends Error {
+  constructor(public readonly offenders: CamelCaseIdentifier[]) {
+    const lines = offenders.map(
+      (o) =>
+        `  ${o.file}  ${o.column === null ? o.table : `${o.table}.${o.column}`}  →  ${o.suggestion}`
+    )
+    super(
+      `[PKU-DB-CAMEL] Migrations declare camelCase identifiers.\n\n` +
+        `Pikku's Kysely runs with CamelCasePlugin, which maps camelCase in TypeScript\n` +
+        `to snake_case in SQL. A camelCase column half-works: \`.selectAll()\` emits\n` +
+        `\`SELECT *\` so the table reads fine, but naming the column compiles it to\n` +
+        `snake_case and the database answers \`no such column\`.\n\n` +
+        `${lines.join('\n')}\n\n` +
+        `Fix the column definition in the migration file itself and replay your dev\n` +
+        `database from scratch. Do not write a RENAME COLUMN migration — that leaves\n` +
+        `the banned identifier in a SQL file forever.`
+    )
+    this.name = 'CamelCaseIdentifierError'
+  }
+}
+
+/**
+ * Strip comments so a word in prose can never be read as an identifier.
+ *
+ * `splitStatements` already skips over comments when it looks for a boundary,
+ * but it hands back the statement with them still in it, and `-- the userId
+ * column` would otherwise be flagged. Quoting rules are honoured for the same
+ * reason they are there: `'a -- b'` is a string, not a comment.
+ */
+export function stripSqlComments(sql: string): string {
+  let out = ''
+  let i = 0
+
+  while (i < sql.length) {
+    const ch = sql[i]!
+
+    if (ch === "'" || ch === '"' || ch === '`') {
+      const start = i
+      i++
+      while (i < sql.length) {
+        if (sql[i] === '\\' && ch === "'") {
+          i += 2
+          continue
+        }
+        if (sql[i] === ch) {
+          if (sql[i + 1] === ch) {
+            i += 2
+            continue
+          }
+          i++
+          break
+        }
+        i++
+      }
+      out += sql.slice(start, i)
+      continue
+    }
+
+    if (ch === '-' && sql[i + 1] === '-') {
+      const end = sql.indexOf('\n', i)
+      i = end === -1 ? sql.length : end
+      continue
+    }
+
+    if (ch === '/' && sql[i + 1] === '*') {
+      const end = sql.indexOf('*/', i + 2)
+      i = end === -1 ? sql.length : end + 2
+      // A block comment can span lines, and removing it outright would join two
+      // statements onto one line. A space keeps the tokens either side apart.
+      out += ' '
+      continue
+    }
+
+    out += ch
+    i++
+  }
+
+  return out
+}
+
+const IDENTIFIER = String.raw`"[^"]*"|\`[^\`]*\`|\[[^\]]*\]|[A-Za-z_][A-Za-z_0-9$]*`
+
+const CREATE_TABLE = new RegExp(
+  String.raw`^CREATE\s+(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)*TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\S+?)\s*\(`,
+  'i'
+)
+
+const ALTER_TABLE = new RegExp(
+  String.raw`^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?(\S+)`,
+  'i'
+)
+
+const ADD_COLUMN = new RegExp(
+  String.raw`^\s*ADD\s+(?:COLUMN\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(${IDENTIFIER})`,
+  'i'
+)
+
+const COLUMN_NAME = new RegExp(String.raw`^\s*(${IDENTIFIER})`)
+
+/**
+ * The words that open a table-level constraint rather than a column.
+ *
+ * Only consulted for an unquoted first token: `"check"` in quotes is a column
+ * named check, however unwise, and skipping it would let `"checkedAt"`'s
+ * neighbours hide behind it.
+ */
+const CONSTRAINT_KEYWORDS = new Set([
+  'constraint',
+  'primary',
+  'foreign',
+  'unique',
+  'check',
+  'exclude',
+  'index',
+  'key',
+  'like',
+  'period',
+  'fulltext',
+  'spatial',
+])
+
+/** Drop the quoting a dialect happens to use, leaving the identifier itself. */
+const unquote = (name: string): string =>
+  /^["`[]/.test(name) ? name.slice(1, -1) : name
+
+const isCamelCase = (name: string): boolean => /[a-z][A-Z]/.test(name)
+
+const toSnakeCase = (name: string): string =>
+  name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase()
+
+/**
+ * Walk `sql` from `from` and return the offsets just inside and just outside
+ * the parenthesised group that starts there, or `null` if it never closes.
+ *
+ * Quote-aware, because a `)` inside `DEFAULT ')'` closes nothing.
+ */
+function parenSpan(
+  sql: string,
+  from: number
+): { start: number; end: number } | null {
+  let depth = 0
+  let i = from
+
+  while (i < sql.length) {
+    const ch = sql[i]!
+
+    if (ch === "'" || ch === '"' || ch === '`') {
+      i++
+      while (i < sql.length && sql[i] !== ch) i++
+      i++
+      continue
+    }
+
+    if (ch === '(') {
+      depth++
+      if (depth === 1) from = i + 1
+    } else if (ch === ')') {
+      depth--
+      if (depth === 0) return { start: from, end: i }
+    }
+
+    i++
+  }
+
+  return null
+}
+
+/**
+ * Split a definition list on the commas that separate its items.
+ *
+ * The commas inside `NUMERIC(10,2)`, a `CHECK (x IN ('a','b'))` or a compound
+ * `PRIMARY KEY (a, b)` belong to those and not to the list, so only depth zero
+ * counts.
+ */
+function splitTopLevel(list: string): string[] {
+  const items: string[] = []
+  let depth = 0
+  let start = 0
+  let i = 0
+
+  while (i < list.length) {
+    const ch = list[i]!
+
+    if (ch === "'" || ch === '"' || ch === '`') {
+      i++
+      while (i < list.length && list[i] !== ch) i++
+      i++
+      continue
+    }
+
+    if (ch === '(') depth++
+    else if (ch === ')') depth--
+    else if (ch === ',' && depth === 0) {
+      items.push(list.slice(start, i))
+      start = i + 1
+    }
+
+    i++
+  }
+
+  items.push(list.slice(start))
+  return items.filter((item) => item.trim().length > 0)
+}
+
+/**
+ * Every camelCase identifier one migration file declares.
+ *
+ * Only declarations are read — a `CREATE TABLE` column list and an `ALTER TABLE
+ * … ADD COLUMN`. Everywhere else an identifier merely refers to something that
+ * was declared somewhere, and reporting those would name the same mistake once
+ * per reference while adding nothing to the fix.
+ */
+export function findCamelCaseIdentifiers(
+  file: string,
+  sql: string
+): CamelCaseIdentifier[] {
+  const offenders: CamelCaseIdentifier[] = []
+
+  for (const statement of splitStatements(stripSqlComments(sql))) {
+    const create = CREATE_TABLE.exec(statement)
+    if (create) {
+      const table = unquote(create[1]!.split('.').pop()!)
+      if (isCamelCase(table)) {
+        offenders.push({
+          file,
+          table,
+          column: null,
+          suggestion: toSnakeCase(table),
+        })
+      }
+
+      const span = parenSpan(statement, create.index + create[0]!.length - 1)
+      if (!span) continue
+
+      for (const item of splitTopLevel(statement.slice(span.start, span.end))) {
+        const name = COLUMN_NAME.exec(item)?.[1]
+        if (!name) continue
+        if (CONSTRAINT_KEYWORDS.has(name.toLowerCase())) continue
+        const column = unquote(name)
+        if (isCamelCase(column)) {
+          offenders.push({
+            file,
+            table,
+            column,
+            suggestion: toSnakeCase(column),
+          })
+        }
+      }
+      continue
+    }
+
+    const alter = ALTER_TABLE.exec(statement)
+    if (!alter) continue
+
+    const table = unquote(alter[1]!.split('.').pop()!)
+    // Postgres lets one ALTER carry several actions, and only the ADDs declare.
+    for (const action of splitTopLevel(
+      statement.slice(alter[0]!.length).replace(/;\s*$/, '')
+    )) {
+      const name = ADD_COLUMN.exec(action)?.[1]
+      if (!name) continue
+      if (CONSTRAINT_KEYWORDS.has(name.toLowerCase())) continue
+      const column = unquote(name)
+      if (isCamelCase(column)) {
+        offenders.push({
+          file,
+          table,
+          column,
+          suggestion: toSnakeCase(column),
+        })
+      }
+    }
+  }
+
+  return offenders
+}
+
+/**
+ * Bail unless every migration on disk is snake_case throughout.
+ *
+ * Reports all of them at once: a camelCase column is rarely alone, and a
+ * one-at-a-time failure turns a single edit into one migrate run per column.
+ */
+export function assertSnakeCaseIdentifiers(
+  migrations: Array<{ name: string; sql: string }>
+): void {
+  const offenders = migrations.flatMap(({ name, sql }) =>
+    findCamelCaseIdentifiers(name, sql)
+  )
+  if (offenders.length > 0) throw new CamelCaseIdentifierError(offenders)
+}

package/src/postgres/index.ts

@@ -0,0 +1,4 @@
+export {
+  PostgresMigrationExecutor,
+  type PostgresMigrationClient,
+} from './postgres-migrator.js'

package/src/postgres/postgres-migrator.ts

@@ -0,0 +1,81 @@
+import type { MigrationExecutor, AppliedMigration } from '../sql-migrator.js'
+import { MIGRATION_TRACKING_TABLE as TRACKING_TABLE } from '../sql-migrator.js'
+
+export interface PostgresMigrationClient {
+  query<T = unknown>(sql: string, params?: unknown[]): Promise<{ rows: T[] }>
+  exec?(sql: string): Promise<unknown>
+  /**
+   * Run a migration and its bookkeeping row on one connection.
+   *
+   * A pooled client is free to answer `BEGIN`, the migration and `COMMIT` on
+   * three different connections, which leaves a transaction open on one and the
+   * DDL committed outside it on another — a failed migration then stays half
+   * applied with nothing to roll back. A client that hands out a connection
+   * implements this; one that only ever has a single connection does not need
+   * to, and the statement pair below is correct for it.
+   */
+  begin?<T>(handler: (client: PostgresMigrationClient) => Promise<T>): Promise<T>
+}
+
+export class PostgresMigrationExecutor implements MigrationExecutor {
+  constructor(private readonly client: PostgresMigrationClient) {}
+
+  async ensureTrackingTable(): Promise<void> {
+    await this.client.query(`
+      CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE} (
+        name       TEXT PRIMARY KEY,
+        hash       TEXT NOT NULL,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `)
+  }
+
+  async getApplied(): Promise<AppliedMigration[]> {
+    const { rows } = await this.client.query<AppliedMigration>(
+      `SELECT name, hash, applied_at FROM ${TRACKING_TABLE} ORDER BY name`
+    )
+    return rows
+  }
+
+  async recordMigration(name: string, hash: string): Promise<void> {
+    await this.client.query(
+      `INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES ($1, $2)`,
+      [name, hash]
+    )
+  }
+
+  async runMigration(sql: string, name: string, hash: string): Promise<void> {
+    if (typeof this.client.begin === 'function') {
+      await this.client.begin(async (tx) => {
+        await this.applyOn(tx, sql, name, hash)
+      })
+      return
+    }
+
+    await this.client.query('BEGIN')
+    try {
+      await this.applyOn(this.client, sql, name, hash)
+      await this.client.query('COMMIT')
+    } catch (err) {
+      await this.client.query('ROLLBACK')
+      throw err
+    }
+  }
+
+  private async applyOn(
+    client: PostgresMigrationClient,
+    sql: string,
+    name: string,
+    hash: string
+  ): Promise<void> {
+    if (typeof client.exec === 'function') {
+      await client.exec(sql)
+    } else {
+      await client.query(sql)
+    }
+    await client.query(
+      `INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES ($1, $2)`,
+      [name, hash]
+    )
+  }
+}