rake-db 2.3.0 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "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.2"
   },
   "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,150 @@
+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 columns with indexes and foreignKeys', () => {
+      const result = astToMigration([
+        {
+          ...tableAst,
+          shape: {
+            someId: columnTypes
+              .integer()
+              .unique({ name: 'indexName' })
+              .foreignKey('otherTable', 'otherId', {
+                name: 'fkey',
+                match: 'FULL',
+                onUpdate: 'CASCADE',
+                onDelete: 'CASCADE',
+              }),
+          },
+        },
+      ]);
+
+      expect(result).toBe(`import { change } from 'rake-db';
+
+change(async (db) => {
+  await db.createTable('schema.table', (t) => ({
+    someId: t.integer().foreignKey('otherTable', 'otherId', {
+      name: 'fkey',
+      match: 'FULL',
+      onUpdate: 'CASCADE',
+      onDelete: 'CASCADE',
+    }).unique({
+      name: 'indexName',
+    }),
+  }));
+});
+`);
+    });
+
+    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,93 @@
+import { RakeDbAst } from '../ast';
+import {
+  addCode,
+  Code,
+  codeToString,
+  ColumnType,
+  foreignKeyToCode,
+  indexToCode,
+  isRaw,
+  primaryKeyToCode,
+  quoteObjectKey,
+  singleQuote,
+  TimestampColumn,
+} 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) => ({`);
+
+  const hasTimestamps =
+    isTimestamp(ast.shape.createdAt) && isTimestamp(ast.shape.updatedAt);
+
+  for (const key in ast.shape) {
+    if (hasTimestamps && (key === 'createdAt' || key === 'updatedAt')) continue;
+
+    const line: Code[] = [`${quoteObjectKey(key)}: `];
+    for (const part of ast.shape[key].toCode('t')) {
+      addCode(line, part);
+    }
+    addCode(line, ',');
+    code.push(line);
+  }
+
+  if (hasTimestamps) {
+    code.push(['...t.timestamps(),']);
+  }
+
+  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;
+};
+
+const isTimestamp = (column?: ColumnType) => {
+  if (!column) return false;
+
+  const { default: def } = column.data;
+  return (
+    column instanceof TimestampColumn &&
+    !column.data.isNullable &&
+    def &&
+    typeof def === 'object' &&
+    isRaw(def) &&
+    def.__raw === 'now()'
+  );
+};

package/src/pull/pull.test.ts

@@ -0,0 +1,111 @@
+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,
+      },
+      {
+        schemaName: 'public',
+        tableName: 'table2',
+        name: 'createdAt',
+        type: 'timestamp',
+        dateTimePrecision: 6,
+        isNullable: false,
+        default: 'now()',
+      },
+      {
+        schemaName: 'public',
+        tableName: 'table2',
+        name: 'updatedAt',
+        type: 'timestamp',
+        dateTimePrecision: 6,
+        isNullable: false,
+        default: 'now()',
+      },
+    ];
+
+    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(),
+    ...t.timestamps(),
+  }));
+});
+`,
+    );
+  });
+});

package/src/pull/pull.ts

@@ -0,0 +1,22 @@
+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 adapter = new Adapter(options);
+  const db = new DbStructure(adapter);
+  const ast = await structureToAst(db);
+
+  await adapter.close();
+
+  const result = astToMigration(ast);
+  if (!result) return;
+
+  await writeMigrationFile(config, 'pull', result);
+};

package/src/pull/structureToAst.test.ts

@@ -1,8 +1,13 @@
 import { DbStructure } from './dbStructure';
 import {
   Adapter,
+  BigSerialColumn,
   DecimalColumn,
   IntegerColumn,
+  isRaw,
+  RawExpression,
+  SerialColumn,
+  SmallSerialColumn,
   TextColumn,
   TimestampColumn,
   VarCharColumn,
@@ -118,7 +123,9 @@ describe('structureToAst', () => {
       db.getTables = async () => [
         { schemaName: 'public', name: 'table', comment: 'comment' },
       ];
+
       const ast = await structureToAst(db);
+
       expect(ast).toEqual([
         {
           type: 'table',
@@ -136,7 +143,9 @@ describe('structureToAst', () => {
     it('should add table with schema', async () => {
       const db = new DbStructure(adapter);
       db.getTables = async () => [{ schemaName: 'custom', name: 'table' }];
+
       const ast = await structureToAst(db);
+
       expect(ast).toEqual([
         {
           type: 'table',
@@ -151,9 +160,20 @@ describe('structureToAst', () => {
       ]);
     });
 
+    it('should ignore schemaMigrations table', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [
+        { schemaName: 'public', name: 'schemaMigrations' },
+      ];
+
+      const ast = await structureToAst(db);
+
+      expect(ast).toEqual([]);
+    });
+
     it('should add columns', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => columns;
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
@@ -164,9 +184,83 @@ describe('structureToAst', () => {
       expect(ast.shape.name).toBeInstanceOf(TextColumn);
     });
 
+    it('should wrap column default into raw', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => [{ ...timestampColumn, default: 'now()' }];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+
+      const { default: def } = ast.shape.timestamp.data;
+      expect(def && typeof def === 'object' && isRaw(def)).toBe(true);
+      expect((def as RawExpression).__raw).toBe('now()');
+    });
+
+    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' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => [varCharColumn];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
@@ -178,7 +272,7 @@ describe('structureToAst', () => {
 
     it('should set numericPrecision and numericScale to decimal column', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => [decimalColumn];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
@@ -191,7 +285,7 @@ describe('structureToAst', () => {
 
     it('should set dateTimePrecision to timestamp column', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => [timestampColumn];
 
       const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
@@ -205,7 +299,7 @@ describe('structureToAst', () => {
 
     it('should set primaryKey to column', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => columns;
       db.getPrimaryKeys = async () => [primaryKey];
 
@@ -218,7 +312,7 @@ describe('structureToAst', () => {
 
     it('should add composite primary key', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => columns;
       db.getPrimaryKeys = async () => [
         { ...primaryKey, columnNames: ['id', 'name'] },
@@ -236,7 +330,7 @@ describe('structureToAst', () => {
 
     it('should ignore primary key name if it is standard', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [{ schemaName: 'public', name: 'table' }];
+      db.getTables = async () => [table];
       db.getColumns = async () => columns;
       db.getPrimaryKeys = async () => [
         { ...primaryKey, columnNames: ['id', 'name'], name: 'table_pkey' },