rake-db 1.3.2 → 2.0.0

package/src/commands/createOrDrop.test.ts

@@ -0,0 +1,145 @@
+import { createDb, dropDb } from './createOrDrop';
+import { Adapter } from 'pqb';
+import {
+  createSchemaMigrations,
+  migrationConfigDefaults,
+  setAdminCredentialsToOptions,
+} from '../common';
+
+jest.mock('../common', () => ({
+  ...jest.requireActual('../common'),
+  setAdminCredentialsToOptions: jest.fn((options: Record<string, unknown>) => ({
+    ...options,
+    user: 'admin-user',
+    password: 'admin-password',
+  })),
+  createSchemaMigrations: jest.fn(),
+}));
+
+const options = { database: 'dbname', user: 'user', password: 'password' };
+const queryMock = jest.fn();
+Adapter.prototype.query = queryMock;
+
+const logMock = jest.fn();
+console.log = logMock;
+
+describe('createOrDrop', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('createDb', () => {
+    it('should create database when user is an admin', async () => {
+      queryMock.mockResolvedValueOnce(undefined);
+
+      await createDb(options, migrationConfigDefaults);
+
+      expect(queryMock.mock.calls).toEqual([
+        [`CREATE DATABASE "dbname" OWNER "user"`],
+      ]);
+      expect(logMock.mock.calls).toEqual([
+        [`Database dbname successfully created`],
+      ]);
+      expect(createSchemaMigrations).toHaveBeenCalled();
+    });
+
+    it('should create databases for each provided option', async () => {
+      queryMock.mockResolvedValue(undefined);
+
+      await createDb(
+        [options, { ...options, database: 'dbname-test' }],
+        migrationConfigDefaults,
+      );
+
+      expect(queryMock.mock.calls).toEqual([
+        [`CREATE DATABASE "dbname" OWNER "user"`],
+        [`CREATE DATABASE "dbname-test" OWNER "user"`],
+      ]);
+      expect(logMock.mock.calls).toEqual([
+        [`Database dbname successfully created`],
+        [`Database dbname-test successfully created`],
+      ]);
+      expect(createSchemaMigrations).toHaveBeenCalledTimes(2);
+    });
+
+    it('should inform if database already exists', async () => {
+      queryMock.mockRejectedValueOnce({ code: '42P04' });
+
+      await createDb(options, migrationConfigDefaults);
+
+      expect(queryMock.mock.calls).toEqual([
+        [`CREATE DATABASE "dbname" OWNER "user"`],
+      ]);
+      expect(logMock.mock.calls).toEqual([[`Database dbname already exists`]]);
+      expect(createSchemaMigrations).toHaveBeenCalled();
+    });
+
+    it('should ask and use admin credentials when cannot connect', async () => {
+      queryMock.mockRejectedValueOnce({ code: '42501' });
+
+      await createDb(options, migrationConfigDefaults);
+
+      expect(setAdminCredentialsToOptions).toHaveBeenCalled();
+      expect(queryMock.mock.calls).toEqual([
+        [`CREATE DATABASE "dbname" OWNER "user"`],
+        [`CREATE DATABASE "dbname" OWNER "user"`],
+      ]);
+      expect(logMock.mock.calls).toEqual([
+        [`Database dbname successfully created`],
+      ]);
+      expect(createSchemaMigrations).toHaveBeenCalled();
+    });
+  });
+
+  describe('dropDb', () => {
+    it('should drop database when user is an admin', async () => {
+      queryMock.mockResolvedValueOnce(undefined);
+
+      await dropDb(options);
+
+      expect(queryMock.mock.calls).toEqual([[`DROP DATABASE "dbname"`]]);
+      expect(logMock.mock.calls).toEqual([
+        [`Database dbname was successfully dropped`],
+      ]);
+    });
+
+    it('should drop databases for each provided option', async () => {
+      queryMock.mockResolvedValue(undefined);
+
+      await dropDb([options, { ...options, database: 'dbname-test' }]);
+
+      expect(queryMock.mock.calls).toEqual([
+        [`DROP DATABASE "dbname"`],
+        [`DROP DATABASE "dbname-test"`],
+      ]);
+      expect(logMock.mock.calls).toEqual([
+        [`Database dbname was successfully dropped`],
+        [`Database dbname-test was successfully dropped`],
+      ]);
+    });
+
+    it('should inform if database does not exist', async () => {
+      queryMock.mockRejectedValueOnce({ code: '3D000' });
+
+      await dropDb(options);
+
+      expect(queryMock.mock.calls).toEqual([[`DROP DATABASE "dbname"`]]);
+      expect(logMock.mock.calls).toEqual([[`Database dbname does not exist`]]);
+    });
+
+    it('should ask and use admin credentials when cannot connect', async () => {
+      queryMock.mockRejectedValueOnce({ code: '42501' });
+
+      await dropDb(options);
+
+      expect(setAdminCredentialsToOptions).toHaveBeenCalled();
+      expect(queryMock.mock.calls).toEqual([
+        [`DROP DATABASE "dbname"`],
+        [`DROP DATABASE "dbname"`],
+      ]);
+      expect(logMock.mock.calls).toEqual([
+        [`Database dbname was successfully dropped`],
+      ]);
+    });
+  });
+});

