rake-db 2.3.0 → 2.3.2

package/src/pull/structureToAst.ts

@@ -5,6 +5,7 @@ import {
   ColumnsShape,
   ForeignKeyOptions,
   instantiateColumn,
+  singleQuote,
 } from 'pqb';
 
 const matchMap = {
@@ -14,8 +15,8 @@ const matchMap = {
 };
 
 const fkeyActionMap = {
-  a: 'NO ACTION',
-  r: undefined, // default
+  a: undefined, // default
+  r: 'RESTRICT',
   c: 'CASCADE',
   n: 'SET NULL',
   d: 'SET DEFAULT',
@@ -55,6 +56,8 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
   for (const table of tables) {
     const { schemaName, name } = table;
 
+    if (name === 'schemaMigrations') continue;
+
     const belongsToTable = makeBelongsToTable(schemaName, name);
 
     const columns = allColumns.filter(belongsToTable);
@@ -63,11 +66,17 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
     const tableForeignKeys = allForeignKeys.filter(belongsToTable);
 
     const shape: ColumnsShape = {};
-    for (const item of columns) {
-      const klass = columnsByType[item.type];
+    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 (
@@ -194,3 +203,35 @@ 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;
+};

package/src/rakeDb.test.ts

@@ -0,0 +1,100 @@
+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';
+
+jest.mock('./common', () => ({
+  getMigrationConfigWithDefaults: (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',
+};
+
+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('other', async () => {
+    const log = jest.fn();
+    console.log = log;
+
+    await rakeDb(options, config, ['other']);
+
+    expect(log).toBeCalled();
+  });
+});

package/src/rakeDb.ts

@@ -1,8 +1,9 @@
-import { AdapterOptions, MaybeArray } from 'pqb';
+import { AdapterOptions, MaybeArray, toArray } from 'pqb';
 import { createDb, dropDb, resetDb } from './commands/createOrDrop';
 import { migrate, rollback } from './commands/migrateOrRollback';
 import { getMigrationConfigWithDefaults, RakeDbConfig } from './common';
 import { generate } from './commands/generate';
+import { pullDbStructure } from './pull/pull';
 
 export const rakeDb = async (
   options: MaybeArray<AdapterOptions>,
@@ -25,6 +26,8 @@ export const rakeDb = async (
     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 {
     printHelp();
   }