rake-db 2.17.1 → 2.17.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { EmptyObject, RawSQLBase, ColumnSchemaConfig, MaybeArray, ColumnTypeBase, RecordOptionalString } from 'orchid-core';
+import { EmptyObject, RawSQLBase, ColumnSchemaConfig, MaybeArray, RecordString, ColumnTypeBase, RecordOptionalString } from 'orchid-core';
 import * as pqb from 'pqb';
 import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, raw, Adapter, IndexColumnOptions, IndexOptions, ForeignKeyOptions, DbResult, TransactionAdapter, QueryLogObject, TextColumn, TableData, NoPrimaryKeyOption, SingleColumnIndexOptions, DefaultColumnTypes, DefaultSchemaConfig, QueryLogOptions, AdapterOptions } from 'pqb';
 
@@ -584,6 +584,116 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      * @param options - enum options
      */
     dropEnum(name: string, values: [string, ...string[]], options?: Omit<RakeDbAst.Enum, 'type' | 'action' | 'name' | 'values' | 'schema'>): Promise<void>;
+    /**
+     * Use these methods to add or drop one or multiple values from an existing enum.
+     *
+     * `addEnumValues` will drop values when rolling back the migration.
+     *
+     * Dropping a value internally acts in multiple steps:
+     *
+     * 1. Select all columns from the database that depends on the enum;
+     * 2. Alter all these columns to have text type;
+     * 3. Drop the enum;
+     * 4. Re-create the enum without the value given;
+     * 5. Alter all columns from the first step to have the enum type;
+     *
+     * In the case when the value is used by some table,
+     * migrating `dropEnumValue` or rolling back `addEnumValue` will throw an error with a descriptive message,
+     * in such case you'd need to manually resolve the issue by deleting rows with the value, or changing such values.
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.addEnumValue('numbers', 'four');
+     *
+     *   // you can pass options
+     *   await db.addEnumValue('numbers', 'three', {
+     *     // where to insert
+     *     before: 'four',
+     *     // skip if already exists
+     *     ifNotExists: true,
+     *   });
+     *
+     *   // enum name can be prefixed with schema
+     *   await db.addEnumValue('public.numbers', 'five', {
+     *     after: 'four',
+     *   });
+     * });
+     * ```
+     *
+     * @param enumName - target enum name
+     * @param values - array of values to add
+     * @param options - optional object with options
+     * @param options.before - insert before the specified value
+     * @param options.after - insert after the specified value
+     * @param options.ifNotExists - skip adding if already exists
+     */
+    addEnumValues(enumName: string, values: string[], options?: AddEnumValueOptions): Promise<void>;
+    /**
+     * See {@link addEnumValues}
+     */
+    dropEnumValues(enumName: string, values: string[], options?: AddEnumValueOptions): Promise<void>;
+    /**
+     * Rename one or multiple enum values using this method:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   // rename value "from" to "to"
+     *   await db.rename('numbers', { from: 'to' });
+     *
+     *   // enum name can be prefixed with schema
+     *   await db.rename('public.numbers', { from: 'to' });
+     * });
+     * ```
+     *
+     * @param enumName - target enum name, can be prefixed with schema
+     * @param values - object where keys are for old names, values are for new names
+     */
+    renameEnumValues(enumName: string, values: RecordString): Promise<void>;
+    /**
+     * Rename a type (such as enum):
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameType('oldTypeName', 'newTypeName');
+     * });
+     * ```
+     *
+     * Prefix the type name with a schema to set a different schema:
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.renameType('fromSchema.oldType', 'toSchema.newType');
+     * });
+     * ```
+     *
+     * @param from - rename the type from
+     * @param to - rename the type to
+     */
+    renameType(from: string, to: string): Promise<void>;
+    /**
+     * Set a different schema to the type (such as enum):
+     *
+     * ```ts
+     * import { change } from '../dbScript';
+     *
+     * change(async (db) => {
+     *   await db.changeTypeSchema('typeName', 'fromSchema', 'toSchema');
+     * });
+     * ```
+     *
+     * @param name - type name
+     * @param from - current table schema
+     * @param to - desired table schema
+     */
+    changeTypeSchema(name: string, from: string, to: string): Promise<void>;
     /**
      * Domain is a custom database type that allows to predefine a `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
      *
@@ -833,8 +943,15 @@ declare class Migration<CT extends RakeDbColumnTypes> {
      */
     constraintExists(constraintName: string): Promise<boolean>;
 }
+declare const renameType: (migration: Migration<RakeDbColumnTypes>, from: string, to: string, table: boolean) => Promise<void>;
+interface AddEnumValueOptions {
+    ifNotExists?: boolean;
+    before?: string;
+    after?: string;
+}
+declare const addOrDropEnumValues: (migration: Migration<RakeDbColumnTypes>, up: boolean, enumName: string, values: string[], options?: AddEnumValueOptions) => Promise<void>;
 