package/src/commands/createOrDrop.ts

@@ -0,0 +1,107 @@
+import { Adapter, AdapterOptions, MaybeArray, toArray } from 'pqb';
+import {
+  getDatabaseAndUserFromOptions,
+  setAdminCredentialsToOptions,
+  setAdapterOptions,
+  createSchemaMigrations,
+  MigrationConfig,
+  migrationConfigDefaults,
+} from '../common';
+
+const execute = async (
+  options: AdapterOptions,
+  sql: string,
+): Promise<'ok' | 'already' | 'forbidden' | { error: unknown }> => {
+  const db = new Adapter(options);
+  try {
+    await db.query(sql);
+    return 'ok';
+  } catch (error) {
+    const err = error as Record<string, unknown>;
+    if (err.code === '42P04' || err.code === '3D000') {
+      return 'already';
+    } else if (err.code === '42501') {
+      return 'forbidden';
+    } else {
+      return { error };
+    }
+  } finally {
+    await db.destroy();
+  }
+};
+
+const createOrDrop = async (
+  options: AdapterOptions,
+  adminOptions: AdapterOptions,
+  config: MigrationConfig,
+  args: {
+    sql(params: { database: string; user: string }): string;
+    successMessage(params: { database: string }): string;
+    alreadyMessage(params: { database: string }): string;
+    createVersionsTable?: boolean;
+  },
+) => {
+  const params = getDatabaseAndUserFromOptions(options);
+
+  const result = await execute(
+    setAdapterOptions(adminOptions, { database: 'postgres' }),
+    args.sql(params),
+  );
+  if (result === 'ok') {
+    console.log(args.successMessage(params));
+  } else if (result === 'already') {
+    console.log(args.alreadyMessage(params));
+  } else if (result === 'forbidden') {
+    await createOrDrop(
+      options,
+      await setAdminCredentialsToOptions(options),
+      config,
+      args,
+    );
+    return;
+  } else {
+    throw result.error;
+  }
+
+  if (!args.createVersionsTable) return;
+
+  const db = new Adapter(options);
+  await createSchemaMigrations(db, config);
+  await db.destroy();
+};
+
+export const createDb = async (
+  arg: MaybeArray<AdapterOptions>,
+  config: MigrationConfig,
+) => {
+  for (const options of toArray(arg)) {
+    await createOrDrop(options, options, config, {
+      sql({ database, user }) {
+        return `CREATE DATABASE "${database}" OWNER "${user}"`;
+      },
+      successMessage({ database }) {
+        return `Database ${database} successfully created`;
+      },
+      alreadyMessage({ database }) {
+        return `Database ${database} already exists`;
+      },
+      createVersionsTable: true,
+    });
+  }
+};
+
+export const dropDb = async (arg: MaybeArray<AdapterOptions>) => {
+  for (const options of toArray(arg)) {
+    await createOrDrop(options, options, migrationConfigDefaults, {
+      sql({ database }) {
+        return `DROP DATABASE "${database}"`;
+      },
+      successMessage({ database }) {
+        return `Database ${database} was successfully dropped`;
+      },
+      alreadyMessage({ database }) {
+        return `Database ${database} does not exist`;
+      },
+    });
+  }
+};

package/src/commands/generate.test.ts

