@everystack/cli 0.4.67 → 0.4.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/cli",
-  "version": "0.4.67",
+  "version": "0.4.68",
   "description": "CLI and OTA updates for Expo apps on everystack",
   "license": "AGPL-3.0-only",
   "author": "Scalable Technology, Inc. <licensing@scalable.technology>",

package/src/cli/deparse-normal.ts

@@ -24,13 +24,33 @@
  *   for n ≥ 1. PostgreSQL defines an array-to-array cast element-wise (parse_coerce), so
  *   the two expressions denote the same value for every input; wrapping an element in
  *   parentheses is parse-neutral. The empty array is EXCLUDED: `ARRAY[]` without a cast has
- *   no type, so its cast is load-bearing and stays.
+ *   no type, so its cast is load-bearing and stays. (The measured CROSS-VERSION case: two PG
+ *   majors const-fold the same DDL differently.)
+ *
+ *   LITERAL-TEXT-CAST STRIP: `'lit'::text  ==  'lit'`, but ONLY the bare `text` cast applied
+ *   directly to a single-quoted string literal. This is a CROSS-PRODUCER class, present on
+ *   every version: PostgreSQL coerces an unknown-type string literal compared to a text
+ *   column and RECORDS `'lit'::text` in the stored tree, while the author's model source
+ *   writes the un-cast `'lit'`. The two producers' texts never converge without this rule, so
+ *   a `text_col = 'lit'` partial index / CHECK / policy re-diffs DROP+CREATE forever and the
+ *   fingerprint gate cannot MATCH. Safe because `text` takes no typmod and its input function
+ *   is the identity on the literal's bytes — the cast cannot change the value. The rule is
+ *   `text`-ONLY for exactly that reason: `bpchar`/`character(n)` blank-pad or blank-trim,
+ *   `varchar(n)`/`"char"` truncate — those casts CHANGE the value, so stripping one would
+ *   collapse two opposite-truth predicates to equal text (a false match, the disaster). The
+ *   array-type cast `::text[]` is likewise excluded — it carries the element type. See the
+ *   `char(2)` false-match test for why the family is not widened.
  *
  * Anything the scanner does not positively recognize is left byte-for-byte unchanged — an
  * unrecognized spelling is a MISS (drop + create, the pre-existing behavior), never a guess.
- * Escalation is named, not implied: the SECOND cross-version variant found in the field is
+ * Escalation is named, not implied: the SECOND cross-VERSION variant found in the field is
  * the trigger to adopt libpg_query and move identity onto normalized ASTs (Ty, 2026-08-09) —
- * a growing rule table over raw text is where scanning stops being defensible.
+ * a growing rule table over raw text is where scanning stops being defensible. One correction
+ * to that trigger (2026-08-24): libpg_query closes cross-VERSION SYNTAX drift (whitespace,
+ * parens, keyword case), NOT cross-PRODUCER COERCION drift — a raw parse tree carries no type
+ * resolution, so `'lit'` and `'lit'::text` still differ structurally without a catalog, which
+ * the CI-pure `db:diff` lane does not have. That class earns a provable text rewrite here,
+ * verified end-to-end by `db:check`'s from-scratch build on a real database.
  *
  * Applied at the PRODUCERS (live introspection's `predicate()`, the compiler's policy
  * assembly), so every downstream comparison — the identity matcher, the canonical hash, the
@@ -121,6 +141,53 @@ function distributeOnce(s: string): string | null {
   return null;
 }
 
+/**
+ * A bare `text` cast token — `::text` or `::pg_catalog.text` — from just past a literal's
+ * closing quote. Whitespace around `::` is tolerated (pg emits none; an author might). The
+ * trailing `\b` rejects `::textfoo`; the caller additionally rejects a following `[` so the
+ * array-type cast `::text[]` is never stripped.
+ */
+const LITERAL_TEXT_CAST = /^\s*::\s*(?:pg_catalog\.)?text\b/;
+
+/**
+ * Strip a bare `text` cast applied directly to a single-quoted string literal, wherever one
+ * appears. One left-to-right pass is complete: removing a cast token cannot create a new
+ * `'literal'::text` pair to its left, and it never forms an `(ARRAY[…])::T[]` for the other
+ * rule. Quoted regions are skipped so a `::text` inside a literal is content, not structure.
+ */
+function stripLiteralTextCast(s: string): string {
+  let out = '';
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "'") {
+      const close = skipQuoted(s, i);
+      if (close < 0) return out + s.slice(i); // unterminated literal — leave the rest alone
+      out += s.slice(i, close + 1); // the literal itself, verbatim
+      i = close + 1;
+      // Drop a bare text cast on the literal, and any stacked `::text::text`, so the result
+      // is a true fixpoint. `::text[]` is the array-type cast (element type, load-bearing),
+      // not a scalar text cast — the look-ahead skips whitespace so `::text []` is kept too.
+      let m = LITERAL_TEXT_CAST.exec(s.slice(i));
+      while (m && !/^\s*\[/.test(s.slice(i + m[0].length))) {
+        i += m[0].length; // drop the cast token
+        m = LITERAL_TEXT_CAST.exec(s.slice(i));
+      }
+      continue;
+    }
+    if (c === '"') {
+      const close = skipQuoted(s, i);
+      if (close < 0) return out + s.slice(i);
+      out += s.slice(i, close + 1); // a quoted identifier — never a string literal, skip whole
+      i = close + 1;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+
 /**
  * Normalize one deparsed expression. Idempotent; unrecognized text returns unchanged.
  * Fixpoint-bounded: nesting deeper than the cap returns its progress, which is still
@@ -130,8 +197,8 @@ export function normalizeDeparsedExpr(text: string): string {
   let s = text;
   for (let n = 0; n < 64; n++) {
     const next = distributeOnce(s);
-    if (next === null) return s;
+    if (next === null) break;
     s = next;
   }
-  return s;
+  return stripLiteralTextCast(s);
 }