rake-db 2.3.26 → 2.3.28

package/src/pull/dbStructure.ts

@@ -97,6 +97,12 @@ export namespace DbStructure {
     name: string;
     version?: string;
   };
+
+  export type Enum = {
+    schemaName: string;
+    name: string;
+    values: string[];
+  };
 }
 
 const filterSchema = (table: string) =>
@@ -389,4 +395,19 @@ JOIN pg_catalog.pg_namespace n ON n.oid = extnamespace
     );
     return rows;
   }
+
+  async getEnums() {
+    const { rows } = await this.db.query<DbStructure.Enum>(
+      `SELECT
+  n.nspname as "schemaName",
+  t.typname as name,
+  json_agg(e.enumlabel) as values
+FROM pg_type t
+JOIN pg_enum e ON t.oid = e.enumtypid
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+WHERE ${filterSchema('n.nspname')}
+GROUP BY n.nspname, t.typname`,
+    );
+    return rows;
+  }
 }

package/src/pull/pull.test.ts

@@ -95,11 +95,15 @@ describe('pull', () => {
 change(async (db) => {
   await db.createSchema('schema1');
   await db.createSchema('schema2');
+});
 
+change(async (db) => {
   await db.createTable('schema.table1', (t) => ({
     id: t.serial().primaryKey(),
   }));
+});
 
+change(async (db) => {
   await db.createTable('table2', (t) => ({
     text: t.text(),
     ...t.timestamps(),

package/src/pull/structureToAst.test.ts

@@ -99,6 +99,12 @@ const extension: DbStructure.Extension = {
   version: '123',
 };
 
+const enumType: DbStructure.Enum = {
+  schemaName: 'public',
+  name: 'mood',
+  values: ['sad', 'ok', 'happy'],
+};
+
 describe('structureToAst', () => {
   it('should add schema except public', async () => {
     const db = new DbStructure(adapter);
@@ -801,4 +807,35 @@ describe('structureToAst', () => {
       });
     });
   });
+
+  describe('enum', () => {
+    it('should add enum', async () => {
+      const db = new DbStructure(adapter);
+      db.getEnums = async () => [{ ...enumType, schemaName: 'custom' }];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Enum];
+
+      expect(ast).toEqual({
+        type: 'enum',
+        action: 'create',
+        name: 'mood',
+        schema: 'custom',
+        values: enumType.values,
+      });
+    });
+
+    it('should ignore schema if it is `public`', async () => {
+      const db = new DbStructure(adapter);
+      db.getEnums = async () => [enumType];
+
+      const [ast] = (await structureToAst(db)) as [RakeDbAst.Enum];
+
+      expect(ast).toEqual({
+        type: 'enum',
+        action: 'create',
+        name: 'mood',
+        values: enumType.values,
+      });
+    });
+  });
 });

package/src/pull/structureToAst.ts

@@ -32,6 +32,7 @@ type Data = {
   indexes: DbStructure.Index[];
   foreignKeys: DbStructure.ForeignKey[];
   extensions: DbStructure.Extension[];
+  enums: DbStructure.Enum[];
 };
 
 type PendingTables = Record<
@@ -81,6 +82,26 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
 
   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];
@@ -110,16 +131,6 @@ export const structureToAst = async (db: DbStructure): Promise<RakeDbAst[]> => {
     });
   }
 
-  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,
-    });
-  }
-
   return ast;
 };
 
@@ -132,6 +143,7 @@ const getData = async (db: DbStructure): Promise<Data> => {
     indexes,
     foreignKeys,
     extensions,
+    enums,
   ] = await Promise.all([
     db.getSchemas(),
     db.getTables(),
@@ -140,6 +152,7 @@ const getData = async (db: DbStructure): Promise<Data> => {
     db.getIndexes(),
     db.getForeignKeys(),
     db.getExtensions(),
+    db.getEnums(),
   ]);
 
   return {
@@ -150,6 +163,7 @@ const getData = async (db: DbStructure): Promise<Data> => {
     indexes,
     foreignKeys,
     extensions,
+    enums,
   };
 };
 

package/src/rakeDb.test.ts

@@ -3,6 +3,7 @@ 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,
@@ -108,4 +109,23 @@ describe('rakeDb', () => {
 
     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

@@ -4,6 +4,7 @@ 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>,
@@ -14,24 +15,32 @@ export const rakeDb = async (
 
   const command = args[0]?.split(':')[0];
 
-  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();
+  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;
   }
 };
 

package/src/test-utils.ts

@@ -24,6 +24,7 @@ export const getDb = () => {
     {},
   );
   db.adapter.query = queryMock;
+  db.adapter.arrays = queryMock;
   return db;
 };