@roostorg/db-migrator 1.0.6

package/README.md

@@ -0,0 +1,52 @@
+## Concepts/Terminology
+
+The CLI classifies scripts as "seeds" or a "migrations". The
+fundamental difference is that a migration runs across every environment --
+including production -- whereas a seed only runs in one environment. Therefore,
+schema changes should always be migrations. "Reference data" that are the same
+in every environment -- essentially, application constants that just happen to
+be stored in the database -- are also appropriate to add as migrations. But
+fixtures data for tests or other specific use cases is a seed.
+
+Critically, seed files are timestamped just like migrations, and they're run
+interspersed with the migrations. This approach is unconventional -- the normal
+approach is to have seed scripts run after all migrations have been applied --
+but it makes sense _given that we're writing the seeds as SQL or JS scripts that
+don't have access to our Sequelize model's db mappings_.
+
+Under the conventional approach, the seed scripts must be written against the
+latest schema (since they run after all migrations). This isn't a problem when
+the seed scripts are written using entity classes that the main application also
+uses to talk to the database, because the ORM mapping for those classes will
+also have updated when the migration is deployed. I.e., if we wrote our seed
+scripts in typescript using our sequelize models classes, then updating the
+model definitions to keep our classes working for our app would also keep our
+seed scripts working, and we might even get type errors (from Typescript) if,
+e.g., we removed a field from the model class that a seed script depended on.
+
+However, when seed scripts don't go though the Sequelize model classes, and
+instead include direct references to SQL column names etc (as ours do), then
+using the conventional approach of running seeds at the end means that making a
+schema change in a new migration can break the existing seed scripts. This is
+bad. It creates extra work that must be done after each new migration to keep
+the seed scripts working with the latest schema. More importantly, though, we
+might not catch for quite a while that a migration has broken one of our seed
+scripts, since we'd get no compile errors and since, even on deploy, only the
+seed scripts for the environment being deployed get run. E.g., it'd be a pain to
+find out three weeks after writing a migration, when we go to re-deploy demo,
+that we'd actually broken its seed script; then we'd have to go back, remember
+what we changed, and fix it.
+
+For now, we don't want to introduce the complexity of exporting/depending on our
+Sequelize model classes in our seed scripts, so it makes sense to ditch the
+conventional approach of running seeds all at the end.
+
+By instead interspersing the running of the seed scripts w/ the migrations'
+schema changes, each script knows exactly what the schema will look like at the
+time it runs, and can't be broken by future schema changes.
+
+That said, long term, it would be nice to write the seed scripts using Sequelize
+models and run them at the end, because that would allow us to have fewer,
+more-intentionally-divided seed scripts, which makes it a bit easier to see
+exactly what seed data we're setting up (without actually checking the db). It
+would also be more performant.

package/build/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/cli/cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import path from 'path';
+import { makeCli } from './index.js';
+// For now, discover the configs by reading the filesystem, at a path that's
+// overrideable by an env var. This is simpler than taking a CLI option that
+// we'd have to set with every command invocation.
+const configPath = process.env.MIGRATOR_CONFIG_PATH ?? './configs/index.js';
+makeCli(await import(path.resolve(process.cwd(), configPath)));

package/build/cli/index.d.ts

@@ -0,0 +1,5 @@
+import '@total-typescript/ts-reset/array-includes';
+import type { DatabaseConfig } from './typescript-types.js';
+export declare function makeCli(dbs: {
+    [k: string]: DatabaseConfig<string, any>;
+}): void;

package/build/cli/index.js

