@dbsp/adapter-pgsql 1.10.1 → 1.11.1

package/dist/index.js

@@ -95,7 +95,46 @@ var init_naming_plugin = __esm({
 });
 
 // src/validate.ts
+function assertString(value, context) {
+  if (typeof value !== "string") {
+    throw new Error(`${context}: expected a string, received ${typeof value}`);
+  }
+}
+function assertNumericLiteral(value, context) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw new Error(
+      `${context}: expected a finite number or numeric string, received ${typeof value}`
+    );
+  }
+  const literal4 = typeof value === "number" ? String(value) : value;
+  if (typeof value === "number" && !Number.isFinite(value) || !SAFE_DECIMAL_LITERAL.test(literal4)) {
+    throw new Error(`${context}: unsafe numeric literal "${literal4}"`);
+  }
+  return literal4;
+}
+function formatStorageParameterValue(value, context) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw new Error(
+      `${context}: expected a string or number, received ${typeof value}`
+    );
+  }
+  if (typeof value === "number") {
+    return assertNumericLiteral(value, context);
+  }
+  if (value.includes("\0")) {
+    throw new Error(`${context}: contains null byte`);
+  }
+  if (SAFE_DECIMAL_LITERAL.test(value) || SAFE_STORAGE_BOOLEAN_LITERAL.test(value) || SAFE_SIMPLE_IDENTIFIER_VALUE.test(value) && !isReservedKeyword(value) && value.toLowerCase() !== "null") {
+    return value;
+  }
+  return `'${value.replace(/'/g, "''")}'`;
+}
 function validateIdentifier(value, type) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `Invalid ${type} identifier: expected a string, received ${typeof value}`
+    );
+  }
   if (!value || value.length === 0) {
     throw new InvalidIdentifierError(value, type, "cannot be empty");
   }
