durcno 1.0.0-alpha.3 → 1.0.0-alpha.4

package/README.md

@@ -1,8 +1,6 @@
 <p align="center">
-  <a href="https://npmjs.com/package/durcno" target="_blank">
-    <img src="https://img.shields.io/npm/v/durcno?style=flat&logo=npm&color=339933" alt="npm version" />
-  </a>
-  <img src="https://img.shields.io/badge/Node.js-24%2B-339933?style=flat&logo=node.js&logoColor=white" alt="Node.js 24+" />
+  <img alt="NPM Downloads" src="https://img.shields.io/npm/dw/durcno" alt="Downloads" />
+  <img src="https://img.shields.io/badge/Node.js-24%2B-339935?style=flat&logo=node.js&logoColor=white" alt="Node.js 24+" />
   <img src="https://img.shields.io/badge/PostgreSQL-14%2B-336791?style=flat&logo=postgresql&logoColor=white" alt="PostgreSQL 14+" />
   <img src="https://img.shields.io/badge/License-Apache%202.0-blue?style=flat" alt="License" />
   <img src="https://img.shields.io/badge/vitest--green?logo=vitest" alt="License" />
@@ -31,7 +29,7 @@
 ## Setup
 
 ```bash
-npm install durcno
+npm add durcno@alpha
 ```
 
 ```bash

package/dist/bin.cjs

@@ -8961,25 +8961,24 @@ async function runDownMigration(migrationDirName, isFirstMigration, migrationsDi
     const options = migrationModule.options ?? {};
     const useTransaction = options.transaction ?? true;
     const execution = options.execution ?? "joined";
-    if (useTransaction) {
-      await client.query("BEGIN;");
-    }
     try {
       if (statements.length > 0) {
         if (execution === "sequential") {
+          if (useTransaction) await client.query("BEGIN;");
           for (const st of statements) {
             await client.query(st.toSQL());
           }
+          if (useTransaction) await client.query("COMMIT;");
         } else {
-          const sql = `${statements.map((st) => st.toSQL()).join("\n")}`;
+          let sql = "";
+          if (useTransaction) sql += "BEGIN;\n";
+          sql += statements.map((st) => st.toSQL()).join("\n");
+          if (useTransaction) sql += "\nCOMMIT;";
           await client.query(sql);
         }
       }
-      if (useTransaction) {
-        await client.query("COMMIT;");
-      }
     } catch (e) {
-      if (useTransaction) {
+      if (useTransaction && execution === "sequential") {
         await client.query("ROLLBACK;");
       }
       throw e;
@@ -12275,12 +12274,14 @@ async function generate(options) {
     ssCurrent,
     renamedTables
   );
+  const connectorMigrationOpts = config2.connector.constructor.migrationOptions;
   const migrationUpTs = generateMigration(
     ssPrevious,
     ssCurrent,
     "up",
     renamedTables,
-    renamedColumns
+    renamedColumns,
+    connectorMigrationOpts
   );
   const reverseRenamedTables = {};
   for (const [oldKey, newKey] of Object.entries(renamedTables)) {
@@ -12299,7 +12300,8 @@ async function generate(options) {
     ssPrevious,
     "down",
     reverseRenamedTables,
-    reverseRenamedColumns
+    reverseRenamedColumns,
+    connectorMigrationOpts
   );
   if (migrationUpTs === null) {
     console.log(yellow3("No changes detected. Skipping migration creation."));
@@ -12311,14 +12313,14 @@ async function generate(options) {
   (0, import_node_fs2.writeFileSync)((0, import_node_path4.resolve)(migrationDir, "up.ts"), migrationUpTs);
   (0, import_node_fs2.writeFileSync)(
     (0, import_node_path4.resolve)(migrationDir, "down.ts"),
-    migrationDnTs ?? generateNoOpMigration()
+    migrationDnTs ?? generateNoOpMigration(connectorMigrationOpts)
   );
   const migrationsRelativePath = (0, import_node_path4.relative)(process.cwd(), migrationsDir);
   console.log(
     `${bgGreen2.white.bold("[CREATED]")} ${cyan3(migrationName)} at ${cyan3(`${migrationsRelativePath}/`)}`
   );
 }
-function generateMigration(prev, curr, direction, renamedTables = {}, renamedColumns = {}) {
+function generateMigration(prev, curr, direction, renamedTables = {}, renamedColumns = {}, defaultOptions) {
   const statements = [];
   const renamedFromKeys = new Set(Object.keys(renamedTables));
   const renamedToKeys = new Set(Object.values(renamedTables));
@@ -12351,7 +12353,7 @@ function generateMigration(prev, curr, direction, renamedTables = {}, renamedCol
   for (const enumName in prev.enums) {
     if (!(enumName in curr.enums)) {
       const enm = prev.enums[enumName];
-      statements.push(`ddl.dropEnum("${enm.schema}", "${enm.name}")`);
+      statements.push(`ddl.dropType("${enm.schema}", "${enm.name}")`);
     }
   }
   for (const enumName in curr.enums) {
@@ -12359,7 +12361,7 @@ function generateMigration(prev, curr, direction, renamedTables = {}, renamedCol
       const enm = curr.enums[enumName];
       const values = enm.values.map((v) => `"${v}"`).join(", ");
       statements.push(
-        `ddl.createEnum("${enm.schema}", "${enm.name}", [${values}])`
+        `ddl.createType("${enm.schema}", "${enm.name}", { asEnum: [${values}] })`
       );
     } else {
       const prevValues = prev.enums[enumName].values;
@@ -12417,15 +12419,15 @@ function generateMigration(prev, curr, direction, renamedTables = {}, renamedCol
             }
             if (afterValue !== null) {
               statements.push(
-                `ddl.alterEnumAddValue("${enm.schema}", "${enm.name}", "${addedValue}", { after: "${afterValue}" })`
+                `ddl.alterType("${enm.schema}", "${enm.name}").addValue("${addedValue}", { after: "${afterValue}" })`
               );
             } else if (beforeValue !== null) {
               statements.push(
-                `ddl.alterEnumAddValue("${enm.schema}", "${enm.name}", "${addedValue}", { before: "${beforeValue}" })`
+                `ddl.alterType("${enm.schema}", "${enm.name}").addValue("${addedValue}", { before: "${beforeValue}" })`
               );
             } else {
               statements.push(
-                `ddl.alterEnumAddValue("${enm.schema}", "${enm.name}", "${addedValue}")`
+                `ddl.alterType("${enm.schema}", "${enm.name}").addValue("${addedValue}")`
               );
             }
           }
@@ -12524,25 +12526,25 @@ function generateMigration(prev, curr, direction, renamedTables = {}, renamedCol
   if (statements.length === 0) return null;
   return `import { type DDLStatement, ddl, type MigrationOptions } from "durcno/migration";
 