@@ -0,0 +1,320 @@
+import path from 'path';
+import { promisify } from 'util';
+import glob from 'glob';
+import '@total-typescript/ts-reset/array-includes';
+import { Umzug } from 'umzug';
+import yargs from 'yargs';
+import { nameScript, scriptTypes, shouldRun } from './script-generator.js';
+const globAsync = promisify(glob);
+export function makeCli(dbs) {
+    const dbNames = Object.keys(dbs);
+    const dbOpt = {
+        alias: 'database',
+        describe: 'The database(s) to run migration against',
+        type: 'array',
+        choices: dbNames,
+        default: process.env.MIGRATOR_DB_NAME?.split(',').map((it) => it.trim()) ??
+            dbNames,
+    };
+    const envOpt = {
+        alias: 'environment',
+        describe: "Environment you're creating a seed for or running the migrations/seeds " +
+            'in (effects which/whether seeds are run and how generated files are named).',
+        type: 'string',
+        choices: [
+            ...new Set(dbNames.flatMap((it) => dbs[it].supportedEnvironments)),
+        ],
+    };
+    const formatOpt = {
+        alias: 'format',
+        describe: 'Whether this script (seed or migration) will be in SQL or JS.',
+        type: 'string',
+        choices: Object.values(dbs).flatMap((it) => it.supportedScriptFormats),
+        demandOption: false,
+        default: undefined,
+    };
+    yargs(process.argv.slice(2))
+        .command({
+        command: 'add <db> <type> <name>',
+        describe: 'Creates a blank migration or seed file, properly named.',
+        builder(yargs) {
+            return yargs
+                .positional('db', {
+                alias: 'database',
+                describe: 'The name of the database for which to create the script.',
+                choices: dbNames,
+                demandOption: true,
+            })
+                .positional('type', {
+                choices: scriptTypes,
+                demandOption: true,
+            })
+                .positional('name', {
+                describe: 'Name of the script to create.',
+                type: 'string',
+                demandOption: true,
+            })
+                .option('env', envOpt)
+                .option('format', formatOpt)
+                .check((opts) => {
+                if (opts.type === 'seed' && !opts.env) {
+                    throw new Error('Environment is required when adding a seed file, to indicate' +
+                        'in which environment the seed should be applied.');
+                }
+                if (opts.type === 'migration' && opts.env) {
+                    throw new Error('You cannot provide an environment when creating a migration; ' +
+                        'every migration is run in every environment for schema consistency.');
+                }
+                const dbConfig = dbs[opts.db];
+                if (opts.env &&
+                    !dbConfig.supportedEnvironments.includes(opts.env)) {
+                    throw new Error(`The db "${opts.db}" doesn't support the "${opts.env}" environment.`);
+                }
+                if (opts.format !== undefined &&
+                    !dbConfig.supportedScriptFormats.includes(opts.format)) {
+                    throw new Error(`The db "${opts.db}" doesn't support .${opts.format} files as scripts.`);
+                }
+                return true;
+            }, false);
+        },
+        async handler({ db, name, type, env, format: formatOptValue }) {
+            const { defaultScriptFormat, getTemplate, scriptsDirectory } = dbs[db];
+            // Umzug couples together script creation and running into one class,
+            // presumaly to support the `verify` behavior mentioned below, so we have
+            // to instantiate it w/ dummy values for `migrations` and `context` here.
+            const migrator = new Umzug({
+                async migrations() {
+                    return [];
+                },
+                create: {
+                    template: (filePath) => [[filePath, getTemplate?.(filePath) ?? '']],
+                    folder: scriptsDirectory,
+                },
+                context: {},
+                logger: console,
+            });
+            const format = formatOptValue ?? defaultScriptFormat;
+            await migrator.create({
+                name: `${nameScript(type, env, name)}.${format}`,
+                allowExtension: `.${format}`,
+                prefix: 'TIMESTAMP',
+                // skipVerify lets us run this command without an active db connection,
+                // at least for pg, which is a bit safer. It will prevent umzug from
+                // checking that we haven't already run a migration with the same name,
+                // but that check isn't super useful (it only checks whatever db this
+                // script happens to be connected to when the migration is created) and
+                // this error should be prevented by the filesystem not allowing
+                // duplicate names anyway.
+                skipVerify: true,
+            });
+        },
+    })
+        .command({
+        command: ['apply-scripts [target] [name]', 'apply'],
+        describe: 'Runs one or more migration/seed scripts. By default, applies ' +
+            "all that haven't been applied to the db yet.",
+        builder: (yargs) => {
+            return yargs
+                .option('env', envOpt)
+                .option('db', dbOpt)
+                .demandOption('env')
+                .positional('target', {
+                choices: ['remaining', 'next', 'only', 'until'],
+                default: 'remaining',
+            })
+                .check(({ target, name, db, env }) => {
+                const needsSpecificScript = target === 'only' || target === 'until';
+                if (!needsSpecificScript && name) {
+                    throw new Error("Can't provide a general script/set of scripts to run (with " +
+                        '"next" or "remaining") and then also provide the name of a ' +
+                        'specific script.');
+                }
+                if (needsSpecificScript && !name) {
+                    throw new Error('Must provide a script name when you use "only"/"until" to ' +
+                        'apply (only or up to) a specific script.');
+                }
+                if (env &&
+                    !db.every((it) => dbs[it].supportedEnvironments.includes(env))) {
+                    throw new Error(`The db "${db}" doesn't support the "${env}" environment.`);
+                }
+                return true;
+            });
+        },
+        handler: async function ({ target, name, env, db: optDbs }) {
+            const migrationTasks = Object.entries(dbs)
+                .filter(([dbName, _]) => optDbs.includes(dbName))
+                .map(([_, db]) => async () => {
+                const { scriptsDirectory, supportedScriptFormats } = db;
+                const [context, storage] = await Promise.all([
+                    db.createContext(),
+                    db.createStorage(),
+                ]);
+                const migrator = new Umzug({
+                    migrations: async (context) => {
+                        const supportedExtensions = supportedScriptFormats.length > 1
+                            ? `{${supportedScriptFormats.join(',')}}`
+                            : `${supportedScriptFormats[0]}`;
+                        const matchingFilePaths = await globAsync(`${scriptsDirectory}/*.${supportedExtensions}`, { absolute: true });
+                        return matchingFilePaths
+                            .filter(shouldRun.bind(null, env, supportedScriptFormats))
+                            .map((unresolvedPath) => {
+                            const filepath = path.resolve(unresolvedPath);
+                            const name = path.basename(filepath);
+                            return {
+                                path: filepath,
+                                ...db.resolveScript({
+                                    name,
+                                    path: filepath,
+                                    context,
+                                }),
+                            };
+                        });
+                    },
+                    context,
+                    storage,
+                    logger: console,
+                });
+                try {
+                    switch (target) {
+                        case 'remaining':
+                            await migrator.up();
+                            break;
+                        case 'next':
+                            await migrator.up({ step: 1 });
+                            break;
+                        case 'only':
+                            await migrator.up({ migrations: [name] });
+                            break;
+                        case 'until':
+                            await migrator.up({ to: name });
+                    }
+                }
+                finally {
+                    // Await not return so that any errors from the try aren't swallowed.
+                    await db.destroyContext(context);
+                    if ('destroyStorage' in db) {
+                        await db.destroyStorage?.(storage);
+                    }
+                }
+            });
+            // Run in sequence so that the logs don't get interleaved (easier to follow).
+            return migrationTasks.reduce((res, task) => res.then(task), Promise.resolve());
+        },
+    })
+        .command({
+        command: 'clean',
+        describe: 'Deletes all the data in the databases specified in the ENV vars.',
+        builder: (yargs) => {
+            return yargs
+                .option('db', dbOpt)
+                .option('env', {
+                ...envOpt,
+                demand: 'Must provide an environment (even though it has no effect; the ' +
+                    'connection-related env vars determine which db(s) are cleaned) ' +
+                    'to help prevent accidentally deleting prod!',
+            })
+                .check((opts) => {
+                return opts.env !== 'prod';
+            });
+        },
+        handler: async ({ db: optDbs }) => {
+            await Promise.all(Object.entries(dbs)
+                .filter(([dbName, _]) => optDbs.includes(dbName))
+                .map(async ([_, db]) => {
+                const { dropDbAndDisconnect, prepareDbAndDisconnect } = db;
+                // If drop fails, assume the db didn't exist, for convenience,
+                // and just move on to attempting the create. If the error was
+                // something different, then the create will fail (because we don't
+                // do CREATE IF NOT EXISTS, which isn't even supported by postgres)
+                // so this should be fine.
+                await dropDbAndDisconnect().catch(() => { });
+                await prepareDbAndDisconnect();
+            }));
+        },
+    })
+        .command({
+        command: 'drop',
+        describe: 'Drops the databases specified in the ENV vars.',
+        builder: (yargs) => {
+            return yargs
+                .option('db', dbOpt)
+                .option('env', {
+                ...envOpt,
+                demand: 'Must provide an environment (even though it has no effect; the ' +
+                    'connection-related env vars determine which db(s) are cleaned) ' +
+                    'to help prevent accidentally deleting prod!',
+            })
+                .check((opts) => {
+                return opts.env !== 'prod';
+            });
+        },
+        handler: async ({ db: optDbs }) => {
+            await Promise.all(Object.entries(dbs)
+                .filter(([dbName, _]) => optDbs.includes(dbName))
+                .map(([_, db]) => db.dropDbAndDisconnect()));
+        },
+    })
+        .command({
+        command: 'create',
+        describe: 'Creates the databases specified in the ENV vars.',
+        builder: (yargs) => {
+            return yargs
+                .option('db', dbOpt)
+                .option('env', {
+                ...envOpt,
+                demand: 'Must provide an environment (even though it has no effect; the ' +
+                    'connection-related env vars determine which db(s) are cleaned) ' +
+                    'to help prevent accidentally deleting prod!',
+            })
+                .check((opts) => {
+                return opts.env !== 'prod';
+            });
+        },
+        handler: async ({ db: optDbs }) => {
+            await Promise.all(Object.entries(dbs)
+                .filter(([dbName, _]) => optDbs.includes(dbName))
+                .map(([_, db]) => db.prepareDbAndDisconnect()));
+        },
+    })
+        .command({
+        command: 'restore <target>',
+        describe: "Restores an environment's database to the last backup of prod.",
+        builder: (yargs) => {
+            return yargs
+                .positional('target', {
+                alias: 'to',
+                describe: 'The environment whose data will be replaced with the backup of prod.',
+                type: 'string',
+                choices: [...envOpt.choices, 'local'],
+                demand: 'Must provide a target environment to restore to.',
+            })
+                .demandOption('target')
+                .option('db', dbOpt)
+                .option('force', {
+                alias: 'f',
+                default: false,
+                type: 'string',
+            })
+                .check(({ target, force, db: dbNames }) => {
+                if (target === 'prod') {
+                    throw new Error('Cannot restore prod to itself');
+                }
+                if (!dbNames.every((it) => dbs[it].supportedEnvironments.includes(target))) {
+                    throw new Error(`Some db(s) in "${dbNames}" doesn't support the "${target}" environment.`);
+                }
+                if (!['staging', 'local'].includes(target) && !force) {
+                    throw new Error('We currently only imagine applying this command to `staging` or ' +
+                        `\`local\`. If you really want to reset ${target}'s data to` +
+                        'the latest data from prod, run the command again with --force.');
+                }
+                return true;
+            });
+        },
+        handler: async (_) => {
+            // TODO: need to implement for AWS.
+            throw new Error('not implemented');
+        },
+    })
+        .demandCommand(1, 'Must invoke a command (e.g., "clean" or "migrate")')
+        .parse();
+}

