pgterra 0.2.11 → 0.2.13

package/dist/index.js

@@ -17322,19 +17322,19 @@ var require_utils = __commonJS((exports, module) => {
       ret += " BC";
     return ret;
   }
-  function normalizeQueryConfig(config, values, callback) {
-    config = typeof config === "string" ? { text: config } : config;
+  function normalizeQueryConfig(config6, values, callback) {
+    config6 = typeof config6 === "string" ? { text: config6 } : config6;
     if (values) {
       if (typeof values === "function") {
-        config.callback = values;
+        config6.callback = values;
       } else {
-        config.values = values;
+        config6.values = values;
       }
     }
     if (callback) {
-      config.callback = callback;
+      config6.callback = callback;
     }
-    return config;
+    return config6;
   }
   var escapeIdentifier = function(str) {
     return '"' + str.replace(/"/g, '""') + '"';
@@ -17775,10 +17775,10 @@ var require_type_overrides = __commonJS((exports, module) => {
 var require_pg_connection_string = __commonJS((exports, module) => {
   function parse2(str, options = {}) {
     if (str.charAt(0) === "/") {
-      const config2 = str.split(" ");
-      return { host: config2[0], database: config2[1] };
+      const config7 = str.split(" ");
+      return { host: config7[0], database: config7[1] };
     }
-    const config = {};
+    const config6 = {};
     let result;
     let dummyHost = false;
     if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
@@ -17791,72 +17791,72 @@ var require_pg_connection_string = __commonJS((exports, module) => {
       dummyHost = true;
     }
     for (const entry of result.searchParams.entries()) {
-      config[entry[0]] = entry[1];
+      config6[entry[0]] = entry[1];
     }
-    config.user = config.user || decodeURIComponent(result.username);
-    config.password = config.password || decodeURIComponent(result.password);
+    config6.user = config6.user || decodeURIComponent(result.username);
+    config6.password = config6.password || decodeURIComponent(result.password);
     if (result.protocol == "socket:") {
-      config.host = decodeURI(result.pathname);
-      config.database = result.searchParams.get("db");
-      config.client_encoding = result.searchParams.get("encoding");
-      return config;
+      config6.host = decodeURI(result.pathname);
+      config6.database = result.searchParams.get("db");
+      config6.client_encoding = result.searchParams.get("encoding");
+      return config6;
     }
     const hostname = dummyHost ? "" : result.hostname;
-    if (!config.host) {
-      config.host = decodeURIComponent(hostname);
+    if (!config6.host) {
+      config6.host = decodeURIComponent(hostname);
     } else if (hostname && /^%2f/i.test(hostname)) {
       result.pathname = hostname + result.pathname;
     }
-    if (!config.port) {
-      config.port = result.port;
+    if (!config6.port) {
+      config6.port = result.port;
     }
     const pathname = result.pathname.slice(1) || null;
-    config.database = pathname ? decodeURI(pathname) : null;
-    if (config.ssl === "true" || config.ssl === "1") {
-      config.ssl = true;
+    config6.database = pathname ? decodeURI(pathname) : null;
+    if (config6.ssl === "true" || config6.ssl === "1") {
+      config6.ssl = true;
     }
-    if (config.ssl === "0") {
-      config.ssl = false;
+    if (config6.ssl === "0") {
+      config6.ssl = false;
     }
-    if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) {
-      config.ssl = {};
+    if (config6.sslcert || config6.sslkey || config6.sslrootcert || config6.sslmode) {
+      config6.ssl = {};
     }
-    const fs = config.sslcert || config.sslkey || config.sslrootcert ? __require("fs") : null;
-    if (config.sslcert) {
-      config.ssl.cert = fs.readFileSync(config.sslcert).toString();
+    const fs = config6.sslcert || config6.sslkey || config6.sslrootcert ? __require("fs") : null;
+    if (config6.sslcert) {
+      config6.ssl.cert = fs.readFileSync(config6.sslcert).toString();
     }
-    if (config.sslkey) {
-      config.ssl.key = fs.readFileSync(config.sslkey).toString();
+    if (config6.sslkey) {
+      config6.ssl.key = fs.readFileSync(config6.sslkey).toString();
     }
-    if (config.sslrootcert) {
-      config.ssl.ca = fs.readFileSync(config.sslrootcert).toString();
+    if (config6.sslrootcert) {
+      config6.ssl.ca = fs.readFileSync(config6.sslrootcert).toString();
     }
-    if (options.useLibpqCompat && config.uselibpqcompat) {
+    if (options.useLibpqCompat && config6.uselibpqcompat) {
       throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
     }
-    if (config.uselibpqcompat === "true" || options.useLibpqCompat) {
-      switch (config.sslmode) {
+    if (config6.uselibpqcompat === "true" || options.useLibpqCompat) {
+      switch (config6.sslmode) {
         case "disable": {
-          config.ssl = false;
+          config6.ssl = false;
           break;
         }
         case "prefer": {
-          config.ssl.rejectUnauthorized = false;
+          config6.ssl.rejectUnauthorized = false;
           break;
         }
         case "require": {
-          if (config.sslrootcert) {
-            config.ssl.checkServerIdentity = function() {};
+          if (config6.sslrootcert) {
+            config6.ssl.checkServerIdentity = function() {};
           } else {
-            config.ssl.rejectUnauthorized = false;
+            config6.ssl.rejectUnauthorized = false;
           }
           break;
         }
         case "verify-ca": {
-          if (!config.ssl.ca) {
+          if (!config6.ssl.ca) {
             throw new Error("SECURITY WARNING: Using sslmode=verify-ca requires specifying a CA with sslrootcert. If a public CA is used, verify-ca allows connections to a server that somebody else may have registered with the CA, making you vulnerable to Man-in-the-Middle attacks. Either specify a custom CA certificate with sslrootcert parameter or use sslmode=verify-full for proper security.");
           }
-          config.ssl.checkServerIdentity = function() {};
+          config6.ssl.checkServerIdentity = function() {};
           break;
         }
         case "verify-full": {
@@ -17864,9 +17864,9 @@ var require_pg_connection_string = __commonJS((exports, module) => {
         }
       }
     } else {
-      switch (config.sslmode) {
+      switch (config6.sslmode) {
         case "disable": {
-          config.ssl = false;
+          config6.ssl = false;
           break;
         }
         case "prefer":
@@ -17876,12 +17876,12 @@ var require_pg_connection_string = __commonJS((exports, module) => {
           break;
         }
         case "no-verify": {
-          config.ssl.rejectUnauthorized = false;
+          config6.ssl.rejectUnauthorized = false;
           break;
         }
       }
     }
-    return config;
+    return config6;
   }
   function toConnectionOptions(sslConfig) {
     const connectionOptions = Object.entries(sslConfig).reduce((c, [key, value]) => {
@@ -17892,8 +17892,8 @@ var require_pg_connection_string = __commonJS((exports, module) => {
     }, {});
     return connectionOptions;
   }
-  function toClientConfig(config) {
-    const poolConfig = Object.entries(config).reduce((c, [key, value]) => {
+  function toClientConfig(config6) {
+    const poolConfig = Object.entries(config6).reduce((c, [key, value]) => {
       if (key === "ssl") {
         const sslConfig = value;
         if (typeof sslConfig === "boolean") {
@@ -17933,13 +17933,13 @@ var require_connection_parameters = __commonJS((exports, module) => {
   var dns = __require("dns");
   var defaults = require_defaults();
   var parse2 = require_pg_connection_string().parse;
-  var val = function(key, config, envVar) {
+  var val = function(key, config6, envVar) {
     if (envVar === undefined) {
       envVar = process.env["PG" + key.toUpperCase()];
     } else if (envVar === false) {} else {
       envVar = process.env[envVar];
     }
-    return config[key] || envVar || defaults[key];
+    return config6[key] || envVar || defaults[key];
   };
   var readSSLConfigFromEnvironment = function() {
     switch (process.env.PGSSLMODE) {
@@ -17958,35 +17958,35 @@ var require_connection_parameters = __commonJS((exports, module) => {
   var quoteParamValue = function(value) {
     return "'" + ("" + value).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
   };
-  var add = function(params, config, paramName) {
-    const value = config[paramName];
+  var add = function(params, config6, paramName) {
+    const value = config6[paramName];
     if (value !== undefined && value !== null) {
       params.push(paramName + "=" + quoteParamValue(value));
     }
   };
 
   class ConnectionParameters {
-    constructor(config) {
-      config = typeof config === "string" ? parse2(config) : config || {};
-      if (config.connectionString) {
-        config = Object.assign({}, config, parse2(config.connectionString));
+    constructor(config6) {
+      config6 = typeof config6 === "string" ? parse2(config6) : config6 || {};
+      if (config6.connectionString) {
+        config6 = Object.assign({}, config6, parse2(config6.connectionString));
       }
-      this.user = val("user", config);
-      this.database = val("database", config);
+      this.user = val("user", config6);
+      this.database = val("database", config6);
       if (this.database === undefined) {
         this.database = this.user;
       }
-      this.port = parseInt(val("port", config), 10);
-      this.host = val("host", config);
+      this.port = parseInt(val("port", config6), 10);
+      this.host = val("host", config6);
       Object.defineProperty(this, "password", {
         configurable: true,
         enumerable: false,
         writable: true,
-        value: val("password", config)
+        value: val("password", config6)
       });
-      this.binary = val("binary", config);
-      this.options = val("options", config);
-      this.ssl = typeof config.ssl === "undefined" ? readSSLConfigFromEnvironment() : config.ssl;
+      this.binary = val("binary", config6);
+      this.options = val("options", config6);
+      this.ssl = typeof config6.ssl === "undefined" ? readSSLConfigFromEnvironment() : config6.ssl;
       if (typeof this.ssl === "string") {
         if (this.ssl === "true") {
           this.ssl = true;
@@ -18000,27 +18000,27 @@ var require_connection_parameters = __commonJS((exports, module) => {
           enumerable: false
         });
       }
-      this.client_encoding = val("client_encoding", config);
-      this.replication = val("replication", config);
+      this.client_encoding = val("client_encoding", config6);
+      this.replication = val("replication", config6);
       this.isDomainSocket = !(this.host || "").indexOf("/");
-      this.application_name = val("application_name", config, "PGAPPNAME");
-      this.fallback_application_name = val("fallback_application_name", config, false);
-      this.statement_timeout = val("statement_timeout", config, false);
-      this.lock_timeout = val("lock_timeout", config, false);
-      this.idle_in_transaction_session_timeout = val("idle_in_transaction_session_timeout", config, false);
-      this.query_timeout = val("query_timeout", config, false);
-      if (config.connectionTimeoutMillis === undefined) {
+      this.application_name = val("application_name", config6, "PGAPPNAME");
+      this.fallback_application_name = val("fallback_application_name", config6, false);
+      this.statement_timeout = val("statement_timeout", config6, false);
+      this.lock_timeout = val("lock_timeout", config6, false);
+      this.idle_in_transaction_session_timeout = val("idle_in_transaction_session_timeout", config6, false);
+      this.query_timeout = val("query_timeout", config6, false);
+      if (config6.connectionTimeoutMillis === undefined) {
         this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0;
       } else {
-        this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1000);
+        this.connect_timeout = Math.floor(config6.connectionTimeoutMillis / 1000);
       }
-      if (config.keepAlive === false) {
+      if (config6.keepAlive === false) {
         this.keepalives = 0;
-      } else if (config.keepAlive === true) {
+      } else if (config6.keepAlive === true) {
         this.keepalives = 1;
       }
-      if (typeof config.keepAliveInitialDelayMillis === "number") {
-        this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1000);
+      if (typeof config6.keepAliveInitialDelayMillis === "number") {
+        this.keepalives_idle = Math.floor(config6.keepAliveInitialDelayMillis / 1000);
       }
     }
     getLibpqConnectionString(cb) {
@@ -18158,21 +18158,21 @@ var require_query = __commonJS((exports, module) => {
   var utils = require_utils();
 
   class Query extends EventEmitter {
-    constructor(config, values, callback) {
+    constructor(config6, values, callback) {
       super();
-      config = utils.normalizeQueryConfig(config, values, callback);
-      this.text = config.text;
-      this.values = config.values;
-      this.rows = config.rows;
-      this.types = config.types;
-      this.name = config.name;
-      this.queryMode = config.queryMode;
-      this.binary = config.binary;
-      this.portal = config.portal || "";
-      this.callback = config.callback;
-      this._rowMode = config.rowMode;
-      if (process.domain && config.callback) {
-        this.callback = process.domain.bind(config.callback);
+      config6 = utils.normalizeQueryConfig(config6, values, callback);
+      this.text = config6.text;
+      this.values = config6.values;
+      this.rows = config6.rows;
+      this.types = config6.types;
+      this.name = config6.name;
+      this.queryMode = config6.queryMode;
+      this.binary = config6.binary;
+      this.portal = config6.portal || "";
+      this.callback = config6.callback;
+      this._rowMode = config6.rowMode;
+      if (process.domain && config6.callback) {
+        this.callback = process.domain.bind(config6.callback);
       }
       this._result = new Result(this._rowMode, this.types);
       this._results = this._result;
@@ -18661,27 +18661,27 @@ var require_serializer = __commonJS((exports) => {
       }
     }
   };
-  var bind = (config = {}) => {
-    const portal = config.portal || "";
-    const statement = config.statement || "";
-    const binary = config.binary || false;
-    const values = config.values || emptyArray;
+  var bind = (config6 = {}) => {
+    const portal = config6.portal || "";
+    const statement = config6.statement || "";
+    const binary = config6.binary || false;
+    const values = config6.values || emptyArray;
     const len = values.length;
     writer.addCString(portal).addCString(statement);
     writer.addInt16(len);
-    writeValues(values, config.valueMapper);
+    writeValues(values, config6.valueMapper);
     writer.addInt16(len);
     writer.add(paramWriter.flush());
     writer.addInt16(binary ? 1 : 0);
     return writer.flush(66);
   };
   var emptyExecute = Buffer.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]);
-  var execute = (config) => {
-    if (!config || !config.portal && !config.rows) {
+  var execute = (config6) => {
+    if (!config6 || !config6.portal && !config6.rows) {
       return emptyExecute;
     }
-    const portal = config.portal || "";
-    const rows = config.rows || 0;
+    const portal = config6.portal || "";
+    const rows = config6.rows || 0;
     const portalLength = Buffer.byteLength(portal);
     const len = 4 + portalLength + 1 + 4;
     const buff = Buffer.allocUnsafe(1 + len);
@@ -19337,18 +19337,18 @@ var require_connection = __commonJS((exports, module) => {
   var endBuffer = serialize.end();
 
   class Connection extends EventEmitter {
-    constructor(config) {
+    constructor(config6) {
       super();
-      config = config || {};
-      this.stream = config.stream || getStream(config.ssl);
+      config6 = config6 || {};
+      this.stream = config6.stream || getStream(config6.ssl);
       if (typeof this.stream === "function") {
-        this.stream = this.stream(config);
+        this.stream = this.stream(config6);
       }
-      this._keepAlive = config.keepAlive;
-      this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis;
+      this._keepAlive = config6.keepAlive;
+      this._keepAliveInitialDelayMillis = config6.keepAliveInitialDelayMillis;
       this.lastBuffer = false;
       this.parsedStatements = {};
-      this.ssl = config.ssl || false;
+      this.ssl = config6.ssl || false;
       this._ending = false;
       this._emitMessage = false;
       const self = this;
@@ -19429,8 +19429,8 @@ var require_connection = __commonJS((exports, module) => {
     requestSsl() {
       this.stream.write(serialize.requestSsl());
     }
-    startup(config) {
-      this.stream.write(serialize.startup(config));
+    startup(config6) {
+      this.stream.write(serialize.startup(config6));
     }
     cancel(processID, secretKey) {
       this._send(serialize.cancel(processID, secretKey));
@@ -19456,11 +19456,11 @@ var require_connection = __commonJS((exports, module) => {
     parse(query) {
       this._send(serialize.parse(query));
     }
-    bind(config) {
-      this._send(serialize.bind(config));
+    bind(config6) {
+      this._send(serialize.bind(config6));
     }
-    execute(config) {
-      this._send(serialize.execute(config));
+    execute(config6) {
+      this._send(serialize.execute(config6));
     }
     flush() {
       if (this.stream.writable) {
@@ -19800,9 +19800,9 @@ var require_client = __commonJS((exports, module) => {
   var crypto = require_utils2();
 
   class Client extends EventEmitter {
-    constructor(config) {
+    constructor(config6) {
       super();
-      this.connectionParameters = new ConnectionParameters(config);
+      this.connectionParameters = new ConnectionParameters(config6);
       this.user = this.connectionParameters.user;
       this.database = this.connectionParameters.database;
       this.port = this.connectionParameters.port;
@@ -19814,7 +19814,7 @@ var require_client = __commonJS((exports, module) => {
         value: this.connectionParameters.password
       });
       this.replication = this.connectionParameters.replication;
-      const c = config || {};
+      const c = config6 || {};
       this._Promise = c.Promise || global.Promise;
       this._types = new TypeOverrides(c.types);
       this._ending = false;
@@ -20194,23 +20194,23 @@ var require_client = __commonJS((exports, module) => {
         }
       }
     }
-    query(config, values, callback) {
+    query(config6, values, callback) {
       let query;
       let result;
       let readTimeout;
       let readTimeoutTimer;
       let queryCallback;
-      if (config === null || config === undefined) {
+      if (config6 === null || config6 === undefined) {
         throw new TypeError("Client was passed a null or undefined query");
-      } else if (typeof config.submit === "function") {
-        readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
-        result = query = config;
+      } else if (typeof config6.submit === "function") {
+        readTimeout = config6.query_timeout || this.connectionParameters.query_timeout;
+        result = query = config6;
         if (typeof values === "function") {
           query.callback = query.callback || values;
         }
       } else {
-        readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
-        query = new Query(config, values, callback);
+        readTimeout = config6.query_timeout || this.connectionParameters.query_timeout;
+        query = new Query(config6, values, callback);
         if (!query.callback) {
           result = new this._Promise((resolve, reject) => {
             query.callback = (err, res) => err ? reject(err) : resolve(res);
@@ -20679,16 +20679,16 @@ var require_query2 = __commonJS((exports, module) => {
   var EventEmitter = __require("events").EventEmitter;
   var util = __require("util");
   var utils = require_utils();
-  var NativeQuery = module.exports = function(config, values, callback) {
+  var NativeQuery = module.exports = function(config6, values, callback) {
     EventEmitter.call(this);
-    config = utils.normalizeQueryConfig(config, values, callback);
-    this.text = config.text;
-    this.values = config.values;
-    this.name = config.name;
-    this.queryMode = config.queryMode;
-    this.callback = config.callback;
+    config6 = utils.normalizeQueryConfig(config6, values, callback);
+    this.text = config6.text;
+    this.values = config6.values;
+    this.name = config6.name;
+    this.queryMode = config6.queryMode;
+    this.callback = config6.callback;
     this.state = "new";
-    this._arrayMode = config.rowMode === "array";
+    this._arrayMode = config6.rowMode === "array";
     this._emitRowEvents = false;
     this.on("newListener", function(event) {
       if (event === "row")
@@ -20823,11 +20823,11 @@ var require_client2 = __commonJS((exports, module) => {
   var util = __require("util");
   var ConnectionParameters = require_connection_parameters();
   var NativeQuery = require_query2();
-  var Client = module.exports = function(config) {
+  var Client = module.exports = function(config6) {
     EventEmitter.call(this);
-    config = config || {};
-    this._Promise = config.Promise || global.Promise;
-    this._types = new TypeOverrides(config.types);
+    config6 = config6 || {};
+    this._Promise = config6.Promise || global.Promise;
+    this._types = new TypeOverrides(config6.types);
     this.native = new Native({
       types: this._types
     });
@@ -20836,9 +20836,9 @@ var require_client2 = __commonJS((exports, module) => {
     this._connecting = false;
     this._connected = false;
     this._queryable = true;
-    const cp = this.connectionParameters = new ConnectionParameters(config);
-    if (config.nativeConnectionString)
-      cp.nativeConnectionString = config.nativeConnectionString;
+    const cp = this.connectionParameters = new ConnectionParameters(config6);
+    if (config6.nativeConnectionString)
+      cp.nativeConnectionString = config6.nativeConnectionString;
     this.user = cp.user;
     Object.defineProperty(this, "password", {
       configurable: true,
@@ -20917,23 +20917,23 @@ var require_client2 = __commonJS((exports, module) => {
       });
     });
   };
-  Client.prototype.query = function(config, values, callback) {
+  Client.prototype.query = function(config6, values, callback) {
     let query;
     let result;
     let readTimeout;
     let readTimeoutTimer;
     let queryCallback;
-    if (config === null || config === undefined) {
+    if (config6 === null || config6 === undefined) {
       throw new TypeError("Client was passed a null or undefined query");
-    } else if (typeof config.submit === "function") {
-      readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
-      result = query = config;
+    } else if (typeof config6.submit === "function") {
+      readTimeout = config6.query_timeout || this.connectionParameters.query_timeout;
+      result = query = config6;
       if (typeof values === "function") {
-        config.callback = values;
+        config6.callback = values;
       }
     } else {
-      readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
-      query = new NativeQuery(config, values, callback);
+      readTimeout = config6.query_timeout || this.connectionParameters.query_timeout;
+      query = new NativeQuery(config6, values, callback);
       if (!query.callback) {
         let resolveOut, rejectOut;
         result = new this._Promise((resolve, reject) => {
@@ -21475,6 +21475,7 @@ function parseCreateIndex(stmt) {
     const schema = stmt.relation?.schemaname || undefined;
     const indexParams = stmt.indexParams || [];
     const columns = [];
+    let opclasses;
     let expression;
     if (indexParams.length === 1 && indexParams[0].IndexElem?.expr) {
       expression = import_pgsql_parser3.deparseSync([indexParams[0].IndexElem.expr]).trim();
@@ -21484,6 +21485,14 @@ function parseCreateIndex(stmt) {
           const colName = param.IndexElem.name;
           if (colName) {
             columns.push(colName);
+            if (param.IndexElem.opclass && param.IndexElem.opclass.length > 0) {
+              const opclassName = param.IndexElem.opclass.map((node) => node.String?.sval).filter(Boolean).join(".");
+              if (opclassName) {
+                if (!opclasses)
+                  opclasses = {};
+                opclasses[colName] = opclassName;
+              }
+            }
           } else if (param.IndexElem.expr) {
             expression = import_pgsql_parser3.deparseSync([param.IndexElem.expr]).trim();
             break;
@@ -21553,6 +21562,7 @@ function parseCreateIndex(stmt) {
       tableName,
       schema,
       columns,
+      opclasses,
       type,
       unique,
       concurrent,
@@ -22846,6 +22856,22 @@ class DatabaseInspector {
             -- Expression index - no simple column names
             ARRAY[]::text[]
         END as column_names,
+        -- Get operator class names for each column (non-default only)
+        CASE
+          WHEN ix.indexprs IS NULL THEN
+            ARRAY(
+              SELECT
+                CASE
+                  WHEN opc.opcdefault THEN NULL
+                  ELSE opc.opcname
+                END
+              FROM unnest(ix.indclass) WITH ORDINALITY AS u(opcoid, ord)
+              JOIN pg_opclass opc ON opc.oid = u.opcoid
+              ORDER BY u.ord
+            )
+          ELSE
+            ARRAY[]::text[]
+        END as opclass_names,
         CASE
           WHEN ix.indpred IS NOT NULL THEN
             regexp_replace(
@@ -22874,19 +22900,32 @@ class DatabaseInspector {
         )
       ORDER BY i.indexname
       `, [tableName, tableSchema]);
-    return result.rows.map((row) => ({
-      name: row.index_name,
-      tableName: row.table_name,
-      schema: row.table_schema,
-      columns: row.column_names || [],
-      type: this.mapPostgreSQLIndexType(row.access_method),
-      unique: row.is_unique,
-      concurrent: false,
-      where: row.where_clause || undefined,
-      expression: row.has_expressions ? row.expression_def : undefined,
-      storageParameters: this.parseStorageOptions(row.storage_options),
-      tablespace: row.tablespace_name || undefined
-    }));
+    return result.rows.map((row) => {
+      const columns = row.column_names || [];
+      const opclassNames = row.opclass_names || [];
+      let opclasses;
+      for (let i = 0;i < columns.length; i++) {
+        if (opclassNames[i]) {
+          if (!opclasses)
+            opclasses = {};
+          opclasses[columns[i]] = opclassNames[i];
+        }
+      }
+      return {
+        name: row.index_name,
+        tableName: row.table_name,
+        schema: row.table_schema,
+        columns,
+        opclasses,
+        type: this.mapPostgreSQLIndexType(row.access_method),
+        unique: row.is_unique,
+        concurrent: false,
+        where: row.where_clause || undefined,
+        expression: row.has_expressions ? row.expression_def : undefined,
+        storageParameters: this.parseStorageOptions(row.storage_options),
+        tablespace: row.tablespace_name || undefined
+      };
+    });
   }
   parseStorageOptions(reloptions) {
     if (!reloptions || !Array.isArray(reloptions) || reloptions.length === 0) {
@@ -23688,6 +23727,30 @@ function normalizeDefault(value) {
   normalized = normalized.replace(/::[a-z_]+(\s+[a-z_]+)*(\([^)]*\))?$/i, "");
   return normalized.trim();
 }
+function normalizeExpression(expr) {
+  let normalized = expr.replace(/\s+/g, " ").trim().replace(/::[a-z_]+(\([^)]*\))?/gi, "").replace(/\(([a-z_][a-z0-9_]*)\)/gi, "$1");
+  while (/^\(.*\)$/.test(normalized)) {
+    const inner = normalized.slice(1, -1);
+    let depth = 0;
+    let balanced = true;
+    for (const char of inner) {
+      if (char === "(")
+        depth++;
+      if (char === ")")
+        depth--;
+      if (depth < 0) {
+        balanced = false;
+        break;
+      }
+    }
+    if (balanced && depth === 0) {
+      normalized = inner.trim();
+    } else {
+      break;
+    }
+  }
+  return normalized.replace(/\s+/g, " ").trim();
+}
 function columnsAreDifferent(desired, current) {
   const normalizedDesiredType = normalizeType(desired.type);
   const normalizedCurrentType = normalizeType(current.type);
@@ -23718,7 +23781,7 @@ function columnsAreDifferent(desired, current) {
     if (!desired.generated || !current.generated) {
       return true;
     }
-    if (desired.generated.always !== current.generated.always || desired.generated.stored !== current.generated.stored || desired.generated.expression !== current.generated.expression) {
+    if (desired.generated.always !== current.generated.always || desired.generated.stored !== current.generated.stored || normalizeExpression(desired.generated.expression) !== normalizeExpression(current.generated.expression)) {
       return true;
     }
   }
@@ -24073,94 +24136,10 @@ class DependencyResolver {
     return this.topologicalSort(true);
   }
   topologicalSortCreation() {
-    const inDegree = new Map;
-    for (const tableName of this.nodes.keys()) {
-      inDegree.set(tableName, 0);
-    }
-    for (const [tableName, node] of this.nodes) {
-      for (const dependency of node.dependencies) {
-        inDegree.set(tableName, (inDegree.get(tableName) || 0) + 1);
-      }
-    }
-    const result = [];
-    const queue = [];
-    for (const [tableName, degree] of inDegree) {
-      if (degree === 0) {
-        queue.push(tableName);
-      }
-    }
-    while (queue.length > 0) {
-      const current = queue.shift();
-      result.push(current);
-      const currentNode = this.nodes.get(current);
-      if (currentNode) {
-        for (const dependent of currentNode.dependents) {
-          const newDegree = (inDegree.get(dependent) || 0) - 1;
-          inDegree.set(dependent, newDegree);
-          if (newDegree === 0) {
-            queue.push(dependent);
-          }
-        }
-      }
-    }
-    if (result.length !== this.nodes.size) {
-      const cycles = this.getCircularDependencies();
-      if (cycles.length > 0) {
-        const cycleDescriptions = cycles.map((cycle) => cycle.join(" → ")).join(`
-  `);
-        throw new Error(`Circular dependency detected. Cannot resolve table creation order.
-` + `Detected cycles:
-  ${cycleDescriptions}
-` + `Tables involved in cycles cannot be created because they reference each other.`);
-      }
-      throw new Error(`Cannot resolve table creation order. ` + `Processed ${result.length} out of ${this.nodes.size} tables.`);
-    }
-    return result;
+    return this.topologicalSortCore(this.nodes, false, "creation");
   }
   topologicalSortDeletion() {
-    const inDegree = new Map;
-    for (const tableName of this.nodes.keys()) {
-      inDegree.set(tableName, 0);
-    }
-    for (const [tableName, node] of this.nodes) {
-      for (const dependent of node.dependents) {
-        inDegree.set(tableName, (inDegree.get(tableName) || 0) + 1);
-      }
-    }
-    const result = [];
-    const queue = [];
-    for (const [tableName, degree] of inDegree) {
-      if (degree === 0) {
-        queue.push(tableName);
-      }
-    }
-    while (queue.length > 0) {
-      const current = queue.shift();
-      result.push(current);
-      const currentNode = this.nodes.get(current);
-      if (currentNode) {
-        for (const dependency of currentNode.dependencies) {
-          const newDegree = (inDegree.get(dependency) || 0) - 1;
-          inDegree.set(dependency, newDegree);
-          if (newDegree === 0) {
-            queue.push(dependency);
-          }
-        }
-      }
-    }
-    if (result.length !== this.nodes.size) {
-      const cycles = this.getCircularDependencies();
-      if (cycles.length > 0) {
-        const cycleDescriptions = cycles.map((cycle) => cycle.join(" → ")).join(`
-  `);
-        throw new Error(`Circular dependency detected. Cannot resolve table deletion order.
-` + `Detected cycles:
-  ${cycleDescriptions}
-` + `Tables involved in cycles cannot be deleted in a valid order.`);
-      }
-      throw new Error(`Cannot resolve table deletion order. ` + `Processed ${result.length} out of ${this.nodes.size} tables.`);
-    }
-    return result;
+    return this.topologicalSortCore(this.nodes, true, "deletion");
   }
   topologicalSort(reverse) {
     return reverse ? this.topologicalSortDeletion() : this.topologicalSortCreation();
@@ -24250,7 +24229,7 @@ class DependencyResolver {
         }
       }
     }
-    const order = this.topologicalSortWithNodes(modifiedNodes, false);
+    const order = this.topologicalSortCore(modifiedNodes, false);
     return {
       order,
       foreignKeysToDefer
@@ -24299,13 +24278,13 @@ class DependencyResolver {
         }
       }
     }
-    const order = this.topologicalSortWithNodes(modifiedNodes, true);
+    const order = this.topologicalSortCore(modifiedNodes, true);
     return {
       order,
       foreignKeysToDefer: foreignKeysToDrop
     };
   }
-  topologicalSortWithNodes(nodes, reverse) {
+  topologicalSortCore(nodes, reverse, mode = "internal") {
     const inDegree = new Map;
     for (const tableName of nodes.keys()) {
       inDegree.set(tableName, 0);
@@ -24346,7 +24325,21 @@ class DependencyResolver {
       }
     }
     if (result.length !== nodes.size) {
-      throw new Error(`Internal error: topological sort failed even after removing cycle-forming edges. ` + `Processed ${result.length} out of ${nodes.size} tables.`);
+      if (mode === "internal") {
+        throw new Error(`Internal error: topological sort failed even after removing cycle-forming edges. ` + `Processed ${result.length} out of ${nodes.size} tables.`);
+      }
+      const cycles = this.getCircularDependencies();
+      if (cycles.length > 0) {
+        const cycleDescriptions = cycles.map((cycle) => cycle.join(" → ")).join(`
+  `);
+        const orderType2 = mode === "creation" ? "creation" : "deletion";
+        throw new Error(`Circular dependency detected. Cannot resolve table ${orderType2} order.
+` + `Detected cycles:
+  ${cycleDescriptions}
+` + `Tables involved in cycles cannot be ${mode === "creation" ? "created because they reference each other" : "deleted in a valid order"}.`);
+      }
+      const orderType = mode === "creation" ? "creation" : "deletion";
+      throw new Error(`Cannot resolve table ${orderType} order. ` + `Processed ${result.length} out of ${nodes.size} tables.`);
     }
     return result;
   }
@@ -24489,7 +24482,7 @@ class SchemaDiffer {
   }
   generateColumnModificationStatements(tableName, desiredColumn, currentColumn) {
     const statements = [];
-    const generatedChanging = (desiredColumn.generated || currentColumn.generated) && (!desiredColumn.generated || !currentColumn.generated || desiredColumn.generated.expression !== currentColumn.generated.expression || desiredColumn.generated.always !== currentColumn.generated.always || desiredColumn.generated.stored !== currentColumn.generated.stored);
+    const generatedChanging = (desiredColumn.generated || currentColumn.generated) && (!desiredColumn.generated || !currentColumn.generated || normalizeExpression(desiredColumn.generated.expression) !== normalizeExpression(currentColumn.generated.expression) || desiredColumn.generated.always !== currentColumn.generated.always || desiredColumn.generated.stored !== currentColumn.generated.stored);
     if (generatedChanging) {
       const dropSql = new SQLBuilder().p("ALTER TABLE").p(tableName).p("DROP COLUMN").ident(desiredColumn.name).p(";").build();
       statements.push(dropSql);
@@ -24694,6 +24687,16 @@ class SchemaDiffer {
       return false;
     if (index1.tablespace !== index2.tablespace)
       return false;
+    const opclasses1 = index1.opclasses || {};
+    const opclasses2 = index2.opclasses || {};
+    const opKeys1 = Object.keys(opclasses1);
+    const opKeys2 = Object.keys(opclasses2);
+    if (opKeys1.length !== opKeys2.length)
+      return false;
+    for (const key of opKeys1) {
+      if (opclasses1[key] !== opclasses2[key])
+        return false;
+    }
     const params1 = index1.storageParameters || {};
     const params2 = index2.storageParameters || {};
     const keys1 = Object.keys(params1);
@@ -24739,7 +24742,11 @@ class SchemaDiffer {
     if (index.expression) {
       builder.p(`(${index.expression})`);
     } else {
-      const quotedColumns = index.columns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
+      const quotedColumns = index.columns.map((col) => {
+        const quoted = `"${col.replace(/"/g, '""')}"`;
+        const opclass = index.opclasses?.[col];
+        return opclass ? `${quoted} ${opclass}` : quoted;
+      }).join(", ");
       builder.p(`(${quotedColumns})`);
     }
     if (index.where) {
@@ -24769,9 +24776,9 @@ class SchemaDiffer {
   }
   generateCheckConstraintStatements(tableName, desiredConstraints, currentConstraints) {
     const statements = [];
-    const normalizeExpression = (expr) => expr.replace(/\s+/g, " ").trim();
-    const currentMap = new Map(currentConstraints.map((c) => [normalizeExpression(c.expression), c]));
-    const desiredMap = new Map(desiredConstraints.map((c) => [normalizeExpression(c.expression), c]));
+    const normalizeExpression2 = (expr) => expr.replace(/\s+/g, " ").trim();
+    const currentMap = new Map(currentConstraints.map((c) => [normalizeExpression2(c.expression), c]));
+    const desiredMap = new Map(desiredConstraints.map((c) => [normalizeExpression2(c.expression), c]));
     for (const [key, constraint] of currentMap) {
       if (!desiredMap.has(key)) {
         if (constraint.name) {
@@ -24892,7 +24899,7 @@ class SchemaDiffer {
     return alterations;
   }
   collectColumnModificationAlterations(desiredColumn, currentColumn, alterations) {
-    const generatedChanging = (desiredColumn.generated || currentColumn.generated) && (!desiredColumn.generated || !currentColumn.generated || desiredColumn.generated.expression !== currentColumn.generated.expression || desiredColumn.generated.always !== currentColumn.generated.always || desiredColumn.generated.stored !== currentColumn.generated.stored);
+    const generatedChanging = (desiredColumn.generated || currentColumn.generated) && (!desiredColumn.generated || !currentColumn.generated || normalizeExpression(desiredColumn.generated.expression) !== normalizeExpression(currentColumn.generated.expression) || desiredColumn.generated.always !== currentColumn.generated.always || desiredColumn.generated.stored !== currentColumn.generated.stored);
     if (generatedChanging) {
       alterations.push({ type: "drop_column", columnName: desiredColumn.name });
       alterations.push({ type: "add_column", column: desiredColumn });
@@ -24950,9 +24957,9 @@ class SchemaDiffer {
     }
   }
   collectCheckConstraintAlterations(desiredConstraints, currentConstraints, alterations) {
-    const normalizeExpression = (expr) => expr.replace(/\s+/g, " ").trim();
-    const currentMap = new Map(currentConstraints.map((c) => [normalizeExpression(c.expression), c]));
-    const desiredMap = new Map(desiredConstraints.map((c) => [normalizeExpression(c.expression), c]));
+    const normalizeExpression2 = (expr) => expr.replace(/\s+/g, " ").trim();
+    const currentMap = new Map(currentConstraints.map((c) => [normalizeExpression2(c.expression), c]));
+    const desiredMap = new Map(desiredConstraints.map((c) => [normalizeExpression2(c.expression), c]));
     for (const [key, constraint] of currentMap) {
       if (!desiredMap.has(key) && constraint.name) {
         alterations.push({
@@ -25189,27 +25196,32 @@ class MigrationExecutor {
             spinner.stopAndPersist({ symbol: "✔", text: `Applied concurrent change (${elapsed}s)` });
           } catch (error2) {
             spinner.stopAndPersist({ symbol: "✗", text: "Failed to apply concurrent change" });
-            throw error2;
+            if (error2 && typeof error2 === "object" && "code" in error2) {
+              const pgError = error2;
+              throw new MigrationError(pgError.message || "Concurrent statement failed", statement, {
+                code: pgError.code,
+                detail: pgError.detail,
+                hint: pgError.hint,
+                position: pgError.position
+              });
+            }
+            throw new MigrationError(error2 instanceof Error ? error2.message : String(error2), statement);
           }
         }
       }
     } catch (error2) {
+      if (error2 instanceof MigrationError) {
+        throw error2;
+      }
       if (error2 && typeof error2 === "object" && "code" in error2) {
         const pgError = error2;
-        let failedStatement;
-        if (pgError.message) {
-          failedStatement = undefined;
-        }
-        throw new MigrationError(pgError.message || "Database migration failed", failedStatement, {
+        throw new MigrationError(pgError.message || "Database migration failed", undefined, {
           code: pgError.code,
           detail: pgError.detail,
           hint: pgError.hint,
           position: pgError.position
         });
       }
-      if (error2 instanceof MigrationError) {
-        throw error2;
-      }
       throw new MigrationError(error2 instanceof Error ? error2.message : String(error2));
     }
   }
@@ -25279,18 +25291,13 @@ class EnumHandler {
     }
     return { transactional, concurrent };
   }
-  async generateRemovalStatements(desiredEnums, currentEnums, client, schemas) {
+  generateRemovalStatements(desiredEnums, currentEnums) {
     const statements = [];
     const desiredEnumNames = new Set(desiredEnums.map((e) => e.name));
     for (const currentEnum of currentEnums) {
       if (!desiredEnumNames.has(currentEnum.name)) {
-        const isUsed = await this.isTypeUsed(currentEnum.name, client, schemas);
-        if (!isUsed) {
-          statements.push(generateDropTypeSQL(currentEnum.name, currentEnum.schema));
-          Logger.info(`Dropping unused ENUM type '${currentEnum.name}'`);
-        } else {
-          Logger.warning(`ENUM type '${currentEnum.name}' is not in schema but is still referenced by table columns. ` + `Cannot auto-drop. Remove column references first.`);
-        }
+        statements.push(generateDropTypeSQL(currentEnum.name, currentEnum.schema));
+        Logger.info(`Dropping ENUM type '${currentEnum.name}'`);
       }
     }
     return statements;
@@ -25328,14 +25335,6 @@ class EnumHandler {
     }
     return statements;
   }
-  async isTypeUsed(enumName, client, schemas) {
-    const result = await client.query(`
-      SELECT COUNT(*) as usage_count
-      FROM information_schema.columns
-      WHERE udt_name = $1 AND table_schema = ANY($2::text[])
-    `, [enumName, schemas]);
-    return parseInt(result.rows[0].usage_count) > 0;
-  }
 }
 // src/core/schema/handlers/extension-handler.ts
 class ExtensionHandler {
@@ -25380,72 +25379,77 @@ class ExtensionHandler {
     return builder.build() + ";";
   }
 }
-// src/core/schema/handlers/function-handler.ts
-class FunctionHandler {
-  generateStatements(desiredFunctions, currentFunctions) {
-    const statements = [];
-    const currentFunctionMap = new Map(currentFunctions.map((f) => [f.name, f]));
-    const desiredFunctionNames = new Set(desiredFunctions.map((f) => f.name));
-    for (const currentFunc of currentFunctions) {
-      if (!desiredFunctionNames.has(currentFunc.name)) {
-        statements.push(generateDropFunctionSQL(currentFunc));
-        Logger.info(`Dropping function '${currentFunc.name}'`);
-      }
-    }
-    for (const desiredFunc of desiredFunctions) {
-      const currentFunc = currentFunctionMap.get(desiredFunc.name);
-      if (!currentFunc) {
-        statements.push(generateCreateFunctionSQL(desiredFunc));
-        Logger.info(`Creating function '${desiredFunc.name}'`);
+// src/core/schema/handlers/base-handler.ts
+function generateStatements(desired, current, config) {
+  const statements = [];
+  const currentMap = new Map(current.map((obj) => [config.getKey(obj), obj]));
+  const desiredKeys = new Set(desired.map((obj) => config.getKey(obj)));
+  const getLogName = config.getLogName ?? config.getKey;
+  for (const curr of current) {
+    const shouldManage = config.shouldManage?.(curr) ?? true;
+    if (!desiredKeys.has(config.getKey(curr)) && shouldManage) {
+      statements.push(config.generateDrop(curr));
+      Logger.info(`Dropping ${config.name} '${getLogName(curr)}'`);
+    }
+  }
+  for (const des of desired) {
+    const key = config.getKey(des);
+    const curr = currentMap.get(key);
+    const shouldManage = config.shouldManage?.(curr ?? des) ?? true;
+    if (!shouldManage) {
+      Logger.info(`${config.name} '${getLogName(des)}' is owned by a table column, skipping`);
+      continue;
+    }
+    if (!curr) {
+      statements.push(config.generateCreate(des));
+      Logger.info(`Creating ${config.name} '${getLogName(des)}'`);
+    } else if (config.needsUpdate(des, curr)) {
+      if (config.generateUpdate) {
+        statements.push(config.generateUpdate(des));
       } else {
-        if (this.needsUpdate(desiredFunc, currentFunc)) {
-          statements.push(generateDropFunctionSQL(currentFunc));
-          statements.push(generateCreateFunctionSQL(desiredFunc));
-          Logger.info(`Updating function '${desiredFunc.name}'`);
-        } else {
-          Logger.info(`Function '${desiredFunc.name}' is up to date, skipping`);
-        }
+        statements.push(config.generateDrop(curr));
+        statements.push(config.generateCreate(des));
       }
+      Logger.info(`Updating ${config.name} '${getLogName(des)}'`);
+    } else {
+      Logger.info(`${config.name} '${getLogName(des)}' is up to date, skipping`);
     }
-    return statements;
   }
-  needsUpdate(desired, current) {
-    const normalizeBody = (body) => body.replace(/\s+/g, " ").trim();
-    return normalizeBody(desired.body) !== normalizeBody(current.body) || desired.returnType !== current.returnType || desired.language !== current.language || desired.volatility !== current.volatility;
+  return statements;
+}
+
+// src/core/schema/handlers/function-handler.ts
+function normalizeBody(body) {
+  return body.replace(/\s+/g, " ").trim();
+}
+var config = {
+  name: "function",
+  getKey: (f) => f.name,
+  generateDrop: generateDropFunctionSQL,
+  generateCreate: generateCreateFunctionSQL,
+  needsUpdate: (desired, current) => normalizeBody(desired.body) !== normalizeBody(current.body) || desired.returnType !== current.returnType || desired.language !== current.language || desired.volatility !== current.volatility
+};
+
+class FunctionHandler {
+  generateStatements(desiredFunctions, currentFunctions) {
+    return generateStatements(desiredFunctions, currentFunctions, config);
   }
 }
 // src/core/schema/handlers/procedure-handler.ts
+function normalizeBody2(body) {
+  return body.replace(/\s+/g, " ").trim();
+}
+var config2 = {
+  name: "procedure",
+  getKey: (p) => p.name,
+  generateDrop: generateDropProcedureSQL,
+  generateCreate: generateCreateProcedureSQL,
+  needsUpdate: (desired, current) => normalizeBody2(desired.body) !== normalizeBody2(current.body) || desired.language !== current.language
+};
+
 class ProcedureHandler {
   generateStatements(desiredProcedures, currentProcedures) {
-    const statements = [];
-    const currentProcedureMap = new Map(currentProcedures.map((p) => [p.name, p]));
-    const desiredProcedureNames = new Set(desiredProcedures.map((p) => p.name));
-    for (const currentProc of currentProcedures) {
-      if (!desiredProcedureNames.has(currentProc.name)) {
-        statements.push(generateDropProcedureSQL(currentProc));
-        Logger.info(`Dropping procedure '${currentProc.name}'`);
-      }
-    }
-    for (const desiredProc of desiredProcedures) {
-      const currentProc = currentProcedureMap.get(desiredProc.name);
-      if (!currentProc) {
-        statements.push(generateCreateProcedureSQL(desiredProc));
-        Logger.info(`Creating procedure '${desiredProc.name}'`);
-      } else {
-        if (this.needsUpdate(desiredProc, currentProc)) {
-          statements.push(generateDropProcedureSQL(currentProc));
-          statements.push(generateCreateProcedureSQL(desiredProc));
-          Logger.info(`Updating procedure '${desiredProc.name}'`);
-        } else {
-          Logger.info(`Procedure '${desiredProc.name}' is up to date, skipping`);
-        }
-      }
-    }
-    return statements;
-  }
-  needsUpdate(desired, current) {
-    const normalizeBody = (body) => body.replace(/\s+/g, " ").trim();
-    return normalizeBody(desired.body) !== normalizeBody(current.body) || desired.language !== current.language;
+    return generateStatements(desiredProcedures, currentProcedures, config2);
   }
 }
 // src/core/schema/handlers/schema-handler.ts
@@ -25473,123 +25477,51 @@ class SchemaHandler {
   }
 }
 // src/core/schema/handlers/sequence-handler.ts
+var config3 = {
+  name: "sequence",
+  getKey: (s) => s.name,
+  generateDrop: (s) => generateDropSequenceSQL(s.name),
+  generateCreate: generateCreateSequenceSQL,
+  shouldManage: (s) => !s.ownedBy,
+  needsUpdate: (desired, current) => desired.increment !== current.increment || desired.minValue !== current.minValue || desired.maxValue !== current.maxValue || desired.start !== current.start || desired.cache !== current.cache || desired.cycle !== current.cycle
+};
+
 class SequenceHandler {
   generateStatements(desiredSequences, currentSequences) {
-    const statements = [];
-    const currentSequenceMap = new Map(currentSequences.map((s) => [s.name, s]));
-    const desiredSequenceNames = new Set(desiredSequences.map((s) => s.name));
-    for (const currentSeq of currentSequences) {
-      if (!desiredSequenceNames.has(currentSeq.name) && !currentSeq.ownedBy) {
-        statements.push(generateDropSequenceSQL(currentSeq.name));
-        Logger.info(`Dropping sequence '${currentSeq.name}'`);
-      }
-    }
-    for (const desiredSeq of desiredSequences) {
-      const currentSeq = currentSequenceMap.get(desiredSeq.name);
-      if (!currentSeq) {
-        statements.push(generateCreateSequenceSQL(desiredSeq));
-        Logger.info(`Creating sequence '${desiredSeq.name}'`);
-      } else if (!currentSeq.ownedBy) {
-        if (this.needsUpdate(desiredSeq, currentSeq)) {
-          statements.push(generateDropSequenceSQL(currentSeq.name));
-          statements.push(generateCreateSequenceSQL(desiredSeq));
-          Logger.info(`Updating sequence '${desiredSeq.name}'`);
-        } else {
-          Logger.info(`Sequence '${desiredSeq.name}' is up to date, skipping`);
-        }
-      } else {
-        Logger.info(`Sequence '${desiredSeq.name}' is owned by a table column, skipping`);
-      }
-    }
-    return statements;
-  }
-  needsUpdate(desired, current) {
-    return desired.increment !== current.increment || desired.minValue !== current.minValue || desired.maxValue !== current.maxValue || desired.start !== current.start || desired.cache !== current.cache || desired.cycle !== current.cycle;
+    return generateStatements(desiredSequences, currentSequences, config3);
   }
 }
 // src/core/schema/handlers/trigger-handler.ts
+var config4 = {
+  name: "trigger",
+  getKey: (t) => `${t.tableName}.${t.name}`,
+  getLogName: (t) => `${t.name}' on '${t.tableName}`,
+  generateDrop: generateDropTriggerSQL,
+  generateCreate: generateCreateTriggerSQL,
+  needsUpdate: (desired, current) => desired.timing !== current.timing || desired.forEach !== current.forEach || desired.functionName !== current.functionName || JSON.stringify(desired.events) !== JSON.stringify(current.events)
+};
+
 class TriggerHandler {
   generateStatements(desiredTriggers, currentTriggers) {
-    const statements = [];
-    const currentTriggerMap = new Map(currentTriggers.map((t) => [`${t.tableName}.${t.name}`, t]));
-    const desiredTriggerKeys = new Set(desiredTriggers.map((t) => `${t.tableName}.${t.name}`));
-    for (const currentTrig of currentTriggers) {
-      const key = `${currentTrig.tableName}.${currentTrig.name}`;
-      if (!desiredTriggerKeys.has(key)) {
-        statements.push(generateDropTriggerSQL(currentTrig));
-        Logger.info(`Dropping trigger '${currentTrig.name}' on '${currentTrig.tableName}'`);
-      }
-    }
-    for (const desiredTrig of desiredTriggers) {
-      const key = `${desiredTrig.tableName}.${desiredTrig.name}`;
-      const currentTrig = currentTriggerMap.get(key);
-      if (!currentTrig) {
-        statements.push(generateCreateTriggerSQL(desiredTrig));
-        Logger.info(`Creating trigger '${desiredTrig.name}' on '${desiredTrig.tableName}'`);
-      } else {
-        if (this.needsUpdate(desiredTrig, currentTrig)) {
-          statements.push(generateDropTriggerSQL(currentTrig));
-          statements.push(generateCreateTriggerSQL(desiredTrig));
-          Logger.info(`Updating trigger '${desiredTrig.name}' on '${desiredTrig.tableName}'`);
-        } else {
-          Logger.info(`Trigger '${desiredTrig.name}' is up to date, skipping`);
-        }
-      }
-    }
-    return statements;
-  }
-  needsUpdate(desired, current) {
-    return desired.timing !== current.timing || desired.forEach !== current.forEach || desired.functionName !== current.functionName || JSON.stringify(desired.events) !== JSON.stringify(current.events);
+    return generateStatements(desiredTriggers, currentTriggers, config4);
   }
 }
 // src/core/schema/handlers/view-handler.ts
+function normalizeDefinition(def) {
+  return def.replace(/\s+/g, " ").trim();
+}
+var config5 = {
+  name: "view",
+  getKey: (v) => v.name,
+  generateDrop: (v) => generateDropViewSQL(v.name, v.materialized),
+  generateCreate: generateCreateViewSQL,
+  generateUpdate: generateCreateOrReplaceViewSQL,
+  needsUpdate: (desired, current) => desired.materialized !== current.materialized || normalizeDefinition(desired.definition) !== normalizeDefinition(current.definition) || desired.checkOption !== current.checkOption || desired.securityBarrier !== current.securityBarrier
+};
+
 class ViewHandler {
   generateStatements(desiredViews, currentViews) {
-    const statements = [];
-    const currentViewMap = new Map(currentViews.map((v) => [v.name, v]));
-    const desiredViewNames = new Set(desiredViews.map((v) => v.name));
-    for (const currentView of currentViews) {
-      if (!desiredViewNames.has(currentView.name)) {
-        statements.push(generateDropViewSQL(currentView.name, currentView.materialized));
-        Logger.info(`Dropping view '${currentView.name}'`);
-      }
-    }
-    for (const desiredView of desiredViews) {
-      const currentView = currentViewMap.get(desiredView.name);
-      if (!currentView) {
-        statements.push(generateCreateViewSQL(desiredView));
-        Logger.info(`Creating view '${desiredView.name}'`);
-      } else {
-        if (this.needsUpdate(desiredView, currentView)) {
-          statements.push(generateCreateOrReplaceViewSQL(desiredView));
-          Logger.info(`Updating view '${desiredView.name}'`);
-        } else {
-          Logger.info(`View '${desiredView.name}' is up to date, skipping`);
-        }
-      }
-    }
-    return statements;
-  }
-  needsUpdate(desired, current) {
-    if (desired.materialized !== current.materialized) {
-      return true;
-    }
-    const normalizeDefinition = (def) => def.replace(/\s+/g, " ").trim();
-    const normalizedDesired = normalizeDefinition(desired.definition);
-    const normalizedCurrent = normalizeDefinition(current.definition);
-    if (normalizedDesired !== normalizedCurrent) {
-      Logger.info(`View '${desired.name}' needs update:`);
-      Logger.info(`  Desired: ${normalizedDesired.substring(0, 100)}...`);
-      Logger.info(`  Current: ${normalizedCurrent.substring(0, 100)}...`);
-      return true;
-    }
-    if (desired.checkOption !== current.checkOption) {
-      return true;
-    }
-    if (desired.securityBarrier !== current.securityBarrier) {
-      return true;
-    }
-    return false;
+    return generateStatements(desiredViews, currentViews, config5);
   }
 }
 // src/core/schema/service.ts
@@ -25741,15 +25673,25 @@ class SchemaService {
           return;
         }
       }
-      await this.executeStatements(client, sequenceStatements, autoApprove);
-      await this.executor.executePlan(client, plan, autoApprove);
-      await this.executeEnumRemovals(client, desiredEnums, currentEnums, schemas);
-      await this.executeStatements(client, functionStatements, autoApprove);
-      await this.executeStatements(client, procedureStatements, autoApprove);
-      await this.executeStatements(client, viewStatements, autoApprove);
-      await this.executeStatements(client, triggerStatements, autoApprove);
-      await this.executeStatements(client, commentStatements, autoApprove);
-      await this.executeStatements(client, extensionDropStatements, autoApprove);
+      const enumRemovalStatements = this.enumHandler.generateRemovalStatements(desiredEnums, currentEnums);
+      const combinedPlan = {
+        transactional: [
+          ...sequenceStatements,
+          ...plan.transactional,
+          ...plan.deferred,
+          ...enumRemovalStatements,
+          ...functionStatements,
+          ...procedureStatements,
+          ...viewStatements,
+          ...triggerStatements,
+          ...commentStatements,
+          ...extensionDropStatements
+        ],
+        concurrent: plan.concurrent,
+        deferred: [],
+        hasChanges: true
+      };
+      await this.executor.executePlan(client, combinedPlan, autoApprove);
     } finally {
       if (lockOptions && !dryRun) {
         await this.databaseService.releaseAdvisoryLock(client, lockOptions.lockName);
@@ -25782,32 +25724,6 @@ class SchemaService {
       return await this.parser.parseSchemaFile(input);
     }
   }
-  async executeStatements(client, statements, autoApprove) {
-    if (statements.length === 0)
-      return;
-    await this.executor.executePlan(client, {
-      transactional: statements,
-      concurrent: [],
-      deferred: [],
-      hasChanges: true
-    }, autoApprove);
-  }
-  async executeEnumRemovals(client, desiredEnums, currentEnums, schemas) {
-    const statements = await this.enumHandler.generateRemovalStatements(desiredEnums, currentEnums, client, schemas);
-    for (const statement of statements) {
-      try {
-        await client.query(statement);
-      } catch (error2) {
-        if (error2.code === "2BP01") {
-          const match = statement.match(/DROP TYPE\s+(?:"?(\w+)"?\.)?"?(\w+)"?/i);
-          const typeName = match ? match[1] ? `${match[1]}.${match[2]}` : match[2] : "unknown";
-          Logger.warning(`Could not drop ENUM '${typeName}': now in use (concurrent change). Will retry next migration.`);
-        } else {
-          throw error2;
-        }
-      }
-    }
-  }
   validateSchemaReferences(managedSchemas, tables, enums, views, functions, procedures, triggers, sequences) {
     const errors = [];
     const checkSchema = (objType, objName, objSchema) => {
@@ -25852,8 +25768,8 @@ var defaults = import_lib.default.defaults;
 // src/core/database/client.ts
 class DatabaseService {
   config;
-  constructor(config) {
-    this.config = config;
+  constructor(config6) {
+    this.config = config6;
   }
   async createClient() {
     const client = new Client(this.config);
@@ -25906,6 +25822,7 @@ class DatabaseService {
     const timeoutMs = options.lockTimeout;
     const lockKeyResult = await client.query("SELECT hashtext($1)::bigint as lock_key", [options.lockName]);
     const lockKey = lockKeyResult.rows[0].lock_key;
+    let delay = 100;
     while (true) {
       const result = await client.query("SELECT pg_try_advisory_lock($1) as acquired", [lockKey]);
       if (result.rows[0].acquired) {
@@ -25915,7 +25832,8 @@ class DatabaseService {
       if (elapsed >= timeoutMs) {
         throw new MigrationError(`Failed to acquire advisory lock '${options.lockName}' within ${timeoutMs / 1000}s. Another migration may be in progress. Please wait and try again.`);
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay = Math.min(delay * 2, 5000);
     }
   }
   async releaseAdvisoryLock(client, lockName) {
@@ -25930,8 +25848,8 @@ class DatabaseService {
 }
 
 // src/cli/commands/apply.ts
-async function applyCommand(options, config) {
-  const databaseService = new DatabaseService(config);
+async function applyCommand(options, config6) {
+  const databaseService = new DatabaseService(config6);
   const schemaService = new SchemaService(databaseService);
   const lockTimeout = parseInt(options.lockTimeout, 10);
   if (isNaN(lockTimeout) || lockTimeout <= 0) {
@@ -25946,7 +25864,7 @@ async function applyCommand(options, config) {
 // package.json
 var package_default = {
   name: "pgterra",
-  version: "0.2.11",
+  version: "0.2.13",
   description: "Declarative schema management for Postgres",
   keywords: [
     "postgres",
@@ -26042,8 +25960,8 @@ async function runCLI() {
   const program2 = new Command;
   program2.name("pgterra").description("Declarative schema management for Postgres").version(package_default.version, "-v, --version");
   program2.command("apply").description("Apply schema changes to database").requiredOption("-f, --file <file>", "Schema file path").option("-u, --url <url>", "Database connection string (overrides DATABASE_URL)").option("-s, --schema <schema>", "Database schema to manage (can be specified multiple times, defaults to 'public')", collectSchemas, []).option("--auto-approve", "Skip confirmation prompt").option("--dry-run", "Show migration plan without executing changes").option("--lock-name <name>", "Advisory lock name to prevent concurrent migrations", "pgterra_migrate_execute").option("--lock-timeout <seconds>", "Maximum time to wait for advisory lock in seconds", "10").action(async (options) => {
-    const config = loadConfig(options.url);
-    await applyCommand(options, config);
+    const config6 = loadConfig(options.url);
+    await applyCommand(options, config6);
   });
   await program2.parseAsync();
 }