@@ -0,0 +1,133 @@
+import { generate } from './generate';
+import { migrationConfigDefaults } from '../common';
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+
+jest.mock('fs/promises', () => ({
+  mkdir: jest.fn(),
+  writeFile: jest.fn(),
+}));
+
+const logMock = jest.fn();
+console.log = logMock;
+
+const migrationsPath = migrationConfigDefaults.migrationsPath;
+
+const testGenerate = async (args: string[], content: string) => {
+  const name = args[0];
+  await generate(migrationConfigDefaults, args);
+
+  expect(mkdir).toHaveBeenCalledWith(migrationsPath, { recursive: true });
+
+  const filePath = path.resolve(migrationsPath, `20000101000000_${name}.ts`);
+  expect(writeFile).toHaveBeenCalledWith(filePath, content);
+
+  expect(logMock.mock.calls).toEqual([[`Created ${filePath}`]]);
+};
+
+describe('generate', () => {
+  beforeEach(() => {
+    jest.useFakeTimers().setSystemTime(new Date(2000, 0, 1, 0, 0, 0));
+    jest.clearAllMocks();
+  });
+
+  it('should throw if migration name is not provided', async () => {
+    expect(generate(migrationConfigDefaults, [])).rejects.toThrow(
+      'Migration name is missing',
+    );
+  });
+
+  it('should create a file for create table migration', async () => {
+    await testGenerate(
+      ['createTable', 'id:integer.primaryKey', 'name:varchar(20).nullable'],
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  db.createTable('table', (t) => ({
+    id: t.integer().primaryKey(),
+    name: t.varchar(20).nullable(),
+  }));
+});
+`,
+    );
+  });
+
+  it('should create a file for change migration', async () => {
+    await testGenerate(
+      ['changeTable'],
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  db.changeTable('table', (t) => ({
+  }));
+});
+`,
+    );
+  });
+
+  it('should create a file for add columns migration', async () => {
+    await testGenerate(
+      ['addColumns'],
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  db.changeTable(tableName, (t) => ({
+  }));
+});
+`,
+    );
+  });
+
+  it('should create a file for add columns migration with table', async () => {
+    await testGenerate(
+      [
+        'addColumnsToTable',
+        'id:integer.primaryKey',
+        'name:varchar(20).nullable',
+      ],
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  db.changeTable('table', (t) => ({
+    id: t.add(t.integer().primaryKey()),
+    name: t.add(t.varchar(20).nullable()),
+  }));
+});
+`,
+    );
+  });
+
+  it('should create a file for remove columns migration with table', async () => {
+    await testGenerate(
+      [
+        'removeColumnsFromTable',
+        'id:integer.primaryKey',
+        'name:varchar(20).nullable',
+      ],
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  db.changeTable('table', (t) => ({
+    id: t.remove(t.integer().primaryKey()),
+    name: t.remove(t.varchar(20).nullable()),
+  }));
+});
+`,
+    );
+  });
+
+  it('should create a file for drop table migration', async () => {
+    await testGenerate(
+      ['dropTable', 'id:integer.primaryKey', 'name:varchar(20).nullable'],
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  db.dropTable('table', (t) => ({
+    id: t.integer().primaryKey(),
+    name: t.varchar(20).nullable(),
+  }));
+});
+`,
+    );
+  });
+});

package/src/commands/generate.ts

@@ -0,0 +1,85 @@
+import {
+  getFirstWordAndRest,
+  getTextAfterFrom,
+  getTextAfterTo,
+  MigrationConfig,
+} from '../common';
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+
+export const generate = async (config: MigrationConfig, args: string[]) => {
+  const name = args[0];
+  if (!name) throw new Error('Migration name is missing');
+
+  await mkdir(config.migrationsPath, { recursive: true });
+
+  const filePath = path.resolve(
+    config.migrationsPath,
+    `${makeFileTimeStamp()}_${name}.ts`,
+  );
+  await writeFile(filePath, makeContent(name, args.slice(1)));
+  console.log(`Created ${filePath}`);
+};
+
+const makeFileTimeStamp = () => {
+  const now = new Date();
+  return [
+    now.getUTCFullYear(),
+    now.getUTCMonth() + 1,
+    now.getUTCDate(),
+    now.getUTCHours(),
+    now.getUTCMinutes(),
+    now.getUTCSeconds(),
+  ]
+    .map((value) => (value < 10 ? `0${value}` : value))
+    .join('');
+};
+
+const makeContent = (name: string, args: string[]): string => {
+  let content = `import { change } from 'rake-db';\n\nchange(async (db) => {`;
+
+  const [first, rest] = getFirstWordAndRest(name);
+  if (rest) {
+    if (first === 'create' || first === 'drop') {
+      content += `\n  db.${
+        first === 'create' ? 'createTable' : 'dropTable'
+      }('${rest}', (t) => ({`;
+      content += makeColumnsContent(args);
+      content += '\n  }));';
+    } else if (first === 'change') {
+      content += `\n  db.changeTable('${rest}', (t) => ({`;
+      content += '\n  }));';
+    } else if (first === 'add' || first === 'remove') {
+      const table =
+        first === 'add' ? getTextAfterTo(rest) : getTextAfterFrom(rest);
+      content += `\n  db.changeTable(${
+        table ? `'${table}'` : 'tableName'
+      }, (t) => ({`;
+      content += makeColumnsContent(args, first);
+      content += '\n  }));';
+    }
+  }
+
+  return content + '\n});\n';
+};
+
+const makeColumnsContent = (args: string[], method?: string) => {
+  let content = '';
+  const prepend = method ? `t.${method}(` : '';
+  const append = method ? ')' : '';
+
+  for (const arg of args) {
+    const [name, def] = arg.split(':');
+    if (!def) {
+      throw new Error(
+        `Column argument should be similar to name:type, name:type.method1.method2, name:type(arg).method(arg). Example: name:varchar(20).nullable. Received: ${arg}`,
+      );
+    }
+
+    const methods = def
+      .split('.')
+      .map((method) => (method.endsWith(')') ? `.${method}` : `.${method}()`));
+    content += `\n    ${name}: ${prepend}t${methods.join('')}${append},`;
+  }
+  return content;
+};