package/build/cli/script-generator.d.ts

@@ -0,0 +1,20 @@
+export declare const scriptTypes: readonly ["seed", "migration"];
+type ScriptType = (typeof scriptTypes)[number];
+/**
+ * Generates the name of a script file, excluding the file extension and the
+ * ordering-related prefixes added by umzug. This function enforces a convention
+ * that allows us to identify whether a script is a seed and, if so, which
+ * environment it should run in.
+ *
+ * @param type - Whether this is a migration or seed
+ * @param env - If a seed, which environment the seed applies to.
+ * @param userNamePortion - The portion of the name provided by the user to
+ *   actually describe what the script does.
+ */
+export declare function nameScript(type: ScriptType, env: string | undefined, userNamePortion: string): string;
+/**
+ * Returns whether the given script, based on its name as generated by
+ * {@see nameScript}, should run in the given environment.
+ */
+export declare function shouldRun(env: string, legalScriptFormats: readonly string[], scriptName: string): boolean;
+export {};

package/build/cli/script-generator.js

@@ -0,0 +1,25 @@
+export const scriptTypes = ['seed', 'migration'];
+/**
+ * Generates the name of a script file, excluding the file extension and the
+ * ordering-related prefixes added by umzug. This function enforces a convention
+ * that allows us to identify whether a script is a seed and, if so, which
+ * environment it should run in.
+ *
+ * @param type - Whether this is a migration or seed
+ * @param env - If a seed, which environment the seed applies to.
+ * @param userNamePortion - The portion of the name provided by the user to
+ *   actually describe what the script does.
+ */
+export function nameScript(type, env, userNamePortion) {
+    return `${userNamePortion}${type === 'seed' ? `.seed.${env}` : ''}`;
+}
+/**
+ * Returns whether the given script, based on its name as generated by
+ * {@see nameScript}, should run in the given environment.
+ */
+export function shouldRun(env, legalScriptFormats, scriptName) {
+    const anyEnvSeedFileRegex = new RegExp(`\\.seed\\.[^\\.]+\\.(${legalScriptFormats.join('|')})$`);
+    const thisEnvSeedFileRegex = new RegExp(`\\.seed\\.${env}\\.(${legalScriptFormats.join('|')})$`);
+    const isSeed = anyEnvSeedFileRegex.test(scriptName);
+    return !isSeed || thisEnvSeedFileRegex.test(scriptName);
+}