@@ -171,7 +210,12 @@ function validateIdentifiers(identifiers) {
 function sanitizeForDisplay(value) {
   return value.replace(/[\x00-\x1f\x7f]/g, "?").slice(0, 100);
 }
+function sanitizeCommentText(value) {
+  assertString(value, "SQL comment text");
+  return value.replace(/[\x00-\x1f\x7f]/g, "");
+}
 function validateExtensionName(name, context = "extension") {
+  assertString(name, `Invalid ${context} identifier`);
   if (!name || name.length === 0) {
     throw new InvalidIdentifierError(name, context, "cannot be empty");
   }
@@ -257,6 +301,7 @@ function validateExtensionName(name, context = "extension") {
   }
 }
 function validateCollationName(name, context = "collation") {
+  assertString(name, `Invalid ${context} identifier`);
   if (!name || name.length === 0) {
     throw new InvalidIdentifierError(name, context, "cannot be empty");
   }
@@ -349,13 +394,106 @@ function validateCollationName(name, context = "collation") {
   }
 }
 function validateSqlExpression(sql, context) {
+  assertString(sql, `Unsafe SQL expression in ${context}`);
   if (/[;]|--|\/\*|\*\/|\$\$|\\/.test(sql)) {
     throw new Error(
       `Unsafe SQL expression in ${context}: contains forbidden characters (;, --, /*, */, "$$" (dollar-quoted strings), \\). Value: "${sql}"`
     );
   }
 }
+function validateCheckExpression(sql, context) {
+  if (typeof sql !== "string") {
+    throw new Error(
+      `Unsafe SQL expression in ${context}: expected a string, received ${typeof sql}`
+    );
+  }
+  let i = 0;
+  let singleQuoted = false;
+  let dollarQuoteDelimiter;
+  while (i < sql.length) {
+    if (singleQuoted) {
+      if (sql[i] === "'") {
+        if (sql[i + 1] === "'") {
+          i += 2;
+          continue;
+        }
+        singleQuoted = false;
+      }
+      i++;
+      continue;
+    }
+    if (dollarQuoteDelimiter) {
+      if (sql.startsWith(dollarQuoteDelimiter, i)) {
+        i += dollarQuoteDelimiter.length;
+        dollarQuoteDelimiter = void 0;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (sql[i] === "'") {
+      singleQuoted = true;
+      i++;
+      continue;
+    }
+    const dollarDelimiter = readDollarQuoteDelimiter(sql, i);
+    if (dollarDelimiter) {
+      dollarQuoteDelimiter = dollarDelimiter;
+      i += dollarDelimiter.length;
+      continue;
+    }
+    const forbiddenToken = forbiddenCheckTokenAt(sql, i);
+    if (forbiddenToken) {
+      throw new Error(
+        `Unsafe SQL expression in ${context}: contains forbidden token "${forbiddenToken}" outside string literal. Value: "${sql}"`
+      );
+    }
+    i++;
+  }
+  if (singleQuoted) {
+    throw new Error(
+      `Unsafe SQL expression in ${context}: unterminated single-quoted string literal. Value: "${sql}"`
+    );
+  }
+  if (dollarQuoteDelimiter) {
+    throw new Error(
+      `Unsafe SQL expression in ${context}: unterminated dollar-quoted string literal ${dollarQuoteDelimiter}. Value: "${sql}"`
+    );
+  }
+}
+function forbiddenCheckTokenAt(sql, index) {
+  const ch = sql[index];
+  if (ch === ";" || ch === "\\") return ch;
+  const pair = sql.slice(index, index + 2);
+  if (pair === "--" || pair === "/*" || pair === "*/") return pair;
+  return void 0;
+}
+function readDollarQuoteDelimiter(sql, index) {
+  if (sql[index] !== "$") return void 0;
+  const previous = index > 0 ? sql[index - 1] : void 0;
+  if (previous && isIdentifierContinuationBeforeDollarQuote(previous)) {
+    return void 0;
+  }
+  if (sql[index + 1] === "$") return "$$";
+  if (!isDollarQuoteTagStart(sql[index + 1])) return void 0;
+  let cursor = index + 2;
+  while (isDollarQuoteTagContinuation(sql[cursor])) {
+    cursor++;
+  }
+  if (sql[cursor] !== "$") return void 0;
+  return sql.slice(index, cursor + 1);
+}
+function isIdentifierContinuationBeforeDollarQuote(ch) {
+  return /[A-Za-z0-9_$]/.test(ch) || (ch.codePointAt(0) ?? 0) > 127;
+}
+function isDollarQuoteTagStart(ch) {
+  return ch !== void 0 && /[A-Za-z_]/.test(ch);
+}
+function isDollarQuoteTagContinuation(ch) {
+  return ch !== void 0 && /[A-Za-z0-9_]/.test(ch);
+}
 function validateDbTypeName(type) {
+  assertString(type, "Unsafe database type name");
   if (!SAFE_TYPE_PATTERN.test(type)) {
     throw new Error(
       `Unsafe database type name: "${type}". Must match PostgreSQL type name rules.`
@@ -363,7 +501,7 @@ function validateDbTypeName(type) {
   }
   return type;
 }
-var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_TYPE_PATTERN;
+var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_DECIMAL_LITERAL, SAFE_STORAGE_BOOLEAN_LITERAL, SAFE_SIMPLE_IDENTIFIER_VALUE, SAFE_TYPE_PATTERN;
 var init_validate = __esm({
   "src/validate.ts"() {
     "use strict";
@@ -482,6 +620,9 @@ var init_validate = __esm({
       identifierType;
       reason;
     };
+    SAFE_DECIMAL_LITERAL = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)$/;
+    SAFE_STORAGE_BOOLEAN_LITERAL = /^(?:true|false|on|off)$/i;
+    SAFE_SIMPLE_IDENTIFIER_VALUE = /^[A-Za-z_][A-Za-z0-9_]*$/;
     SAFE_TYPE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])?$/;
   }
 });
@@ -1126,7 +1267,7 @@ var init_param_value = __esm({
 });
 
 // src/handlers/expression/case-value.ts
-function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler) {
+function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler, expressionHandler) {
   if (value === null || value === void 0) {
     return nullConstNode();
   }
@@ -1160,7 +1301,8 @@ function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler
         schema,
         naming,
         state,
-        nestedCaseHandler
+        nestedCaseHandler,
+        expressionHandler
       );
       const right = resolveCaseValue(
         expr.right,
@@ -1168,7 +1310,8 @@ function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler
         schema,
         naming,
         state,
-        nestedCaseHandler
+        nestedCaseHandler,
+        expressionHandler
       );
       return {
         A_Expr: {
@@ -1186,15 +1329,29 @@ function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler
       }
     // falls through
     default: {
+      if (expressionHandler && typeof expr.kind === "string" && EXPRESSION_HANDLER_KINDS.has(expr.kind)) {
+        return expressionHandler(expr);
+      }
       return bindParameter(value, state);
     }
   }
 }
+var EXPRESSION_HANDLER_KINDS;
 var init_case_value = __esm({
   "src/handlers/expression/case-value.ts"() {
     "use strict";
     init_ast_helpers();
     init_param_value();
+    EXPRESSION_HANDLER_KINDS = /* @__PURE__ */ new Set([
+      "customOp",
+      "customFn",
+      "ref",
+      "cast",
+      "unary",
+      "array",
+      "subquery",
+      "relationColumn"
+    ]);
   }
 });
 
@@ -6659,7 +6816,21 @@ var init_arithmetic = __esm({
 // src/handlers/expression/case.ts
 function resolveCaseValue2(value, ctx, state) {
   const alias = ctx.currentAlias ?? ctx.rootTable;
-  return resolveCaseValue(value, alias, void 0, ctx.naming, state);
+  return resolveCaseValue(
+    value,
+    alias,
+    void 0,
+    ctx.naming,
+    state,
+    void 0,
+    // Handler-level path: renders every expression kind via the shared
+    // expression compiler. It does NOT apply the customFn FILTER modifier
+    // (agg_filter) — that requires compiler-private compileFilterCondition,
+    // which cannot be reached here without a circular dependency. The primary
+    // DX caseWhen path (PlanCompiler.compileCustomExpressionNode) filter-patches
+    // correctly; use it for filtered aggregates as CASE branches.
+    (expr) => compileExpressionIntent(expr, ctx, state)
+  );
 }
 var caseHandler, simpleCaseHandler;
 var init_case = __esm({
@@ -6668,6 +6839,7 @@ var init_case = __esm({
     init_ast_helpers();
     init_param_intent();
     init_case_value();
+    init_custom();
     init_param_value();
     caseHandler = {
       types: ["case", "CASE", "caseWhen"],
@@ -9366,6 +9538,24 @@ function renumberNode(value, offset) {
   }
   return result;
 }
+function maxParamRefNumber(value) {
+  if (value === null || typeof value !== "object") return 0;
+  if (Array.isArray(value)) {
+    let max2 = 0;
+    for (const item of value) max2 = Math.max(max2, maxParamRefNumber(item));
+    return max2;
+  }
+  const obj = value;
+  if ("ParamRef" in obj && obj.ParamRef !== null && typeof obj.ParamRef === "object") {
+    const n = obj.ParamRef.number;
+    return typeof n === "number" ? n : 0;
+  }
+  let max = 0;
+  for (const key of Object.keys(obj)) {
+    max = Math.max(max, maxParamRefNumber(obj[key]));
+  }
+  return max;
+}
 var includeHandlersInitialized = false;
 function ensureIncludeHandlersRegistered() {
   if (includeHandlersInitialized) return;
@@ -10400,7 +10590,7 @@ var PlanCompiler = class _PlanCompiler {
       }
       case "selectExpression": {
         if (decision.expressionType === "case") {
-          const caseNode = this.compileCaseExpression(decision);
+          const caseNode = this.compileCaseExpression(decision, plan);
           const alias = decision.alias;
           targetList.push({
             ResTarget: {
@@ -10413,34 +10603,7 @@ var PlanCompiler = class _PlanCompiler {
       }
       case "selectCustomExpression": {
         const exprIntent = decision.expressionIntent;
-        const outerThis = this;
-        const ctx = {
-          ...this.createHandlerContext(plan, plan.rootTable),
-          compileSubquery(query, paramOffset) {
-            return outerThis.compileExpressionSubquery(query, paramOffset);
-          }
-        };
-        const state = this.createHandlerState();
-        const node = compileExpressionIntent(exprIntent, ctx, state);
-        if (exprIntent.kind === "customFn" && exprIntent.filter) {
-          const filterIntent = exprIntent.filter;
-          const filterDecision = convertWhereCondition(
-            filterIntent,
-            plan.rootTable
-          );
-          if (filterDecision) {
-            const filterNode = compileFilterCondition(
-              filterDecision,
-              createWhereDispatcher(),
-              ctx,
-              state
-            );
-            if (filterNode && "FuncCall" in node) {
-              node.FuncCall.agg_filter = filterNode;
-            }
-          }
-        }
-        this.state.paramIndex = state.paramIndex;
+        const node = this.compileCustomExpressionNode(exprIntent, plan);
         const alias = decision.alias || decision.column || void 0;
         targetList.push({
           ResTarget: {
@@ -10707,14 +10870,28 @@ var PlanCompiler = class _PlanCompiler {
    */
   compileJoinDecision(decision, plan, from) {
     if (isPrecompiledJoinDecision(decision)) {
-      if (isBatchValuesJoinDecision(decision)) {
+      const isBatchValues = isBatchValuesJoinDecision(decision);
+      if (isBatchValues) {
         for (const p of decision.batchValuesParams) {
           this.state.parameters.push(p);
         }
         this.state.paramIndex = this.state.parameters.length;
       }
       const jRarg = decision.joinRarg;
-      const jOn = decision.joinOnNode;
+      let jOn = decision.joinOnNode;
+      if (!isBatchValues && decision.joinOnParams?.length) {
+        if (maxParamRefNumber(decision.joinOnNode) > decision.joinOnParams.length) {
+          throw new Error(
+            "Table-mode JOIN ON clauses support only inline param() values; externally pre-assigned or bound parameters in an ON clause are not supported."
+          );
+        }
+        const offset = this.state.parameters.length;
+        jOn = renumberParamRefsInAst(decision.joinOnNode, offset);
+        for (const p of decision.joinOnParams) {
+          this.state.parameters.push(p);
+        }
+        this.state.paramIndex = this.state.parameters.length;
+      }
       from[0] = decision.joinType === "left" ? leftJoin(from[0], jRarg, jOn) : innerJoin(from[0], jRarg, jOn);
     } else {
       from[0] = this.compileJoin(decision, plan, from[0]);
@@ -10747,11 +10924,9 @@ var PlanCompiler = class _PlanCompiler {
     }
     if (decision.column) {
       return sortBy(
-        columnRef(
+        this.compileRelationAwareColumnRef(
           decision.column,
-          decision.table,
-          void 0,
-          this.naming
+          decision.table
         ),
         decision.direction ?? "ASC",
         decision.nulls ?? "DEFAULT"
@@ -11010,7 +11185,7 @@ var PlanCompiler = class _PlanCompiler {
   // --------------------------------------------------------------------------
   // CASE Expression Compilation
   // --------------------------------------------------------------------------
-  compileCaseExpression(decision) {
+  compileCaseExpression(decision, plan) {
     const conditions = decision.conditions;
     const elseValue = decision.value;
     if (!conditions || conditions.length === 0) {
@@ -11018,7 +11193,7 @@ var PlanCompiler = class _PlanCompiler {
     }
     const args = conditions.map((cond) => {
       const whenExpr = this.dispatchWhere(cond.when);
-      const thenResult = this.compileCaseValue(cond.then);
+      const thenResult = this.compileCaseValue(cond.then, plan);
       return {
         CaseWhen: {
           expr: whenExpr,
@@ -11028,7 +11203,7 @@ var PlanCompiler = class _PlanCompiler {
     });
     let defresult;
     if (elseValue !== void 0) {
-      defresult = this.compileCaseValue(elseValue);
+      defresult = this.compileCaseValue(elseValue, plan);
     }
     return {
       CaseExpr: {
@@ -11041,26 +11216,66 @@ var PlanCompiler = class _PlanCompiler {
    * Compile a CASE THEN/ELSE value based on its ExpressionIntent kind.
    * Delegates to shared resolveCaseValue with nested CASE support.
    */
-  compileCaseValue(value) {
+  compileCaseValue(value, plan) {
     return resolveCaseValue(
       value,
       this.currentRootTable,
       void 0,
       this.naming,
       this.state,
-      (expr) => this.compileCaseExpression({
-        type: "selectExpression",
-        expressionType: "case",
-        conditions: expr.when.map((wc) => ({
-          when: wc.condition,
-          // biome-ignore lint/suspicious/noThenProperty: intentional
-          then: wc.result
-        })),
-        value: expr.else,
-        table: this.currentRootTable
-      })
+      (expr) => {
+        const nestedDecision = {
+          type: "selectExpression",
+          expressionType: "case",
+          conditions: expr.when.map((wc) => ({
+            when: wc.condition,
+            // biome-ignore lint/suspicious/noThenProperty: intentional
+            then: wc.result
+          })),
+          value: expr.else,
+          table: this.currentRootTable
+        };
+        return this.compileCaseExpression(nestedDecision, plan);
+      },
+      (expr) => this.compileCustomExpressionNode(
+        expr,
+        plan
+      )
     );
   }
+  /**
+   * Compile a custom ExpressionIntent (customFn, customOp, ref, cast, unary,
+   * array, function, subquery, …) to an AST node, applying the customFn FILTER
+   * clause. Shared by the `selectCustomExpression` target path and CASE
+   * THEN/ELSE values so both render the full expression surface identically
+   * (every expression kind + FILTER), rather than one path silently binding
+   * expressions as parameters or dropping FILTER.
+   */
+  compileCustomExpressionNode(exprIntent, plan) {
+    const ctx = this.createHandlerContext(plan, plan.rootTable);
+    const state = this.createHandlerState();
+    const node = compileExpressionIntent(exprIntent, ctx, state);
+    if (exprIntent.kind === "customFn" && exprIntent.filter) {
+      const filterIntent = exprIntent.filter;
+      const filterDecision = convertWhereCondition(
+        filterIntent,
+        plan.rootTable
+      );
+      if (filterDecision) {
+        const filterNode = compileFilterCondition(
+          filterDecision,
+          createWhereDispatcher(),
+          ctx,
+          state
+        );
+        if (filterNode && "FuncCall" in node) {
+          node.FuncCall.agg_filter = filterNode;
+        }
+      }
+    }
+    this.state.paramIndex = state.paramIndex;
+    return node;
+  }
   // --------------------------------------------------------------------------
   // INSERT Compilation
   // --------------------------------------------------------------------------
@@ -11263,6 +11478,9 @@ function compilePlan(plan, options) {
 init_naming_plugin();
 init_validate();
 
+// src/ddl/phases/comments.ts
+init_validate();
+
 // src/ddl/phases/types.ts
 function sup(caps, flag) {
   return !caps || flag === true;
@@ -11283,6 +11501,7 @@ var VALID_INDEX_METHODS = /* @__PURE__ */ new Set([
   "bloom"
 ]);
 function validateIndexMethod(method, context = "index method") {
+  assertString(method, `Invalid ${context}`);
   if (!VALID_INDEX_METHODS.has(method)) {
     throw new Error(
       `Invalid ${context}: "${method}". Must be one of: ${[...VALID_INDEX_METHODS].join(", ")}`
@@ -11290,6 +11509,7 @@ function validateIndexMethod(method, context = "index method") {
   }
 }
 function validateEnumLabel(value, context = "enum label") {
+  assertString(value, `Invalid ${context}`);
   if (/\x00/.test(value)) {
     throw new Error(
       `Invalid ${context}: contains NUL byte (\\x00) which would be silently truncated by PostgreSQL`
@@ -11314,6 +11534,7 @@ function quoteCollation(name) {
   return `"${name}"`;
 }
 function quoteRoleName(name) {
+  assertString(name, "quoteRoleName: role name");
   if (!name) {
     throw new Error("quoteRoleName: role name must not be empty");
   }
@@ -11380,17 +11601,21 @@ function generateCommentsPhase(ctx) {
   }
   const statements = [];
   for (const table of tables) {
-    if (table.comment) {
+    const tableComment = table.comment;
+    if (tableComment) {
+      assertString(tableComment, "table comment");
       const qualifiedTable = qualifyTableIdent(table.name, schemaName, naming);
       statements.push(
-        `COMMENT ON TABLE ${qualifiedTable} IS '${table.comment.replace(/'/g, "''")}';`
+        `COMMENT ON TABLE ${qualifiedTable} IS '${tableComment.replace(/'/g, "''")}';`
       );
     }
     for (const col of table.columns) {
-      if (col.comment) {
+      const columnComment = col.comment;
+      if (columnComment) {
+        assertString(columnComment, "column comment");
         const qualifiedTable = qualifyTableIdent(table.name, schemaName, naming);
         statements.push(
-          `COMMENT ON COLUMN ${qualifiedTable}.${quoteIdent2(naming.toDatabase(col.name))} IS '${col.comment.replace(/'/g, "''")}';`
+          `COMMENT ON COLUMN ${qualifiedTable}.${quoteIdent2(naming.toDatabase(col.name))} IS '${columnComment.replace(/'/g, "''")}';`
         );
       }
     }
@@ -11415,9 +11640,10 @@ function generateConstraintsPhase(ctx) {
       for (const check of table.checkConstraints ?? []) {
         const qualifiedTable = qualifyTableIdent(table.name, schemaName, naming);
         const constraintName = quoteIdent2(check.name);
-        validateSqlExpression(check.expression, "check constraint expression");
+        const expression = check.expression;
+        validateCheckExpression(expression, "check constraint expression");
         statements.push(
-          `ALTER TABLE ${qualifiedTable} ADD CONSTRAINT ${constraintName} ${check.expression};`
+          `ALTER TABLE ${qualifiedTable} ADD CONSTRAINT ${constraintName} ${expression};`
         );
       }
     }
@@ -11600,12 +11826,29 @@ function mapOnDeleteAction(action) {
 function qualifyTable(table, schemaName) {
   return schemaName ? `${quoteIdent2(schemaName, "schema")}.${quoteIdent2(table, "table")}` : quoteIdent2(table, "table");
 }
+function buildDoBlock(body) {
+  const delimiter = chooseDoBlockDelimiter(body);
+  return `DO ${delimiter} ${body} ${delimiter};`;
+}
+function chooseDoBlockDelimiter(body) {
+  if (!body.includes("$$")) return "$$";
+  let suffix = 0;
+  let delimiter = "$dbsp_check$";
+  while (body.includes(delimiter)) {
+    suffix++;
+    delimiter = `$dbsp_check_${suffix}$`;
+  }
+  return delimiter;
+}
 function pkName(table) {
   return `pk_${table}`;
 }
 function fkName(table, columns) {
   return `fk_${table}_${columns.join("_")}`;
 }
+function uniqueName(table, column) {
+  return `${table}_${column}_key`;
+}
 function idxName(table, columns, customName) {
   return customName ?? `idx_${table}_${columns.join("_")}`;
 }
@@ -11660,11 +11903,22 @@ function buildPolicySQL(tableName, policy, schemaName) {
 }
 function buildSequenceClause(verb, seqName, seq, includeCycleNoCycle = false) {
   const parts = [`${verb} ${seqName}`];
-  if (seq.startWith !== void 0) parts.push(`START WITH ${seq.startWith}`);
+  if (seq.startWith !== void 0)
+    parts.push(
+      `START WITH ${assertNumericLiteral(seq.startWith, "sequence START WITH")}`
+    );
   if (seq.incrementBy !== void 0)
-    parts.push(`INCREMENT BY ${seq.incrementBy}`);
-  if (seq.minValue !== void 0) parts.push(`MINVALUE ${seq.minValue}`);
-  if (seq.maxValue !== void 0) parts.push(`MAXVALUE ${seq.maxValue}`);
+    parts.push(
+      `INCREMENT BY ${assertNumericLiteral(seq.incrementBy, "sequence INCREMENT BY")}`
+    );
+  if (seq.minValue !== void 0)
+    parts.push(
+      `MINVALUE ${assertNumericLiteral(seq.minValue, "sequence MINVALUE")}`
+    );
+  if (seq.maxValue !== void 0)
+    parts.push(
+      `MAXVALUE ${assertNumericLiteral(seq.maxValue, "sequence MAXVALUE")}`
+    );
   if (includeCycleNoCycle) {
     if (seq.cycle !== void 0) parts.push(seq.cycle ? "CYCLE" : "NO CYCLE");
   } else {
@@ -11674,7 +11928,7 @@ function buildSequenceClause(verb, seqName, seq, includeCycleNoCycle = false) {
 }
 function failSafeUnknownDownChange(kind) {
   return {
-    sql: `-- WARNING: Cannot reverse unsupported SchemaChange kind "${kind}"`,
+    sql: `-- WARNING: Cannot reverse unsupported SchemaChange kind "${sanitizeCommentText(kind)}"`,
     destructive: true
   };
 }
@@ -11736,7 +11990,7 @@ function generateMigrationSQL(diff, options) {
     [],
     // 8: alter column
     [],
-    // 9: add PK
+    // 9: add PK / column UNIQUE constraint
     [],
     // 10: add FK
     [],
@@ -11823,6 +12077,7 @@ function getPhase(kind) {
     case "alter_column_collation":
     case "alter_column_identity":
       return 8;
+    case "alter_column_unique":
     case "add_primary_key":
       return 9;
     case "add_foreign_key":
@@ -11859,7 +12114,7 @@ function upAddColumn(change, schemaName) {
 }
 function upAlterColumnType(change, schemaName) {
   const col = change.meta?.column;
-  const toType = col ? mapColumnType(col) : String(change.meta?.toType);
+  const toType = col ? mapColumnType(col) : validateDbTypeName(change.meta?.toType);
   return `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} TYPE ${toType};`;
 }
 function upAlterColumnNullable(change, schemaName) {
@@ -11874,6 +12129,34 @@ function upAlterColumnDefault(change, schemaName) {
   }
   return `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} SET DEFAULT ${formatDefault(def)};`;
 }
+function addColumnUniqueSQL(table, column, schemaName, constraintName) {
+  const name = constraintName ?? uniqueName(table, column);
+  if (constraintName !== void 0) validateIdentifier(constraintName, "alias");
+  const quotedConstraintName = quoteIdent2(name, "alias");
+  return `ALTER TABLE ${qualifyTable(table, schemaName)} ADD CONSTRAINT ${quotedConstraintName} UNIQUE (${quoteIdent2(column, "alias")});`;
+}
+function dropColumnUniqueSQL(table, column, schemaName, constraintName) {
+  const name = constraintName ?? uniqueName(table, column);
+  if (constraintName !== void 0) validateIdentifier(constraintName, "alias");
+  const quotedConstraintName = quoteIdent2(name, "alias");
+  return `ALTER TABLE ${qualifyTable(table, schemaName)} DROP CONSTRAINT IF EXISTS ${quotedConstraintName};`;
+}
+function upAlterColumnUnique(change, schemaName) {
+  const unique = change.meta?.unique;
+  if (unique === void 0 || !change.column) return void 0;
+  const constraintName = change.meta?.constraintName;
+  return unique ? addColumnUniqueSQL(
+    change.table,
+    change.column,
+    schemaName,
+    constraintName
+  ) : dropColumnUniqueSQL(
+    change.table,
+    change.column,
+    schemaName,
+    constraintName
+  );
+}
 function upAddPrimaryKey(change, schemaName) {
   const columns = change.meta?.columns;
   const pkCols = columns.map((n) => quoteIdent2(n, "alias")).join(", ");
@@ -11902,8 +12185,9 @@ function upCreateIndex(change, schemaName) {
     "alias"
   );
   const unique = idx.unique ? "UNIQUE " : "";
-  if (idx.method) validateIndexMethod(idx.method, "index method");
-  const method = idx.method ? ` USING ${idx.method}` : "";
+  const indexMethod = idx.method;
+  if (indexMethod) validateIndexMethod(indexMethod, "index method");
+  const method = indexMethod ? ` USING ${indexMethod}` : "";
   const colParts = [
     ...(idx.expressions ?? []).map((expr) => {
       validateSqlExpression(expr, "index expression");
@@ -11920,10 +12204,11 @@ function upCreateIndex(change, schemaName) {
   const nullsNotDistinct = idx.unique && idx.nullsNotDistinct ? " NULLS NOT DISTINCT" : "";
   const withParams = idx.with && Object.keys(idx.with).length > 0 ? ` WITH (${Object.entries(idx.with).map(([k, v]) => {
     validateIdentifier(k, "alias");
-    return `${k} = ${v}`;
+    return `${k} = ${formatStorageParameterValue(v, `index WITH parameter "${k}"`)}`;
   }).join(", ")})` : "";
-  if (idx.where) validateSqlExpression(idx.where, "index WHERE predicate");
-  const where = idx.where ? ` WHERE ${idx.where}` : "";
+  const whereExpr = idx.where;
+  if (whereExpr) validateSqlExpression(whereExpr, "index WHERE predicate");
+  const where = whereExpr ? ` WHERE ${whereExpr}` : "";
   return `CREATE ${unique}INDEX IF NOT EXISTS ${indexName} ON ${qualifyTable(change.table, schemaName)}${method} (${cols})${include}${nullsNotDistinct}${withParams}${where};`;
 }
 function upDropIndex(change, schemaName) {
@@ -11939,12 +12224,12 @@ function upDropIndex(change, schemaName) {
 function upAddCheckConstraint(change, schemaName) {
   const check = change.meta?.check;
   if (!check) return void 0;
+  const expression = check.expression;
   const notValid = check.notValid ? " NOT VALID" : "";
-  validateSqlExpression(
-    check.expression,
-    "migration check constraint expression"
+  validateCheckExpression(expression, "migration check constraint expression");
+  return buildDoBlock(
+    "BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + expression + notValid + "; EXCEPTION WHEN duplicate_object THEN NULL; END"
   );
-  return "DO $$ BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + check.expression + notValid + "; EXCEPTION WHEN duplicate_object THEN NULL; END $$;";
 }
 function upValidateConstraint(change, schemaName) {
   const fk = change.meta?.fk;
@@ -12013,6 +12298,7 @@ function upAlterColumnIdentity(change, schemaName) {
 function upAddComment(change, schemaName) {
   const comment = change.meta?.comment;
   const target = change.meta?.target;
+  assertString(comment, "migration comment");
   const escaped = comment.replace(/'/g, "''");
   if (target === "table") {
     return `COMMENT ON TABLE ${qualifyTable(change.table, schemaName)} IS '${escaped}';`;
@@ -12040,6 +12326,8 @@ function changeToUpSQL(change, schemaName) {
       return upAlterColumnNullable(change, schemaName);
     case "alter_column_default":
       return upAlterColumnDefault(change, schemaName);
+    case "alter_column_unique":
+      return upAlterColumnUnique(change, schemaName);
     case "add_primary_key":
       return upAddPrimaryKey(change, schemaName);
     case "drop_primary_key":
@@ -12137,7 +12425,7 @@ function changeToDownSQL(change, schemaName) {
       };
     case "drop_table":
       return {
-        sql: `-- WARNING: Cannot reverse drop_table "${change.table}" -- table data was lost`,
+        sql: `-- WARNING: Cannot reverse drop_table "${sanitizeCommentText(change.table)}" -- table data was lost`,
         destructive: true
       };
     case "add_column":
@@ -12147,19 +12435,20 @@ function changeToDownSQL(change, schemaName) {
       };
     case "drop_column":
       return {
-        sql: `-- WARNING: Cannot reverse drop_column "${change.table}"."${change.column}" -- column data was lost`,
+        sql: `-- WARNING: Cannot reverse drop_column "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- column data was lost`,
         destructive: true
       };
     case "alter_column_type": {
       const fromType = change.meta?.fromType;
-      if (!fromType) {
+      if (fromType == null) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_type "${change.table}"."${change.column}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_type "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
           destructive: true
         };
       }
+      const safeFromType = validateDbTypeName(fromType);
       return {
-        sql: `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} TYPE ${fromType};`,
+        sql: `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} TYPE ${safeFromType};`,
         destructive: true
       };
     }
@@ -12167,7 +12456,7 @@ function changeToDownSQL(change, schemaName) {
       const oldNullable = change.meta?.oldNullable;
       if (oldNullable === void 0) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_nullable "${change.table}"."${change.column}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_nullable "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12182,7 +12471,7 @@ function changeToDownSQL(change, schemaName) {
       const oldDefault = change.meta?.oldDefault;
       if (oldDefault === void 0) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_default "${change.table}"."${change.column}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_default "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12199,6 +12488,30 @@ function changeToDownSQL(change, schemaName) {
         destructive: false
       };
     }
+    case "alter_column_unique": {
+      const unique = change.meta?.unique;
+      if (unique === void 0 || !change.column) {
+        return {
+          sql: `-- WARNING: Cannot reverse alter_column_unique "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
+          destructive: true
+        };
+      }
+      const constraintName = change.meta?.constraintName;
+      return {
+        sql: unique ? dropColumnUniqueSQL(
+          change.table,
+          change.column,
+          schemaName,
+          constraintName
+        ) : addColumnUniqueSQL(
+          change.table,
+          change.column,
+          schemaName,
+          constraintName
+        ),
+        destructive: unique === true
+      };
+    }
     case "add_primary_key": {
       return {
         sql: `ALTER TABLE ${qualifyTable(change.table, schemaName)} DROP CONSTRAINT IF EXISTS ${quoteIdent2(pkName(change.table), "alias")} CASCADE;`,
@@ -12216,7 +12529,7 @@ function changeToDownSQL(change, schemaName) {
         };
       }
       return {
-        sql: `-- WARNING: Cannot reverse drop_primary_key "${change.table}" -- columns unknown`,
+        sql: `-- WARNING: Cannot reverse drop_primary_key "${sanitizeCommentText(change.table)}" -- columns unknown`,
         destructive: true
       };
     }
@@ -12236,7 +12549,7 @@ function changeToDownSQL(change, schemaName) {
       const fk = change.meta?.fk;
       if (!fk) {
         return {
-          sql: `-- WARNING: Cannot reverse drop_foreign_key "${change.table}" -- FK definition was lost`,
+          sql: `-- WARNING: Cannot reverse drop_foreign_key "${sanitizeCommentText(change.table)}" -- FK definition was lost`,
           destructive: true
         };
       }
@@ -12251,7 +12564,7 @@ function changeToDownSQL(change, schemaName) {
       const fk = change.meta?.fk;
       if (!oldFk || !fk) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_foreign_key "${change.table}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_foreign_key "${sanitizeCommentText(change.table)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12281,7 +12594,7 @@ ${add}`, destructive: false };
       const idx = change.meta?.index;
       if (!idx) {
         return {
-          sql: `-- WARNING: Cannot reverse drop_index "${change.table}" -- index definition was lost`,
+          sql: `-- WARNING: Cannot reverse drop_index "${sanitizeCommentText(change.table)}" -- index definition was lost`,
           destructive: true
         };
       }
@@ -12302,12 +12615,12 @@ ${add}`, destructive: false };
     case "drop_check_constraint": {
       const check = change.meta?.check;
       if (!check) return { sql: void 0, destructive: true };
-      validateSqlExpression(
-        check.expression,
-        "migration check constraint (down)"
-      );
+      const expression = check.expression;
+      validateCheckExpression(expression, "migration check constraint (down)");
       return {
-        sql: "DO $$ BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + check.expression + "; EXCEPTION WHEN duplicate_object THEN NULL; END $$;",
+        sql: buildDoBlock(
+          "BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + expression + "; EXCEPTION WHEN duplicate_object THEN NULL; END"
+        ),
         // Allowlisted: re-adds the dropped CHECK constraint from metadata.
         destructive: false
       };
@@ -12325,7 +12638,10 @@ ${add}`, destructive: false };
       const enumDef = change.meta?.enum;
       if (!enumDef) return { sql: void 0, destructive: true };
       const enumName = schemaName ? `${quoteIdent2(schemaName, "alias")}.${quoteIdent2(enumDef.name, "alias")}` : quoteIdent2(enumDef.name, "alias");
-      const values = enumDef.values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+      const values = enumDef.values.map((v) => {
+        validateEnumLabel(v, "enum value");
+        return `'${v.replace(/'/g, "''")}'`;
+      }).join(", ");
       return {
         sql: `CREATE TYPE ${enumName} AS ENUM (${values});`,
         // Allowlisted: re-creates the dropped enum type from metadata.
@@ -12339,7 +12655,7 @@ ${add}`, destructive: false };
       };
     case "alter_column_collation": {
       return {
-        sql: `-- WARNING: Cannot reverse alter_column_collation "${change.table}"."${change.column}" -- previous collation unknown`,
+        sql: `-- WARNING: Cannot reverse alter_column_collation "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- previous collation unknown`,
         destructive: true
       };
     }
@@ -12365,7 +12681,7 @@ ${add}`, destructive: false };
       }
       if (!prevIdentity && !col.identity) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_identity "${change.table}"."${change.column}" -- missing previous identity metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_identity "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing previous identity metadata`,
           destructive: true
         };
       }
@@ -12392,7 +12708,8 @@ ${add}`, destructive: false };
     case "drop_comment": {
       const target = change.meta?.target;
       const comment = change.meta?.comment;
-      if (typeof comment === "string") {
+      if (comment !== void 0) {
+        assertString(comment, "migration comment");
         const escaped = comment.replace(/'/g, "''");
         if (target === "table") {
           return {
@@ -12409,8 +12726,9 @@ ${add}`, destructive: false };
           };
         }
       }
+      const columnTarget2 = change.column === void 0 ? "" : `."${sanitizeCommentText(change.column)}"`;
       return {
-        sql: `-- WARNING: Cannot reverse drop_comment "${change.table}"${change.column ? `."${change.column}"` : ""} -- comment text was lost`,
+        sql: '-- WARNING: Cannot reverse drop_comment "' + sanitizeCommentText(change.table) + '"' + columnTarget2 + " -- comment text was lost",
         destructive: true
       };
     }
@@ -12444,7 +12762,7 @@ ${add}`, destructive: false };
       const prevSeq = change.meta?.previousSequence;
       if (!prevSeq) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_sequence "${change.table}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_sequence "${sanitizeCommentText(change.table)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12467,7 +12785,7 @@ ${add}`, destructive: false };
     }
     case "validate_constraint":
       return {
-        sql: `-- VALIDATE CONSTRAINT cannot be reversed in PostgreSQL (table: "${change.table}")`,
+        sql: `-- VALIDATE CONSTRAINT cannot be reversed in PostgreSQL (table: "${sanitizeCommentText(change.table)}")`,
         destructive: true
       };
     case "enable_rls":
@@ -12508,7 +12826,6 @@ function generateDownSQL(diff, options) {
 function generateDownMigrationSQL(diff, options) {
   const schemaName = options?.schemaName;
   const includeDestructive = options?.includeDestructive ?? true;
-  const changes = includeDestructive ? diff.changes : diff.changes.filter((c) => !c.destructive);
   const phases = [
     [],
     // 0: drop FK, drop CHECK
@@ -12529,7 +12846,7 @@ function generateDownMigrationSQL(diff, options) {
     [],
     // 8: alter column
     [],
-    // 9: add PK
+    // 9: add PK / column UNIQUE constraint
     [],
     // 10: add FK
     [],
@@ -12549,7 +12866,7 @@ function generateDownMigrationSQL(diff, options) {
     []
     // 18: CREATE/DROP POLICY
   ];
-  for (const change of changes) {
+  for (const change of diff.changes) {
     const phase = getPhase(change.kind);
     phases[phase].push(change);
   }
@@ -12558,6 +12875,7 @@ function generateDownMigrationSQL(diff, options) {
   for (let i = phases.length - 1; i >= 0; i--) {
     for (const change of phases[i]) {
       const down = changeToDownSQL(change, schemaName);
+      if (!includeDestructive && down.destructive) continue;
       destructive = down.destructive || destructive;
       if (down.sql) statements.push(down.sql);
     }
@@ -12602,7 +12920,10 @@ function generateAddFKSQL(tableName, fk, schemaName) {
   const qualTable = qualifyTable(tableName, schemaName);
   const constraintName = quoteIdent2(fkName(tableName, fk.columns), "alias");
   const fkCols = fk.columns.map((n) => quoteIdent2(n, "alias")).join(", ");
-  const refTable = qualifyTable(fk.references.table, schemaName);
+  const refTable = qualifyTable(
+    fk.references.table,
+    fk.references.schema ?? schemaName
+  );
   const refCols = fk.references.columns.map((n) => quoteIdent2(n, "alias")).join(", ");
   const onDelete = fk.onDelete ? ` ON DELETE ${mapOnDeleteAction(fk.onDelete)}` : "";
   const onUpdate = fk.onUpdate ? ` ON UPDATE ${mapOnDeleteAction(fk.onUpdate)}` : "";
@@ -12688,10 +13009,11 @@ function quoteIdentifier(name) {
   validateIdentifier(name, "alias");
   return `"${name.replace(/"/g, '""')}"`;
 }
-function qualifyTable2(tableName, schemaName, naming) {
+function qualifyTable2(tableName, schemaName, naming, transformSchema = true) {
   const table = quoteIdentifier(naming.toDatabase(tableName));
   if (schemaName) {
-    return `${quoteIdentifier(naming.toDatabase(schemaName))}.${table}`;
+    const schema = transformSchema ? naming.toDatabase(schemaName) : schemaName;
+    return `${quoteIdentifier(schema)}.${table}`;
   }
   return table;
 }
@@ -12762,7 +13084,7 @@ function generateAlterTableAddFK(tableName, fk, schemaName, naming) {
     `fk_${tableName}_${fk.columns.join("_")}`
   );
   const fkCols = fk.columns.map((col) => quoteIdentifier(naming.toDatabase(col))).join(", ");
-  const refTable = qualifyTable2(fk.references.table, schemaName, naming);
+  const refTable = fk.references.schema !== void 0 ? qualifyTable2(fk.references.table, fk.references.schema, naming, false) : qualifyTable2(fk.references.table, schemaName, naming);
   const refCols = fk.references.columns.map((col) => quoteIdentifier(naming.toDatabase(col))).join(", ");
   const onDelete = fk.onDelete ? ` ON DELETE ${mapOnDeleteAction(fk.onDelete)}` : "";
   const onUpdate = fk.onUpdate ? ` ON UPDATE ${mapOnDeleteAction(fk.onUpdate)}` : "";
@@ -12776,8 +13098,9 @@ function generateCreateIndex(tableName, idx, schemaName, naming) {
   );
   const qualifiedTable = qualifyTable2(tableName, schemaName, naming);
   const unique = idx.unique ? "UNIQUE " : "";
-  if (idx.method) validateIndexMethod(idx.method, "index method");
-  const method = idx.method ? ` USING ${idx.method}` : "";
+  const indexMethod = idx.method;
+  if (indexMethod) validateIndexMethod(indexMethod, "index method");
+  const method = indexMethod ? ` USING ${indexMethod}` : "";
   const colParts = [];
   if (idx.expressions && idx.expressions.length > 0) {
     for (const expr of idx.expressions) {
@@ -12797,10 +13120,11 @@ function generateCreateIndex(tableName, idx, schemaName, naming) {
   const nullsNotDistinct = idx.unique && idx.nullsNotDistinct ? " NULLS NOT DISTINCT" : "";
   const withParams = idx.with && Object.keys(idx.with).length > 0 ? ` WITH (${Object.entries(idx.with).map(([k, v]) => {
     validateIdentifier(k, "alias");
-    return `${k} = ${v}`;
+    return `${k} = ${formatStorageParameterValue(v, `index WITH parameter "${k}"`)}`;
   }).join(", ")})` : "";
-  if (idx.where) validateSqlExpression(idx.where, "index WHERE predicate");
-  const where = idx.where ? ` WHERE ${idx.where}` : "";
+  const whereExpr = idx.where;
+  if (whereExpr) validateSqlExpression(whereExpr, "index WHERE predicate");
+  const where = whereExpr ? ` WHERE ${whereExpr}` : "";
   return `CREATE ${unique}INDEX ${indexName} ON ${qualifiedTable}${method} (${cols})${include}${nullsNotDistinct}${withParams}${where};`;
 }
 function generateCreatePolicy(tableName, policy, schemaName, naming) {
@@ -13167,7 +13491,8 @@ function normalizeTable(table, plugin) {
       columns: fk.columns.map(toDb),
       references: {
         table: toDb(fk.references.table),
-        columns: fk.references.columns.map(toDb)
+        columns: fk.references.columns.map(toDb),
+        ...fk.references.schema !== void 0 ? { schema: fk.references.schema } : {}
       }
     })),
     indexes: table.indexes.map((idx) => ({
@@ -13260,6 +13585,21 @@ function compareColumnDetails(tableName, schema, db, changes) {
       meta: { default: schema.default, oldDefault: db.default }
     });
   }
+  const schemaUnique = schema.unique === true;
+  const dbUnique = db.unique === true;
+  if (schemaUnique !== dbUnique) {
+    changes.push({
+      kind: "alter_column_unique",
+      table: tableName,
+      column: schema.name,
+      destructive: schemaUnique === false,
+      details: `Change unique of "${schema.name}" from ${dbUnique} to ${schemaUnique}`,
+      meta: {
+        unique: schemaUnique,
+        ...db.uniqueConstraintName !== void 0 ? { constraintName: db.uniqueConstraintName } : {}
+      }
+    });
+  }
   if ((schema.collation ?? null) !== (db.collation ?? null)) {
     changes.push({
       kind: "alter_column_collation",
@@ -13331,7 +13671,8 @@ function comparePrimaryKeys(schema, db, changes) {
       kind: "drop_primary_key",
       table: schema.name,
       destructive: true,
-      details: `Drop primary key (${dbPK.join(", ")})`
+      details: `Drop primary key (${dbPK.join(", ")})`,
+      meta: { columns: dbPK }
     });
     return;
   }
@@ -13339,7 +13680,8 @@ function comparePrimaryKeys(schema, db, changes) {
     kind: "drop_primary_key",
     table: schema.name,
     destructive: true,
-    details: `Drop primary key (${dbPK.join(", ")})`
+    details: `Drop primary key (${dbPK.join(", ")})`,
+    meta: { columns: dbPK }
   });
   changes.push({
     kind: "add_primary_key",
@@ -13411,7 +13753,7 @@ function compareForeignKeys(schema, db, changes) {
   }
 }
 function fkKey(fk) {
-  return `${fk.columns.join(",")}\u2192${fk.references.table}(${fk.references.columns.join(",")})`;
+  return `${fk.columns.join(",")}\u2192${fk.references.schema ?? ""}.${fk.references.table}(${fk.references.columns.join(",")})`;
 }
 function compareIndexes(schema, db, changes) {
   const explicitIndexCols = new Set(
@@ -13444,16 +13786,15 @@ function compareIndexes(schema, db, changes) {
       });
     }
   }
-  const autoUniqueIndexKeys = new Set(
-    schema.columns.filter((col) => col.unique === true).map(
-      (col) => indexKey({
-        columns: [col.name],
-        unique: true
-      })
-    )
+  const dbColMap = new Map(db.columns.map((col) => [col.name, col]));
+  const autoUniqueIndexColumns = new Set(
+    schema.columns.filter((schemaCol) => {
+      const dbCol = dbColMap.get(schemaCol.name);
+      return dbCol !== void 0 && (schemaCol.unique === true || dbCol.unique === true);
+    }).map((col) => col.name)
   );
   for (const [key, idx] of dbIdxMap) {
-    if (!schemaIdxMap.has(key) && !autoFkIndexKeys.has(key) && !autoUniqueIndexKeys.has(key)) {
+    if (!schemaIdxMap.has(key) && !autoFkIndexKeys.has(key) && !isAutoUniqueIndex(schema.name, idx, autoUniqueIndexColumns)) {
       changes.push({
         kind: "drop_index",
         table: schema.name,
@@ -13464,6 +13805,16 @@ function compareIndexes(schema, db, changes) {
     }
   }
 }
+function isAutoUniqueIndex(tableName, idx, autoUniqueIndexColumns) {
+  if (idx.columns.length !== 1) return false;
+  const column = idx.columns[0];
+  if (column === void 0 || !autoUniqueIndexColumns.has(column)) return false;
+  if (idx.unique !== true) return false;
+  if (idx.name !== void 0 && idx.name !== `${tableName}_${column}_key`) {
+    return false;
+  }
+  return idx.nullsNotDistinct !== true && (idx.method === void 0 || idx.method === "btree") && idx.where === void 0 && (idx.expressions === void 0 || idx.expressions.length === 0) && (idx.include === void 0 || idx.include.length === 0) && (idx.opclass === void 0 || Object.keys(idx.opclass).length === 0) && (idx.with === void 0 || Object.keys(idx.with).length === 0);
+}
 function indexKey(idx) {
   const parts = [
     idx.columns.join(","),
@@ -13828,6 +14179,7 @@ function buildSummary(changes) {
       case "alter_column_type":
       case "alter_column_nullable":
       case "alter_column_default":
+      case "alter_column_unique":
         columns.altered++;
         break;
       case "add_primary_key":
@@ -14078,6 +14430,7 @@ async function queryAllCatalogs(pool, schema) {
     pksResult,
     fksResult,
     indexesResult,
+    uniqueColumnsResult,
     enumsResult,
     commentsResult,
     checksResult,
@@ -14111,28 +14464,44 @@ async function queryAllCatalogs(pool, schema) {
     // 3. Foreign keys
     pool.query(
       `SELECT
-			   tc.constraint_name,
-			   kcu.table_name AS source_table,
-			   kcu.column_name AS source_column,
-			   ccu.table_name AS target_table,
-			   ccu.column_name AS target_column,
-			   rc.delete_rule,
-			   rc.update_rule,
-			   tc.is_deferrable,
-			   tc.initially_deferred
-			 FROM information_schema.table_constraints tc
-			 JOIN information_schema.key_column_usage kcu
-			   ON tc.constraint_name = kcu.constraint_name
-			   AND tc.table_schema = kcu.table_schema
-			 JOIN information_schema.constraint_column_usage ccu
-			   ON ccu.constraint_name = tc.constraint_name
-			   AND ccu.table_schema = tc.table_schema
-			 JOIN information_schema.referential_constraints rc
-			   ON rc.constraint_name = tc.constraint_name
-			   AND rc.constraint_schema = tc.table_schema
-			 WHERE tc.constraint_type = 'FOREIGN KEY'
-			   AND tc.table_schema = $1
-			 ORDER BY tc.constraint_name, kcu.ordinal_position`,
+			   c.conname AS constraint_name,
+			   source_rel.relname AS source_table,
+			   source_attr.attname AS source_column,
+			   target_ns.nspname AS target_schema,
+			   target_rel.relname AS target_table,
+			   target_attr.attname AS target_column,
+			   CASE c.confdeltype
+			     WHEN 'c' THEN 'CASCADE'
+			     WHEN 'n' THEN 'SET NULL'
+			     WHEN 'd' THEN 'SET DEFAULT'
+			     WHEN 'r' THEN 'RESTRICT'
+			     ELSE 'NO ACTION'
+			   END AS delete_rule,
+			   CASE c.confupdtype
+			     WHEN 'c' THEN 'CASCADE'
+			     WHEN 'n' THEN 'SET NULL'
+			     WHEN 'd' THEN 'SET DEFAULT'
+			     WHEN 'r' THEN 'RESTRICT'
+			     ELSE 'NO ACTION'
+			   END AS update_rule,
+			   CASE WHEN c.condeferrable THEN 'YES' ELSE 'NO' END AS is_deferrable,
+			   CASE WHEN c.condeferred THEN 'YES' ELSE 'NO' END AS initially_deferred
+			 FROM pg_constraint c
+			 JOIN pg_class source_rel ON source_rel.oid = c.conrelid
+			 JOIN pg_namespace source_ns ON source_ns.oid = source_rel.relnamespace
+			 JOIN pg_class target_rel ON target_rel.oid = c.confrelid
+			 JOIN pg_namespace target_ns ON target_ns.oid = target_rel.relnamespace
+			 JOIN LATERAL unnest(c.conkey, c.confkey) WITH ORDINALITY AS cols(source_attnum, target_attnum, ord) ON true
+			 JOIN pg_attribute source_attr
+			   ON source_attr.attrelid = c.conrelid
+			   AND source_attr.attnum = cols.source_attnum
+			 JOIN pg_attribute target_attr
+			   ON target_attr.attrelid = c.confrelid
+			   AND target_attr.attnum = cols.target_attnum
+			 WHERE c.contype = 'f'
+			   AND c.conparentid = 0
+			   AND source_ns.nspname = $1
+			 ORDER BY c.conname, cols.ord`,
       [schema]
     ),
     // 4. Indexes (excluding PK-backing indexes and unique-constraint-backing indexes).
@@ -14196,7 +14565,19 @@ async function queryAllCatalogs(pool, schema) {
 			 ORDER BY t.relname, i.relname`,
       [schema]
     ),
-    // 5. ENUM types
+    // 5. Single-column UNIQUE constraints tracked as ColumnIR.unique
+    pool.query(
+      `SELECT rel.relname AS table_name, att.attname AS column_name, c.conname AS constraint_name
+				 FROM pg_constraint c
+				 JOIN pg_class rel ON rel.oid = c.conrelid
+				 JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+				 JOIN pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = c.conkey[1]
+				 WHERE c.contype = 'u'
+				   AND array_length(c.conkey, 1) = 1
+				   AND ns.nspname = $1`,
+      [schema]
+    ),
+    // 6. ENUM types
     pool.query(
       `SELECT
 			   t.typname AS name,
@@ -14209,7 +14590,7 @@ async function queryAllCatalogs(pool, schema) {
 			 GROUP BY t.typname`,
       [schema]
     ),
-    // 6. Comments (table and column level) from pg_description
+    // 7. Comments (table and column level) from pg_description
     pool.query(
       `SELECT
 			   c.relname AS table_name,
@@ -14223,7 +14604,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND d.objsubid >= 0`,
       [schema]
     ),
-    // 7. CHECK constraints
+    // 8. CHECK constraints
     pool.query(
       `SELECT
 			   c.conname AS name,
@@ -14235,7 +14616,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND n.nspname = $1`,
       [schema]
     ),
-    // 8. Partition configurations
+    // 9. Partition configurations
     pool.query(
       `SELECT
 			   c.relname AS table_name,
@@ -14250,13 +14631,13 @@ async function queryAllCatalogs(pool, schema) {
 			 GROUP BY c.relname, p.partstrat`,
       [schema]
     ),
-    // 9. Installed extensions (no schema param — queries globally; skip plpgsql)
+    // 10. Installed extensions (no schema param — queries globally; skip plpgsql)
     pool.query(
       `SELECT extname AS name
 			 FROM pg_extension
 			 WHERE extname != 'plpgsql'`
     ),
-    // 10. Sequences not backed by SERIAL
+    // 11. Sequences not backed by SERIAL
     pool.query(
       `SELECT s.sequencename AS name, s.start_value, s.increment_by, s.min_value, s.max_value, s.cycle
 			 FROM pg_sequences s
@@ -14267,7 +14648,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND d.objid IS NULL`,
       [schema]
     ),
-    // 11. RLS enabled state per table
+    // 12. RLS enabled state per table
     pool.query(
       `SELECT c.relname AS table_name, c.relrowsecurity AS rls_enabled
 			 FROM pg_class c
@@ -14276,7 +14657,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND c.relkind = 'r'`,
       [schema]
     ),
-    // 12. Row-Level Security policies
+    // 13. Row-Level Security policies
     pool.query(
       `SELECT
 			   c.relname AS table_name,
@@ -14298,6 +14679,7 @@ async function queryAllCatalogs(pool, schema) {
     pks: pksResult.rows,
     fks: fksResult.rows,
     indexes: indexesResult.rows,
+    uniqueColumns: uniqueColumnsResult.rows,
     enums: enumsResult.rows,
     comments: commentsResult.rows,
     checks: checksResult.rows,
@@ -14383,6 +14765,21 @@ function buildIndexMap(rows) {
   }
   return result;
 }
+function buildUniqueColumnMap(rows) {
+  const result = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const existing = result.get(row.table_name);
+    if (existing) {
+      existing.set(row.column_name, row.constraint_name);
+    } else {
+      result.set(
+        row.table_name,
+        /* @__PURE__ */ new Map([[row.column_name, row.constraint_name]])
+      );
+    }
+  }
+  return result;
+}
 function buildColumnMap(rows) {
   const result = /* @__PURE__ */ new Map();
   for (const col of rows) {
@@ -14410,14 +14807,16 @@ function buildPKMap(rows) {
 function buildFKMap(rows) {
   const result = /* @__PURE__ */ new Map();
   for (const fk of rows) {
-    const existing = result.get(fk.constraint_name);
+    const key = JSON.stringify([fk.source_table, fk.constraint_name]);
+    const existing = result.get(key);
     if (existing) {
       existing.cols.push(fk.source_column);
       existing.refs.push(fk.target_column);
     } else {
-      result.set(fk.constraint_name, {
+      result.set(key, {
         source: fk.source_table,
         target: fk.target_table,
+        targetSchema: fk.target_schema,
         cols: [fk.source_column],
         refs: [fk.target_column],
         deleteRule: fk.delete_rule,
@@ -14483,10 +14882,12 @@ function buildRLSMaps(rlsRows, policiesRows) {
 function buildTableIR(tableName, ctx) {
   const rawCols = ctx.tableColumns.get(tableName) ?? [];
   const pkCols = ctx.tablePKs.get(tableName);
+  const uniqueColumns = ctx.uniqueColumns.get(tableName);
   const columns = rawCols.map((col) => {
     const identity = col.is_identity === "YES" && col.identity_generation ? col.identity_generation === "ALWAYS" ? "always" : "byDefault" : void 0;
     const collation = col.collation_name && col.collation_name !== "default" ? col.collation_name : void 0;
     const colComment = ctx.columnComments.get(`${tableName}.${col.column_name}`) ?? void 0;
+    const uniqueConstraintName = uniqueColumns?.get(col.column_name);
     return {
       name: col.column_name,
       type: mapPgType(col.data_type, col.udt_name),
@@ -14496,6 +14897,7 @@ function buildTableIR(tableName, ctx) {
       // of quoting it as a string literal.
       ...col.column_default != null ? { default: { sql: col.column_default } } : {},
       originalDbType: col.udt_name,
+      ...uniqueConstraintName !== void 0 ? { unique: true, uniqueConstraintName } : {},
       ...collation ? { collation } : {},
       ...identity ? { identity } : {},
       ...colComment ? { comment: colComment } : {}
@@ -14504,12 +14906,17 @@ function buildTableIR(tableName, ctx) {
   const foreignKeys = [];
   for (const [, fk] of ctx.fksByConstraint) {
     if (fk.source !== tableName) continue;
-    if (!ctx.tableNames.includes(fk.target)) continue;
+    const isCrossSchema = fk.targetSchema !== void 0 && fk.targetSchema !== ctx.schema;
+    if (!isCrossSchema && !ctx.tableNames.includes(fk.target)) continue;
     const onDelete = mapDeleteRule(fk.deleteRule);
     const onUpdate = mapDeleteRule(fk.updateRule);
     foreignKeys.push({
       columns: fk.cols,
-      references: { table: fk.target, columns: fk.refs },
+      references: {
+        table: fk.target,
+        columns: fk.refs,
+        ...isCrossSchema ? { schema: fk.targetSchema } : {}
+      },
       ...onDelete !== "NO ACTION" ? { onDelete } : {},
       ...onUpdate !== "NO ACTION" ? { onUpdate } : {},
       ...fk.deferred ? { deferred: true } : {}
@@ -14557,6 +14964,7 @@ async function introspect(pool, options) {
   const tablePartitions = buildPartitionMap(raw.partitions);
   const tableChecks = buildCheckMap(raw.checks);
   const tableIndexes = buildIndexMap(raw.indexes);
+  const uniqueColumns = buildUniqueColumnMap(raw.uniqueColumns);
   const tableColumns = buildColumnMap(raw.columns);
   const tablePKs = buildPKMap(raw.pks);
   const fksByConstraint = buildFKMap(raw.fks);
@@ -14575,6 +14983,7 @@ async function introspect(pool, options) {
       tablePKs,
       fksByConstraint,
       tableIndexes,
+      uniqueColumns,
       tableChecks,
       tableComments,
       columnComments,
@@ -14582,20 +14991,33 @@ async function introspect(pool, options) {
       tableRlsEnabled,
       tablePolicies,
       tableNames,
+      schema,
       warnings
     });
     tables.set(tableName, table);
   }
   const extensions = raw.extensions.map((r) => r.name);
   const sequenceMap = buildSequenceMap(raw.sequences);
-  const relations = inferRelations(fksByConstraint, tableNames);
-  const hierarchies = detectHierarchies(tables, fksByConstraint, tableNames);
+  const relations = inferRelations(fksByConstraint, tableNames, schema);
+  const hierarchies = detectHierarchies(
+    tables,
+    fksByConstraint,
+    tableNames,
+    schema
+  );
+  const externalTables = /* @__PURE__ */ new Set();
+  for (const fk of fksByConstraint.values()) {
+    if (fk.targetSchema !== void 0 && fk.targetSchema !== schema && !tables.has(fk.target)) {
+      externalTables.add(fk.target);
+    }
+  }
   const modelIR = new ModelIRImpl(
     tables,
     relations,
     enumMap,
     extensions,
-    sequenceMap
+    sequenceMap,
+    externalTables
   );
   return Object.assign(modelIR, {
     hierarchies,
@@ -14603,10 +15025,11 @@ async function introspect(pool, options) {
     warnings
   });
 }
-function inferRelations(fksByConstraint, filteredTables) {
+function inferRelations(fksByConstraint, filteredTables, schema) {
   const relations = /* @__PURE__ */ new Map();
   const filteredSet = new Set(filteredTables);
   for (const [, fk] of fksByConstraint) {
+    if (fk.targetSchema !== void 0 && fk.targetSchema !== schema) continue;
     if (!filteredSet.has(fk.source) || !filteredSet.has(fk.target)) continue;
     const belongsToName = deriveRelationName(fk.cols[0], fk.target);
     const relationFk = {
@@ -14656,13 +15079,14 @@ function deriveRelationName(fkColumn, _targetTable) {
   }
   return fkColumn;
 }
-function detectHierarchies(tables, fksByConstraint, filteredTables) {
+function detectHierarchies(tables, fksByConstraint, filteredTables, schema) {
   const hierarchies = [];
   const filteredSet = new Set(filteredTables);
   const fksBySourceTarget = /* @__PURE__ */ new Map();
   for (const [, fk] of fksByConstraint) {
+    if (fk.targetSchema !== void 0 && fk.targetSchema !== schema) continue;
     if (!filteredSet.has(fk.source) || !filteredSet.has(fk.target)) continue;
-    if (fk.source === fk.target && fk.cols.length === 1) {
+    if (fk.source === fk.target && fk.cols.length === 1 && (fk.targetSchema === void 0 || fk.targetSchema === schema)) {
       const table = tables.get(fk.source);
       const pk = table?.primaryKey;
       const nodeIdColumn = typeof pk === "string" ? pk : pk?.[0] ?? DEFAULT_PK_COLUMN;
@@ -16065,10 +16489,9 @@ function convertDottedFieldsToExists(decisions, rootTable, model) {
       ...resolved.relationType && { relationType: resolved.relationType },
       conditions: [
         {
+          ...d,
           type: "where",
           column: targetColumn,
-          operator: d.operator,
-          value: d.value,
           table: resolved.target
         }
       ]
@@ -16938,14 +17361,16 @@ function compileJoinIntents(joins, rootTable, schemaName, deps) {
         schemaForFromName(schemaName, intent.table, deps.bindingNames, naming),
         naming
       );
-      results.push({
+      const joinDecision = {
         type: "join",
         targetTable: intent.table,
         alias: tableAlias,
         joinType: intent.type,
         joinRarg: joinedRangeVar,
-        joinOnNode: onNode
-      });
+        joinOnNode: onNode,
+        joinOnParams: paramState.parameters
+      };
+      results.push(joinDecision);
     }
   }
   return results;
@@ -18152,8 +18577,9 @@ function qualifyTable3(table, schema) {
   return schema ? `${quoteIdent2(schema, "schema")}.${quoteIdent2(table, "table")}` : quoteIdent2(table, "table");
 }
 function generateCreateIndexSQL(table, options, schema) {
-  if (options.method !== void 0) {
-    validateIndexMethod(options.method, "index method");
+  const indexMethod = options.method;
+  if (indexMethod !== void 0) {
+    validateIndexMethod(indexMethod, "index method");
   }
   const parts = ["CREATE"];
   if (options.unique) parts.push("UNIQUE");
@@ -18162,8 +18588,8 @@ function generateCreateIndexSQL(table, options, schema) {
   if (options.ifNotExists) parts.push("IF NOT EXISTS");
   parts.push(quoteIdentifier2(options.name));
   parts.push(`ON ${qualifyTable3(table, schema)}`);
-  if (options.method) {
-    parts.push(`USING ${options.method}`);
+  if (indexMethod) {
+    parts.push(`USING ${indexMethod}`);
   }
   const colParts = [];
   for (const col of options.columns) {
@@ -18180,13 +18606,14 @@ function generateCreateIndexSQL(table, options, schema) {
   if (options.with && Object.keys(options.with).length > 0) {
     const withParams = Object.entries(options.with).map(([k, v]) => {
       validateIdentifier(k, "alias");
-      return `${k} = ${v}`;
+      return `${k} = ${formatStorageParameterValue(v, `index WITH parameter "${k}"`)}`;
     }).join(", ");
     parts.push(`WITH (${withParams})`);
   }
-  if (options.where) {
-    validateSqlExpression(options.where, "index WHERE predicate");
-    parts.push(`WHERE ${options.where}`);
+  const whereExpr = options.where;
+  if (whereExpr) {
+    validateSqlExpression(whereExpr, "index WHERE predicate");
+    parts.push(`WHERE ${whereExpr}`);
   }
   return parts.join(" ");
 }
@@ -18197,10 +18624,11 @@ function buildColumnPart(col, opclassMap) {
     if (opclass2) validateIdentifier(opclass2, "alias");
     return opclass2 ? `${quoted} ${opclass2}` : quoted;
   }
-  validateSqlExpression(col.expression, "index expression");
+  const expression = col.expression;
+  validateSqlExpression(expression, "index expression");
   const opclass = col.opclass;
   if (opclass) validateIdentifier(opclass, "alias");
-  return opclass ? `${col.expression} ${opclass}` : col.expression;
+  return opclass ? `${expression} ${opclass}` : expression;
 }
 function generateDropIndexSQL(name, options) {
   const parts = ["DROP INDEX"];