-export const options: MigrationOptions = {
-  transaction: true,
-};
+export const options: MigrationOptions = ${stringifyMigrationOpts(defaultOptions ?? { transaction: true })};
 
 export const statements: DDLStatement[] = [
   ${statements.join(",\n  ")},
 ];
 `;
 }
-function generateNoOpMigration() {
+function generateNoOpMigration(defaultOptions) {
   return `import { type DDLStatement, ddl, type MigrationOptions } from "durcno/migration";
 
-export const options: MigrationOptions = {
-  transaction: true,
-};
+export const options: MigrationOptions = ${stringifyMigrationOpts(defaultOptions ?? { transaction: true })};
 
 export const statements: DDLStatement[] = [];
 `;
 }
+function stringifyMigrationOpts(opts) {
+  if (opts.transaction === void 0) opts.transaction = true;
+  return JSON.stringify(opts, null, 2);
+}
 function generateAlterTableStmts(prevTable, currTable, tableName, curr, statements, columnRenames) {
   const alterStatements = [];
   const renamedFromCols = new Set(
@@ -13060,23 +13062,22 @@ async function runUpMigration(migrationDirName, migrationsDir, client, config2)
   const options = migrationModule.options ?? {};
   const useTransaction = options.transaction ?? true;
   const execution = options.execution ?? "joined";
-  if (useTransaction) {
-    await client.query("BEGIN;");
-  }
   try {
     if (statements.length > 0) {
       if (execution === "sequential") {
+        if (useTransaction) await client.query("BEGIN;");
         for (const st of statements) {
           await client.query(st.toSQL());
         }
+        if (useTransaction) await client.query("COMMIT;");
       } else {
-        const sql = `${statements.map((st) => st.toSQL()).join("\n")}`;
+        let sql = "";
+        if (useTransaction) sql += "BEGIN;\n";
+        sql += statements.map((st) => st.toSQL()).join("\n");
+        if (useTransaction) sql += "\nCOMMIT;";
         await client.query(sql);
       }
     }
-    if (useTransaction) {
-      await client.query("COMMIT;");
-    }
     console.log(
       bgGreen3.white.bold("[APPLIED]") + " " + green2(`Migration ${cyan5(migrationDirName)}`) + dim3(".")
     );
@@ -13089,7 +13090,7 @@ async function runUpMigration(migrationDirName, migrationsDir, client, config2)
     });
     await db.close();
   } catch (e) {
-    if (useTransaction) {
+    if (useTransaction && execution === "sequential") {
       await client.query("ROLLBACK;");
     }
     throw e;
@@ -13472,6 +13473,8 @@ async function status(options) {
     console.log(source_default.yellow("No migrations found."));
     process.exit(0);
   }
+  connector.pool = { ...connector.pool, max: 1 };
+  connector.logger = void 0;
   const db = (0, import_durcno4.database)({ Migrations: import_durcno4.Migrations }, config2);
   const migrationsQuery = db.from(import_durcno4.Migrations).select();
   let migrations;
@@ -13505,7 +13508,7 @@ async function status(options) {
 }
 
 // src/cli/index.ts
-program.version("1.0.0-alpha.2");
+program.version("1.0.0-alpha.3");
 var Options = {
   config: ["--config <path>", "Path to the config file"]
 };

package/dist/src/columns/common.d.mts

@@ -1,7 +1,7 @@
 import { Sql } from "../sql.mjs";
 import { entityType } from "../symbols.mjs";
-import { StdTableColumn, TableColumn } from "../table.mjs";
 import { Arg } from "../query-builders/pre.mjs";
+import { StdTableColumn, TableColumn } from "../table.mjs";
 import * as z from "zod";
 
 //#region src/columns/common.d.ts

package/dist/src/columns/enum.d.mts

@@ -1,6 +1,6 @@
 import { Sql } from "../sql.mjs";
-import { Column, ColumnConfig } from "./common.mjs";
 import { Enum } from "../enumtype.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
 import * as z from "zod";
 
 //#region src/columns/enum.d.ts

package/dist/src/connectors/common.d.mts

@@ -1,5 +1,6 @@
 import { DurcnoLogger } from "../logger.mjs";
 import { Query } from "../query-builders/query.mjs";
+import { MigrationOptions } from "../migration/index.mjs";
 import { ConnectionOptions } from "node:tls";
 
 //#region src/connectors/common.d.ts
@@ -55,6 +56,23 @@ type ConnectorOptions = {
  * @abstract
  */
 declare abstract class Connector {
+  /**
+   * Default migration options applied to generated migration files for this
+   * connector. When set, the `generate` CLI command will use these values as
+   * the `options` export in the produced `up.ts` / `down.ts` files instead of
+   * the built-in defaults.
+   *
+   * @example
+   * ```typescript
+   * class MyConnector extends Connector {
+   *   static override migrationOptions: MigrationOptions = {
+   *     transaction: false,
+   *     execution: "sequential",
+   *   };
+   * }
+   * ```
+   */
+  static migrationOptions?: MigrationOptions;
   /**
    * The original options passed to the connector constructor.
    * Provides full access to `dbCredentials`, `pool`, and `logger`.
@@ -207,4 +225,4 @@ declare abstract class $Pool extends $QueryExecutor {
  */
 type QueryExecutor = $Client | $Pool;
 //#endregion
-export { $Pool, Connector, ConnectorOptions, QueryExecutor };
+export { $Client, $Pool, Connector, ConnectorOptions, QueryExecutor };

package/dist/src/connectors/common.mjs

@@ -30,6 +30,23 @@ function getUrlFromDbCredentials(dbCredentials) {
 * @abstract
 */
 var Connector = class {
+	/**
+	* Default migration options applied to generated migration files for this
+	* connector. When set, the `generate` CLI command will use these values as
+	* the `options` export in the produced `up.ts` / `down.ts` files instead of
+	* the built-in defaults.
+	*
+	* @example
+	* ```typescript
+	* class MyConnector extends Connector {
+	*   static override migrationOptions: MigrationOptions = {
+	*     transaction: false,
+	*     execution: "sequential",
+	*   };
+	* }
+	* ```
+	*/
+	static migrationOptions;
 	/**
 	* The original options passed to the connector constructor.
 	* Provides full access to `dbCredentials`, `pool`, and `logger`.

package/dist/src/connectors/pglite.d.mts

@@ -14,6 +14,14 @@ import { PGliteOptions } from "@electric-sql/pglite";
  */
 declare class PgLiteConnector extends Connector {
   #private;
+  /**
+   * PGlite does not support DDL statements inside transactions and requires
+   * sequential execution, so migrations are generated with these defaults.
+   */
+  static migrationOptions: {
+    transaction: boolean;
+    execution: "sequential";
+  };
   constructor(options: ConnectorOptions, driverOptions?: PGliteOptions);
   getClient(): PgLiteClient;
   getPool(): PgLitePool;

package/dist/src/connectors/pglite.mjs

@@ -12,6 +12,14 @@ import { PGlite } from "@electric-sql/pglite";
 * @see https://www.npmjs.com/package/@electric-sql/pglite
 */
 var PgLiteConnector = class extends Connector {
+	/**
+	* PGlite does not support DDL statements inside transactions and requires
+	* sequential execution, so migrations are generated with these defaults.
+	*/
+	static migrationOptions = {
+		transaction: false,
+		execution: "sequential"
+	};
 	#driverOptions;
 	constructor(options, driverOptions) {
 		super(options);

package/dist/src/db.d.mts

@@ -1,4 +1,3 @@
-import { AnyColumn, AnyRelations, IsTableWC, Relations, TColsToLeftRight, TableWCorNever, TableWithColumns } from "./table.mjs";
 import { SelectBuilder } from "./query-builders/select.mjs";
 import { BuildFilterExpression } from "./filters/index.mjs";
 import { Config } from "./index.mjs";
@@ -13,6 +12,7 @@ import { InsertReturningQuery } from "./query-builders/insert-returning.mjs";
 import { RawQuery } from "./query-builders/raw.mjs";
 import { RelationQueryBuilder } from "./query-builders/rq.mjs";
 import { UpdateBuilder } from "./query-builders/update.mjs";
+import { AnyColumn, AnyRelations, IsTableWC, Relations, TColsToLeftRight, TableWCorNever, TableWithColumns } from "./table.mjs";
 import { $Pool, QueryExecutor } from "./connectors/common.mjs";
 
 //#region src/db.d.ts

package/dist/src/filters/array.d.mts

@@ -1,6 +1,6 @@
-import { AnyColumn, TableColumn } from "../table.mjs";
-import { Filter } from "./custom.mjs";
 import { Query } from "../query-builders/query.mjs";
+import { Filter } from "./custom.mjs";
+import { AnyColumn, TableColumn } from "../table.mjs";
 
 //#region src/filters/array.d.ts
 /** Shorthand for the Filter's TableColumn constraint. */

package/dist/src/filters/custom.d.mts

@@ -1,5 +1,5 @@
-import { AnyColumn, TableColumn } from "../table.mjs";
 import { Query } from "../query-builders/query.mjs";
+import { AnyColumn, TableColumn } from "../table.mjs";
 
 //#region src/filters/custom.d.ts
 /** Abstract base class for SQL filter expressions used in `WHERE`/`ON` clauses. */

package/dist/src/filters/index.d.mts

@@ -1,9 +1,9 @@
-import { Sql } from "../sql.mjs";
-import { AnyColumn, AnyTableWithColumns, TColsToLeftRight, TableColumn, TableColumnArgs } from "../table.mjs";
+import { Query } from "../query-builders/query.mjs";
 import { SelectQuery } from "../query-builders/select.mjs";
+import { Sql } from "../sql.mjs";
 import { Filter } from "./custom.mjs";
 import { Arg } from "../query-builders/pre.mjs";
-import { Query } from "../query-builders/query.mjs";
+import { AnyColumn, AnyTableWithColumns, TColsToLeftRight, TableColumn, TableColumnArgs } from "../table.mjs";
 
 //#region src/filters/index.d.ts
 type ConditionExpression<Left extends TableColumnArgs, Right extends Record<string, TableColumnArgs>, TArg extends boolean = false> = EqualValCondition<Left[0], Left[1], Left[2], Left[3], Left[3]["ValType"]> | (TArg extends true ? EqualValCondition<Left[0], Left[1], Left[2], Left[3], Arg<Left[3]["ValType"]>> : never) | { [RightKey in keyof Right]: EqualColCondition<Left[0], Left[1], Left[2], Left[3], Right[RightKey][0], Right[RightKey][1], Right[RightKey][2], Right[RightKey][3]> }[keyof Right] | GreaterEqualValCondition<Left[0], Left[1], Left[2], Left[3], Left[3]["ValType"] | (TArg extends true ? Arg<Left[3]["ValType"]> : never)> | { [RightKey in keyof Right]: GreaterEqualColCondition<Left[0], Left[1], Left[2], Left[3], Right[RightKey][0], Right[RightKey][1], Right[RightKey][2], Right[RightKey][3]> }[keyof Right] | GreaterThanValCondition<Left[0], Left[1], Left[2], Left[3], Left[3]["ValType"] | (TArg extends true ? Arg<Left[3]["ValType"]> : never)> | { [RightKey in keyof Right]: GreaterThanColCondition<Left[0], Left[1], Left[2], Left[3], Right[RightKey][0], Right[RightKey][1], Right[RightKey][2], Right[RightKey][3]> }[keyof Right] | LessThanValCondition<Left[0], Left[1], Left[2], Left[3], Left[3]["ValType"] | (TArg extends true ? Arg<Left[3]["ValType"]> : never)> | { [RightKey in keyof Right]: LessThanColCondition<Left[0], Left[1], Left[2], Left[3], Right[RightKey][0], Right[RightKey][1], Right[RightKey][2], Right[RightKey][3]> }[keyof Right] | LessEqualValCondition<Left[0], Left[1], Left[2], Left[3], Left[3]["ValType"] | (TArg extends true ? Arg<Left[3]["ValType"]> : never)> | { [RightKey in keyof Right]: LessEqualColCondition<Left[0], Left[1], Left[2], Left[3], Right[RightKey][0], Right[RightKey][1], Right[RightKey][2], Right[RightKey][3]> }[keyof Right] | IsNullCondition<Left[0], Left[1], Left[2], Left[3]> | InCondition<Left[0], Left[1], Left[2], Left[3], TArg>;

package/dist/src/index.d.mts

@@ -1,11 +1,7 @@
 import { DurcnoLogger } from "./logger.mjs";
-import { Sql, sql } from "./sql.mjs";
-import { Column, ColumnConfig, notNull, primaryKey, unique } from "./columns/common.mjs";
-import { PrimaryKeyConstraint, primaryKeyConstraint } from "./constraints/primary-key.mjs";
-import { UniqueConstraint, uniqueConstraint } from "./constraints/unique.mjs";
-import { index, uniqueIndex } from "./indexes.mjs";
-import { AnyColumn, AnyTableColumn, Table, TableColumn, fk, many, one, relations, table } from "./table.mjs";
+import { Query } from "./query-builders/query.mjs";
 import { asc, desc } from "./query-builders/orderby-clause.mjs";
+import { Sql, sql } from "./sql.mjs";
 import { Filter } from "./filters/custom.mjs";
 import { and, eq, gt, gte, isIn, isNotNull, isNull, lt, lte, ne, or } from "./filters/index.mjs";
 import { Sequence, SequenceOptions, sequence } from "./sequence.mjs";
@@ -33,13 +29,17 @@ import { time } from "./columns/time.mjs";
 import { timestamp } from "./columns/timestamp.mjs";
 import { UuidVersion, uuid } from "./columns/uuid.mjs";
 import { varchar } from "./columns/varchar.mjs";
+import { PrimaryKeyConstraint, primaryKeyConstraint } from "./constraints/primary-key.mjs";
+import { UniqueConstraint, uniqueConstraint } from "./constraints/unique.mjs";
 import { arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps } from "./filters/array.mjs";
 import { now, uuidv4, uuidv7 } from "./functions/index.mjs";
+import { index, uniqueIndex } from "./indexes.mjs";
 import { Migrations, pk } from "./models.mjs";
 import { database } from "./db.mjs";
 import { Arg, prequery } from "./query-builders/pre.mjs";
-import { Query } from "./query-builders/query.mjs";
-import { Connector, ConnectorOptions } from "./connectors/common.mjs";
+import { Column, ColumnConfig, notNull, primaryKey, unique } from "./columns/common.mjs";
+import { AnyColumn, AnyTableColumn, Table, TableColumn, fk, many, one, relations, table } from "./table.mjs";
+import { $Client, Connector, ConnectorOptions } from "./connectors/common.mjs";
 
 //#region src/index.d.ts
 declare const $: {
@@ -101,4 +101,4 @@ declare global {
   type Prettify<T> = { [K in keyof T]: T[K] } & {};
 }
 //#endregion
-export { $, type AnyColumn, type AnyTableColumn, Arg, Column, type ColumnConfig, Config, type ConnectorOptions, type DurcnoLogger, Filter, Migrations, PrimaryKeyConstraint, Query, Sql, type TableColumn, UniqueConstraint, type UuidVersion, and, arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps, asc, bigint, bigserial, boolean, bytea, char, cidr, database, date, defineConfig, desc, enumed, enumtype, eq, fk, geography, gt, gte, index, inet, integer, isIn, isNotNull, isNull, json, jsonb, lt, lte, macaddr, many, ne, notNull, now, numeric, one, or, pk, prequery, primaryKey, primaryKeyConstraint, relations, sequence, serial, smallint, smallserial, sql, table, text, time, timestamp, unique, uniqueConstraint, uniqueIndex, uuid, uuidv4, uuidv7, varchar };
+export { $, type $Client, type AnyColumn, type AnyTableColumn, Arg, Column, type ColumnConfig, Config, type ConnectorOptions, type DurcnoLogger, Filter, Migrations, PrimaryKeyConstraint, Query, Sql, type TableColumn, UniqueConstraint, type UuidVersion, and, arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps, asc, bigint, bigserial, boolean, bytea, char, cidr, database, date, defineConfig, desc, enumed, enumtype, eq, fk, geography, gt, gte, index, inet, integer, isIn, isNotNull, isNull, json, jsonb, lt, lte, macaddr, many, ne, notNull, now, numeric, one, or, pk, prequery, primaryKey, primaryKeyConstraint, relations, sequence, serial, smallint, smallserial, sql, table, text, time, timestamp, unique, uniqueConstraint, uniqueIndex, uuid, uuidv4, uuidv7, varchar };

package/dist/src/migration/ddl/enum.d.mts

@@ -0,0 +1,100 @@
+import { Snapshot } from "../snapshot.mjs";
+import { DDLStatement } from "./statement.mjs";
+
+//#region src/migration/ddl/enum.d.ts
+/**
+ * DDL statement that creates a new PostgreSQL enum type.
+ *
+ * Generates: `CREATE TYPE "schema"."name" AS ENUM('val1', 'val2', ...);`
+ *
+ * @deprecated Use {@link CreateTypeStatement} via `ddl.createType()` instead.
+ *
+ * @example
+ * ```typescript
+ * ddl.createEnum('public', 'user_type', ['admin', 'user', 'guest']);
+ * // CREATE TYPE "public"."user_type" AS ENUM('admin', 'user', 'guest');
+ * ```
+ */
+declare class CreateEnumStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  private readonly values;
+  readonly type: "createEnum";
+  /**
+   * @param schema - The schema the enum belongs to.
+   * @param name - The name of the enum type to create.
+   * @param values - Ordered list of allowed enum values.
+   */
+  constructor(schema: string, name: string, values: string[]);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that adds a value to an existing PostgreSQL enum type.
+ *
+ * Generates: `ALTER TYPE "schema"."name" ADD VALUE IF NOT EXISTS 'value' [AFTER|BEFORE 'ref'];`
+ *
+ * @remarks
+ * PostgreSQL does not support removing values from an enum.
+ * Values can only be added, optionally positioned relative to an existing value.
+ *
+ * @deprecated Use {@link AlterTypeBuilder} via `ddl.alterType()` instead.
+ *
+ * @example
+ * ```typescript
+ * // Append a value
+ * ddl.alterEnumAddValue('public', 'user_type', 'moderator');
+ *
+ * // Insert after a specific value
+ * ddl.alterEnumAddValue('public', 'user_type', 'moderator', { after: 'admin' });
+ *
+ * // Insert before a specific value
+ * ddl.alterEnumAddValue('public', 'user_type', 'moderator', { before: 'user' });
+ * ```
+ */
+declare class AlterEnumAddValueStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  private readonly value;
+  private readonly position?;
+  readonly type: "alterEnum";
+  /**
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name.
+   * @param value - The new value to add.
+   * @param position - Optional positioning: `{ after: 'val' }` or `{ before: 'val' }`.
+   */
+  constructor(schema: string, name: string, value: string, position?: {
+    after?: string;
+    before?: string;
+  } | undefined);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * DDL statement that drops an existing PostgreSQL enum type.
+ *
+ * Generates: `DROP TYPE "schema"."name";`
+ *
+ * @deprecated Use {@link DropTypeStatement} via `ddl.dropType()` instead.
+ *
+ * @example
+ * ```typescript
+ * ddl.dropEnum('public', 'user_type');
+ * // DROP TYPE "public"."user_type";
+ * ```
+ */
+declare class DropEnumStatement extends DDLStatement {
+  private readonly schema;
+  private readonly name;
+  readonly type: "dropEnum";
+  /**
+   * @param schema - The schema the enum belongs to.
+   * @param name - The enum type name to drop.
+   */
+  constructor(schema: string, name: string);
+  toSQL(): string;
+  applyToSnapshot(snapshot: Snapshot): void;
+}
+//#endregion
+export { AlterEnumAddValueStatement, CreateEnumStatement, DropEnumStatement };

package/dist/src/migration/ddl/enum.mjs

@@ -0,0 +1,138 @@
+import { DDLStatement } from "./statement.mjs";
+//#region src/migration/ddl/enum.ts
+/**
+* DDL statement that creates a new PostgreSQL enum type.
+*
+* Generates: `CREATE TYPE "schema"."name" AS ENUM('val1', 'val2', ...);`
+*
+* @deprecated Use {@link CreateTypeStatement} via `ddl.createType()` instead.
+*
+* @example
+* ```typescript
+* ddl.createEnum('public', 'user_type', ['admin', 'user', 'guest']);
+* // CREATE TYPE "public"."user_type" AS ENUM('admin', 'user', 'guest');
+* ```
+*/
+var CreateEnumStatement = class extends DDLStatement {
+	type = "createEnum";
+	/**
+	* @param schema - The schema the enum belongs to.
+	* @param name - The name of the enum type to create.
+	* @param values - Ordered list of allowed enum values.
+	*/
+	constructor(schema, name, values) {
+		super();
+		this.schema = schema;
+		this.name = name;
+		this.values = values;
+	}
+	toSQL() {
+		return `CREATE TYPE ${`"${this.schema}"."${this.name}"`} AS ENUM(${this.values.map((v) => `'${v}'`).join(", ")});`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		snapshot.enums[key] = {
+			schema: this.schema,
+			name: this.name,
+			values: [...this.values]
+		};
+	}
+};
+/**
+* DDL statement that adds a value to an existing PostgreSQL enum type.
+*
+* Generates: `ALTER TYPE "schema"."name" ADD VALUE IF NOT EXISTS 'value' [AFTER|BEFORE 'ref'];`
+*
+* @remarks
+* PostgreSQL does not support removing values from an enum.
+* Values can only be added, optionally positioned relative to an existing value.
+*
+* @deprecated Use {@link AlterTypeBuilder} via `ddl.alterType()` instead.
+*
+* @example
+* ```typescript
+* // Append a value
+* ddl.alterEnumAddValue('public', 'user_type', 'moderator');
+*
+* // Insert after a specific value
+* ddl.alterEnumAddValue('public', 'user_type', 'moderator', { after: 'admin' });
+*
+* // Insert before a specific value
+* ddl.alterEnumAddValue('public', 'user_type', 'moderator', { before: 'user' });
+* ```
+*/
+var AlterEnumAddValueStatement = class extends DDLStatement {
+	type = "alterEnum";
+	/**
+	* @param schema - The schema the enum belongs to.
+	* @param name - The enum type name.
+	* @param value - The new value to add.
+	* @param position - Optional positioning: `{ after: 'val' }` or `{ before: 'val' }`.
+	*/
+	constructor(schema, name, value, position) {
+		super();
+		this.schema = schema;
+		this.name = name;
+		this.value = value;
+		this.position = position;
+	}
+	toSQL() {
+		let sql = `ALTER TYPE ${`"${this.schema}"."${this.name}"`} ADD VALUE IF NOT EXISTS '${this.value}'`;
+		if (this.position?.after) sql += ` AFTER '${this.position.after}'`;
+		else if (this.position?.before) sql += ` BEFORE '${this.position.before}'`;
+		return `${sql};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		const enm = snapshot.enums[key];
+		if (!enm) return;
+		if (this.position?.after) {
+			const afterIdx = enm.values.indexOf(this.position.after);
+			if (afterIdx !== -1) {
+				enm.values.splice(afterIdx + 1, 0, this.value);
+				return;
+			}
+		} else if (this.position?.before) {
+			const beforeIdx = enm.values.indexOf(this.position.before);
+			if (beforeIdx !== -1) {
+				enm.values.splice(beforeIdx, 0, this.value);
+				return;
+			}
+		}
+		enm.values.push(this.value);
+	}
+};
+/**
+* DDL statement that drops an existing PostgreSQL enum type.
+*
+* Generates: `DROP TYPE "schema"."name";`
+*
+* @deprecated Use {@link DropTypeStatement} via `ddl.dropType()` instead.
+*
+* @example
+* ```typescript
+* ddl.dropEnum('public', 'user_type');
+* // DROP TYPE "public"."user_type";
+* ```
+*/
+var DropEnumStatement = class extends DDLStatement {
+	type = "dropEnum";
+	/**
+	* @param schema - The schema the enum belongs to.
+	* @param name - The enum type name to drop.
+	*/
+	constructor(schema, name) {
+		super();
+		this.schema = schema;
+		this.name = name;
+	}
+	toSQL() {
+		return `DROP TYPE ${`"${this.schema}"."${this.name}"`};`;
+	}
+	applyToSnapshot(snapshot) {
+		const key = `${this.schema}.${this.name}`;
+		delete snapshot.enums[key];
+	}
+};
+//#endregion
+export { AlterEnumAddValueStatement, CreateEnumStatement, DropEnumStatement };