package/build/cli/typescript-types.d.ts

@@ -0,0 +1,86 @@
+import { type MigrationParams, type RunnableMigration, type UmzugStorage } from 'umzug';
+export type Bind1<F extends (arg0: A0, ...args: never[]) => unknown, A0> = F extends (arg0: A0, ...args: infer Args) => infer R ? (...args: Args) => R : never;
+/**
+ * Every database for which we want to support migrations must provide a config
+ * object for itself that satisfies this type.
+ *
+ * NB: file extensions in the options below should be given with no leading dot.
+ *
+ * NB: "scripts" refers collectively to migrations or seed files.
+ */
+export type DatabaseConfig<SupportedScriptFormat extends string = string, ContextType = unknown, StorageType extends UmzugStorage = UmzugStorage> = {
+    /**
+     * The file type (i.e., extension) to use for a new script when a file type
+     * isn't specified explicitly.
+     */
+    readonly defaultScriptFormat: SupportedScriptFormat;
+    /**
+     * A list of supported file extensions for this db's scripts (no leading dot).
+     */
+    readonly supportedScriptFormats: readonly SupportedScriptFormat[];
+    /**
+     * The directory in which the migrator will look for this db's scripts and
+     * into which it'll create new scripts.
+     */
+    readonly scriptsDirectory: string;
+    /**
+     * Which environments does this db support?
+     */
+    readonly supportedEnvironments: readonly string[];
+    /**
+     * A reference to the database client/connection that is passed to the Umzug
+     * storage object. Used in the case of a custom UmzugStorage implementation
+     * to ensure we close all connections to the database.
+     */
+    storageDbClient?: unknown;
+    /**
+     * Creates this db to with an initial state and then closes any open
+     * connections/resources.
+     */
+    prepareDbAndDisconnect(): Promise<void>;
+    /**
+     * Deletes this db and then closes any open connections/resources.
+     */
+    dropDbAndDisconnect(): Promise<void>;
+    /**
+     * Returns an object capable of recording that a script has been run, listing
+     * the scripts that have run, and removing the record of a script (if it's
+     * rolled back).
+     */
+    createStorage(): UmzugStorage<ContextType>;
+    /**
+     * Takes the name and path of a script and turns it into a runnable object
+     * that has an `up` and (optionally) `down` method. `up` and `down` will be
+     * called with the context object (see below) and should actually update the
+     * database.
+     */
+    resolveScript(params: MigrationParams<ContextType> & {
+        path: string;
+    }): RunnableMigration<ContextType>;
+    /**
+     * Returns a "context" object, which is simply an object that'll be passed to
+     * all scripts. Often this context object is an instance of the db driver
+     * connected to the database.
+     */
+    createContext(): ContextType | Promise<ContextType>;
+    /**
+     * A function that destroys the context object and cleans up associated
+     * resources. This is called after all the migrations have been run with the
+     * context. If the context has an open db connection, that connection should
+     * be closed so the process can exit.
+     */
+    destroyContext(context: ContextType): Promise<void>;
+    /**
+     * A function that destroys the storage object and cleans up associated
+     * resources. This is called after all the migrations have been run with the
+     * storage. If the storage has an open db connection, that connection should
+     * be closed so the process can exit.
+     */
+    destroyStorage?(context: StorageType): Promise<void>;
+    /**
+     * Given the path of the new script file that is being created, returns a
+     * string that will be that file's initial contents. This template can include
+     * helper/boilerplate code, like common imports.
+     */
+    getTemplate?(filePath: string): string;
+};

