pgterra 0.2.1 → 0.2.2

package/dist/index.js

@@ -1844,7 +1844,7 @@ var require_types2 = __commonJS((exports) => {
 
 // node_modules/libpg-query/wasm/libpg-query.js
 var require_libpg_query = __commonJS((exports, module) => {
-  var __dirname = "/home/runner/work/terra/terra/node_modules/libpg-query/wasm", __filename = "/home/runner/work/terra/terra/node_modules/libpg-query/wasm/libpg-query.js";
+  var __dirname = "/home/runner/work/pgterra/pgterra/node_modules/libpg-query/wasm", __filename = "/home/runner/work/pgterra/pgterra/node_modules/libpg-query/wasm/libpg-query.js";
   var PgQueryModule = (() => {
     var _scriptName = typeof document != "undefined" ? document.currentScript?.src : undefined;
     return async function(moduleArg = {}) {
@@ -26472,17 +26472,17 @@ function columnsAreDifferent(desired, current) {
 }
 function generateCreateTableStatement(table) {
   const columnDefs = table.columns.map((col) => {
-    const builder = new SQLBuilder;
-    builder.ident(col.name).p(col.type);
+    const builder2 = new SQLBuilder;
+    builder2.ident(col.name).p(col.type);
     if (col.generated) {
-      builder.p(`GENERATED ${col.generated.always ? "ALWAYS" : "BY DEFAULT"} AS (${col.generated.expression}) ${col.generated.stored ? "STORED" : "VIRTUAL"}`);
+      builder2.p(`GENERATED ${col.generated.always ? "ALWAYS" : "BY DEFAULT"} AS (${col.generated.expression}) ${col.generated.stored ? "STORED" : "VIRTUAL"}`);
     } else {
       if (!col.nullable)
-        builder.p("NOT NULL");
+        builder2.p("NOT NULL");
       if (col.default)
-        builder.p(`DEFAULT ${col.default}`);
+        builder2.p(`DEFAULT ${col.default}`);
     }
-    return builder.build();
+    return builder2.build();
   });
   if (table.primaryKey) {
     const primaryKeyClause = generatePrimaryKeyClause(table.primaryKey);
@@ -26500,11 +26500,11 @@ function generateCreateTableStatement(table) {
       columnDefs.push(uniqueClause);
     }
   }
-  const qualifiedName = getQualifiedTableName(table);
-  return `CREATE TABLE ${qualifiedName} (
-  ${columnDefs.join(`,
-  `)}
-);`;
+  const builder = new SQLBuilder().p("CREATE TABLE").table(table.name, table.schema).p(`(
+  ` + columnDefs.join(`,
+  `) + `
+)`);
+  return builder.build() + ";";
 }
 function generatePrimaryKeyClause(primaryKey) {
   const columns = primaryKey.columns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
@@ -27126,10 +27126,9 @@ class SchemaDiffer {
         statements.push(generateCreateTableStatement(filteredTable));
       } else {
         const currentTable = currentTables.get(table.name);
-        const qualifiedName = getQualifiedTableName(table);
         const alterations = this.collectTableAlterations(table, currentTable);
         if (alterations.length > 0) {
-          const batchedStatement = this.batchAlterTableChanges(qualifiedName, alterations);
+          const batchedStatement = this.batchAlterTableChanges(table, alterations);
           if (batchedStatement) {
             statements.push(batchedStatement);
           }
@@ -27310,18 +27309,19 @@ class SchemaDiffer {
   generateUsingExpression(columnName, currentType, desiredType) {
     const currentNormalized = normalizeType(currentType).toLowerCase();
     const desiredNormalized = normalizeType(desiredType).toLowerCase();
+    const quotedCol = `"${columnName.replace(/"/g, '""')}"`;
     if (currentNormalized.includes("varchar") || currentNormalized.includes("text")) {
       if (desiredNormalized.includes("decimal") || desiredNormalized.includes("numeric")) {
-        return `${columnName}::${desiredType}`;
+        return `${quotedCol}::${desiredType}`;
       }
       if (desiredNormalized.includes("integer") || desiredNormalized.includes("int")) {
-        return `TRUNC(${columnName}::DECIMAL)::integer`;
+        return `TRUNC(${quotedCol}::DECIMAL)::integer`;
       }
       if (desiredNormalized.includes("bool")) {
-        return `TRIM(${columnName})::boolean`;
+        return `TRIM(${quotedCol})::boolean`;
       }
     }
-    return `${columnName}::${desiredType}`;
+    return `${quotedCol}::${desiredType}`;
   }
   generatePrimaryKeyStatements(desiredTable, currentTable) {
     const statements = [];
@@ -27461,35 +27461,37 @@ class SchemaDiffer {
     });
   }
   generateCreateIndexSQL(index, useConcurrent = true) {
-    let sql = "CREATE";
+    const builder = new SQLBuilder;
+    builder.p("CREATE");
     if (index.unique) {
-      sql += " UNIQUE";
+      builder.p("UNIQUE");
     }
-    sql += " INDEX";
+    builder.p("INDEX");
     const shouldUseConcurrent = index.concurrent !== undefined ? index.concurrent : useConcurrent;
     if (shouldUseConcurrent) {
-      sql += " CONCURRENTLY";
+      builder.p("CONCURRENTLY");
     }
-    sql += ` ${index.name} ON ${index.tableName}`;
+    builder.ident(index.name).p("ON").table(index.tableName, index.schema);
     if (index.type && index.type !== "btree") {
-      sql += ` USING ${index.type.toUpperCase()}`;
+      builder.p(`USING ${index.type.toUpperCase()}`);
     }
     if (index.expression) {
-      sql += ` (${index.expression})`;
+      builder.p(`(${index.expression})`);
     } else {
-      sql += ` (${index.columns.join(", ")})`;
+      const quotedColumns = index.columns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
+      builder.p(`(${quotedColumns})`);
     }
     if (index.where) {
-      sql += ` WHERE ${index.where}`;
+      builder.p(`WHERE ${index.where}`);
     }
     if (index.storageParameters && Object.keys(index.storageParameters).length > 0) {
       const params = Object.entries(index.storageParameters).map(([key, value]) => `${key}=${value}`).join(", ");
-      sql += ` WITH (${params})`;
+      builder.p(`WITH (${params})`);
     }
     if (index.tablespace) {
-      sql += ` TABLESPACE ${index.tablespace}`;
+      builder.p(`TABLESPACE ${index.tablespace}`);
     }
-    return sql + ";";
+    return builder.build() + ";";
   }
   generateConstraintStatementsWithColumnContext(desiredTable, currentTable, qualifiedName) {
     const statements = [];
@@ -27802,7 +27804,7 @@ class SchemaDiffer {
       }
     }
   }
-  batchAlterTableChanges(tableName, alterations) {
+  batchAlterTableChanges(table, alterations) {
     if (alterations.length === 0) {
       return "";
     }
@@ -27815,7 +27817,7 @@ class SchemaDiffer {
         return 1;
       return 0;
     });
-    const builder = new SQLBuilder().p("ALTER TABLE").p(tableName);
+    const builder = new SQLBuilder().p("ALTER TABLE").table(table.name, table.schema);
     builder.indentIn();
     builder.mapComma(sorted, (alt, b) => {
       b.nl();
@@ -27853,7 +27855,7 @@ class SchemaDiffer {
           b.p("ALTER COLUMN").ident(alt.columnName).p("DROP NOT NULL");
           break;
         case "add_primary_key": {
-          const constraintName = alt.constraint.name || `pk_${tableName}`;
+          const constraintName = alt.constraint.name || `pk_${table.name}`;
           const columns = alt.constraint.columns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
           b.p("ADD CONSTRAINT").ident(constraintName).p(`PRIMARY KEY (${columns})`);
           break;
@@ -27862,7 +27864,7 @@ class SchemaDiffer {
           b.p("DROP CONSTRAINT").ident(alt.constraintName);
           break;
         case "add_check": {
-          const constraintName = alt.constraint.name || `check_${tableName}_${Date.now()}`;
+          const constraintName = alt.constraint.name || `check_${table.name}_${Date.now()}`;
           b.p("ADD CONSTRAINT").ident(constraintName).p(`CHECK (${alt.constraint.expression})`);
           break;
         }
@@ -27870,7 +27872,7 @@ class SchemaDiffer {
           b.p("DROP CONSTRAINT").ident(alt.constraintName);
           break;
         case "add_foreign_key": {
-          const constraintName = alt.constraint.name || `fk_${tableName}_${alt.constraint.referencedTable}`;
+          const constraintName = alt.constraint.name || `fk_${table.name}_${alt.constraint.referencedTable}`;
           const columns = alt.constraint.columns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
           const referencedColumns = alt.constraint.referencedColumns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
           b.p("ADD CONSTRAINT").ident(constraintName).p(`FOREIGN KEY (${columns}) REFERENCES`).table(alt.constraint.referencedTable).p(`(${referencedColumns})`);
@@ -27886,7 +27888,7 @@ class SchemaDiffer {
           b.p("DROP CONSTRAINT").ident(alt.constraintName);
           break;
         case "add_unique": {
-          const constraintName = alt.constraint.name || `unique_${tableName}_${alt.constraint.columns.join("_")}`;
+          const constraintName = alt.constraint.name || `unique_${table.name}_${alt.constraint.columns.join("_")}`;
           const columns = alt.constraint.columns.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ");
           b.p("ADD CONSTRAINT").ident(constraintName).p(`UNIQUE (${columns})`);
           break;
@@ -28294,9 +28296,14 @@ To fix this, either:
     if (valuesIdentical) {
       Logger.info(`ENUM type '${desiredEnum.name}' values already match, no changes needed`);
     } else if (isOnlyAppending) {
-      const fullName = desiredEnum.schema ? `${desiredEnum.schema}.${desiredEnum.name}` : desiredEnum.name;
       for (const value of valuesToAdd) {
-        statements.push(`ALTER TYPE ${fullName} ADD VALUE '${value}';`);
+        const builder = new SQLBuilder().p("ALTER TYPE");
+        if (desiredEnum.schema) {
+          builder.ident(desiredEnum.schema).rewriteLastChar(".");
+        }
+        builder.ident(desiredEnum.name);
+        builder.p(`ADD VALUE '${value}';`);
+        statements.push(builder.build());
         Logger.info(`Adding value '${value}' to ENUM type '${desiredEnum.name}'`);
       }
     } else {
@@ -28365,7 +28372,8 @@ To fix this, either:
     const desiredExtensionNames = new Set(desiredExtensions.map((e) => e.name));
     for (const currentExt of currentExtensions) {
       if (!desiredExtensionNames.has(currentExt.name)) {
-        dropStatements.push(`DROP EXTENSION IF EXISTS ${currentExt.name} CASCADE;`);
+        const dropBuilder = new SQLBuilder().p("DROP EXTENSION IF EXISTS").ident(currentExt.name).p("CASCADE");
+        dropStatements.push(dropBuilder.build() + ";");
         Logger.info(`Dropping extension '${currentExt.name}' (CASCADE will drop dependent objects)`);
       }
     }
@@ -28385,18 +28393,17 @@ To fix this, either:
     return { create: createStatements, drop: dropStatements };
   }
   generateCreateExtensionSQL(extension) {
-    let sql = `CREATE EXTENSION IF NOT EXISTS ${extension.name}`;
+    const builder = new SQLBuilder().p("CREATE EXTENSION IF NOT EXISTS").ident(extension.name);
     if (extension.schema) {
-      sql += ` SCHEMA ${extension.schema}`;
+      builder.p("SCHEMA").ident(extension.schema);
     }
     if (extension.version) {
-      sql += ` VERSION '${extension.version}'`;
+      builder.p(`VERSION '${extension.version}'`);
     }
     if (extension.cascade) {
-      sql += ` CASCADE`;
+      builder.p("CASCADE");
     }
-    sql += ";";
-    return sql;
+    return builder.build() + ";";
   }
   generateSequenceStatements(desiredSequences, currentSequences) {
     const statements = [];
@@ -28529,13 +28536,15 @@ To fix this, either:
     const currentSchemaNames = new Set(currentSchemas.map((s) => s.name));
     for (const desiredSchema of desiredSchemas) {
       if (!currentSchemaNames.has(desiredSchema.name)) {
-        const ifNotExists = desiredSchema.ifNotExists ? "IF NOT EXISTS " : "";
-        let sql = `CREATE SCHEMA ${ifNotExists}${desiredSchema.name}`;
+        const builder = new SQLBuilder().p("CREATE SCHEMA");
+        if (desiredSchema.ifNotExists) {
+          builder.p("IF NOT EXISTS");
+        }
+        builder.ident(desiredSchema.name);
         if (desiredSchema.owner) {
-          sql += ` AUTHORIZATION ${desiredSchema.owner}`;
+          builder.p("AUTHORIZATION").ident(desiredSchema.owner);
         }
-        sql += ";";
-        statements.push(sql);
+        statements.push(builder.build() + ";");
         Logger.info(`Creating schema '${desiredSchema.name}'`);
       } else {
         Logger.info(`Schema '${desiredSchema.name}' already exists, skipping`);
@@ -28568,15 +28577,18 @@ To fix this, either:
   }
   generateCommentSQL(comment) {
     const escapedComment = comment.comment.replace(/'/g, "''");
+    const builder = new SQLBuilder().p("COMMENT ON");
     if (comment.objectType === "SCHEMA") {
-      return `COMMENT ON SCHEMA ${comment.objectName} IS '${escapedComment}';`;
-    }
-    if (comment.objectType === "COLUMN") {
-      const tableName = comment.schemaName ? `${comment.schemaName}.${comment.objectName}` : comment.objectName;
-      return `COMMENT ON COLUMN ${tableName}.${comment.columnName} IS '${escapedComment}';`;
+      builder.p("SCHEMA").ident(comment.objectName);
+    } else if (comment.objectType === "COLUMN") {
+      builder.p("COLUMN").table(comment.objectName, comment.schemaName);
+      builder.rewriteLastChar(".");
+      builder.ident(comment.columnName);
+    } else {
+      builder.p(comment.objectType).table(comment.objectName, comment.schemaName);
     }
-    const objectName = comment.schemaName ? `${comment.schemaName}.${comment.objectName}` : comment.objectName;
-    return `COMMENT ON ${comment.objectType} ${objectName} IS '${escapedComment}';`;
+    builder.p(`IS '${escapedComment}'`);
+    return builder.build() + ";";
   }
 }
 
@@ -28691,7 +28703,7 @@ async function applyCommand(options, config) {
 // package.json
 var package_default = {
   name: "pgterra",
-  version: "0.2.1",
+  version: "0.2.2",
   description: "Declarative schema management for Postgres",
   keywords: [
     "postgres",

package/package.json

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