kern-migrations 0.1.0 → 0.2.0

package/dist/cli.d.mts

@@ -1,4 +1,4 @@
-import { i as MigrationHistory, t as MigrationTarget } from "./target-GAW46krF.mjs";
+import { i as MigrationHistory, t as MigrationTarget } from "./target-iyJah0hO.mjs";
 /** Options of the list module that the command `new` writes. */
 interface MigrationListModuleOptions {
   /** Path of the module, absolute or relative to the working directory, or its `file:` URL. */

package/dist/cli.mjs

@@ -1,5 +1,5 @@
-import { d as moduleExtensions, i as isMigrationTargetDb, l as getMigrationNumber, s as compareMigrationNumbers, w as getErrorMessage } from "./target-Bxf6BZub.mjs";
-import { i as rollback, n as migrate, r as redo, t as getMigrationStatus } from "./migrate-Bd9skEp-.mjs";
+import { d as moduleExtensions, i as isMigrationTargetDb, l as getMigrationNumber, s as compareMigrationNumbers, w as getErrorMessage } from "./target-BHaRgZJG.mjs";
+import { i as rollback, n as migrate, r as redo, t as getMigrationStatus } from "./migrate-CxWPJJmr.mjs";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { n as MigrationError, t as MigrationDirection } from "./error-BOZbdvKf.mjs";
-import { a as MigrationHistoryOptions, c as Migration, d as MigrationStep, f as defineMigration, i as MigrationHistory, l as MigrationChange, n as MigrationTargetDb, o as MigrationLoader, r as MigrationTargetOptions, s as defineMigrations, t as MigrationTarget, u as MigrationDatabase } from "./target-GAW46krF.mjs";
+import { a as MigrationHistoryOptions, c as Migration, d as MigrationStep, f as defineMigration, i as MigrationHistory, l as MigrationChange, n as MigrationTargetDb, o as MigrationLoader, r as MigrationTargetOptions, s as defineMigrations, t as MigrationTarget, u as MigrationDatabase } from "./target-iyJah0hO.mjs";
 /** Builds a step that adds a column of a SQL definition, such as `"text NOT NULL DEFAULT ''"`, to a table, and drops it on rollback. */
 export declare function addColumn(table: string, column: string, definition: string): MigrationStep;
 /**
@@ -149,6 +149,7 @@ interface MigrationStatus {
  * Inside a transaction, it runs in a nested transaction, so that the migrations commit or roll back with the enclosing one, and every migration runs in it.
  * A target that is up to date costs two statements outside a transaction; otherwise, it locks the target, so that processes that migrate it at once apply each migration once.
  * It rejects when the target has applied a migration that the history lacks before its last migration, or a migration after a pending one; applied migrations after the last one, such as of a newer version of the application, are allowed.
+ * In a transaction at `repeatable read` or `serializable`, it rejects when it has migrations to apply, before it locks the target, since the snapshot of the transaction misses the migrations that another process applies meanwhile.
  */
 export declare function migrate(target: MigrationTarget, history: MigrationHistory, options?: MigrateOptions): Promise<string[]>;
 /**
@@ -156,6 +157,7 @@ export declare function migrate(target: MigrationTarget, history: MigrationHisto
  *
  * It rolls them back in one transaction, unless a migration runs outside a transaction, as `migrate` applies them.
  * It rejects when the target has applied a migration that the history lacks, since it cannot roll it back.
+ * In a transaction at `repeatable read` or `serializable`, it rejects when the target has applied migrations, before it locks the target.
  */
 export declare function rollback(target: MigrationTarget, history: MigrationHistory, options?: RollbackOptions): Promise<string[]>;
 /**
@@ -163,6 +165,7 @@ export declare function rollback(target: MigrationTarget, history: MigrationHist
  *
  * It runs them in one transaction, unless a migration runs outside a transaction, as `migrate` applies them.
  * It rejects when the target has applied a migration that the history lacks, since it cannot roll it back.
+ * In a transaction at `repeatable read` or `serializable`, it rejects when the target has applied migrations, before it locks the target.
  */
 export declare function redo(target: MigrationTarget, history: MigrationHistory, options?: RedoOptions): Promise<string[]>;
 /** Lists the applied and the pending migrations of `history` on `target`, and the applied migrations that the history lacks. */

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { C as MigrationError, S as quoteLiteral, b as quoteDollar, c as defineMigrations, f as defineMigration, g as runChange, m as findStepProblem, p as findSharedStepProblem, x as quoteIdentifier } from "./target-Bxf6BZub.mjs";
-import { i as rollback, n as migrate, r as redo, t as getMigrationStatus } from "./migrate-Bd9skEp-.mjs";
+import { C as MigrationError, S as quoteLiteral, b as quoteDollar, c as defineMigrations, f as defineMigration, g as runChange, m as findStepProblem, p as findSharedStepProblem, x as quoteIdentifier } from "./target-BHaRgZJG.mjs";
+import { i as rollback, n as migrate, r as redo, t as getMigrationStatus } from "./migrate-CxWPJJmr.mjs";
 // src/helpers/step.ts
 /**
 * Inverts a step: its `down` becomes `up`, and its `up` becomes `down`, also of its changes outside a transaction, such as to build a helper that drops what another helper creates.

package/dist/{migrate-Bd9skEp-.mjs → migrate-CxWPJJmr.mjs}

@@ -1,4 +1,4 @@
-import { _ as runMigrationSteps, a as openTarget, h as getOutsideTransactionChange, l as getMigrationNumber, n as deleteVersion, o as readVersions, r as insertVersion, t as createVersionsTable, v as runOutsideTransaction, y as toMigrationDatabase } from "./target-Bxf6BZub.mjs";
+import { _ as runMigrationSteps, a as openTarget, h as getOutsideTransactionChange, l as getMigrationNumber, n as deleteVersion, o as readVersions, r as insertVersion, t as createVersionsTable, v as runOutsideTransaction, y as toMigrationDatabase } from "./target-BHaRgZJG.mjs";
 // src/migrate.ts
 /**
 * Applies the pending migrations of `history` to `target`, or the first `count` of them, and resolves to their keys.
@@ -7,12 +7,13 @@ import { _ as runMigrationSteps, a as openTarget, h as getOutsideTransactionChan
 * Inside a transaction, it runs in a nested transaction, so that the migrations commit or roll back with the enclosing one, and every migration runs in it.
 * A target that is up to date costs two statements outside a transaction; otherwise, it locks the target, so that processes that migrate it at once apply each migration once.
 * It rejects when the target has applied a migration that the history lacks before its last migration, or a migration after a pending one; applied migrations after the last one, such as of a newer version of the application, are allowed.
+* In a transaction at `repeatable read` or `serializable`, it rejects when it has migrations to apply, before it locks the target, since the snapshot of the transaction misses the migrations that another process applies meanwhile.
 */
 async function migrate(target, history, options = {}) {
 	const count = options.count === void 0 ? Number.POSITIVE_INFINITY : getCount(options.count, false);
 	const opened = await openTarget(target, history, options);
 	if (getPendingKeys(history, opened.target, opened.versions).length === 0) return [];
-	return await runLocked(opened.target, history, (versions) => {
+	return await runLocked(opened, history, "migrate", (versions) => {
 		const keys = getPendingKeys(history, opened.target, versions).slice(0, count);
 		return {
 			keys,
@@ -28,13 +29,14 @@ async function migrate(target, history, options = {}) {
 *
 * It rolls them back in one transaction, unless a migration runs outside a transaction, as `migrate` applies them.
 * It rejects when the target has applied a migration that the history lacks, since it cannot roll it back.
+* In a transaction at `repeatable read` or `serializable`, it rejects when the target has applied migrations, before it locks the target.
 */
 async function rollback(target, history, options = {}) {
 	const count = getCount(options.count, true);
 	const opened = await openTarget(target, history, options);
 	checkAppliedKeys(history, opened.target, opened.versions, "roll back the migrations of");
 	if (opened.versions.applied.length === 0) return [];
-	return await runLocked(opened.target, history, (versions) => {
+	return await runLocked(opened, history, "roll back the migrations of", (versions) => {
 		checkAppliedKeys(history, opened.target, versions, "roll back the migrations of");
 		const keys = getLastKeys(versions, count).reverse();
 		return {
@@ -51,13 +53,14 @@ async function rollback(target, history, options = {}) {
 *
 * It runs them in one transaction, unless a migration runs outside a transaction, as `migrate` applies them.
 * It rejects when the target has applied a migration that the history lacks, since it cannot roll it back.
+* In a transaction at `repeatable read` or `serializable`, it rejects when the target has applied migrations, before it locks the target.
 */
 async function redo(target, history, options = {}) {
 	const count = getCount(options.count, false);
 	const opened = await openTarget(target, history, options);
 	checkAppliedKeys(history, opened.target, opened.versions, "redo the migrations of");
 	if (opened.versions.applied.length === 0) return [];
-	return await runLocked(opened.target, history, (versions) => {
+	return await runLocked(opened, history, "redo the migrations of", (versions) => {
 		checkAppliedKeys(history, opened.target, versions, "redo the migrations of");
 		const keys = getLastKeys(versions, count);
 		const runs = [];
@@ -119,16 +122,19 @@ function checkAppliedKeys(history, target, versions, action) {
 	if (unknown !== void 0) throw new Error(`Cannot ${action} schema "${target.schemaName}": migration ${unknown} is applied, but the history lacks it`);
 }
 /**
-* Locks `target`, reads its versions again, loads the migrations that `plan` chooses from them, runs them, and resolves to the keys of the plan.
+* Locks the target of `opened`, reads its versions again, loads the migrations that `plan` chooses from them, runs them, and resolves to the keys of the plan.
 *
-* The lock belongs to the qualified name of the table of versions, so that different targets migrate at once.
+* The lock belongs to the qualified name of the table of versions, so that different targets and histories of one target migrate at once.
 * In a transaction block, such as of an enclosing transaction or a test, it runs every migration in a nested transaction that locks the target, with the search path of the migrations.
 * Outside one, it runs them in a session with that search path, which polls for the lock, since a transaction that waits for it would keep a snapshot, which `CREATE INDEX CONCURRENTLY` of the session that holds the lock waits for.
 * It decides which migrations run outside a transaction only from the steps that it loads under the lock, since another process may change the applied migrations before the lock.
+* `action` names the call in its errors, such as `roll back the migrations of`.
 */
-async function runLocked(target, history, plan) {
+async function runLocked(opened, history, action, plan) {
+	const { target } = opened;
 	const { database } = target;
 	const inTransaction = database.isInTransactionBlock();
+	if (inTransaction && snapshotIsolationLevels.has(opened.isolation)) throw new Error(`Cannot ${action} schema "${target.schemaName}" in a transaction at isolation level ${opened.isolation}, whose snapshot misses the migrations that another process applies or rolls back meanwhile; run the call outside a transaction or in a transaction at read committed`);
 	const run = async () => {
 		await (inTransaction ? database.lock(target.table) : database.pollLock(target.table));
 		const versions = await readVersions(target);
@@ -140,6 +146,18 @@ async function runLocked(target, history, plan) {
 	const options = { searchPath: target.searchPath };
 	return inTransaction ? await database.transaction(run, options) : await database.session(run, options);
 }
+/**
+* Isolation levels whose transaction reads from one snapshot, which misses what other transactions commit after it.
+*
+* A call in a transaction block reads the versions under the lock from that snapshot, so it would apply again the migrations that another process has applied meanwhile, or roll back others than the last ones.
+*/
+const snapshotIsolationLevels = /* @__PURE__ */ new Set(["repeatable read", "serializable"]);
+/**
+* Options of the transactions of a call in a session, whatever the default isolation level of the database.
+*
+* Creating the target schema and `createExtension` check again under a lock what another transaction has committed meanwhile, which a transaction at `read committed` sees, since each statement takes a new snapshot there.
+*/
+const sessionTransactionOptions = { isolation: "read committed" };
 /** Runs `runs` in order in the transaction of a call, creating the schema and the table of versions that `versions` lacks before them. */
 async function runInTransaction(target, versions, runs) {
 	if (runs.length === 0) return;
@@ -149,6 +167,8 @@ async function runInTransaction(target, versions, runs) {
 /**
 * Runs `runs` in order in the session of a call: a migration that has a change of its direction outside a transaction runs it alone and is recorded after it in a statement of its own, and each sequence of other migrations between such migrations runs in one transaction.
 *
+* Before a first migration outside a transaction, it creates the schema and the table of versions in a transaction of their own.
+*
 * The migrations before a failure stay committed, and a migration whose change fails outside a transaction keeps its record, so that `migrate` runs its `up` again, and `rollback` its `down`.
 */
 async function runInSession(target, versions, runs) {
@@ -157,7 +177,7 @@ async function runInSession(target, versions, runs) {
 		const run = runs[start];
 		const change = getOutsideTransactionChange(run.steps, run.direction);
 		if (change !== void 0) {
-			if (start === 0) await createVersionsTable(target, versions);
+			if (start === 0) await target.database.transaction(() => createVersionsTable(target, versions), sessionTransactionOptions);
 			await runOutsideTransaction(toMigrationDatabase(target.database), run.key, run.direction, change);
 			await recordRun(target, run);
 			start++;
@@ -170,7 +190,7 @@ async function runInSession(target, versions, runs) {
 		await target.database.transaction(async () => {
 			if (first) await createVersionsTable(target, versions);
 			await runMigrations(target, batch);
-		});
+		}, sessionTransactionOptions);
 		start = end;
 	}
 }

package/dist/{target-Bxf6BZub.mjs → target-BHaRgZJG.mjs}

@@ -108,10 +108,14 @@ async function runOutsideTransaction(database, key, direction, change) {
 		});
 	}
 }
-/** Returns the steps of the default export of the module of migration `key`, rejecting a value that is not a migration. */
-function toMigrationSteps(key, value) {
+/**
+* Returns the steps of migration `key`, rejecting a value that is not a migration.
+*
+* `requirement` completes the message that rejects a value that is neither a step nor a non-empty array of steps, such as `be a step or a non-empty array of steps`.
+*/
+function toMigrationSteps(key, value, requirement) {
 	const steps = Array.isArray(value) ? value : [value];
-	if (typeof value !== "object" || value === null || steps.length === 0) throw new MigrationError(`Migration ${key} must export a step or a non-empty array of steps as its default export`, { key });
+	if (typeof value !== "object" || value === null || steps.length === 0) throw new MigrationError(`Migration ${key} must ${requirement}`, { key });
 	for (let index = 0; index < steps.length; index++) {
 		const step = steps[index];
 		const problem = findStepProblem(step) ?? (steps.length > 1 ? findSharedStepProblem(step) : void 0);
@@ -198,14 +202,14 @@ function compareMigrationNumbers(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
 /**
-* Defines a history of migrations from the loaders of their modules, by key or by path, as `import.meta.glob` returns them.
+* Defines a history of migrations from the loaders of their modules or the migrations themselves, by key or by path as `import.meta.glob` returns them.
 *
 * A key is the file name without directories and extension, of the form `<number>_<name>`, such as `0001_create_form`, and the numbers order the history.
-* It rejects a key of another form, a path of a file of migration tests, and two keys of one number, such as migrations of two branches that took one number.
+* It rejects a key of another form, a path of a file of migration tests, two keys of one number, such as migrations of two branches that took one number, and a value that is neither a loader nor a migration.
 */
-function defineMigrations(loaders, options = {}) {
+function defineMigrations(migrations, options = {}) {
 	const entries = [];
-	for (const [name, load] of Object.entries(loaders)) {
+	for (const [name, value] of Object.entries(migrations)) {
 		const isPath = name.includes("/");
 		if (isPath && getMigrationTestKey(name.slice(name.lastIndexOf("/") + 1)) !== void 0) throw new Error(`${name} is a file of migration tests rather than a migration: exclude migration tests from the modules of the history, such as with "!./migrations/*.migration-test.ts" in the patterns of import.meta.glob`);
 		const key = isPath ? getFileKey(name) : name;
@@ -214,7 +218,7 @@ function defineMigrations(loaders, options = {}) {
 		entries.push({
 			key,
 			number,
-			load
+			load: toEntryLoader(key, value)
 		});
 	}
 	entries.sort((left, right) => compareMigrationNumbers(left.number, right.number));
@@ -232,19 +236,29 @@ function defineMigrations(loaders, options = {}) {
 		async load(key) {
 			const entry = byKey.get(key);
 			if (entry === void 0) throw new Error(`The history has no migration ${key}`);
-			let module;
-			try {
-				module = await entry.load();
-			} catch (error) {
-				throw new MigrationError(`Cannot load migration ${key}: ${getErrorMessage(error)}`, {
-					key,
-					cause: error
-				});
-			}
-			return toMigrationSteps(key, typeof module === "object" && module !== null ? module.default : void 0);
+			return await entry.load();
 		}
 	};
 }
+/** Returns the function that gives the steps of migration `key`: it checks a migration given as a value at once, and loads the module of a loader only when the function is called. */
+function toEntryLoader(key, value) {
+	if (typeof value === "function") return () => loadModule(key, value);
+	const steps = toMigrationSteps(key, value, "be the loader of its module, a step, or a non-empty array of steps");
+	return async () => steps;
+}
+/** Loads the module of migration `key` with `loader` and returns the steps of its default export. */
+async function loadModule(key, loader) {
+	let module;
+	try {
+		module = await loader();
+	} catch (error) {
+		throw new MigrationError(`Cannot load migration ${key}: ${getErrorMessage(error)}`, {
+			key,
+			cause: error
+		});
+	}
+	return toMigrationSteps(key, typeof module === "object" && module !== null ? module.default : void 0, "export a step or a non-empty array of steps as its default export");
+}
 /** Returns the key of a migration module at `path`: its file name without directories and extension. */
 function getFileKey(path) {
 	const fileName = path.slice(path.lastIndexOf("/") + 1);
@@ -274,7 +288,8 @@ async function openTarget(target, history, options) {
 	};
 	return {
 		target: resolved,
-		versions: await readApplied(resolved, state)
+		versions: await readApplied(resolved, state),
+		isolation: state.isolation
 	};
 }
 /** Reads the versions of a resolved target again, such as after locking it. */
@@ -288,9 +303,20 @@ async function readVersions(target) {
 * Checking `versions` first keeps PostgreSQL from sending a notice of an existing schema, which postgres.js logs by default.
 */
 async function createVersionsTable(target, versions) {
-	if (!versions.schemaExists) await execute(target.database, `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(target.schemaName)}`);
+	if (!versions.schemaExists) await execute(target.database, buildCreateSchema(target.schemaName));
 	if (!versions.tableExists) await execute(target.database, `CREATE TABLE IF NOT EXISTS ${target.table} (key text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())`);
 }
+/**
+* Builds a statement that creates schema `schemaName` unless it exists, checking it again under a transaction-level advisory lock of the schema.
+*
+* Histories of one target do not share the lock of the target, and `IF NOT EXISTS` misses a schema that another transaction has created and not committed, so without this lock a history that creates the schema while another one does fails on the unique index of `pg_namespace` once the other commits.
+* The lock lasts until the transaction of the statement ends, and the check under it sees a schema that another history committed meanwhile under `READ COMMITTED`, since each statement of the block takes a new snapshot.
+* The key of the lock includes the schema, so that targets of different schemas, such as new tenants, do not wait for each other.
+*/
+function buildCreateSchema(schemaName) {
+	const name = quoteLiteral(schemaName);
+	return `DO ${quoteDollar(`BEGIN PERFORM pg_advisory_xact_lock(hashtextextended(${quoteLiteral(`kern-migrations schema ${schemaName}`)}, 0)); IF NOT EXISTS (SELECT FROM pg_catalog.pg_namespace WHERE nspname = ${name}) THEN CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schemaName)}; END IF; END`)}`;
+}
 /** Records migration `key` as applied. */
 async function insertVersion(target, key) {
 	await execute(target.database, `INSERT INTO ${target.table} (key) VALUES ($1)`, [key]);
@@ -300,14 +326,14 @@ async function deleteVersion(target, key) {
 	await execute(target.database, `DELETE FROM ${target.table} WHERE key = $1`, [key]);
 }
 /**
-* Resolves `schemaName`, or `current_schema()` when it is `null`, and checks that the schema and its table of versions exist, in one statement.
+* Resolves `schemaName`, or `current_schema()` when it is `null`, checks that the schema and its table of versions exist, and reads the isolation level of the transaction, in one statement.
 *
 * It reads `pg_catalog` rather than calling `to_regclass`, whose lookups in the catalog cache of the connection miss a schema that another transaction committed while this one waited for the lock of the target.
 * It rejects a schema or table name longer than `max_identifier_length` bytes, which PostgreSQL would truncate, so that the check never misses a schema or a table that the migrator created.
 */
 async function readState(database, schemaName, tableName) {
-	const { rows } = await execute(database, `SELECT target.name, namespace.oid IS NOT NULL, EXISTS (SELECT FROM pg_catalog.pg_class WHERE relnamespace = namespace.oid AND relname = $2::text), current_setting('max_identifier_length'), octet_length(target.name), octet_length($2::text) FROM (SELECT coalesce($1::text, current_schema()) AS name) AS target LEFT JOIN pg_catalog.pg_namespace AS namespace ON namespace.nspname = target.name`, [schemaName, tableName]);
-	const [name, schemaExists, tableExists, maxLength, schemaLength, tableLength] = rows[0];
+	const { rows } = await execute(database, `SELECT target.name, namespace.oid IS NOT NULL, EXISTS (SELECT FROM pg_catalog.pg_class WHERE relnamespace = namespace.oid AND relname = $2::text), current_setting('max_identifier_length'), octet_length(target.name), octet_length($2::text), current_setting('transaction_isolation') FROM (SELECT coalesce($1::text, current_schema()) AS name) AS target LEFT JOIN pg_catalog.pg_namespace AS namespace ON namespace.nspname = target.name`, [schemaName, tableName]);
+	const [name, schemaExists, tableExists, maxLength, schemaLength, tableLength, isolation] = rows[0];
 	if (name === null || name === void 0) throw new Error("Cannot resolve the target schema: current_schema() is NULL, since no schema of the search path exists; pass schemaName");
 	const limit = Number(maxLength);
 	for (const [kind, value, length] of [[
@@ -322,7 +348,8 @@ async function readState(database, schemaName, tableName) {
 	return {
 		schemaName: name,
 		schemaExists: schemaExists === "t",
-		tableExists: tableExists === "t"
+		tableExists: tableExists === "t",
+		isolation
 	};
 }
 /** Reads the applied keys of a target whose table of versions `state` found. */

package/dist/{target-GAW46krF.d.mts → target-iyJah0hO.d.mts}

@@ -51,19 +51,19 @@ interface MigrationHistory {
   /** PostgreSQL schemas that the search path of the migrations lists after the target schema. */
   readonly searchPath: readonly string[];
   /**
-   * Loads the module of the migration of `key` and returns its steps.
+   * Returns the steps of the migration of `key`, loading its module when the history has its loader.
    *
    * It rejects with a `MigrationError` when the module fails to load or does not export a migration.
    */
   load(key: string): Promise<readonly MigrationStep[]>;
 }
 /**
- * Defines a history of migrations from the loaders of their modules, by key or by path, as `import.meta.glob` returns them.
+ * Defines a history of migrations from the loaders of their modules or the migrations themselves, by key or by path as `import.meta.glob` returns them.
  *
  * A key is the file name without directories and extension, of the form `<number>_<name>`, such as `0001_create_form`, and the numbers order the history.
- * It rejects a key of another form, a path of a file of migration tests, and two keys of one number, such as migrations of two branches that took one number.
+ * It rejects a key of another form, a path of a file of migration tests, two keys of one number, such as migrations of two branches that took one number, and a value that is neither a loader nor a migration.
  */
-declare function defineMigrations(loaders: Readonly<Record<string, MigrationLoader>>, options?: MigrationHistoryOptions): MigrationHistory;
+declare function defineMigrations(migrations: Readonly<Record<string, MigrationLoader | Migration>>, options?: MigrationHistoryOptions): MigrationHistory;
 /**
  * Target of migrations: a database and a PostgreSQL schema, the target schema.
  *

package/dist/testing.d.mts

@@ -1,5 +1,5 @@
 import { n as MigrationError } from "./error-BOZbdvKf.mjs";
-import { i as MigrationHistory, t as MigrationTarget, u as MigrationDatabase } from "./target-GAW46krF.mjs";
+import { i as MigrationHistory, t as MigrationTarget, u as MigrationDatabase } from "./target-iyJah0hO.mjs";
 /** Callback of a migration test that prepares or checks the data of the schema through the database of the migration. */
 type MigrationTestCallback = (database: MigrationDatabase) => unknown;
 /** Type that rejects `assertUpError` of a migration test together with `assertUp` or `assertDown`. */

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { C as MigrationError, _ as runMigrationSteps, i as isMigrationTargetDb, u as getMigrationTestKey, w as getErrorMessage, x as quoteIdentifier, y as toMigrationDatabase } from "./target-Bxf6BZub.mjs";
+import { C as MigrationError, _ as runMigrationSteps, i as isMigrationTargetDb, u as getMigrationTestKey, w as getErrorMessage, x as quoteIdentifier, y as toMigrationDatabase } from "./target-BHaRgZJG.mjs";
 import { join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { readdir } from "node:fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kern-migrations",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Migrations of PostgreSQL schemas for kern-db and kern-orm",
   "keywords": [
     "kern-db",