rake-db 2.3.0 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Migrations tool for Postgresql DB",
   "homepage": "https://orchid-orm.netlify.app/guide/migration-setup-and-overview.html",
   "repository": {
@@ -42,7 +42,7 @@
   "dependencies": {
     "enquirer": "^2.3.6",
     "pluralize": "^8.0.0",
-    "pqb": "0.9.0"
+    "pqb": "0.9.1"
   },
   "devDependencies": {
     "@swc/core": "^1.2.210",

package/src/commands/generate.ts

@@ -7,20 +7,28 @@ import {
 import { mkdir, writeFile } from 'fs/promises';
 import path from 'path';
 
-export const generate = async (config: RakeDbConfig, args: string[]) => {
-  const name = args[0];
-  if (!name) throw new Error('Migration name is missing');
-
-  await mkdir(config.migrationsPath, { recursive: true });
+export const writeMigrationFile = async (
+  config: RakeDbConfig,
+  name: string,
+  content: string,
+) => {
+  await mkdir(path.resolve(config.migrationsPath), { recursive: true });
 
   const filePath = path.resolve(
     config.migrationsPath,
     `${makeFileTimeStamp()}_${name}.ts`,
   );
-  await writeFile(filePath, makeContent(name, args.slice(1)));
+  await writeFile(filePath, content);
   console.log(`Created ${filePath}`);
 };
 
+export const generate = async (config: RakeDbConfig, args: string[]) => {
+  const name = args[0];
+  if (!name) throw new Error('Migration name is missing');
+
+  await writeMigrationFile(config, name, makeContent(name, args.slice(1)));
+};
+
 const makeFileTimeStamp = () => {
   const now = new Date();
   return [

package/src/common.ts

@@ -3,6 +3,7 @@ import {
   AdapterOptions,
   NoPrimaryKeyOption,
   QueryLogOptions,
+  singleQuote,
 } from 'pqb';
 import Enquirer from 'enquirer';
 import path from 'path';
@@ -25,7 +26,7 @@ export type AppCodeUpdater = (params: {
 }) => Promise<void>;
 
 export const migrationConfigDefaults = {
-  migrationsPath: path.resolve(process.cwd(), 'src', 'migrations'),
+  migrationsPath: path.resolve('src', 'migrations'),
   migrationsTable: 'schemaMigrations',
   requireTs: require,
   log: true,
@@ -191,7 +192,7 @@ export const getMigrationFiles = async (
 
   let files: string[];
   try {
-    files = await readdir(migrationsPath);
+    files = await readdir(path.resolve(migrationsPath));
   } catch (_) {
     return [];
   }
@@ -212,7 +213,7 @@ export const getMigrationFiles = async (
     }
 
     return {
-      path: path.join(migrationsPath, file),
+      path: path.resolve(migrationsPath, file),
       version: timestampMatch[1],
     };
   });
@@ -253,3 +254,13 @@ export const getSchemaAndTableFromName = (
     ? [name.slice(0, index), name.slice(index + 1)]
     : [undefined, name];
 };
+
+export const quoteSchemaTable = ({
+  schema,
+  name,
+}: {
+  schema?: string;
+  name: string;
+}) => {
+  return singleQuote(schema ? `${schema}.${name}` : name);
+};

package/src/pull/astToMigration.test.ts

@@ -0,0 +1,115 @@
+import { astToMigration } from './astToMigration';
+import { columnTypes } from 'pqb';
+import { RakeDbAst } from '../ast';
+
+const template = (content: string) => `import { change } from 'rake-db';
+
+change(async (db) => {
+${content}
+});
+`;
+
+const tableAst: RakeDbAst.Table = {
+  type: 'table',
+  action: 'create',
+  schema: 'schema',
+  name: 'table',
+  shape: {},
+  noPrimaryKey: 'ignore',
+  indexes: [],
+  foreignKeys: [],
+};
+
+describe('astToMigration', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('should return undefined when ast is empty', () => {
+    const result = astToMigration([]);
+
+    expect(result).toBe(undefined);
+  });
+
+  it('should create schema', () => {
+    const result = astToMigration([
+      {
+        type: 'schema',
+        action: 'create',
+        name: 'schemaName',
+      },
+    ]);
+
+    expect(result).toBe(template(`  await db.createSchema('schemaName');`));
+  });
+
+  describe('table', () => {
+    it('should create table', () => {
+      const result = astToMigration([
+        {
+          ...tableAst,
+          shape: {
+            id: columnTypes.serial().primaryKey(),
+          },
+        },
+      ]);
+
+      expect(result).toBe(
+        template(`  await db.createTable('schema.table', (t) => ({
+    id: t.serial().primaryKey(),
+  }));`),
+      );
+    });
+
+    it('should add composite primaryKeys, indexes, foreignKeys', () => {
+      const result = astToMigration([
+        {
+          ...tableAst,
+          shape: {
+            id: columnTypes.serial().primaryKey(),
+          },
+          primaryKey: { columns: ['id', 'name'], options: { name: 'pkey' } },
+          indexes: [
+            {
+              columns: [{ column: 'id' }, { column: 'name' }],
+              options: { name: 'index', unique: true },
+            },
+          ],
+          foreignKeys: [
+            {
+              columns: ['id', 'name'],
+              fnOrTable: 'otherTable',
+              foreignColumns: ['otherId', 'otherName'],
+              options: {
+                name: 'fkey',
+                match: 'FULL',
+                onUpdate: 'CASCADE',
+                onDelete: 'CASCADE',
+              },
+            },
+          ],
+        },
+      ]);
+
+      expect(result).toBe(
+        template(`  await db.createTable('schema.table', (t) => ({
+    id: t.serial().primaryKey(),
+    ...t.primaryKey(['id', 'name'], { name: 'pkey' }),
+    ...t.index(['id', 'name'], {
+      name: 'index',
+      unique: true,
+    }),
+    ...t.foreignKey(
+      ['id', 'name'],
+      'otherTable',
+      ['otherId', 'otherName'],
+      {
+        name: 'fkey',
+        match: 'FULL',
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+    ),
+  }));`),
+      );
+    });
+  });
+});

package/src/pull/astToMigration.ts

@@ -0,0 +1,65 @@
+import { RakeDbAst } from '../ast';
+import {
+  addCode,
+  Code,
+  codeToString,
+  foreignKeyToCode,
+  indexToCode,
+  primaryKeyToCode,
+  quoteObjectKey,
+  singleQuote,
+} from 'pqb';
+import { quoteSchemaTable } from '../common';
+
+export const astToMigration = (ast: RakeDbAst[]): string | undefined => {
+  const code: Code[] = [];
+  for (const item of ast) {
+    if (item.type === 'schema' && item.action === 'create') {
+      code.push(createSchema(item));
+    } else if (item.type === 'table' && item.action === 'create') {
+      if (code.length) code.push([]);
+      code.push(...createTable(item));
+    }
+  }
+
+  if (!code.length) return;
+
+  return `import { change } from 'rake-db';
+
+change(async (db) => {
+${codeToString(code, '  ', '  ')}
+});
+`;
+};
+
+const createSchema = (ast: RakeDbAst.Schema) => {
+  return `await db.createSchema(${singleQuote(ast.name)});`;
+};
+
+const createTable = (ast: RakeDbAst.Table) => {
+  const code: Code[] = [];
+  addCode(code, `await db.createTable(${quoteSchemaTable(ast)}, (t) => ({`);
+
+  for (const key in ast.shape) {
+    const line: Code[] = [`${quoteObjectKey(key)}: `];
+    addCode(line, ast.shape[key].toCode('t'));
+    addCode(line, ',');
+    code.push(line);
+  }
+
+  if (ast.primaryKey) {
+    code.push([primaryKeyToCode(ast.primaryKey, 't')]);
+  }
+
+  for (const index of ast.indexes) {
+    code.push(indexToCode(index, 't'));
+  }
+
+  for (const foreignKey of ast.foreignKeys) {
+    code.push(foreignKeyToCode(foreignKey, 't'));
+  }
+
+  addCode(code, '}));');
+
+  return code;
+};

package/src/pull/pull.test.ts

@@ -0,0 +1,92 @@
+import { DbStructure } from './dbStructure';
+import { pullDbStructure } from './pull';
+import { getMigrationConfigWithDefaults } from '../common';
+import { writeMigrationFile } from '../commands/generate';
+
+jest.mock('./dbStructure', () => {
+  const { DbStructure } = jest.requireActual('./dbStructure');
+  for (const key of Object.getOwnPropertyNames(DbStructure.prototype)) {
+    (DbStructure.prototype as unknown as Record<string, () => unknown[]>)[key] =
+      () => [];
+  }
+
+  return { DbStructure };
+});
+
+jest.mock('../commands/generate', () => ({
+  writeMigrationFile: jest.fn(),
+}));
+
+const db = DbStructure.prototype;
+
+describe('pull', () => {
+  it('should get db structure, convert it to ast, generate migrations', async () => {
+    db.getSchemas = async () => ['schema1', 'schema2'];
+    db.getTables = async () => [
+      {
+        schemaName: 'schema',
+        name: 'table1',
+      },
+      {
+        schemaName: 'public',
+        name: 'table2',
+      },
+    ];
+    db.getPrimaryKeys = async () => [
+      {
+        schemaName: 'schema',
+        tableName: 'table1',
+        name: 'table1_pkey',
+        columnNames: ['id'],
+      },
+    ];
+    db.getColumns = async () => [
+      {
+        schemaName: 'schema',
+        tableName: 'table1',
+        name: 'id',
+        type: 'int4',
+        default: `nextval('table1_id_seq'::regclass)`,
+        isNullable: false,
+      },
+      {
+        schemaName: 'public',
+        tableName: 'table2',
+        name: 'text',
+        type: 'text',
+        isNullable: false,
+      },
+    ];
+
+    const config = getMigrationConfigWithDefaults({
+      migrationsPath: 'migrations',
+    });
+
+    await pullDbStructure(
+      {
+        databaseURL: 'file:path',
+      },
+      config,
+    );
+
+    expect(writeMigrationFile).toBeCalledWith(
+      config,
+      'pull',
+      `import { change } from 'rake-db';
+
+change(async (db) => {
+  await db.createSchema('schema1');
+  await db.createSchema('schema2');
+
+  await db.createTable('schema.table1', (t) => ({
+    id: t.serial().primaryKey(),
+  }));
+
+  await db.createTable('table2', (t) => ({
+    text: t.text(),
+  }));
+});
+`,
+    );
+  });
+});

package/src/pull/pull.ts

@@ -0,0 +1,18 @@
+import { RakeDbConfig } from '../common';
+import { Adapter, AdapterOptions } from 'pqb';
+import { DbStructure } from './dbStructure';
+import { structureToAst } from './structureToAst';
+import { astToMigration } from './astToMigration';
+import { writeMigrationFile } from '../commands/generate';
+
+export const pullDbStructure = async (
+  options: AdapterOptions,
+  config: RakeDbConfig,
+) => {
+  const db = new DbStructure(new Adapter(options));
+  const ast = await structureToAst(db);
+  const result = astToMigration(ast);
+  if (!result) return;
+
+  await writeMigrationFile(config, 'pull', result);
+};

package/src/pull/structureToAst.test.ts

@@ -1,8 +1,11 @@
 import { DbStructure } from './dbStructure';
 import {
   Adapter,
+  BigSerialColumn,
   DecimalColumn,
   IntegerColumn,
+  SerialColumn,
+  SmallSerialColumn,
   TextColumn,
   TimestampColumn,
   VarCharColumn,
@@ -164,6 +167,68 @@ describe('structureToAst', () => {
       expect(ast.shape.name).toBeInstanceOf(TextColumn);
     });
 
+    describe('serial column', () => {
+      it('should add serial column based on various default values', async () => {
+        const db = new DbStructure(adapter);
+        db.getTables = async () => [{ schemaName: 'schema', name: 'table' }];
+
+        const defaults = [
+          `nextval('table_id_seq'::regclass)`,
+          `nextval('"table_id_seq"'::regclass)`,
+          `nextval('schema.table_id_seq'::regclass)`,
+          `nextval('schema."table_id_seq"'::regclass)`,
+          `nextval('"schema".table_id_seq'::regclass)`,
+          `nextval('"schema"."table_id_seq"'::regclass)`,
+        ];
+
+        for (const def of defaults) {
+          db.getColumns = async () => [
+            {
+              ...intColumn,
+              name: 'id',
+              schemaName: 'schema',
+              tableName: 'table',
+              default: def,
+            },
+          ];
+
+          const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+          expect(ast.shape.id).toBeInstanceOf(SerialColumn);
+          expect(ast.shape.id.data.default).toBe(undefined);
+        }
+      });
+
+      it('should support smallserial, serial, and bigserial', async () => {
+        const db = new DbStructure(adapter);
+        db.getTables = async () => [{ schemaName: 'schema', name: 'table' }];
+
+        const types = [
+          ['int2', SmallSerialColumn],
+          ['int4', SerialColumn],
+          ['int8', BigSerialColumn],
+        ] as const;
+
+        for (const [type, Column] of types) {
+          db.getColumns = async () => [
+            {
+              ...intColumn,
+              type,
+              name: 'id',
+              schemaName: 'schema',
+              tableName: 'table',
+              default: `nextval('table_id_seq'::regclass)`,
+            },
+          ];
+
+          const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+          expect(ast.shape.id).toBeInstanceOf(Column);
+          expect(ast.shape.id.data.default).toBe(undefined);
+        }
+      });
+    });
+
     it('should set maxChars to char column', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [{ schemaName: 'public', name: 'table' }];

package/src/pull/structureToAst.ts

@@ -5,6 +5,7 @@ import {
   ColumnsShape,
   ForeignKeyOptions,
   instantiateColumn,
+  singleQuote,
 } from 'pqb';
 
 const matchMap = {
@@ -63,11 +64,16 @@ 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);
+      const klass = columnsByType[getColumnType(item, isSerial)];
       if (!klass) {
         throw new Error(`Column type \`${item.type}\` is not supported`);
       }
+      if (isSerial) {
+        item = { ...item, default: undefined };
+      }
+
       let column = instantiateColumn(klass, item);
 
       if (
@@ -194,3 +200,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();
   }