Altering a colum to an enum with useNative: true fails, tries to create enum twice

Environment

Knex version: 0.20.9 Database + version: Postgres 12 OS: Linux (Ubuntu)

Bug

If you attempt to alter a column to change it’s type to an enum, and you use the useNative: true enum option, knex will try to create the enum twice, which causes a “type already exists” error.

Here is an example migration which demonstrates the problem:

export async function up(knex: Knex): Promise<any> {
  return knex.schema
    .debug(true)
    .createTable("orders", (table) => {
      table.text("drink");
    })
    .alterTable("orders", (table) => {
      // This one works
      table.enum("size", ["small", "medium", "large"], {
        enumName: "drink_sizes",
        useNative: true,
      });

      // This one tries to create the enum twice
      table
        .enum("drink", ["coffee", "tea", "water"], {
          enumName: "drink_types",
          useNative: true,
        })
        .alter();
    });
}

If you look at the debug output from that migration, you will see that the first enum in the alterTable part generates the sql fine, but the second one (using .alter()) will create two identical create type sql statements, which causes Postgres to fail with ‘type “drink_types” already exists’

EDIT:

tl;dr Altering table to enum seems to try to create column type twice:

https://runkit.com/embed/xemoadwjsojw

[elhigu]

So maybe a simple flag inside the ColumnCompiler instance to keep track of whether the create type query has already been added would resolve this? Then only the first call to getColumnType() would add the query?

It sounds like a bad idea that getColumnType() creates that query as a side effect. Without looking the code to me it would make more sense to have createColumnType() and getColumnType() as a separate methods.

[mogzol]

But in this scenario I wouldn’t expect alter to delete the existing type, so that’s fine, I just don’t see why it is trying to create the type twice? This essentially makes it impossible to use .enum() with .alter() if you’re using native enums.

Is there any scenario where .alter() should create the type? It seems like the .enum() part is responsible for that, so why does alter also try to do it?