rake-db 2.3.25 → 2.3.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rake-db",
-  "version": "2.3.25",
+  "version": "2.3.26",
   "description": "Migrations tool for Postgresql DB",
   "homepage": "https://orchid-orm.netlify.app/guide/migration-setup-and-overview.html",
   "repository": {
@@ -41,7 +41,7 @@
   "license": "ISC",
   "dependencies": {
     "pluralize": "^8.0.0",
-    "pqb": "0.9.14",
+    "pqb": "0.9.15",
     "prompts": "^2.4.2"
   },
   "devDependencies": {

package/src/ast.ts

@@ -15,6 +15,7 @@ export type RakeDbAst =
   | RakeDbAst.RenameTable
   | RakeDbAst.Schema
   | RakeDbAst.Extension
+  | RakeDbAst.Enum
   | RakeDbAst.ForeignKey;
 
 export namespace RakeDbAst {
@@ -101,8 +102,23 @@ export namespace RakeDbAst {
     schema?: string;
     version?: string;
     cascade?: boolean;
-    ifExists?: boolean;
-    ifNotExists?: boolean;
+    createIfNotExists?: boolean;
+    dropIfExists?: boolean;
+  };
+
+  export type Enum = {
+    type: 'enum';
+    action: 'create' | 'drop';
+    schema?: string;
+    name: string;
+    values: string[];
+    cascade?: boolean;
+    dropIfExists?: boolean;
+  };
+
+  export type EnumOptions = {
+    createIfNotExists?: boolean;
+    dropIfExists?: boolean;
   };
 
   export type ForeignKey = {

package/src/migration/changeTable.test.ts

@@ -71,6 +71,7 @@ describe('changeTable', () => {
           dropCascade: t[action](t.text(), { dropMode: 'CASCADE' }),
           nullable: t[action](t.text().nullable()),
           nonNullable: t[action](t.text()),
+          enum: t[action](t.enum('mood')),
           withDefault: t[action](t.boolean().default(false)),
           withDefaultRaw: t[action](t.date().default(t.raw(`now()`))),
           withIndex: t[action](
@@ -115,6 +116,7 @@ describe('changeTable', () => {
               ADD COLUMN "dropCascade" text NOT NULL,
               ADD COLUMN "nullable" text,
               ADD COLUMN "nonNullable" text NOT NULL,
+              ADD COLUMN "enum" "mood" NOT NULL,
               ADD COLUMN "withDefault" boolean NOT NULL DEFAULT false,
               ADD COLUMN "withDefaultRaw" date NOT NULL DEFAULT now(),
               ADD COLUMN "withIndex" text NOT NULL,
@@ -155,6 +157,7 @@ describe('changeTable', () => {
               DROP COLUMN "dropCascade" CASCADE,
               DROP COLUMN "nullable",
               DROP COLUMN "nonNullable",
+              DROP COLUMN "enum",
               DROP COLUMN "withDefault",
               DROP COLUMN "withDefaultRaw",
               DROP COLUMN "withIndex",
@@ -407,6 +410,7 @@ describe('changeTable', () => {
     const fn = () => {
       return db.changeTable('table', (t) => ({
         changeType: t.change(t.integer(), t.text()),
+        changeEnum: t.change(t.enum('one'), t.enum('two')),
         changeTypeUsing: t.change(t.integer(), t.text(), {
           usingUp: t.raw('b::text'),
           usingDown: t.raw('b::int'),
@@ -427,6 +431,7 @@ describe('changeTable', () => {
       `
         ALTER TABLE "table"
         ALTER COLUMN "changeType" TYPE text,
+        ALTER COLUMN "changeEnum" TYPE "two",
         ALTER COLUMN "changeTypeUsing" TYPE text USING b::text,
         ALTER COLUMN "changeCollate" TYPE text COLLATE 'fr_FR',
         ALTER COLUMN "changeDefault" SET DEFAULT 'to',
@@ -443,6 +448,7 @@ describe('changeTable', () => {
       `
         ALTER TABLE "table"
         ALTER COLUMN "changeType" TYPE integer,
+        ALTER COLUMN "changeEnum" TYPE "one",
         ALTER COLUMN "changeTypeUsing" TYPE integer USING b::int,
         ALTER COLUMN "changeCollate" TYPE text COLLATE 'de_DE',
         ALTER COLUMN "changeDefault" SET DEFAULT 'from',

package/src/migration/createTable.test.ts

@@ -57,6 +57,7 @@ const db = getDb();
           id: t.serial().primaryKey(),
           nullable: t.text().nullable(),
           nonNullable: t.text(),
+          enum: t.enum('mood'),
           withDefault: t.boolean().default(false),
           withDefaultRaw: t.date().default(t.raw(`now()`)),
           withIndex: t.text().index({
@@ -94,6 +95,7 @@ const db = getDb();
               "id" serial PRIMARY KEY,
               "nullable" text,
               "nonNullable" text NOT NULL,
+              "enum" "mood" NOT NULL,
               "withDefault" boolean NOT NULL DEFAULT false,
               "withDefaultRaw" date NOT NULL DEFAULT now(),
               "withIndex" text NOT NULL,

package/src/migration/migration.test.ts

@@ -317,8 +317,8 @@ describe('migration', () => {
       } an extension`, async () => {
         const fn = () => {
           return db[action]('extensionName', {
-            ifExists: true,
-            ifNotExists: true,
+            dropIfExists: true,
+            createIfNotExists: true,
             schema: 'schemaName',
             version: '123',
             cascade: true,
@@ -352,6 +352,52 @@ describe('migration', () => {
     });
   });
 
+  (['createEnum', 'dropEnum'] as const).forEach((action) => {
+    describe(action, () => {
+      it('should call appCodeUpdater', async () => {
+        await db[action]('enumName', ['one']);
+
+        expect(db.options.appCodeUpdater).toHaveBeenCalled();
+      });
+
+      it(`should ${
+        action === 'createEnum' ? 'add' : 'drop'
+      } an enum`, async () => {
+        const fn = () => {
+          return db[action]('enumName', ['one', 'two'], {
+            dropIfExists: true,
+            schema: 'schemaName',
+            cascade: true,
+          });
+        };
+
+        const expectCreateExtension = () => {
+          expectSql(`
+            CREATE TYPE "schemaName"."enumName" AS ENUM ($1, $2)
+          `);
+        };
+
+        const expectDropExtension = () => {
+          expectSql(`
+            DROP TYPE IF EXISTS "schemaName"."enumName" CASCADE
+          `);
+        };
+
+        await fn();
+        (action === 'createEnum'
+          ? expectCreateExtension
+          : expectDropExtension)();
+
+        db.up = false;
+        queryMock.mockClear();
+        await fn();
+        (action === 'createEnum'
+          ? expectDropExtension
+          : expectCreateExtension)();
+      });
+    });
+  });
+
   describe('tableExists', () => {
     it('should return boolean', async () => {
       queryMock.mockResolvedValueOnce({ rowCount: 1 });

package/src/migration/migration.ts

@@ -17,6 +17,7 @@ import {
   createDb,
   DbResult,
   DefaultColumnTypes,
+  EnumColumn,
 } from 'pqb';
 import { createTable } from './createTable';
 import { changeTable, TableChangeData, TableChanger } from './changeTable';
@@ -37,9 +38,13 @@ export type TableOptions = {
 
 type TextColumnCreator = () => TextColumn;
 
-export type MigrationColumnTypes = Omit<ColumnTypes, 'text' | 'string'> & {
+export type MigrationColumnTypes = Omit<
+  ColumnTypes,
+  'text' | 'string' | 'enum'
+> & {
   text: TextColumnCreator;
   string: TextColumnCreator;
+  enum: (name: string) => EnumColumn;
 };
 
 export type ColumnsShapeCallback = (
@@ -57,12 +62,6 @@ export type JoinTableOptions = {
   dropMode?: DropMode;
 };
 
-export type ExtensionOptions = {
-  schema?: string;
-  version?: string;
-  cascade?: boolean;
-};
-
 export type Migration = DbResult<DefaultColumnTypes> & MigrationBase;
 
 export const createMigrationInterface = (
@@ -285,18 +284,37 @@ export class MigrationBase {
 
   createExtension(
     name: string,
-    options: ExtensionOptions & { ifNotExists?: boolean } = {},
+    options: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name'> = {},
   ) {
     return createExtension(this, this.up, name, options);
   }
 
   dropExtension(
     name: string,
-    options: { ifExists?: boolean; cascade?: boolean } = {},
+    options: Omit<
+      RakeDbAst.Extension,
+      'type' | 'action' | 'name' | 'values'
+    > = {},
   ) {
     return createExtension(this, !this.up, name, options);
   }
 
+  createEnum(
+    name: string,
+    values: string[],
+    options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values'>,
+  ) {
+    return createEnum(this, this.up, name, values, options);
+  }
+
+  dropEnum(
+    name: string,
+    values: string[],
+    options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values'>,
+  ) {
+    return createEnum(this, !this.up, name, values, options);
+  }
+
   async tableExists(tableName: string) {
     return queryExists(this, {
       text: `SELECT 1 FROM "information_schema"."tables" WHERE "table_name" = $1`,
@@ -420,9 +438,7 @@ const createExtension = async (
   migration: MigrationBase,
   up: boolean,
   name: string,
-  options: ExtensionOptions & {
-    checkExists?: boolean;
-  },
+  options: Omit<RakeDbAst.Extension, 'type' | 'action' | 'name'>,
 ) => {
   const ast: RakeDbAst.Extension = {
     type: 'extension',
@@ -433,13 +449,13 @@ const createExtension = async (
 
   let query;
   if (ast.action === 'drop') {
-    query = `DROP EXTENSION${ast.ifNotExists ? ' IF EXISTS' : ''} "${
+    query = `DROP EXTENSION${ast.dropIfExists ? ' IF EXISTS' : ''} "${
       ast.name
     }"${ast.cascade ? ' CASCADE' : ''}`;
   } else {
-    query = `CREATE EXTENSION${ast.ifExists ? ' IF NOT EXISTS' : ''} "${
-      ast.name
-    }"${ast.schema ? ` SCHEMA "${ast.schema}"` : ''}${
+    query = `CREATE EXTENSION${
+      ast.createIfNotExists ? ' IF NOT EXISTS' : ''
+    } "${ast.name}"${ast.schema ? ` SCHEMA "${ast.schema}"` : ''}${
       ast.version ? ` VERSION '${ast.version}'` : ''
     }${ast.cascade ? ' CASCADE' : ''}`;
   }
@@ -449,6 +465,44 @@ const createExtension = async (
   await runCodeUpdater(migration, ast);
 };
 
+const createEnum = async (
+  migration: MigrationBase,
+  up: boolean,
+  name: string,
+  values: string[],
+  options: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values'> = {},
+) => {
+  const [schema, enumName] = getSchemaAndTableFromName(name);
+
+  const ast: RakeDbAst.Enum = {
+    type: 'enum',
+    action: up ? 'create' : 'drop',
+    schema,
+    name: enumName,
+    values,
+    ...options,
+  };
+
+  let text;
+  const quotedName = quoteWithSchema(ast);
+  if (ast.action === 'create') {
+    text = `CREATE TYPE ${quotedName} AS ENUM (${values
+      .map((_, i) => `$${i + 1}`)
+      .join(', ')})`;
+  } else {
+    text = `DROP TYPE${ast.dropIfExists ? ' IF EXISTS' : ''} ${quotedName}${
+      ast.cascade ? ' CASCADE' : ''
+    }`;
+  }
+
+  await migration.adapter.query({
+    text,
+    values,
+  });
+
+  await runCodeUpdater(migration, ast);
+};
+
 const queryExists = (
   db: MigrationBase,
   sql: { text: string; values: unknown[] },