rake-db 2.3.10 → 2.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "2.3.10",
+  "version": "2.3.13",
   "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.6"
+    "pqb": "0.9.8"
   },
   "devDependencies": {
     "@swc/core": "^1.2.210",

package/src/ast.ts

@@ -14,7 +14,8 @@ export type RakeDbAst =
   | RakeDbAst.ChangeTable
   | RakeDbAst.RenameTable
   | RakeDbAst.Schema
-  | RakeDbAst.Extension;
+  | RakeDbAst.Extension
+  | RakeDbAst.ForeignKey;
 
 export namespace RakeDbAst {
   export type Table = {
@@ -103,4 +104,11 @@ export namespace RakeDbAst {
     ifExists?: boolean;
     ifNotExists?: boolean;
   };
+
+  export type ForeignKey = {
+    type: 'foreignKey';
+    action: 'create';
+    tableSchema?: string;
+    tableName: string;
+  } & TableData.ForeignKey;
 }

package/src/commands/migrateOrRollback.ts

@@ -1,9 +1,9 @@
 import {
   Adapter,
   AdapterOptions,
-  columnTypes,
   createDb,
   DbResult,
+  DefaultColumnTypes,
   MaybeArray,
   toArray,
 } from 'pqb';
@@ -24,7 +24,7 @@ import {
 } from '../migration/change';
 import { createMigrationInterface } from '../migration/migration';
 
-const getDb = (adapter: Adapter) => createDb({ adapter, columnTypes });
+const getDb = (adapter: Adapter) => createDb({ adapter });
 
 const migrateOrRollback = async (
   options: MaybeArray<AdapterOptions>,
@@ -54,7 +54,7 @@ const migrateOrRollback = async (
 
   for (const opts of toArray(options)) {
     const adapter = new Adapter(opts);
-    let db: DbResult<typeof columnTypes> | undefined;
+    let db: DbResult<DefaultColumnTypes> | undefined;
 
     if (up) {
       await config.beforeMigrate?.((db ??= getDb(adapter)));

package/src/common.ts

@@ -1,8 +1,8 @@
 import {
   Adapter,
   AdapterOptions,
-  columnTypes,
   DbResult,
+  DefaultColumnTypes,
   NoPrimaryKeyOption,
   QueryLogOptions,
   singleQuote,
@@ -12,7 +12,7 @@ import path from 'path';
 import { readdir } from 'fs/promises';
 import { RakeDbAst } from './ast';
 
-type Db = DbResult<typeof columnTypes>;
+type Db = DbResult<DefaultColumnTypes>;
 
 export type RakeDbConfig = {
   migrationsPath: string;

package/src/migration/migration.ts

@@ -15,8 +15,8 @@ import {
   TextColumn,
   AdapterOptions,
   createDb,
-  columnTypes,
   DbResult,
+  DefaultColumnTypes,
 } from 'pqb';
 import { createTable } from './createTable';
 import { changeTable, TableChangeData, TableChanger } from './changeTable';
@@ -63,7 +63,7 @@ export type ExtensionOptions = {
   cascade?: boolean;
 };
 
-export type Migration = DbResult<typeof columnTypes> & MigrationBase;
+export type Migration = DbResult<DefaultColumnTypes> & MigrationBase;
 
 export const createMigrationInterface = (
   tx: TransactionAdapter,
@@ -84,7 +84,7 @@ export const createMigrationInterface = (
     return wrapWithLog(log, q, () => arrays.call(adapter, q, types));
   }) as typeof adapter.arrays;
 
-  const db = createDb({ adapter, columnTypes }) as unknown as Migration;
+  const db = createDb({ adapter }) as unknown as Migration;
 
   const { prototype: proto } = MigrationBase;
   for (const key of Object.getOwnPropertyNames(proto)) {

package/src/pull/astToMigration.test.ts

@@ -41,6 +41,25 @@ describe('astToMigration', () => {
     expect(result).toBe(template(`  await db.createSchema('schemaName');`));
   });
 
+  it('should create extension', () => {
+    const result = astToMigration([
+      {
+        type: 'extension',
+        action: 'create',
+        name: 'extensionName',
+        schema: 'schema',
+        version: '123',
+      },
+    ]);
+
+    expect(result).toBe(
+      template(`  await db.createExtension('extensionName', {
+    schema: 'schema',
+    version: '123',
+  })`),
+    );
+  });
+
   describe('table', () => {
     it('should create table', () => {
       const result = astToMigration([
@@ -147,4 +166,41 @@ change(async (db) => {
       );
     });
   });
+
+  describe('foreignKey', () => {
+    it('should add standalone foreignKey', () => {
+      const result = astToMigration([
+        {
+          type: 'foreignKey',
+          action: 'create',
+          tableSchema: 'custom',
+          tableName: 'table',
+          columns: ['otherId'],
+          fnOrTable: 'otherTable',
+          foreignColumns: ['id'],
+          options: {
+            name: 'fkey',
+            match: 'FULL',
+            onUpdate: 'CASCADE',
+            onDelete: 'CASCADE',
+          },
+        },
+      ]);
+
+      expect(result).toBe(
+        template(`  await db.addForeignKey(
+    'custom.table',
+    ['otherId'],
+    'otherTable',
+    ['id'],
+    {
+      name: 'fkey',
+      match: 'FULL',
+      onUpdate: 'CASCADE',
+      onDelete: 'CASCADE',
+    },
+  );`),
+      );
+    });
+  });
 });

package/src/pull/astToMigration.ts

@@ -4,6 +4,7 @@ import {
   Code,
   codeToString,
   ColumnType,
+  foreignKeyArgsToCode,
   foreignKeyToCode,
   indexToCode,
   isRaw,
@@ -19,9 +20,15 @@ export const astToMigration = (ast: RakeDbAst[]): string | undefined => {
   for (const item of ast) {
     if (item.type === 'schema' && item.action === 'create') {
       code.push(createSchema(item));
+    } else if (item.type === 'extension' && item.action === 'create') {
+      if (code.length) code.push([]);
+      code.push(...createExtension(item));
     } else if (item.type === 'table' && item.action === 'create') {
       if (code.length) code.push([]);
       code.push(...createTable(item));
+    } else if (item.type === 'foreignKey') {
+      if (code.length) code.push([]);
+      code.push(...createForeignKey(item));
     }
   }
 
@@ -39,6 +46,22 @@ const createSchema = (ast: RakeDbAst.Schema) => {
   return `await db.createSchema(${singleQuote(ast.name)});`;
 };
 
+const createExtension = (ast: RakeDbAst.Extension): Code[] => {
+  const code: Code[] = [`await db.createExtension(${singleQuote(ast.name)}`];
+  if (ast.schema || ast.version) {
+    addCode(code, ', {');
+    if (ast.schema) {
+      code.push([`schema: ${singleQuote(ast.schema)},`]);
+    }
+    if (ast.version) {
+      code.push([`version: ${singleQuote(ast.version)},`]);
+    }
+    addCode(code, '}');
+  }
+  addCode(code, ')');
+  return code;
+};
+
 const createTable = (ast: RakeDbAst.Table) => {
   const code: Code[] = [];
   addCode(code, `await db.createTable(${quoteSchemaTable(ast)}, (t) => ({`);
@@ -91,3 +114,17 @@ const isTimestamp = (column?: ColumnType) => {
     def.__raw === 'now()'
   );
 };
+
+const createForeignKey = (item: RakeDbAst.ForeignKey): Code[] => {
+  return [
+    `await db.addForeignKey(`,
+    [
+      `${quoteSchemaTable({
+        schema: item.tableSchema,
+        name: item.tableName,
+      })},`,
+      ...foreignKeyArgsToCode(item),
+    ],
+    ');',
+  ];
+};

package/src/pull/structureToAst.test.ts

@@ -523,20 +523,25 @@ describe('structureToAst', () => {
 
     it('should add foreign key to the column', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [table];
+      db.getTables = async () => [
+        { ...table, name: 'table1' },
+        { ...table, name: 'table2' },
+      ];
       db.getColumns = async () => [
         ...columns,
-        { ...intColumn, name: 'otherId' },
+        { ...intColumn, name: 'otherId', tableName: 'table2' },
+      ];
+      db.getForeignKeys = async () => [
+        { ...foreignKey, tableName: 'table2', foreignTableName: 'table1' },
       ];
-      db.getForeignKeys = async () => [foreignKey];
 
-      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      const [, ast] = (await structureToAst(db)) as RakeDbAst.Table[];
 
       expect(ast.shape.otherId.data.foreignKeys).toEqual([
         {
           columns: ['id'],
           name: 'fkey',
-          table: 'otherTable',
+          table: 'table1',
           match: 'FULL',
           onUpdate: 'CASCADE',
           onDelete: 'CASCADE',
@@ -547,21 +552,28 @@ describe('structureToAst', () => {
 
     it('should ignore standard foreign key name', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [table];
+      db.getTables = async () => [
+        { ...table, name: 'table1' },
+        { ...table, name: 'table2' },
+      ];
       db.getColumns = async () => [
-        ...columns,
-        { ...intColumn, name: 'otherId' },
+        { ...intColumn, name: 'otherId', tableName: 'table2' },
       ];
       db.getForeignKeys = async () => [
-        { ...foreignKey, name: `${table.name}_otherId_fkey` },
+        {
+          ...foreignKey,
+          name: `table2_otherId_fkey`,
+          tableName: 'table2',
+          foreignTableName: 'table1',
+        },
       ];
 
-      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      const [, ast] = (await structureToAst(db)) as RakeDbAst.Table[];
 
       expect(ast.shape.otherId.data.foreignKeys).toEqual([
         {
           columns: ['id'],
-          table: 'otherTable',
+          table: 'table1',
           match: 'FULL',
           onUpdate: 'CASCADE',
           onDelete: 'CASCADE',
@@ -572,26 +584,30 @@ describe('structureToAst', () => {
 
     it('should add composite foreign key', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [table];
+      db.getTables = async () => [
+        { ...table, name: 'table1' },
+        { ...table, name: 'table2' },
+      ];
       db.getColumns = async () => [
-        ...columns,
-        { ...intColumn, name: 'otherId' },
+        { ...intColumn, name: 'otherId', tableName: 'table2' },
       ];
       db.getForeignKeys = async () => [
         {
           ...foreignKey,
+          tableName: 'table2',
           columnNames: ['name', 'otherId'],
+          foreignTableName: 'table1',
           foreignColumnNames: ['name', 'id'],
         },
       ];
 
-      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      const [, ast] = (await structureToAst(db)) as RakeDbAst.Table[];
 
       expect(ast.shape.otherId.data.foreignKeys).toBe(undefined);
       expect(ast.foreignKeys).toEqual([
         {
           columns: ['name', 'otherId'],
-          fnOrTable: 'otherTable',
+          fnOrTable: 'table1',
           foreignColumns: ['name', 'id'],
           options: {
             name: 'fkey',
@@ -605,27 +621,31 @@ describe('structureToAst', () => {
 
     it('should ignore standard foreign key name in a composite foreign key', async () => {
       const db = new DbStructure(adapter);
-      db.getTables = async () => [table];
+      db.getTables = async () => [
+        { ...table, name: 'table1' },
+        { ...table, name: 'table2' },
+      ];
       db.getColumns = async () => [
-        ...columns,
-        { ...intColumn, name: 'otherId' },
+        { ...intColumn, name: 'otherId', tableName: 'table2' },
       ];
       db.getForeignKeys = async () => [
         {
           ...foreignKey,
+          tableName: 'table2',
+          foreignTableName: 'table1',
           columnNames: ['name', 'otherId'],
           foreignColumnNames: ['name', 'id'],
-          name: 'table_name_otherId_fkey',
+          name: 'table2_name_otherId_fkey',
         },
       ];
 
-      const [ast] = (await structureToAst(db)) as [RakeDbAst.Table];
+      const [, ast] = (await structureToAst(db)) as RakeDbAst.Table[];
 
       expect(ast.shape.otherId.data.foreignKeys).toBe(undefined);
       expect(ast.foreignKeys).toEqual([
         {
           columns: ['name', 'otherId'],
-          fnOrTable: 'otherTable',
+          fnOrTable: 'table1',
           foreignColumns: ['name', 'id'],
           options: {
             match: 'FULL',
@@ -635,6 +655,120 @@ describe('structureToAst', () => {
         },
       ]);
     });
+
+    it('should have referenced table before the table with foreign key', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [
+        { ...table, name: 'fkTable' },
+        { ...table, name: 'table1' },
+        { ...table, name: 'table2' },
+        { ...table, name: 'otherTable' },
+      ];
+      db.getColumns = async () => [
+        { ...intColumn, name: 'table1Id', tableName: 'fkTable' },
+        { ...intColumn, name: 'table2Id', tableName: 'fkTable' },
+      ];
+      db.getForeignKeys = async () => [
+        {
+          ...foreignKey,
+          tableName: 'fkTable',
+          columnNames: ['table1Id'],
+          foreignTableName: 'table1',
+        },
+        {
+          ...foreignKey,
+          tableName: 'fkTable',
+          columnNames: ['table2Id'],
+          foreignTableName: 'table2',
+        },
+      ];
+
+      const [table1, table2, fkTable, otherTable] = (await structureToAst(
+        db,
+      )) as RakeDbAst.Table[];
+
+      expect(table1.name).toBe('table1');
+      expect(table2.name).toBe('table2');
+      expect(fkTable.name).toBe('fkTable');
+      expect(otherTable.name).toBe('otherTable');
+    });
+
+    it('should add foreign key to a same table', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [table];
+      db.getColumns = async () => [intColumn];
+      db.getForeignKeys = async () => [
+        {
+          ...foreignKey,
+          tableName: table.name,
+          columnNames: [intColumn.name],
+          foreignTableName: table.name,
+        },
+      ];
+
+      const [ast] = (await structureToAst(db)) as RakeDbAst.Table[];
+
+      expect(ast.name).toBe(table.name);
+    });
+
+    it('should add standalone foreign key when it is recursive', async () => {
+      const db = new DbStructure(adapter);
+      db.getTables = async () => [
+        { ...table, name: 'table1' },
+        { ...table, name: 'table2' },
+      ];
+      db.getColumns = async () => [
+        { ...intColumn, tableName: 'table1' },
+        { ...intColumn, tableName: 'table2' },
+      ];
+      db.getForeignKeys = async () => [
+        {
+          ...foreignKey,
+          tableName: 'table1',
+          columnNames: [intColumn.name],
+          foreignTableName: 'table2',
+        },
+        {
+          ...foreignKey,
+          tableName: 'table2',
+          columnNames: [intColumn.name],
+          foreignTableName: 'table1',
+        },
+      ];
+
+      const [table1, table2, fkey] = (await structureToAst(
+        db,
+      )) as RakeDbAst.Table[];
+
+      expect(table1.name).toBe('table1');
+      expect(table1.shape[intColumn.name].data.foreignKeys).toBe(undefined);
+      expect(table2.name).toBe('table2');
+      expect(table2.shape[intColumn.name].data.foreignKeys).toEqual([
+        {
+          table: 'table1',
+          columns: ['id'],
+          match: 'FULL',
+          name: 'fkey',
+          onUpdate: 'CASCADE',
+          onDelete: 'CASCADE',
+        },
+      ]);
+
+      expect(fkey).toEqual({
+        type: 'foreignKey',
+        action: 'create',
+        tableName: 'table1',
+        columns: ['column'],
+        fnOrTable: 'table2',
+        foreignColumns: ['id'],
+        options: {
+          match: 'FULL',
+          name: 'fkey',
+          onDelete: 'CASCADE',
+          onUpdate: 'CASCADE',
+        },
+      });
+    });
   });
 
   describe('extension', () => {