package/src/commands/migrateOrRollback.test.ts

@@ -0,0 +1,118 @@
+import { migrate, rollback } from './migrateOrRollback';
+import { createSchemaMigrations, migrationConfigDefaults } from '../common';
+import { getMigrationFiles } from '../common';
+import { Adapter, TransactionAdapter } from 'pqb';
+import { Migration } from '../migration/migration';
+
+jest.mock('../common', () => ({
+  ...jest.requireActual('../common'),
+  getMigrationFiles: jest.fn(),
+  createSchemaMigrations: jest.fn(),
+}));
+
+const options = { connectionString: 'postgres://user@localhost/dbname' };
+
+const files = [
+  { path: 'file1', version: '1' },
+  { path: 'file2', version: '2' },
+  { path: 'file3', version: '3' },
+];
+
+const getMigratedVersionsArrayMock = jest.fn();
+Adapter.prototype.arrays = getMigratedVersionsArrayMock;
+
+const queryMock = jest.fn();
+Adapter.prototype.query = queryMock;
+
+Adapter.prototype.transaction = (cb) => {
+  return cb({} as unknown as TransactionAdapter);
+};
+
+const transactionQueryMock = jest.fn();
+Migration.prototype.query = transactionQueryMock;
+
+const requireTsMock = jest.fn();
+const config = {
+  ...migrationConfigDefaults,
+  requireTs: requireTsMock,
+};
+
+describe('migrateOrRollback', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('migrate', () => {
+    it('should work properly', async () => {
+      (getMigrationFiles as jest.Mock).mockReturnValueOnce(files);
+      getMigratedVersionsArrayMock.mockResolvedValueOnce({ rows: [['1']] });
+      queryMock.mockReturnValueOnce(undefined);
+      requireTsMock.mockResolvedValue(undefined);
+
+      await migrate(options, config);
+
+      expect(getMigrationFiles).toBeCalledWith(config, true);
+
+      expect(requireTsMock).toBeCalledWith('file2');
+      expect(requireTsMock).toBeCalledWith('file3');
+
+      expect(transactionQueryMock).toBeCalledWith(
+        `INSERT INTO "schemaMigrations" VALUES ('2')`,
+      );
+      expect(transactionQueryMock).toBeCalledWith(
+        `INSERT INTO "schemaMigrations" VALUES ('3')`,
+      );
+    });
+
+    it('should create migrations table if it not exist', async () => {
+      (getMigrationFiles as jest.Mock).mockReturnValueOnce([]);
+      getMigratedVersionsArrayMock.mockRejectedValueOnce({ code: '42P01' });
+      (createSchemaMigrations as jest.Mock).mockResolvedValueOnce(undefined);
+
+      await migrate(options, config);
+
+      expect(getMigrationFiles).toBeCalledWith(config, true);
+      expect(createSchemaMigrations).toBeCalled();
+      expect(requireTsMock).not.toBeCalled();
+      expect(transactionQueryMock).not.toBeCalled();
+    });
+  });
+
+  describe('rollback', () => {
+    it('should work properly', async () => {
+      (getMigrationFiles as jest.Mock).mockReturnValueOnce(files.reverse());
+      getMigratedVersionsArrayMock.mockResolvedValueOnce({
+        rows: [['1'], ['2']],
+      });
+      queryMock.mockReturnValueOnce(undefined);
+      requireTsMock.mockResolvedValue(undefined);
+
+      await rollback(options, config);
+
+      expect(getMigrationFiles).toBeCalledWith(config, false);
+
+      expect(requireTsMock).toBeCalledWith('file2');
+      expect(requireTsMock).toBeCalledWith('file1');
+
+      expect(transactionQueryMock).toBeCalledWith(
+        `DELETE FROM "schemaMigrations" WHERE version = '2'`,
+      );
+      expect(transactionQueryMock).toBeCalledWith(
+        `DELETE FROM "schemaMigrations" WHERE version = '1'`,
+      );
+    });
+
+    it('should create migrations table if it not exist', async () => {
+      (getMigrationFiles as jest.Mock).mockReturnValueOnce([]);
+      getMigratedVersionsArrayMock.mockRejectedValueOnce({ code: '42P01' });
+      (createSchemaMigrations as jest.Mock).mockResolvedValueOnce(undefined);
+
+      await rollback(options, config);
+
+      expect(getMigrationFiles).toBeCalledWith(config, false);
+      expect(createSchemaMigrations).toBeCalled();
+      expect(requireTsMock).not.toBeCalled();
+      expect(transactionQueryMock).not.toBeCalled();
+    });
+  });
+});