package/build/cli/typescript-types.js

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

package/build/cli/utils.d.ts

@@ -0,0 +1,12 @@
+import { type ModelOptions, type Sequelize } from 'sequelize';
+import { RunnableMigration, SequelizeStorage } from 'umzug';
+export declare function makeSequelizeUmzugStorage(sequelize: Sequelize, opts: ModelOptions): SequelizeStorage;
+export declare function wrapMigration<T>(hooks: {
+    runBefore?: () => void | Promise<void>;
+    runAfter?: () => void | Promise<void>;
+}, migration: RunnableMigration<T>): {
+    down?: import("umzug").MigrationFn<T>;
+    up(params: import("umzug").MigrationParams<T>): Promise<void>;
+    name: string;
+    path?: string;
+};

package/build/cli/utils.js

@@ -0,0 +1,35 @@
+import { DataTypes } from 'sequelize';
+import { SequelizeStorage } from 'umzug';
+export function makeSequelizeUmzugStorage(sequelize, opts) {
+    return new SequelizeStorage({
+        sequelize,
+        model: sequelize.define('SequelizeMeta', {
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                unique: true,
+                primaryKey: true,
+                autoIncrement: false,
+            },
+        }, { timestamps: true, ...opts }),
+    });
+}
+export function wrapMigration(hooks, migration) {
+    return {
+        ...migration,
+        async up(params) {
+            await hooks.runBefore?.();
+            await migration.up(params);
+            await hooks.runAfter?.();
+        },
+        ...(migration.down
+            ? {
+                async down(params) {
+                    await hooks.runBefore?.();
+                    await migration.down(params);
+                    await hooks.runAfter?.();
+                },
+            }
+            : {}),
+    };
+}

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ScyllaStorage } from './storage/scyllaStorage.js';
+export { type DatabaseConfig } from './cli/typescript-types.js';
+export { makeCli } from './cli/index.js';
+export { makeSequelizeUmzugStorage, wrapMigration } from './cli/utils.js';
+export declare const SCRIPT_TEMPLATES_DIR_ABSOLUTE_PATH: string;

