pgterra 0.2.12 → 0.2.14

package/dist/index.js

@@ -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;
     }
   }
@@ -24419,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);
@@ -24624,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);
@@ -24669,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) {
@@ -24699,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) {
@@ -24822,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 });
@@ -24880,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({
@@ -25119,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));
     }
   }
@@ -25209,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;
@@ -25258,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 {
@@ -25604,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);
@@ -25645,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) => {
@@ -25811,7 +25864,7 @@ async function applyCommand(options, config6) {
 // package.json
 var package_default = {
   name: "pgterra",
-  version: "0.2.12",
+  version: "0.2.14",
   description: "Declarative schema management for Postgres",
   keywords: [
     "postgres",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgterra",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Declarative schema management for Postgres",
   "keywords": [
     "postgres",