rake-db 2.3.26 → 2.3.28

package/src/migration/changeTable.ts

@@ -6,12 +6,11 @@ import {
   emptyObject,
   TableData,
   RawExpression,
-  raw,
   columnTypes,
-  Sql,
   quote,
   getRaw,
   isRaw,
+  EnumColumn,
 } from 'pqb';
 import {
   ChangeTableCallback,
@@ -23,7 +22,11 @@ import {
   runCodeUpdater,
 } from './migration';
 import { RakeDbAst } from '../ast';
-import { getSchemaAndTableFromName, quoteWithSchema } from '../common';
+import {
+  getSchemaAndTableFromName,
+  makePopulateEnumQuery,
+  quoteWithSchema,
+} from '../common';
 import {
   addColumnComment,
   addColumnIndex,
@@ -33,6 +36,8 @@ import {
   indexesToQuery,
   primaryKeyToSql,
 } from './migrationUtils';
+import { tableMethods } from './tableMethods';
+import { TableQuery } from './createTable';
 
 type ChangeTableData = { add: TableData; drop: TableData };
 const newChangeTableData = (): ChangeTableData => ({
@@ -147,7 +152,7 @@ const columnTypeToColumnChange = (
 
 type TableChangeMethods = typeof tableChangeMethods;
 const tableChangeMethods = {
-  raw: raw,
+  ...tableMethods,
   add,
   drop,
   change(
@@ -216,7 +221,8 @@ export const changeTable = async (
 
   const queries = astToQueries(ast);
   for (const query of queries) {
-    await migration.adapter.query(query);
+    const result = await migration.adapter.arrays(query);
+    query.then?.(result);
   }
 
   await runCodeUpdater(migration, ast);
@@ -285,13 +291,12 @@ type PrimaryKeys = {
   options?: { name?: string };
 };
 
-const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
-  const result: Sql[] = [];
+const astToQueries = (ast: RakeDbAst.ChangeTable): TableQuery[] => {
+  const queries: TableQuery[] = [];
 
   if (ast.comment !== undefined) {
-    result.push({
+    queries.push({
       text: `COMMENT ON TABLE ${quoteWithSchema(ast)} IS ${quote(ast.comment)}`,
-      values: [],
     });
   }
 
@@ -309,6 +314,13 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
   for (const key in ast.shape) {
     const item = ast.shape[key];
 
+    if ('item' in item) {
+      const { item: column } = item;
+      if (column instanceof EnumColumn) {
+        queries.push(makePopulateEnumQuery(column));
+      }
+    }
+
     if (item.type === 'add') {
       if (item.item.isPrimaryKey) {
         addPrimaryKeys.columns.push(key);
@@ -318,6 +330,14 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
         dropPrimaryKeys.columns.push(key);
       }
     } else if (item.type === 'change') {
+      if (item.from.column instanceof EnumColumn) {
+        queries.push(makePopulateEnumQuery(item.from.column));
+      }
+
+      if (item.to.column instanceof EnumColumn) {
+        queries.push(makePopulateEnumQuery(item.to.column));
+      }
+
       if (item.from.primaryKey) {
         dropPrimaryKeys.columns.push(key);
         dropPrimaryKeys.change = true;
@@ -530,7 +550,7 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
   );
 
   if (alterTable.length) {
-    result.push({
+    queries.push({
       text:
         `ALTER TABLE ${quoteWithSchema(ast)}` +
         `\n  ${alterTable.join(',\n  ')}`,
@@ -538,9 +558,9 @@ const astToQueries = (ast: RakeDbAst.ChangeTable): Sql[] => {
     });
   }
 
-  result.push(...indexesToQuery(false, ast, dropIndexes));
-  result.push(...indexesToQuery(true, ast, addIndexes));
-  result.push(...commentsToQuery(ast, comments));
+  queries.push(...indexesToQuery(false, ast, dropIndexes));
+  queries.push(...indexesToQuery(true, ast, addIndexes));
+  queries.push(...commentsToQuery(ast, comments));
 
-  return result;
+  return queries;
 };

package/src/migration/createTable.test.ts

@@ -1,4 +1,11 @@
-import { expectSql, getDb, queryMock, resetDb, toLine } from '../test-utils';
+import {
+  asMock,
+  expectSql,
+  getDb,
+  queryMock,
+  resetDb,
+  toLine,
+} from '../test-utils';
 
 const db = getDb();
 
@@ -90,6 +97,7 @@ const db = getDb();
 
       const expectCreateTable = () => {
         expectSql([
+          'SELECT unnest(enum_range(NULL::"mood"))::text',
           `
             CREATE TABLE "table" (
               "id" serial PRIMARY KEY,
@@ -130,18 +138,32 @@ const db = getDb();
       };
 
       const expectDropTable = () => {
-        expectSql(`
-          DROP TABLE "table" CASCADE
-        `);
+        expectSql([
+          'SELECT unnest(enum_range(NULL::"mood"))::text',
+          `
+            DROP TABLE "table" CASCADE
+          `,
+        ]);
       };
 
+      const enumRows = [['one'], ['two']];
+      asMock(db.adapter.arrays).mockResolvedValueOnce({ rows: enumRows });
+
       await fn();
       (action === 'createTable' ? expectCreateTable : expectDropTable)();
 
+      const [{ ast: ast1 }] = asMock(db.options.appCodeUpdater).mock.calls[0];
+      expect(ast1.shape.enum.options).toEqual(['one', 'two']);
+
       db.up = false;
       queryMock.mockClear();
+      asMock(db.options.appCodeUpdater).mockClear();
+      asMock(db.adapter.arrays).mockResolvedValueOnce({ rows: enumRows });
       await fn();
       (action === 'createTable' ? expectDropTable : expectCreateTable)();
+
+      const [{ ast: ast2 }] = asMock(db.options.appCodeUpdater).mock.calls[0];
+      expect(ast2.shape.enum.options).toEqual(['one', 'two']);
     });
 
     it('should support composite primary key defined on multiple columns', async () => {
@@ -321,7 +343,7 @@ const db = getDb();
 
       it('should throw by default when no primary key', async () => {
         await expect(() => db[action]('table', () => ({}))).rejects.toThrow(
-          'Table table has no primary key',
+          'Table table has no primary key.\nYou can suppress this error by setting { noPrimaryKey: true } after a table name.',
         );
       });
 
@@ -329,7 +351,7 @@ const db = getDb();
         db.options.noPrimaryKey = 'error';
 
         await expect(() => db[action]('table', () => ({}))).rejects.toThrow(
-          'Table table has no primary key',
+          'Table table has no primary key.\nYou can suppress this error by setting { noPrimaryKey: true } after a table name.',
         );
       });
 
@@ -339,7 +361,9 @@ const db = getDb();
 
         db[action]('table', () => ({}));
 
-        expect(console.warn).toBeCalledWith('Table table has no primary key');
+        expect(console.warn).toBeCalledWith(
+          'Table table has no primary key.\nYou can suppress this error by setting { noPrimaryKey: true } after a table name.',
+        );
       });
 
       it('should not throw when no primary key and noPrimaryKey is set to `ignore`', async () => {

package/src/migration/createTable.ts

@@ -1,12 +1,12 @@
 import {
   ColumnsShape,
   columnTypes,
+  EnumColumn,
   getColumnTypes,
   getTableData,
   NoPrimaryKeyOption,
+  QueryArraysResult,
   quote,
-  raw,
-  Sql,
   TableData,
 } from 'pqb';
 import {
@@ -25,12 +25,22 @@ import {
   indexesToQuery,
   primaryKeyToSql,
 } from './migrationUtils';
-import { getSchemaAndTableFromName, quoteWithSchema } from '../common';
+import {
+  getSchemaAndTableFromName,
+  makePopulateEnumQuery,
+  quoteWithSchema,
+} from '../common';
 import { RakeDbAst } from '../ast';
+import { tableMethods } from './tableMethods';
+import { NoPrimaryKey } from '../errors';
+
+const types = Object.assign(Object.create(columnTypes), tableMethods);
 
-const types = Object.assign(Object.create(columnTypes), {
-  raw,
-});
+export type TableQuery = {
+  text: string;
+  values?: unknown[];
+  then?(result: QueryArraysResult): void;
+};
 
 export const createTable = async (
   migration: MigrationBase,
@@ -53,8 +63,9 @@ export const createTable = async (
   validatePrimaryKey(ast);
 
   const queries = astToQueries(ast);
-  for (const query of queries) {
-    await migration.adapter.query(query);
+  for (const { then, ...query } of queries) {
+    const result = await migration.adapter.arrays(query);
+    then?.(result);
   }
 
   await runCodeUpdater(migration, ast);
@@ -110,26 +121,35 @@ const validatePrimaryKey = (ast: RakeDbAst.Table) => {
     }
 
     if (!hasPrimaryKey) {
-      const message = `Table ${ast.name} has no primary key`;
+      const error = new NoPrimaryKey(
+        `Table ${ast.name} has no primary key.\nYou can suppress this error by setting { noPrimaryKey: true } after a table name.`,
+      );
       if (ast.noPrimaryKey === 'error') {
-        throw new Error(message);
+        throw error;
       } else {
-        console.warn(message);
+        console.warn(error.message);
       }
     }
   }
 };
 
-const astToQueries = (ast: RakeDbAst.Table): Sql[] => {
+const astToQueries = (ast: RakeDbAst.Table): TableQuery[] => {
+  const queries: TableQuery[] = [];
+
+  for (const key in ast.shape) {
+    const item = ast.shape[key];
+    if (!(item instanceof EnumColumn)) continue;
+
+    queries.push(makePopulateEnumQuery(item));
+  }
+
   if (ast.action === 'drop') {
-    return [
-      {
-        text: `DROP TABLE ${quoteWithSchema(ast)}${
-          ast.dropMode ? ` ${ast.dropMode}` : ''
-        }`,
-        values: [],
-      },
-    ];
+    queries.push({
+      text: `DROP TABLE ${quoteWithSchema(ast)}${
+        ast.dropMode ? ` ${ast.dropMode}` : ''
+      }`,
+    });
+    return queries;
   }
 
   const lines: string[] = [];
@@ -154,21 +174,20 @@ const astToQueries = (ast: RakeDbAst.Table): Sql[] => {
 
   indexes.push(...ast.indexes);
 
-  const result: Sql[] = [
+  queries.push(
     {
       text: `CREATE TABLE ${quoteWithSchema(ast)} (${lines.join(',')}\n)`,
       values,
     },
     ...indexesToQuery(true, ast, indexes),
     ...commentsToQuery(ast, comments),
-  ];
+  );
 
   if (ast.comment) {
-    result.push({
+    queries.push({
       text: `COMMENT ON TABLE ${quoteWithSchema(ast)} IS ${quote(ast.comment)}`,
-      values: [],
     });
   }
 
-  return result;
+  return queries;
 };

package/src/migration/migration.test.ts

@@ -373,7 +373,7 @@ describe('migration', () => {
 
         const expectCreateExtension = () => {
           expectSql(`
-            CREATE TYPE "schemaName"."enumName" AS ENUM ($1, $2)
+            CREATE TYPE "schemaName"."enumName" AS ENUM ('one', 'two')
           `);
         };
 

package/src/migration/migration.ts

@@ -18,6 +18,7 @@ import {
   DbResult,
   DefaultColumnTypes,
   EnumColumn,
+  quote,
 } from 'pqb';
 import { createTable } from './createTable';
 import { changeTable, TableChangeData, TableChanger } from './changeTable';
@@ -483,22 +484,19 @@ const createEnum = async (
     ...options,
   };
 
-  let text;
+  let query;
   const quotedName = quoteWithSchema(ast);
   if (ast.action === 'create') {
-    text = `CREATE TYPE ${quotedName} AS ENUM (${values
-      .map((_, i) => `$${i + 1}`)
+    query = `CREATE TYPE ${quotedName} AS ENUM (${values
+      .map(quote)
       .join(', ')})`;
   } else {
-    text = `DROP TYPE${ast.dropIfExists ? ' IF EXISTS' : ''} ${quotedName}${
+    query = `DROP TYPE${ast.dropIfExists ? ' IF EXISTS' : ''} ${quotedName}${
       ast.cascade ? ' CASCADE' : ''
     }`;
   }
 
-  await migration.adapter.query({
-    text,
-    values,
-  });
+  await migration.adapter.query(query);
 
   await runCodeUpdater(migration, ast);
 };

package/src/migration/tableMethods.ts

@@ -0,0 +1,8 @@
+import { EnumColumn, raw } from 'pqb';
+
+export const tableMethods = {
+  raw,
+  enum: (name: string) =>
+    // empty array will be filled during the migration by querying db
+    new EnumColumn(name, [] as unknown as [string, ...string[]]),
+};

package/src/pull/astToMigration.test.ts

@@ -9,15 +9,46 @@ ${content}
 });
 `;
 
-const tableAst: RakeDbAst.Table = {
+const schema: RakeDbAst.Schema = {
+  type: 'schema',
+  action: 'create',
+  name: 'schemaName',
+};
+
+const extension: RakeDbAst.Extension = {
+  type: 'extension',
+  action: 'create',
+  name: 'extensionName',
+};
+
+const enumType: RakeDbAst.Enum = {
+  type: 'enum',
+  action: 'create',
+  name: 'mood',
+  values: ['sad', 'ok', 'happy'],
+};
+
+const table: RakeDbAst.Table = {
   type: 'table',
   action: 'create',
   schema: 'schema',
   name: 'table',
-  shape: {},
   noPrimaryKey: 'ignore',
   indexes: [],
   foreignKeys: [],
+  shape: {
+    id: columnTypes.serial().primaryKey(),
+  },
+};
+
+const foreignKey: RakeDbAst.ForeignKey = {
+  type: 'foreignKey',
+  action: 'create',
+  tableName: 'table',
+  columns: ['otherId'],
+  fnOrTable: 'otherTable',
+  foreignColumns: ['id'],
+  options: {},
 };
 
 describe('astToMigration', () => {
@@ -29,24 +60,59 @@ describe('astToMigration', () => {
     expect(result).toBe(undefined);
   });
 
-  it('should create schema', () => {
+  it('should put schema, extension, enum to first change, tables to separate changes, foreignKeys in last change', () => {
     const result = astToMigration([
-      {
-        type: 'schema',
-        action: 'create',
-        name: 'schemaName',
-      },
+      schema,
+      extension,
+      enumType,
+      table,
+      { ...table, name: 'other' },
+      foreignKey,
     ]);
 
+    expect(result).toBe(`import { change } from 'rake-db';
+
+change(async (db) => {
+  await db.createSchema('schemaName');
+
+  await db.createExtension('extensionName');
+
+  await db.createEnum('mood', ['sad', 'ok', 'happy']);
+});
+
+change(async (db) => {
+  await db.createTable('schema.table', (t) => ({
+    id: t.serial().primaryKey(),
+  }));
+});
+
+change(async (db) => {
+  await db.createTable('schema.other', (t) => ({
+    id: t.serial().primaryKey(),
+  }));
+});
+
+change(async (db) => {
+  await db.addForeignKey(
+    'table',
+    ['otherId'],
+    'otherTable',
+    ['id'],
+  );
+});
+`);
+  });
+
+  it('should create schema', () => {
+    const result = astToMigration([schema]);
+
     expect(result).toBe(template(`  await db.createSchema('schemaName');`));
   });
 
   it('should create extension', () => {
     const result = astToMigration([
       {
-        type: 'extension',
-        action: 'create',
-        name: 'extensionName',
+        ...extension,
         schema: 'schema',
         version: '123',
       },
@@ -56,20 +122,28 @@ describe('astToMigration', () => {
       template(`  await db.createExtension('extensionName', {
     schema: 'schema',
     version: '123',
-  })`),
+  });`),
+    );
+  });
+
+  it('should create enum', () => {
+    const result = astToMigration([
+      {
+        ...enumType,
+        schema: 'schema',
+      },
+    ]);
+
+    expect(result).toBe(
+      template(`  await db.createEnum('mood', ['sad', 'ok', 'happy'], {
+    schema: 'schema',
+  });`),
     );
   });
 
   describe('table', () => {
     it('should create table', () => {
-      const result = astToMigration([
-        {
-          ...tableAst,
-          shape: {
-            id: columnTypes.serial().primaryKey(),
-          },
-        },
-      ]);
+      const result = astToMigration([table]);
 
       expect(result).toBe(
         template(`  await db.createTable('schema.table', (t) => ({
@@ -81,7 +155,7 @@ describe('astToMigration', () => {
     it('should add columns with indexes and foreignKeys', () => {
       const result = astToMigration([
         {
-          ...tableAst,
+          ...table,
           shape: {
             someId: columnTypes
               .integer()
@@ -116,7 +190,7 @@ change(async (db) => {
     it('should add composite primaryKeys, indexes, foreignKeys', () => {
       const result = astToMigration([
         {
-          ...tableAst,
+          ...table,
           shape: {
             id: columnTypes.serial().primaryKey(),
           },
@@ -171,13 +245,8 @@ change(async (db) => {
     it('should add standalone foreignKey', () => {
       const result = astToMigration([
         {
-          type: 'foreignKey',
-          action: 'create',
+          ...foreignKey,
           tableSchema: 'custom',
-          tableName: 'table',
-          columns: ['otherId'],
-          fnOrTable: 'otherTable',
-          foreignColumns: ['id'],
           options: {
             name: 'fkey',
             match: 'FULL',

package/src/pull/astToMigration.ts

@@ -16,30 +16,58 @@ import {
 import { quoteSchemaTable } from '../common';
 
 export const astToMigration = (ast: RakeDbAst[]): string | undefined => {
-  const code: Code[] = [];
+  const first: Code[] = [];
+  const tables: Code[] = [];
+  const foreignKeys: Code[] = [];
   for (const item of ast) {
     if (item.type === 'schema' && item.action === 'create') {
-      code.push(createSchema(item));
+      first.push(createSchema(item));
     } else if (item.type === 'extension' && item.action === 'create') {
-      if (code.length) code.push([]);
-      code.push(...createExtension(item));
+      if (first.length) first.push([]);
+      first.push(...createExtension(item));
+    } else if (item.type === 'enum' && item.action === 'create') {
+      if (first.length) first.push([]);
+      first.push(...createEnum(item));
     } else if (item.type === 'table' && item.action === 'create') {
-      if (code.length) code.push([]);
-      code.push(...createTable(item));
+      tables.push(createTable(item));
     } else if (item.type === 'foreignKey') {
-      if (code.length) code.push([]);
-      code.push(...createForeignKey(item));
+      if (foreignKeys.length) foreignKeys.push([]);
+      foreignKeys.push(...createForeignKey(item));
     }
   }
 
-  if (!code.length) return;
+  if (!first.length && !tables.length && !foreignKeys.length) return;
+
+  let code = `import { change } from 'rake-db';
+`;
 
-  return `import { change } from 'rake-db';
+  if (first.length) {
+    code += `
+change(async (db) => {
+${codeToString(first, '  ', '  ')}
+});
+`;
+  }
 
+  if (tables.length) {
+    for (const table of tables) {
+      code += `
 change(async (db) => {
-${codeToString(code, '  ', '  ')}
+${codeToString(table, '  ', '  ')}
 });
 `;
+    }
+  }
+
+  if (foreignKeys.length) {
+    code += `
+change(async (db) => {
+${codeToString(foreignKeys, '  ', '  ')}
+});
+`;
+  }
+
+  return code;
 };
 
 const createSchema = (ast: RakeDbAst.Schema) => {
@@ -58,7 +86,22 @@ const createExtension = (ast: RakeDbAst.Extension): Code[] => {
     }
     addCode(code, '}');
   }
-  addCode(code, ')');
+  addCode(code, ');');
+  return code;
+};
+
+const createEnum = (ast: RakeDbAst.Enum) => {
+  const code: Code[] = [
+    `await db.createEnum(${singleQuote(ast.name)}, [${ast.values
+      .map(singleQuote)
+      .join(', ')}]`,
+  ];
+  if (ast.schema) {
+    addCode(code, ', {');
+    code.push([`schema: ${singleQuote(ast.schema)},`]);
+    addCode(code, '}');
+  }
+  addCode(code, ');');
   return code;
 };
 

package/src/pull/dbStructure.test.ts

@@ -163,4 +163,18 @@ describe('dbStructure', () => {
       expect(result).toEqual(rows);
     });
   });
+
+  describe('getEnums', () => {
+    it('should return enums', async () => {
+      rows = [
+        {
+          schemaName: 'public',
+          name: 'mood',
+          values: ['sad', 'ok', 'happy'],
+        },
+      ];
+      const result = await db.getEnums();
+      expect(result).toEqual(rows);
+    });
+  });
 });