rake-db 2.3.29 → 2.3.31

package/src/ast.ts

@@ -1,130 +0,0 @@
-import {
-  ColumnsShape,
-  ColumnType,
-  ForeignKeyOptions,
-  NoPrimaryKeyOption,
-  RawExpression,
-  SingleColumnIndexOptions,
-  TableData,
-} from 'pqb';
-import { DropMode } from './migration/migration';
-
-export type RakeDbAst =
-  | RakeDbAst.Table
-  | RakeDbAst.ChangeTable
-  | RakeDbAst.RenameTable
-  | RakeDbAst.Schema
-  | RakeDbAst.Extension
-  | RakeDbAst.Enum
-  | RakeDbAst.ForeignKey;
-
-export namespace RakeDbAst {
-  export type Table = {
-    type: 'table';
-    action: 'create' | 'drop';
-    schema?: string;
-    name: string;
-    shape: ColumnsShape;
-    noPrimaryKey: NoPrimaryKeyOption;
-    dropMode?: DropMode;
-    comment?: string;
-  } & TableData;
-
-  export type ChangeTable = {
-    type: 'changeTable';
-    schema?: string;
-    name: string;
-    comment?: string | null;
-    shape: Record<string, ChangeTableItem>;
-    add: TableData;
-    drop: TableData;
-  };
-
-  export type ChangeTableItem =
-    | ChangeTableItem.Column
-    | ChangeTableItem.Change
-    | ChangeTableItem.Rename;
-
-  export namespace ChangeTableItem {
-    export type Column = {
-      type: 'add' | 'drop';
-      item: ColumnType;
-      dropMode?: DropMode;
-    };
-
-    export type Change = {
-      type: 'change';
-      from: ColumnChange;
-      to: ColumnChange;
-      using?: RawExpression;
-    };
-
-    export type Rename = {
-      type: 'rename';
-      name: string;
-    };
-  }
-
-  export type ColumnChange = {
-    column?: ColumnType;
-    type?: string;
-    collate?: string;
-    default?: unknown | RawExpression;
-    nullable?: boolean;
-    comment?: string | null;
-    compression?: string;
-    primaryKey?: boolean;
-    foreignKeys?: ({
-      table: string;
-      columns: string[];
-    } & ForeignKeyOptions)[];
-    indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
-  };
-
-  export type RenameTable = {
-    type: 'renameTable';
-    fromSchema?: string;
-    from: string;
-    toSchema?: string;
-    to: string;
-  };
-
-  export type Schema = {
-    type: 'schema';
-    action: 'create' | 'drop';
-    name: string;
-  };
-
-  export type Extension = {
-    type: 'extension';
-    action: 'create' | 'drop';
-    name: string;
-    schema?: string;
-    version?: string;
-    cascade?: boolean;
-    createIfNotExists?: boolean;
-    dropIfExists?: boolean;
-  };
-
-  export type Enum = {
-    type: 'enum';
-    action: 'create' | 'drop';
-    schema?: string;
-    name: string;
-    values: string[];
-    cascade?: boolean;
-    dropIfExists?: boolean;
-  };
-
-  export type EnumOptions = {
-    createIfNotExists?: boolean;
-    dropIfExists?: boolean;
-  };
-
-  export type ForeignKey = {
-    type: 'foreignKey';
-    action: 'create';
-    tableSchema?: string;
-    tableName: string;
-  } & TableData.ForeignKey;
-}

package/src/commands/createOrDrop.test.ts

@@ -1,214 +0,0 @@
-import { createDb, dropDb, resetDb } from './createOrDrop';
-import { Adapter } from 'pqb';
-import {
-  createSchemaMigrations,
-  migrationConfigDefaults,
-  setAdminCredentialsToOptions,
-} from '../common';
-import { migrate } from './migrateOrRollback';
-
-jest.mock('../common', () => ({
-  ...jest.requireActual('../common'),
-  setAdminCredentialsToOptions: jest.fn((options: Record<string, unknown>) => ({
-    ...options,
-    user: 'admin-user',
-    password: 'admin-password',
-  })),
-  createSchemaMigrations: jest.fn(),
-}));
-
-jest.mock('./migrateOrRollback', () => ({
-  migrate: 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;
-
-const config = {
-  ...migrationConfigDefaults,
-  basePath: __dirname,
-};
-
-describe('createOrDrop', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('createDb', () => {
-    it('should create database when user is an admin', async () => {
-      queryMock.mockResolvedValueOnce(undefined);
-
-      await createDb(options, config);
-
-      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' }],
-        config,
-      );
-
-      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, config);
-
-      expect(queryMock.mock.calls).toEqual([
-        [`CREATE DATABASE "dbname" OWNER "user"`],
-      ]);
-      expect(logMock.mock.calls).toEqual([[`Database dbname already exists`]]);
-      expect(createSchemaMigrations).toHaveBeenCalled();
-    });
-
-    it('should inform if ssl is required', async () => {
-      queryMock.mockRejectedValueOnce({
-        code: 'XX000',
-        message: 'sslmode=require',
-      });
-
-      await createDb(options, config);
-
-      expect(queryMock.mock.calls).toEqual([
-        [`CREATE DATABASE "dbname" OWNER "user"`],
-      ]);
-      expect(logMock.mock.calls).toEqual([
-        ['SSL is required: append ?ssl=true to the database url string'],
-      ]);
-      expect(createSchemaMigrations).not.toHaveBeenCalled();
-    });
-
-    it('should ask and use admin credentials when cannot connect', async () => {
-      queryMock.mockRejectedValueOnce({ code: '42501' });
-
-      await createDb(options, config);
-
-      expect(setAdminCredentialsToOptions).toHaveBeenCalled();
-      expect(queryMock.mock.calls).toEqual([
-        [`CREATE DATABASE "dbname" OWNER "user"`],
-        [`CREATE DATABASE "dbname" OWNER "user"`],
-      ]);
-      expect(logMock.mock.calls).toEqual([
-        [
-          `Permission denied to create database.\nDon't use this command for database service providers, only for a local db.`,
-        ],
-        [`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 inform if ssl is required', async () => {
-      queryMock.mockRejectedValueOnce({
-        code: 'XX000',
-        message: 'sslmode=require',
-      });
-
-      await createDb(options, config);
-
-      expect(queryMock.mock.calls).toEqual([
-        [`CREATE DATABASE "dbname" OWNER "user"`],
-      ]);
-      expect(logMock.mock.calls).toEqual([
-        ['SSL is required: append ?ssl=true to the database url string'],
-      ]);
-      expect(createSchemaMigrations).not.toHaveBeenCalled();
-    });
-
-    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([
-        [
-          `Permission denied to drop database.\nDon't use this command for database service providers, only for a local db.`,
-        ],
-        [`Database dbname was successfully dropped`],
-      ]);
-    });
-  });
-
-  describe('reset', () => {
-    it('should drop and create database', async () => {
-      queryMock.mockResolvedValue(undefined);
-
-      await resetDb(options, config);
-
-      expect(queryMock.mock.calls).toEqual([
-        [`DROP DATABASE "dbname"`],
-        [`CREATE DATABASE "dbname" OWNER "user"`],
-      ]);
-      expect(logMock.mock.calls).toEqual([
-        [`Database dbname was successfully dropped`],
-        [`Database dbname successfully created`],
-      ]);
-      expect(createSchemaMigrations).toHaveBeenCalled();
-      expect(migrate).toBeCalled();
-    });
-  });
-});