package/build/index.js

@@ -0,0 +1,5 @@
+import { fileURLToPath } from 'url';
+export { default as ScyllaStorage } from './storage/scyllaStorage.js';
+export { makeCli } from './cli/index.js';
+export { makeSequelizeUmzugStorage, wrapMigration } from './cli/utils.js';
+export const SCRIPT_TEMPLATES_DIR_ABSOLUTE_PATH = fileURLToPath(new URL('./script-templates', import.meta.url));

package/build/script-templates/scylla.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+// NB: The Datastax Cassandra/Scylla Driver only supports 1 SQL statement
+// per API call. So Scylla migrations should use sequential, raw `query` calls.
+
+/**
+ * @param {{ context: import("cassandra-driver").Client }} context
+ */
+exports.up = async function ({ context }) {
+  const query = context.execute.bind(context);
+};
+
+/**
+ * @param {{ context: import("cassandra-driver").Client }} context
+ */
+exports.down = async function ({ context }) {
+  const query = context.execute.bind(context);
+};

package/build/script-templates/sequelize-snowflake.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+// NB: Snowflake migrations should use raw queries, in case Sequelize doesn't
+// translate the query correctly. Also, Snowflake only supports 1 SQL statement
+// per API call. So Snowflake migrations should use sequential, raw `query` calls.
+
+/**
+ * @param {{ context: import("sequelize").QueryInterface }} context
+ */
+exports.up = async function ({ context }) {
+  const query = context.sequelize.query.bind(context.sequelize);
+};
+
+/**
+ * @param {{ context: import("sequelize").QueryInterface }} context
+ */
+exports.down = async function ({ context }) {
+  const query = context.sequelize.query.bind(context.sequelize);
+};

package/build/script-templates/sequelize.cjs

@@ -0,0 +1,12 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+
+/**
+ * @param {{ context: import("sequelize").QueryInterface }} context
+ */
+exports.up = async function ({ context: queryInterface }) {};
+
+/**
+ * @param {{ context: import("sequelize").QueryInterface }} context
+ */
+exports.down = async function ({ context: queryInterface }) {};