-type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.View;
+type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameType | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.EnumValues | RakeDbAst.RenameEnumValues | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.View;
 declare namespace RakeDbAst {
     interface Table extends TableData {
         type: 'table';
@@ -893,8 +1010,9 @@ declare namespace RakeDbAst {
         indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
         identity?: TableData.Identity;
     }
-    interface RenameTable {
-        type: 'renameTable';
+    interface RenameType {
+        type: 'renameType';
+        table: boolean;
         fromSchema?: string;
         from: string;
         toSchema?: string;
@@ -924,6 +1042,22 @@ declare namespace RakeDbAst {
         cascade?: boolean;
         dropIfExists?: boolean;
     }
+    interface EnumValues {
+        type: 'enumValues';
+        action: 'add' | 'drop';
+        schema?: string;
+        name: string;
+        values: string[];
+        place?: 'before' | 'after';
+        relativeTo?: string;
+        ifNotExists?: boolean;
+    }
+    interface RenameEnumValues {
+        type: 'renameEnumValues';
+        schema?: string;
+        name: string;
+        values: RecordString;
+    }
     interface Domain {
         type: 'domain';
         action: 'create' | 'drop';
@@ -1268,4 +1402,4 @@ type RakeDbChangeFn<CT extends RakeDbColumnTypes> = (fn: ChangeCallback<CT>) =>
 declare const rakeDb: RakeDbFn;
 declare const rakeDbAliases: RecordOptionalString;
 
-export { AnyRakeDbConfig, AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, ConstraintArg, DbMigration, DropMode, InputRakeDbConfig, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbColumnTypes, RakeDbConfig, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, RakeDbResult, SilentQueries, TableOptions, changeCache, createDb, createMigrationInterface, deleteMigratedVersion, dropDb, generate, generateTimeStamp, getDatabaseAndUserFromOptions, getMigratedVersionsMap, makeFileVersion, migrate, migrateOrRollback, migrationConfigDefaults, processRakeDbConfig, rakeDb, rakeDbAliases, redo, resetDb, rollback, saveMigratedVersion, writeMigrationFile };
+export { AnyRakeDbConfig, AppCodeUpdater, AppCodeUpdaterParams, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, ConstraintArg, DbMigration, DropMode, InputRakeDbConfig, Migration, MigrationAdapter, MigrationColumnTypes, ModuleExportsRecord, NoMigrationsTableError, RAKE_DB_LOCK_KEY, RakeDbAppliedVersions, RakeDbAst, RakeDbBaseTable, RakeDbChangeFn, RakeDbColumnTypes, RakeDbConfig, RakeDbFn, RakeDbFnReturns, RakeDbLazyFn, RakeDbMigrationId, RakeDbResult, SilentQueries, TableOptions, addOrDropEnumValues, changeCache, createDb, createMigrationInterface, deleteMigratedVersion, dropDb, generate, generateTimeStamp, getDatabaseAndUserFromOptions, getMigratedVersionsMap, makeFileVersion, migrate, migrateOrRollback, migrationConfigDefaults, processRakeDbConfig, rakeDb, rakeDbAliases, redo, renameType, resetDb, rollback, saveMigratedVersion, writeMigrationFile };

package/dist/index.js

@@ -1218,28 +1218,8 @@ class Migration {
    * @param from - rename the table from
    * @param to - rename the table to
    */
-  async renameTable(from, to) {
-    var _a;
-    const [fromSchema, f] = getSchemaAndTableFromName(this.up ? from : to);
-    const [toSchema, t] = getSchemaAndTableFromName(this.up ? to : from);
-    const ast = {
-      type: "renameTable",
-      fromSchema,
-      from: f,
-      toSchema,
-      to: t
-    };
-    if (ast.from !== ast.to) {
-      await this.adapter.query(
-        `ALTER TABLE ${quoteTable(ast.fromSchema, ast.from)} RENAME TO "${ast.to}"`
-      );
-    }
-    if (ast.fromSchema !== ast.toSchema) {
-      await this.adapter.query(
-        `ALTER TABLE ${quoteTable(ast.fromSchema, ast.to)} SET SCHEMA "${(_a = ast.toSchema) != null ? _a : this.adapter.schema}"`
-      );
-    }
-    this.migratedAsts.push(ast);
+  renameTable(from, to) {
+    return renameType(this, from, to, true);
   }
   /**
    * Set a different schema to the table:
@@ -1609,6 +1589,141 @@ class Migration {
   dropEnum(name, values, options) {
     return createEnum$1(this, !this.up, name, values, options);
   }
+  /**
+   * Use these methods to add or drop one or multiple values from an existing enum.
+   *
+   * `addEnumValues` will drop values when rolling back the migration.
+   *
+   * Dropping a value internally acts in multiple steps:
+   *
+   * 1. Select all columns from the database that depends on the enum;
+   * 2. Alter all these columns to have text type;
+   * 3. Drop the enum;
+   * 4. Re-create the enum without the value given;
+   * 5. Alter all columns from the first step to have the enum type;
+   *
+   * In the case when the value is used by some table,
+   * migrating `dropEnumValue` or rolling back `addEnumValue` will throw an error with a descriptive message,
+   * in such case you'd need to manually resolve the issue by deleting rows with the value, or changing such values.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.addEnumValue('numbers', 'four');
+   *
+   *   // you can pass options
+   *   await db.addEnumValue('numbers', 'three', {
+   *     // where to insert
+   *     before: 'four',
+   *     // skip if already exists
+   *     ifNotExists: true,
+   *   });
+   *
+   *   // enum name can be prefixed with schema
+   *   await db.addEnumValue('public.numbers', 'five', {
+   *     after: 'four',
+   *   });
+   * });
+   * ```
+   *
+   * @param enumName - target enum name
+   * @param values - array of values to add
+   * @param options - optional object with options
+   * @param options.before - insert before the specified value
+   * @param options.after - insert after the specified value
+   * @param options.ifNotExists - skip adding if already exists
+   */
+  addEnumValues(enumName, values, options) {
+    return addOrDropEnumValues(this, this.up, enumName, values, options);
+  }
+  /**
+   * See {@link addEnumValues}
+   */
+  dropEnumValues(enumName, values, options) {
+    return addOrDropEnumValues(this, !this.up, enumName, values, options);
+  }
+  /**
+   * Rename one or multiple enum values using this method:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   // rename value "from" to "to"
+   *   await db.rename('numbers', { from: 'to' });
+   *
+   *   // enum name can be prefixed with schema
+   *   await db.rename('public.numbers', { from: 'to' });
+   * });
+   * ```
+   *
+   * @param enumName - target enum name, can be prefixed with schema
+   * @param values - object where keys are for old names, values are for new names
+   */
+  async renameEnumValues(enumName, values) {
+    const [schema, name] = getSchemaAndTableFromName(enumName);
+    const ast = {
+      type: "renameEnumValues",
+      schema,
+      name,
+      values
+    };
+    for (const pair of Object.entries(ast.values)) {
+      const [from, to] = this.up ? pair : [pair[1], pair[0]];
+      await this.adapter.query(
+        `ALTER TYPE ${quoteTable(
+          ast.schema,
+          ast.name
+        )} RENAME VALUE "${from}" TO "${to}"`
+      );
+    }
+  }
+  /**
+   * Rename a type (such as enum):
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameType('oldTypeName', 'newTypeName');
+   * });
+   * ```
+   *
+   * Prefix the type name with a schema to set a different schema:
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.renameType('fromSchema.oldType', 'toSchema.newType');
+   * });
+   * ```
+   *
+   * @param from - rename the type from
+   * @param to - rename the type to
+   */
+  renameType(from, to) {
+    return renameType(this, from, to, false);
+  }
+  /**
+   * Set a different schema to the type (such as enum):
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.changeTypeSchema('typeName', 'fromSchema', 'toSchema');
+   * });
+   * ```
+   *
+   * @param name - type name
+   * @param from - current table schema
+   * @param to - desired table schema
+   */
+  changeTypeSchema(name, from, to) {
+    return this.renameType(`${from}.${name}`, `${to}.${name}`);
+  }
   /**
    * Domain is a custom database type that allows to predefine a `NOT NULL` and a `CHECK` (see [postgres tutorial](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-user-defined-data-types/)).
    *
@@ -1968,6 +2083,104 @@ const createCollation$1 = async (migration, up, name, options) => {
 const queryExists = (db, sql) => {
   return db.adapter.query(sql).then(({ rowCount }) => rowCount > 0);
 };
+const renameType = async (migration, from, to, table) => {
+  var _a;
+  const [fromSchema, f] = getSchemaAndTableFromName(migration.up ? from : to);
+  const [toSchema, t] = getSchemaAndTableFromName(migration.up ? to : from);
+  const ast = {
+    type: "renameType",
+    table,
+    fromSchema,
+    from: f,
+    toSchema,
+    to: t
+  };
+  const sqlKind = ast.table ? "TABLE" : "TYPE";
+  if (ast.from !== ast.to) {
+    await migration.adapter.query(
+      `ALTER ${sqlKind} ${quoteTable(ast.fromSchema, ast.from)} RENAME TO "${ast.to}"`
+    );
+  }
+  if (ast.fromSchema !== ast.toSchema) {
+    await migration.adapter.query(
+      `ALTER ${sqlKind} ${quoteTable(ast.fromSchema, ast.to)} SET SCHEMA "${(_a = ast.toSchema) != null ? _a : migration.adapter.schema}"`
+    );
+  }
+  migration.migratedAsts.push(ast);
+};
+const addOrDropEnumValues = async (migration, up, enumName, values, options) => {
+  var _a;
+  const defaultSchema = migration.adapter.schema;
+  const [schema, name] = getSchemaAndTableFromName(enumName);
+  const quotedName = quoteTable(schema, name);
+  const ast = {
+    type: "enumValues",
+    action: up ? "add" : "drop",
+    schema,
+    name,
+    values,
+    place: (options == null ? void 0 : options.before) ? "before" : (options == null ? void 0 : options.after) ? "after" : void 0,
+    relativeTo: (_a = options == null ? void 0 : options.before) != null ? _a : options == null ? void 0 : options.after,
+    ifNotExists: options == null ? void 0 : options.ifNotExists
+  };
+  if (ast.action === "add") {
+    await Promise.all(
+      (ast.place === "after" ? [...ast.values].reverse() : ast.values).map(
+        (value) => migration.adapter.query(
+          `ALTER TYPE ${quoteTable(ast.schema, ast.name)} ADD VALUE${ast.ifNotExists ? " IF NOT EXISTS" : ""} ${orchidCore.singleQuote(value)}${ast.place && ast.relativeTo ? ` ${ast.place.toUpperCase()} ${orchidCore.singleQuote(ast.relativeTo)}` : ""}`
+        )
+      )
+    );
+    return;
+  }
+  const { rows: valuesRows } = await migration.adapter.query(
+    `SELECT unnest(enum_range(NULL::${quotedName}))::text value`
+  );
+  const existingValues = valuesRows.map((r) => r.value);
+  const { rows: tables } = await migration.adapter.query(
+    `SELECT n.nspname AS "schema",
+  c.relname AS "table",
+  json_agg(a.attname ORDER BY a.attnum) AS "columns"
+FROM pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = relnamespace
+JOIN pg_attribute a ON a.attrelid = c.oid
+JOIN pg_type t ON a.atttypid = t.oid AND t.typname = ${orchidCore.singleQuote(name)}
+JOIN pg_namespace tn ON tn.oid = t.typnamespace AND tn.nspname = ${orchidCore.singleQuote(
+      schema != null ? schema : defaultSchema
+    )}
+GROUP BY n.nspname, c.relname`
+  );
+  const sql = tables.map(
+    (t) => `ALTER TABLE ${quoteTable(t.schema, t.table)}
+        ${t.columns.map((c) => `  ALTER COLUMN "${c}" TYPE text`).join(",\n")}`
+  );
+  sql.push(
+    `DROP TYPE ${quotedName}`,
+    `CREATE TYPE ${quotedName} AS ENUM (${existingValues.filter((v) => !ast.values.includes(v)).map(orchidCore.singleQuote).join(", ")})`
+  );
+  await migration.adapter.query(sql.join(";\n"));
+  for (const t of tables) {
+    const table = quoteTable(t.schema, t.table);
+    for (const c of t.columns) {
+      try {
+        await migration.adapter.query(
+          `ALTER TABLE ${table}
+  ALTER COLUMN "${c}" TYPE ${quotedName} USING "${c}"::${quotedName}`
+        );
+      } catch (err) {
+        if (err.code === "22P02") {
+          throw new Error(
+            `Cannot drop ${quotedName} enum values [${ast.values.map(orchidCore.singleQuote).join(
+              ", "
+            )}]: table ${table} has a row with such value in the column "${c}"`,
+            { cause: err }
+          );
+        }
+        throw err;
+      }
+    }
+  }
+};
 
 const writeMigrationFile = async (config, version, name, content) => {
   var _a;
@@ -4598,6 +4811,7 @@ Migrate and rollback common arguments:
 exports.Migration = Migration;
 exports.NoMigrationsTableError = NoMigrationsTableError;
 exports.RAKE_DB_LOCK_KEY = RAKE_DB_LOCK_KEY;
+exports.addOrDropEnumValues = addOrDropEnumValues;
 exports.changeCache = changeCache;
 exports.createDb = createDb;
 exports.createMigrationInterface = createMigrationInterface;
@@ -4615,6 +4829,7 @@ exports.processRakeDbConfig = processRakeDbConfig;
 exports.rakeDb = rakeDb;
 exports.rakeDbAliases = rakeDbAliases;
 exports.redo = redo;
+exports.renameType = renameType;
 exports.resetDb = resetDb;
 exports.rollback = rollback;
 exports.saveMigratedVersion = saveMigratedVersion;