rake-db 2.3.30 → 2.3.31

package/src/pull/structureToAst.ts

@@ -1,372 +0,0 @@
-import { DbStructure } from './dbStructure';
-import { RakeDbAst } from '../ast';
-import {
-  columnsByType,
-  ColumnsShape,
-  ForeignKeyOptions,
-  instantiateColumn,
-  singleQuote,
-  TableData,
-} from 'pqb';
-import { getForeignKeyName, getIndexName } from '../migration/migrationUtils';
-
-const matchMap = {
-  s: undefined,
-  f: 'FULL',
-  p: 'PARTIAL',
-};
-
-const fkeyActionMap = {
-  a: undefined, // default
-  r: 'RESTRICT',
-  c: 'CASCADE',
-  n: 'SET NULL',
-  d: 'SET DEFAULT',
-};
-
-type Data = {
-  schemas: string[];
-  tables: DbStructure.Table[];
-  columns: DbStructure.Column[];
-  primaryKeys: DbStructure.PrimaryKey[];
-  indexes: DbStructure.Index[];
-  foreignKeys: DbStructure.ForeignKey[];
-  extensions: DbStructure.Extension[];
-  enums: DbStructure.Enum[];
-};
-
-type PendingTables = Record<
-  string,
-  { table: DbStructure.Table; dependsOn: Set<string> }
->;
-
-export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
-  const ast: RakeDbAst[] = [];
-
-  const data = await getData(db);
-
-  for (const name of data.schemas) {
-    if (name === 'public') continue;
-
-    ast.push({
-      type: 'schema',
-      action: 'create',
-      name,
-    });
-  }
-
-  const pendingTables: PendingTables = {};
-  for (const table of data.tables) {
-    const key = `${table.schemaName}.${table.name}`;
-    const dependsOn = new Set<string>();
-
-    for (const fk of data.foreignKeys) {
-      if (fk.schemaName !== table.schemaName || fk.tableName !== table.name)
-        continue;
-
-      const otherKey = `${fk.foreignTableSchemaName}.${fk.foreignTableName}`;
-      if (otherKey !== key) {
-        dependsOn.add(otherKey);
-      }
-    }
-
-    pendingTables[key] = { table, dependsOn };
-  }
-
-  for (const key in pendingTables) {
-    const { table, dependsOn } = pendingTables[key];
-    if (!dependsOn.size) {
-      pushTableAst(ast, data, table, pendingTables);
-    }
-  }
-
-  const outerFKeys: [DbStructure.ForeignKey, DbStructure.Table][] = [];
-
-  for (const it of data.extensions) {
-    ast.push({
-      type: 'extension',
-      action: 'create',
-      name: it.name,
-      schema: it.schemaName === 'public' ? undefined : it.schemaName,
-      version: it.version,
-    });
-  }
-
-  for (const it of data.enums) {
-    ast.push({
-      type: 'enum',
-      action: 'create',
-      name: it.name,
-      schema: it.schemaName === 'public' ? undefined : it.schemaName,
-      values: it.values,
-    });
-  }
-
-  for (const key in pendingTables) {
-    const innerFKeys: DbStructure.ForeignKey[] = [];
-    const { table } = pendingTables[key];
-
-    for (const fkey of data.foreignKeys) {
-      if (fkey.schemaName !== table.schemaName || fkey.tableName !== table.name)
-        continue;
-
-      const otherKey = `${fkey.foreignTableSchemaName}.${fkey.foreignTableName}`;
-      if (!pendingTables[otherKey] || otherKey === key) {
-        innerFKeys.push(fkey);
-      } else {
-        outerFKeys.push([fkey, table]);
-      }
-    }
-
-    pushTableAst(ast, data, table, pendingTables, innerFKeys);
-  }
-
-  for (const [fkey, table] of outerFKeys) {
-    ast.push({
-      ...foreignKeyToAst(fkey),
-      type: 'foreignKey',
-      action: 'create',
-      tableSchema: table.schemaName === 'public' ? undefined : table.schemaName,
-      tableName: fkey.tableName,
-    });
-  }
-
-  return ast;
-};
-
-const getData = async (db: DbStructure): Promise<Data> => {
-  const [
-    schemas,
-    tables,
-    columns,
-    primaryKeys,
-    indexes,
-    foreignKeys,
-    extensions,
-    enums,
-  ] = await Promise.all([
-    db.getSchemas(),
-    db.getTables(),
-    db.getColumns(),
-    db.getPrimaryKeys(),
-    db.getIndexes(),
-    db.getForeignKeys(),
-    db.getExtensions(),
-    db.getEnums(),
-  ]);
-
-  return {
-    schemas,
-    tables,
-    columns,
-    primaryKeys,
-    indexes,
-    foreignKeys,
-    extensions,
-    enums,
-  };
-};
-
-const makeBelongsToTable =
-  (schema: string | undefined, table: string) =>
-  (item: { schemaName: string; tableName: string }) =>
-    item.schemaName === schema && item.tableName === table;
-
-const getIsSerial = (item: DbStructure.Column) => {
-  if (item.type === 'int2' || item.type === 'int4' || item.type === 'int8') {
-    const { default: def, schemaName, tableName, name } = item;
-    const seq = `${tableName}_${name}_seq`;
-    if (
-      def &&
-      (def === `nextval(${singleQuote(`${seq}`)}::regclass)` ||
-        def === `nextval(${singleQuote(`"${seq}"`)}::regclass)` ||
-        def === `nextval(${singleQuote(`${schemaName}.${seq}`)}::regclass)` ||
-        def === `nextval(${singleQuote(`"${schemaName}".${seq}`)}::regclass)` ||
-        def === `nextval(${singleQuote(`${schemaName}."${seq}"`)}::regclass)` ||
-        def === `nextval(${singleQuote(`"${schemaName}"."${seq}"`)}::regclass)`)
-    ) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const getColumnType = (item: DbStructure.Column, isSerial: boolean) => {
-  if (isSerial) {
-    return item.type === 'int2'
-      ? 'smallserial'
-      : item.type === 'int4'
-      ? 'serial'
-      : 'bigserial';
-  }
-
-  return item.type;
-};
-
-const pushTableAst = (
-  ast: RakeDbAst[],
-  data: Data,
-  table: DbStructure.Table,
-  pendingTables: PendingTables,
-  innerFKeys = data.foreignKeys,
-) => {
-  const { schemaName, name } = table;
-
-  const key = `${schemaName}.${table.name}`;
-  delete pendingTables[key];
-
-  if (name === 'schemaMigrations') return;
-
-  const belongsToTable = makeBelongsToTable(schemaName, name);
-
-  const columns = data.columns.filter(belongsToTable);
-  const primaryKey = data.primaryKeys.find(belongsToTable);
-  const tableIndexes = data.indexes.filter(belongsToTable);
-  const tableForeignKeys = innerFKeys.filter(belongsToTable);
-
-  const shape: ColumnsShape = {};
-  for (let item of columns) {
-    const isSerial = getIsSerial(item);
-    if (isSerial) {
-      item = { ...item, default: undefined };
-    }
-
-    const klass = columnsByType[getColumnType(item, isSerial)];
-    if (!klass) {
-      throw new Error(`Column type \`${item.type}\` is not supported`);
-    }
-
-    let column = instantiateColumn(klass, item);
-
-    if (
-      primaryKey?.columnNames.length === 1 &&
-      primaryKey?.columnNames[0] === item.name
-    ) {
-      column = column.primaryKey();
-    }
-
-    const indexes = tableIndexes.filter(
-      (it) =>
-        it.columns.length === 1 &&
-        'column' in it.columns[0] &&
-        it.columns[0].column === item.name,
-    );
-    for (const index of indexes) {
-      const options = index.columns[0];
-      column = column.index({
-        collate: options.collate,
-        opclass: options.opclass,
-        order: options.order,
-        name:
-          index.name !== getIndexName(name, index.columns)
-            ? index.name
-            : undefined,
-        using: index.using === 'btree' ? undefined : index.using,
-        unique: index.isUnique,
-        include: index.include,
-        with: index.with,
-        tablespace: index.tablespace,
-        where: index.where,
-      });
-    }
-
-    const foreignKeys = tableForeignKeys.filter(
-      (it) => it.columnNames.length === 1 && it.columnNames[0] === item.name,
-    );
-    for (const foreignKey of foreignKeys) {
-      column = column.foreignKey(
-        foreignKey.foreignTableName,
-        foreignKey.foreignColumnNames[0],
-        {
-          name:
-            foreignKey.name &&
-            foreignKey.name !== getForeignKeyName(name, foreignKey.columnNames)
-              ? foreignKey.name
-              : undefined,
-          match: matchMap[foreignKey.match],
-          onUpdate: fkeyActionMap[foreignKey.onUpdate],
-          onDelete: fkeyActionMap[foreignKey.onDelete],
-        } as ForeignKeyOptions,
-      );
-    }
-
-    shape[item.name] = column;
-  }
-
-  ast.push({
-    type: 'table',
-    action: 'create',
-    schema: schemaName === 'public' ? undefined : schemaName,
-    comment: table.comment,
-    name: name,
-    shape,
-    noPrimaryKey: primaryKey ? 'error' : 'ignore',
-    primaryKey:
-      primaryKey && primaryKey.columnNames.length > 1
-        ? {
-            columns: primaryKey.columnNames,
-            options:
-              primaryKey.name === `${name}_pkey`
-                ? undefined
-                : { name: primaryKey.name },
-          }
-        : undefined,
-    indexes: tableIndexes
-      .filter(
-        (index) =>
-          index.columns.length > 1 ||
-          index.columns.some((it) => 'expression' in it),
-      )
-      .map((index) => ({
-        columns: index.columns.map((it) => ({
-          ...('column' in it
-            ? { column: it.column }
-            : { expression: it.expression }),
-          collate: it.collate,
-          opclass: it.opclass,
-          order: it.order,
-        })),
-        options: {
-          name:
-            index.name !== getIndexName(name, index.columns)
-              ? index.name
-              : undefined,
-          using: index.using === 'btree' ? undefined : index.using,
-          unique: index.isUnique,
-          include: index.include,
-          with: index.with,
-          tablespace: index.tablespace,
-          where: index.where,
-        },
-      })),
-    foreignKeys: tableForeignKeys
-      .filter((it) => it.columnNames.length > 1)
-      .map(foreignKeyToAst),
-  });
-
-  for (const otherKey in pendingTables) {
-    const item = pendingTables[otherKey];
-    if (item.dependsOn.delete(key) && item.dependsOn.size === 0) {
-      pushTableAst(ast, data, item.table, pendingTables);
-    }
-  }
-};
-
-const foreignKeyToAst = (
-  fkey: DbStructure.ForeignKey,
-): TableData.ForeignKey => ({
-  columns: fkey.columnNames,
-  fnOrTable: fkey.foreignTableName,
-  foreignColumns: fkey.foreignColumnNames,
-  options: {
-    name:
-      fkey.name &&
-      fkey.name !== getForeignKeyName(fkey.tableName, fkey.columnNames)
-        ? fkey.name
-        : undefined,
-    match: matchMap[fkey.match],
-    onUpdate: fkeyActionMap[fkey.onUpdate],
-    onDelete: fkeyActionMap[fkey.onDelete],
-  } as ForeignKeyOptions,
-});

package/src/rakeDb.test.ts

@@ -1,131 +0,0 @@
-import { rakeDb } from './rakeDb';
-import { createDb, dropDb, resetDb } from './commands/createOrDrop';
-import { migrate, rollback } from './commands/migrateOrRollback';
-import { generate } from './commands/generate';
-import { pullDbStructure } from './pull/pull';
-import { RakeDbError } from './errors';
-
-jest.mock('./common', () => ({
-  processRakeDbConfig: (config: unknown) => config,
-}));
-
-jest.mock('./commands/createOrDrop', () => ({
-  createDb: jest.fn(),
-  dropDb: jest.fn(),
-  resetDb: jest.fn(),
-}));
-
-jest.mock('./commands/migrateOrRollback', () => ({
-  migrate: jest.fn(),
-  rollback: jest.fn(),
-}));
-
-jest.mock('./commands/generate', () => ({
-  generate: jest.fn(),
-}));
-
-jest.mock('./pull/pull', () => ({
-  pullDbStructure: jest.fn(),
-}));
-
-const options = [
-  {
-    databaseURL: 'one',
-  },
-  {
-    databaseURL: 'two',
-  },
-];
-
-const config = {
-  migrationsPath: 'migrations',
-  commands: {},
-};
-
-describe('rakeDb', () => {
-  test('create', async () => {
-    await rakeDb(options, config, ['create']);
-
-    expect(createDb).toBeCalledWith(options, config);
-  });
-
-  test('drop', async () => {
-    await rakeDb(options, config, ['drop']);
-
-    expect(dropDb).toBeCalledWith(options);
-  });
-
-  test('reset', async () => {
-    await rakeDb(options, config, ['reset']);
-
-    expect(resetDb).toBeCalledWith(options, config);
-  });
-
-  test('migrate', async () => {
-    await rakeDb(options, config, ['migrate', 'arg']);
-
-    expect(migrate).toBeCalledWith(options, config, ['arg']);
-  });
-
-  test('rollback', async () => {
-    await rakeDb(options, config, ['rollback', 'arg']);
-
-    expect(rollback).toBeCalledWith(options, config, ['arg']);
-  });
-
-  test('generate', async () => {
-    await rakeDb(options, config, ['g', 'arg']);
-
-    expect(generate).toBeCalledWith(config, ['arg']);
-
-    jest.clearAllMocks();
-
-    await rakeDb(options, config, ['generate', 'arg']);
-
-    expect(generate).toBeCalledWith(config, ['arg']);
-  });
-
-  test('pull', async () => {
-    await rakeDb(options, config, ['pull']);
-
-    expect(pullDbStructure).toBeCalledWith(options[0], config);
-  });
-
-  test('custom command', async () => {
-    const custom = jest.fn();
-
-    const conf = { ...config, commands: { custom } };
-
-    await rakeDb(options, conf, ['custom', 'arg']);
-
-    expect(custom).toBeCalledWith(options, conf, ['arg']);
-  });
-
-  test('other', async () => {
-    const log = jest.fn();
-    console.log = log;
-
-    await rakeDb(options, config, ['other']);
-
-    expect(log).toBeCalled();
-  });
-
-  it('should log error and exit process with 1 when RakeDbError thrown', async () => {
-    const errorLog = jest.fn();
-    const exit = jest.fn(() => undefined as never);
-    console.error = errorLog;
-    process.exit = exit;
-
-    const err = new RakeDbError('message');
-    const custom = () => {
-      throw err;
-    };
-
-    const conf = { ...config, commands: { custom } };
-
-    await expect(() => rakeDb(options, conf, ['custom'])).rejects.toThrow(err);
-
-    expect(errorLog).toBeCalledWith('message');
-    expect(exit).toBeCalledWith(1);
-  });
-});

package/src/rakeDb.ts

@@ -1,84 +0,0 @@
-import { AdapterOptions, MaybeArray, toArray } from 'pqb';
-import { createDb, dropDb, resetDb } from './commands/createOrDrop';
-import { migrate, rollback } from './commands/migrateOrRollback';
-import { processRakeDbConfig, RakeDbConfig } from './common';
-import { generate } from './commands/generate';
-import { pullDbStructure } from './pull/pull';
-import { RakeDbError } from './errors';
-
-export const rakeDb = async (
-  options: MaybeArray<AdapterOptions>,
-  partialConfig: Partial<RakeDbConfig> = {},
-  args: string[] = process.argv.slice(2),
-) => {
-  const config = processRakeDbConfig(partialConfig);
-
-  const command = args[0]?.split(':')[0];
-
-  try {
-    if (command === 'create') {
-      await createDb(options, config);
-    } else if (command === 'drop') {
-      await dropDb(options);
-    } else if (command === 'reset') {
-      await resetDb(options, config);
-    } else if (command === 'migrate') {
-      await migrate(options, config, args.slice(1));
-    } else if (command === 'rollback') {
-      await rollback(options, config, args.slice(1));
-    } else if (command === 'g' || command === 'generate') {
-      await generate(config, args.slice(1));
-    } else if (command === 'pull') {
-      await pullDbStructure(toArray(options)[0], config);
-    } else if (config.commands[command]) {
-      await config.commands[command](toArray(options), config, args.slice(1));
-    } else {
-      printHelp();
-    }
-  } catch (err) {
-    if (err instanceof RakeDbError) {
-      console.error(err.message);
-      process.exit(1);
-    }
-    throw err;
-  }
-};
-
-const printHelp = () =>
-  console.log(
-    `Usage: rake-db [command] [arguments]
-
-Commands:
-  create                  create databases
-  drop                    drop databases
-  reset                   drop, create and migrate databases
-  g, generate             generate migration file, see below
-  migrate                 migrate pending migrations
-  rollback                rollback the last migrated
-  no or unknown command   prints this message
-  
-Migrate arguments:
-  no arguments            run all pending migrations
-  number                  run specific number of pending migrations
-
-Rollback arguments:
-  no arguments            rollback one last applied migration
-  number                  rollback specific number of applied migrations
-  all                     rollback all applied migrations
-
-Migrate and rollback common arguments:
-  --code                  run code updater, overrides \`useCodeUpdater\` option
-  --code false            do not run code updater
-  
-Generate arguments:
-- (required) first argument is migration name
-  * create*               template for create table
-  * change*               template for change table
-  * add*To*               template for add columns
-  * remove*From*          template for remove columns
-  * drop*                 template for drop table
-
-- other arguments considered as columns with types and optional methods:
-  rake-db g createTable id:serial.primaryKey name:text.nullable
-`,
-  );

package/src/test-utils.ts

@@ -1,64 +0,0 @@
-import { createMigrationInterface, Migration } from './migration/migration';
-import { MaybeArray, toArray, TransactionAdapter } from 'pqb';
-
-export const asMock = (fn: unknown) => fn as jest.Mock;
-
-let db: Migration | undefined;
-
-export const getDb = () => {
-  if (db) return db;
-
-  db = createMigrationInterface(
-    {} as unknown as TransactionAdapter,
-    true,
-    {
-      basePath: __dirname,
-      log: false,
-      migrationsPath: 'migrations-path',
-      migrationsTable: 'schemaMigrations',
-      import: require,
-      appCodeUpdater: appCodeUpdaterMock,
-      commands: {},
-    },
-    {},
-    {},
-  );
-  db.adapter.query = queryMock;
-  db.adapter.arrays = queryMock;
-  return db;
-};
-
-export const queryMock = jest.fn();
-const appCodeUpdaterMock = jest.fn();
-
-export const resetDb = () => {
-  queryMock.mockClear();
-  queryMock.mockResolvedValue(undefined);
-  appCodeUpdaterMock.mockClear();
-  getDb().up = true;
-};
-
-export const setDbDown = () => {
-  getDb().up = false;
-  queryMock.mockClear();
-};
-
-export const trim = (s: string) => {
-  return s.trim().replace(/\n\s+/g, '\n');
-};
-
-export const toLine = (s: string) => {
-  return s.trim().replace(/\n\s*/g, ' ');
-};
-
-export const expectSql = (sql: MaybeArray<string>) => {
-  expect(
-    queryMock.mock.calls.map((call) =>
-      trim(
-        typeof call[0] === 'string'
-          ? call[0]
-          : (call[0] as { text: string }).text,
-      ),
-    ),
-  ).toEqual(toArray(sql).map(trim));
-};

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["./src", "jest-setup.ts", "app"],
-  "compilerOptions": {
-    "outDir": "./dist",
-    "noEmit": false,
-    "baseUrl": ".",
-    "paths": {
-      "pqb": ["../qb/pqb/src"]
-    }
-  }
-}