package/src/commands/createOrDrop.ts

@@ -1,151 +0,0 @@
-import { Adapter, AdapterOptions, MaybeArray, toArray } from 'pqb';
-import {
-  getDatabaseAndUserFromOptions,
-  setAdminCredentialsToOptions,
-  setAdapterOptions,
-  createSchemaMigrations,
-  RakeDbConfig,
-  migrationConfigDefaults,
-} from '../common';
-import { migrate } from './migrateOrRollback';
-
-const execute = async (
-  options: AdapterOptions,
-  sql: string,
-): Promise<
-  'ok' | 'already' | 'forbidden' | 'ssl required' | { error: unknown }
-> => {
-  const db = new Adapter(options);
-
-  try {
-    await db.query(sql);
-    return 'ok';
-  } catch (error) {
-    const err = error as Record<string, unknown>;
-
-    if (
-      typeof err.message === 'string' &&
-      err.message.includes('sslmode=require')
-    ) {
-      return 'ssl required';
-    }
-
-    if (err.code === '42P04' || err.code === '3D000') {
-      return 'already';
-    } else if (
-      err.code === '42501' ||
-      (typeof err.message === 'string' &&
-        err.message.includes('password authentication failed'))
-    ) {
-      return 'forbidden';
-    } else {
-      return { error };
-    }
-  } finally {
-    await db.close();
-  }
-};
-
-const createOrDrop = async (
-  options: AdapterOptions,
-  adminOptions: AdapterOptions,
-  config: Pick<RakeDbConfig, 'migrationsTable'>,
-  args: {
-    sql(params: { database: string; user: string }): string;
-    successMessage(params: { database: string }): string;
-    alreadyMessage(params: { database: string }): string;
-    create?: 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 === 'ssl required') {
-    console.log('SSL is required: append ?ssl=true to the database url string');
-    return;
-  } else if (result === 'forbidden') {
-    let message = `Permission denied to ${
-      args.create ? 'create' : 'drop'
-    } database.`;
-
-    const host = adminOptions.databaseURL
-      ? new URL(adminOptions.databaseURL).hostname
-      : adminOptions.host;
-
-    const isLocal = host === 'localhost';
-    if (!isLocal) {
-      message += `\nDon't use this command for database service providers, only for a local db.`;
-    }
-
-    console.log(message);
-
-    const updatedOptions = await setAdminCredentialsToOptions(
-      options,
-      args.create,
-    );
-    if (!updatedOptions) return;
-
-    await createOrDrop(options, updatedOptions, config, args);
-    return;
-  } else {
-    throw result.error;
-  }
-
-  if (!args.create) return;
-
-  const db = new Adapter(options);
-  await createSchemaMigrations(db, config);
-  await db.close();
-};
-
-export const createDb = async (
-  arg: MaybeArray<AdapterOptions>,
-  config: RakeDbConfig,
-) => {
-  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`;
-      },
-      create: 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`;
-      },
-    });
-  }
-};
-
-export const resetDb = async (
-  arg: MaybeArray<AdapterOptions>,
-  config: RakeDbConfig,
-) => {
-  await dropDb(arg);
-  await createDb(arg, config);
-  await migrate(arg, config);
-};

package/src/commands/generate.test.ts

@@ -1,136 +0,0 @@
-import { generate } from './generate';
-import { migrationConfigDefaults, RakeDbConfig } 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 config: RakeDbConfig = {
-  ...migrationConfigDefaults,
-  basePath: __dirname,
-};
-
-const testGenerate = async (args: string[], content: string) => {
-  const name = args[0];
-  await generate(config, 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(config, [])).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) => {
-  await 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) => {
-  await 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) => {
-  await 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) => {
-  await 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) => {
-  await 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) => {
-  await db.dropTable('table', (t) => ({
-    id: t.integer().primaryKey(),
-    name: t.varchar(20).nullable(),
-  }));
-});
-`,
-    );
-  });
-});