package/src/commands/migrateOrRollback.ts

@@ -0,0 +1,108 @@
+import { Adapter, AdapterOptions, MaybeArray, toArray } from 'pqb';
+import {
+  createSchemaMigrations,
+  getMigrationFiles,
+  MigrationConfig,
+  MigrationFile,
+} from '../common';
+import {
+  getCurrentPromise,
+  setCurrentMigrationUp,
+  setCurrentMigration,
+} from '../migration/change';
+import { Migration } from '../migration/migration';
+
+const migrateOrRollback = async (
+  options: MaybeArray<AdapterOptions>,
+  config: MigrationConfig,
+  up: boolean,
+) => {
+  const files = await getMigrationFiles(config, up);
+
+  for (const opts of toArray(options)) {
+    const db = new Adapter(opts);
+    const migratedVersions = await getMigratedVersionsMap(db, config);
+    try {
+      for (const file of files) {
+        if (
+          (up && migratedVersions[file.version]) ||
+          (!up && !migratedVersions[file.version])
+        ) {
+          continue;
+        }
+
+        await processMigration(db, up, file, config);
+      }
+    } finally {
+      await db.destroy();
+    }
+  }
+};
+
+const processMigration = async (
+  db: Adapter,
+  up: boolean,
+  file: MigrationFile,
+  config: MigrationConfig,
+) => {
+  await db.transaction(async (tx) => {
+    const db = new Migration(tx, up);
+    setCurrentMigration(db);
+    setCurrentMigrationUp(up);
+    config.requireTs(file.path);
+    await getCurrentPromise();
+    await (up ? saveMigratedVersion : removeMigratedVersion)(
+      db,
+      file.version,
+      config,
+    );
+  });
+};
+
+const saveMigratedVersion = async (
+  db: Adapter,
+  version: string,
+  config: MigrationConfig,
+) => {
+  await db.query(
+    `INSERT INTO "${config.migrationsTable}" VALUES ('${version}')`,
+  );
+};
+
+const removeMigratedVersion = async (
+  db: Adapter,
+  version: string,
+  config: MigrationConfig,
+) => {
+  await db.query(
+    `DELETE FROM "${config.migrationsTable}" WHERE version = '${version}'`,
+  );
+};
+
+const getMigratedVersionsMap = async (
+  db: Adapter,
+  config: MigrationConfig,
+): Promise<Record<string, boolean>> => {
+  try {
+    const result = await db.arrays<[string]>(
+      `SELECT * FROM "${config.migrationsTable}"`,
+    );
+    return Object.fromEntries(result.rows.map((row) => [row[0], true]));
+  } catch (err) {
+    if ((err as Record<string, unknown>).code === '42P01') {
+      await createSchemaMigrations(db, config);
+      return {};
+    }
+    throw err;
+  }
+};
+
+export const migrate = (
+  options: MaybeArray<AdapterOptions>,
+  config: MigrationConfig,
+) => migrateOrRollback(options, config, true);
+
+export const rollback = (
+  options: MaybeArray<AdapterOptions>,
+  config: MigrationConfig,
+) => migrateOrRollback(options, config, false);