@dungarees/datasource 0.11.4

package/fake.d.ts

@@ -0,0 +1,35 @@
+import type { MigrationSource, Migrator } from './migration/type.ts';
+import type { ConnectionBuilder, Datasource, Generated } from './type.ts';
+export type FakeDbConnectionBuilder = {
+    connectionBuilder: ConnectionBuilder;
+    queries: string[];
+};
+export declare const createFakeDbConnectionBuilder: () => FakeDbConnectionBuilder;
+export type DbFixture<SCHEMA, CONTEXT = undefined> = (datasource: Datasource<SCHEMA>) => Promise<CONTEXT>;
+export type TestDatasourceAndMigrator<SCHEMA> = {
+    datasource: Datasource<SCHEMA>;
+    migrator: Migrator;
+    [Symbol.asyncDispose]: () => Promise<void>;
+};
+export type TestDatasourceWithContext<SCHEMA, CONTEXT> = TestDatasourceAndMigrator<SCHEMA> & {
+    context: CONTEXT;
+};
+export type TestDatasourceAndMigratorArgs<SCHEMA> = MigrationSource & {
+    datasource?: Datasource<SCHEMA>;
+};
+export type TestMigratedDatasourceArgs<SCHEMA, CONTEXT> = TestDatasourceAndMigratorArgs<SCHEMA> & {
+    dbFixture: DbFixture<SCHEMA, CONTEXT>;
+};
+export declare const createTestDatasource: <SCHEMA>() => Datasource<SCHEMA>;
+export declare const createTestDatasourceAndMigrator: <SCHEMA>({ datasource, ...source }: TestDatasourceAndMigratorArgs<SCHEMA>) => Promise<TestDatasourceAndMigrator<SCHEMA>>;
+export declare const createTestMigratedDatasource: <SCHEMA, CONTEXT>({ dbFixture, ...args }: TestMigratedDatasourceArgs<SCHEMA, CONTEXT>) => Promise<TestDatasourceWithContext<SCHEMA, CONTEXT>>;
+export type TestSchema = {
+    table1: {
+        id: Generated<string>;
+        name: string;
+    };
+};
+export declare const testMigrationsFolder: any;
+export declare const testErrorMigrationsFolder: any;
+export declare const createTestDatasourceAndMigratorWithTestMigrations: () => Promise<TestDatasourceAndMigrator<TestSchema>>;
+export declare const createTestDatasourceAndMigratorWithTestErrorMigrations: () => Promise<TestDatasourceAndMigrator<TestSchema>>;

package/fake.js

@@ -0,0 +1,51 @@
+import { createInMemoryMigrator } from './migration/inmemory-migrator.js';
+import { createMigrator } from './migration/service.js';
+import { createInMemoryPostgresConnectionBuilder } from './postgres/fake.js';
+import { createDatasource } from './service.js';
+import { createCausedError } from '@dungarees/core/error.ts';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// Prefer createTestDatasource for anything that asserts on data: that one runs the real SQL.
+export const createFakeDbConnectionBuilder = () => {
+    const queries = [];
+    return {
+        connectionBuilder: () => 
+        // Only the one method is implemented, so this cannot be built as a real Datasource.
+        ({
+            selectFrom: (table) => queries.push(table),
+        }),
+        queries,
+    };
+};
+export const createTestDatasource = () => createDatasource(createInMemoryPostgresConnectionBuilder());
+export const createTestDatasourceAndMigrator = async ({ datasource, ...source }) => {
+    const datasourceToUse = datasource ?? createTestDatasource();
+    return await Promise.resolve({
+        datasource: datasourceToUse,
+        migrator: createMigrator(createInMemoryMigrator({ datasource: datasourceToUse, ...source })),
+        [Symbol.asyncDispose]: async () => {
+            await datasourceToUse.destroy();
+        },
+    });
+};
+export const createTestMigratedDatasource = async ({ dbFixture, ...args }) => {
+    const db = await createTestDatasourceAndMigrator(args);
+    const { error, results } = await db.migrator.migrateToLatest();
+    if (error !== undefined) {
+        throw createCausedError({
+            message: `Failed to migrate: ${describeResults(results)}`,
+            cause: error,
+        });
+    }
+    return { ...db, context: await dbFixture(db.datasource) };
+};
+// Named in the message rather than logged, so the failure says which migration stopped it without
+// this library writing to the console.
+const describeResults = (results) => results.map(({ migrationName, status }) => `${migrationName}=${status}`).join(', ');
+const packageFolder = dirname(fileURLToPath(import.meta.url));
+export const testMigrationsFolder = join(packageFolder, 'test-migrations');
+export const testErrorMigrationsFolder = join(packageFolder, 'test-migrations-with-error');
+export const createTestDatasourceAndMigratorWithTestMigrations = async () => await createTestDatasourceAndMigrator({ migrationsFolder: testMigrationsFolder });
+export const createTestDatasourceAndMigratorWithTestErrorMigrations = async () => await createTestDatasourceAndMigrator({
+    migrationsFolder: testErrorMigrationsFolder,
+});