package/build/storage/scyllaStorage.d.ts

@@ -0,0 +1,26 @@
+import { type DseClientOptions } from 'cassandra-driver';
+/**
+ * Returns an object that can store migration state in Scylla, in a table called
+ * `migrations_metadata`. If the table does not exist it will be created
+ * automatically upon the logging of the first migration.
+ */
+export default class ScyllaStorage {
+    private scyllaClient;
+    private columnName;
+    private tableName;
+    private metadataExists;
+    constructor(options: {
+        driverOptions: DseClientOptions;
+        columnName?: string;
+        tableName?: string;
+    });
+    private createTable;
+    logMigration({ name: migrationName }: {
+        name: string;
+    }): Promise<void>;
+    unlogMigration({ name: migrationName }: {
+        name: string;
+    }): Promise<void>;
+    executed(): Promise<string[]>;
+    shutdown(): Promise<void>;
+}

package/build/storage/scyllaStorage.js

@@ -0,0 +1,62 @@
+import { Client as ScyllaClient, } from 'cassandra-driver';
+/**
+ * Returns an object that can store migration state in Scylla, in a table called
+ * `migrations_metadata`. If the table does not exist it will be created
+ * automatically upon the logging of the first migration.
+ */
+export default class ScyllaStorage {
+    constructor(options) {
+        this.scyllaClient = new ScyllaClient(options.driverOptions);
+        this.columnName = options.columnName ?? 'name';
+        this.tableName = options.tableName ?? 'migrations_metadata';
+        this.metadataExists = false;
+    }
+    async createTable() {
+        await this.scyllaClient.execute(`CREATE TABLE IF NOT EXISTS "${this.tableName}"(
+        migration_static_key int,
+        ${this.columnName} text,
+        createdAt timestamp,
+       PRIMARY KEY (migration_static_key, createdAt))`);
+        this.metadataExists = true;
+    }
+    async logMigration({ name: migrationName }) {
+        if (!this.metadataExists) {
+            await this.createTable();
+        }
+        await this.scyllaClient.execute(`INSERT INTO "${this.tableName}"(
+        migration_static_key,
+        ${this.columnName},
+        createdAt
+      ) VALUES ( ?, ?, ? )`, [1, migrationName, Date.now()], { prepare: true });
+    }
+    async unlogMigration({ name: migrationName }) {
+        await this.scyllaClient.execute(`DELETE FROM ?
+      WHERE migration_static_key = 1
+      AND "${this.columnName}" = ?`, [migrationName], { prepare: true });
+    }
+    async executed() {
+        try {
+            const migrations = await this.scyllaClient.execute(`SELECT * FROM ${this.tableName} ALLOW FILTERING`);
+            const x = migrations.rows.map((migration) => {
+                const name = migration[this.columnName];
+                if (typeof name !== 'string') {
+                    throw new TypeError(`Unexpected migration name type: expected string, got ${typeof name}`);
+                }
+                return name;
+            });
+            return x;
+        }
+        catch (e) {
+            // 8704 is the CQL error code for 'unconfigured table' and will be returned in the
+            // Error object when the metadata table has not been set up, e.g. on the first
+            // migration run
+            if (e.code === 8704) {
+                return [];
+            }
+            throw e;
+        }
+    }
+    async shutdown() {
+        return this.scyllaClient.shutdown();
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@roostorg/db-migrator",
+  "version": "1.0.6",
+  "description": "Migrating (and eventually seeding) our dbs on deploy",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "rm -rf ./build && npm run build && cp -r script-templates build/script-templates"
+  },
+  "exports": {
+    ".": "./build/index.js",
+    "./cli": "./build/cli/cli.js"
+  },
+  "files": [
+    "build"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/yargs": "^17.0.24",
+    "@types/glob": "^7.2.0",
+    "@types/umzug": "^2.3.3",
+    "aws-sdk": "^2.1691.0",
+    "cassandra-driver": "^4.6.4",
+    "glob": "^7.2.0",
+    "sequelize": "^6.32.1",
+    "umzug": "^3.0.0",
+    "yargs": "^16.2.0",
+    "@total-typescript/ts-reset": "^0.5.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.2.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}