package/fake.test.d.ts

@@ -0,0 +1 @@
+export {};

package/fake.test.js

@@ -0,0 +1,558 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createTestDatasourceAndMigrator, createTestDatasourceAndMigratorWithTestErrorMigrations, createTestDatasourceAndMigratorWithTestMigrations, createTestMigratedDatasource, testErrorMigrationsFolder, testMigrationsFolder, } from './fake.js';
+import { createInMemoryPostgresConnectionBuilder } from './postgres/fake.js';
+import { createDatasource } from './service.js';
+import { expect, test } from 'vitest';
+const migrationsFolder = testMigrationsFolder;
+const dbFixture = async (datasource) => {
+    await datasource.insertInto('table1').values({ name: 'test3' }).execute();
+};
+const dbFixtureWithContext = async (datasource) => {
+    await datasource.insertInto('table1').values({ name: 'test3' }).execute();
+    return { value: 3 };
+};
+const MIGRATED_ROWS = [
+    { id: 1, name: 'test1' },
+    { id: 2, name: 'test2' },
+];
+test('a migrated test datasource has run every migration and the fixture', async () => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_1, await createTestMigratedDatasource({ dbFixture, migrationsFolder }), true);
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([
+            ...MIGRATED_ROWS,
+            { id: 3, name: 'test3' },
+        ]);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+});
+test('a migrated test datasource is destroyed when it goes out of scope', async () => {
+    const destroyed = [];
+    {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const db = __addDisposableResource(env_2, await createTestMigratedDatasource({ dbFixture, migrationsFolder }), true);
+            db.datasource.destroy = async () => {
+                destroyed.push(true);
+            };
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    expect(destroyed).toEqual([true]);
+});
+test('a fixture can hand back a context alongside the datasource', async () => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_3, await createTestMigratedDatasource({
+            dbFixture: dbFixtureWithContext,
+            migrationsFolder,
+        }), true);
+        expect(db.context).toEqual({ value: 3 });
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
+    }
+});
+test('a migrated test datasource can be given a datasource to use', async () => {
+    const datasource = createDatasource(createInMemoryPostgresConnectionBuilder());
+    await createTestMigratedDatasource({ dbFixture, migrationsFolder, datasource });
+    expect(await datasource.selectFrom('table1').selectAll().execute()).toEqual([
+        ...MIGRATED_ROWS,
+        { id: 3, name: 'test3' },
+    ]);
+});
+test('a migrated test datasource still exposes its migrator', async () => {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_4, await createTestMigratedDatasource({ dbFixture, migrationsFolder }), true);
+        await db.migrator.migrateDownStep();
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([
+            { id: 1, name: 'test1' },
+            { id: 3, name: 'test3' },
+        ]);
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        const result_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
+    }
+});
+test('a migrated test datasource reports which migration failed', async () => {
+    await expect(createTestMigratedDatasource({ dbFixture, migrationsFolder: testErrorMigrationsFolder })).rejects.toThrow('002-test-migration=Error');
+});
+test('a test datasource and migrator has not run any migration yet', async () => {
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_5, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await expect(db.datasource.selectFrom('table1').selectAll().execute()).rejects.toThrow();
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        const result_5 = __disposeResources(env_5);
+        if (result_5)
+            await result_5;
+    }
+});
+test('a test datasource and migrator is destroyed when it goes out of scope', async () => {
+    const destroyed = [];
+    {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const db = __addDisposableResource(env_6, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+            db.datasource.destroy = async () => {
+                destroyed.push(true);
+            };
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            const result_6 = __disposeResources(env_6);
+            if (result_6)
+                await result_6;
+        }
+    }
+    expect(destroyed).toEqual([true]);
+});
+test('a test datasource and migrator can be given a datasource to use', async () => {
+    const env_7 = { stack: [], error: void 0, hasError: false };
+    try {
+        const datasource = createDatasource(createInMemoryPostgresConnectionBuilder());
+        const db = __addDisposableResource(env_7, await createTestDatasourceAndMigrator({ migrationsFolder, datasource }), true);
+        await db.migrator.migrateToLatest();
+        expect(await datasource.selectFrom('table1').selectAll().execute()).toEqual(MIGRATED_ROWS);
+    }
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
+    }
+    finally {
+        const result_7 = __disposeResources(env_7);
+        if (result_7)
+            await result_7;
+    }
+});
+test('migrateToLatest runs every migration', async () => {
+    const env_8 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_8, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToLatest();
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual(MIGRATED_ROWS);
+    }
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
+    }
+    finally {
+        const result_8 = __disposeResources(env_8);
+        if (result_8)
+            await result_8;
+    }
+});
+test('migrateUpStep runs only the next migration', async () => {
+    const env_9 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_9, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateUpStep();
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([]);
+    }
+    catch (e_9) {
+        env_9.error = e_9;
+        env_9.hasError = true;
+    }
+    finally {
+        const result_9 = __disposeResources(env_9);
+        if (result_9)
+            await result_9;
+    }
+});
+test('migrateUpStep run twice runs the second migration as well', async () => {
+    const env_10 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_10, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateUpStep();
+        await db.migrator.migrateUpStep();
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([
+            { id: 1, name: 'test1' },
+        ]);
+    }
+    catch (e_10) {
+        env_10.error = e_10;
+        env_10.hasError = true;
+    }
+    finally {
+        const result_10 = __disposeResources(env_10);
+        if (result_10)
+            await result_10;
+    }
+});
+test('migrateUpStep past the last migration does nothing', async () => {
+    const env_11 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_11, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToLatest();
+        expect(await db.migrator.migrateUpStep()).toEqual({ error: undefined, results: [] });
+    }
+    catch (e_11) {
+        env_11.error = e_11;
+        env_11.hasError = true;
+    }
+    finally {
+        const result_11 = __disposeResources(env_11);
+        if (result_11)
+            await result_11;
+    }
+});
+test('migrateDownStep undoes the last migration', async () => {
+    const env_12 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_12, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToLatest();
+        await db.migrator.migrateDownStep();
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([
+            { id: 1, name: 'test1' },
+        ]);
+    }
+    catch (e_12) {
+        env_12.error = e_12;
+        env_12.hasError = true;
+    }
+    finally {
+        const result_12 = __disposeResources(env_12);
+        if (result_12)
+            await result_12;
+    }
+});
+test('migrateDownStep with nothing applied does nothing', async () => {
+    const env_13 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_13, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        expect(await db.migrator.migrateDownStep()).toEqual({ error: undefined, results: [] });
+    }
+    catch (e_13) {
+        env_13.error = e_13;
+        env_13.hasError = true;
+    }
+    finally {
+        const result_13 = __disposeResources(env_13);
+        if (result_13)
+            await result_13;
+    }
+});
+test('getMigrations lists every migration as not yet executed', async () => {
+    const env_14 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_14, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        expect(await db.migrator.getMigrations()).toEqual([
+            { name: '001-test-migration', executedAt: undefined },
+            { name: '002-test-migration', executedAt: undefined },
+            { name: '003-test-migration', executedAt: undefined },
+        ]);
+    }
+    catch (e_14) {
+        env_14.error = e_14;
+        env_14.hasError = true;
+    }
+    finally {
+        const result_14 = __disposeResources(env_14);
+        if (result_14)
+            await result_14;
+    }
+});
+test('getMigrations stamps the migrations that have run', async () => {
+    const env_15 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_15, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToLatest();
+        const executed = (await db.migrator.getMigrations()).map(({ name, executedAt }) => ({
+            name,
+            hasRun: executedAt !== undefined,
+        }));
+        expect(executed).toEqual([
+            { name: '001-test-migration', hasRun: true },
+            { name: '002-test-migration', hasRun: true },
+            { name: '003-test-migration', hasRun: true },
+        ]);
+    }
+    catch (e_15) {
+        env_15.error = e_15;
+        env_15.hasError = true;
+    }
+    finally {
+        const result_15 = __disposeResources(env_15);
+        if (result_15)
+            await result_15;
+    }
+});
+test('migrateTo runs up to the named migration and skips the rest', async () => {
+    const env_16 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_16, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        const { results } = await db.migrator.migrateTo('002-test-migration');
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([
+            { id: 1, name: 'test1' },
+        ]);
+        expect(results).toEqual([
+            { migrationName: '001-test-migration', status: 'Success', direction: 'Up' },
+            { migrationName: '002-test-migration', status: 'Success', direction: 'Up' },
+            { migrationName: '003-test-migration', status: 'NotExecuted', direction: 'Up' },
+        ]);
+    }
+    catch (e_16) {
+        env_16.error = e_16;
+        env_16.hasError = true;
+    }
+    finally {
+        const result_16 = __disposeResources(env_16);
+        if (result_16)
+            await result_16;
+    }
+});
+test('migrateTo walks back down to the named migration', async () => {
+    const env_17 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_17, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToLatest();
+        const { results } = await db.migrator.migrateTo('001-test-migration');
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([]);
+        expect(results).toEqual([
+            { migrationName: '001-test-migration', status: 'NotExecuted', direction: 'Down' },
+            { migrationName: '002-test-migration', status: 'Success', direction: 'Down' },
+            { migrationName: '003-test-migration', status: 'Success', direction: 'Down' },
+        ]);
+    }
+    catch (e_17) {
+        env_17.error = e_17;
+        env_17.hasError = true;
+    }
+    finally {
+        const result_17 = __disposeResources(env_17);
+        if (result_17)
+            await result_17;
+    }
+});
+test('migrateTo walks back down from the middle', async () => {
+    const env_18 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_18, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateTo('002-test-migration');
+        const { results } = await db.migrator.migrateTo('001-test-migration');
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([]);
+        expect(results).toEqual([
+            { migrationName: '001-test-migration', status: 'NotExecuted', direction: 'Down' },
+            { migrationName: '002-test-migration', status: 'Success', direction: 'Down' },
+            { migrationName: '003-test-migration', status: 'NotExecuted', direction: 'Down' },
+        ]);
+    }
+    catch (e_18) {
+        env_18.error = e_18;
+        env_18.hasError = true;
+    }
+    finally {
+        const result_18 = __disposeResources(env_18);
+        if (result_18)
+            await result_18;
+    }
+});
+test('migrateTo refuses a migration name that does not exist', async () => {
+    const env_19 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_19, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await expect(db.migrator.migrateTo('009-nope')).rejects.toThrow('Migration 009-nope not found');
+    }
+    catch (e_19) {
+        env_19.error = e_19;
+        env_19.hasError = true;
+    }
+    finally {
+        const result_19 = __disposeResources(env_19);
+        if (result_19)
+            await result_19;
+    }
+});
+test('migrateToEmpty leaves nothing behind', async () => {
+    const env_20 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_20, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToLatest();
+        await db.migrator.migrateToEmpty();
+        await expect(db.datasource.selectFrom('table1').selectAll().execute()).rejects.toThrow();
+    }
+    catch (e_20) {
+        env_20.error = e_20;
+        env_20.hasError = true;
+    }
+    finally {
+        const result_20 = __disposeResources(env_20);
+        if (result_20)
+            await result_20;
+    }
+});
+test('migrateToEmpty on a datasource that was never migrated leaves it empty', async () => {
+    const env_21 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_21, await createTestDatasourceAndMigrator({ migrationsFolder }), true);
+        await db.migrator.migrateToEmpty();
+        await expect(db.datasource.selectFrom('table1').selectAll().execute()).rejects.toThrow();
+    }
+    catch (e_21) {
+        env_21.error = e_21;
+        env_21.hasError = true;
+    }
+    finally {
+        const result_21 = __disposeResources(env_21);
+        if (result_21)
+            await result_21;
+    }
+});
+test('the packaged test migrations helper migrates to latest', async () => {
+    const env_22 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_22, await createTestDatasourceAndMigratorWithTestMigrations(), true);
+        await db.migrator.migrateToLatest();
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual(MIGRATED_ROWS);
+    }
+    catch (e_22) {
+        env_22.error = e_22;
+        env_22.hasError = true;
+    }
+    finally {
+        const result_22 = __disposeResources(env_22);
+        if (result_22)
+            await result_22;
+    }
+});
+test('a failing migration is reported as an error rather than thrown', async () => {
+    const env_23 = { stack: [], error: void 0, hasError: false };
+    try {
+        const db = __addDisposableResource(env_23, await createTestDatasourceAndMigratorWithTestErrorMigrations(), true);
+        const { error, results } = await db.migrator.migrateToLatest();
+        expect(error).toBeInstanceOf(Error);
+        expect(results).toEqual([
+            { migrationName: '001-test-migration', status: 'Success', direction: 'Up' },
+            { migrationName: '002-test-migration', status: 'Error', direction: 'Up' },
+        ]);
+    }
+    catch (e_23) {
+        env_23.error = e_23;
+        env_23.hasError = true;
+    }
+    finally {
+        const result_23 = __disposeResources(env_23);
+        if (result_23)
+            await result_23;
+    }
+});
+test('migrations can be handed over directly instead of read from a folder', async () => {
+    const env_24 = { stack: [], error: void 0, hasError: false };
+    try {
+        const created = [];
+        const db = __addDisposableResource(env_24, await createTestDatasourceAndMigrator({
+            migrations: {
+                '001-inline': {
+                    up: async (datasource) => {
+                        created.push('001-inline');
+                        await datasource.schema
+                            .createTable('table1')
+                            .addColumn('id', 'serial', (col) => col.primaryKey())
+                            .addColumn('name', 'varchar', (col) => col.notNull())
+                            .execute();
+                    },
+                },
+            },
+        }), true);
+        await db.migrator.migrateToLatest();
+        expect(created).toEqual(['001-inline']);
+        expect(await db.datasource.selectFrom('table1').selectAll().execute()).toEqual([]);
+    }
+    catch (e_24) {
+        env_24.error = e_24;
+        env_24.hasError = true;
+    }
+    finally {
+        const result_24 = __disposeResources(env_24);
+        if (result_24)
+            await result_24;
+    }
+});

package/helpers.d.ts

@@ -0,0 +1,2 @@
+export { sql } from 'kysely';
+export { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres';

package/helpers.js

@@ -0,0 +1,4 @@
+// Re-exported so an application that talks to its datasource through this package does not also
+// have to depend on kysely directly for the query helpers.
+export { sql } from 'kysely';
+export { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres';

package/migration/inmemory-migrator.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationRunner, MigratorConfig } from './type.ts';
+export declare const createInMemoryMigrator: ({ datasource, ...source }: MigratorConfig) => MigrationRunner;