test(migrate-ts): pin that a stored length((col)::text) on char(n) is drift

Covers the non-regex bpchar case on real Postgres and offline.

Author: dmealing

server/typescript/packages/migrate-ts/test/check-evolution/diff-offline.test.ts

@@ -77,6 +77,17 @@ describe("diffTableChecks — regex check on a text-family column", () => {
     const r = await diff({ expected: withKey(undefined, [generated]), actual: withKey("bpchar", [uncast]), dialect: "postgres" });
     expect(r.changes.filter((c) => c.kind.endsWith("-check"))).toEqual([]);
   });
+  test("bpchar column: a stored length((col)::text) is drift against the uncast length()", async () => {
+    const expected = CHK("spaces_key_length_chk", `length("key") >= 2`);
+    const cast = CHK("spaces_key_length_chk", `((length((key)::text) >= 2))`);
+    const uncast = CHK("spaces_key_length_chk", `(length(key) >= 2)`);
+    const kinds = async (udt: string, actual: CheckDescriptor) =>
+      (await diff({ expected: withKey(undefined, [expected]), actual: withKey(udt, [actual]), dialect: "postgres" }))
+        .changes.filter((c) => c.kind.endsWith("-check")).map((c) => c.kind).sort();
+    expect(await kinds("bpchar", cast)).toEqual(["add-check", "drop-check"]);
+    expect(await kinds("bpchar", uncast)).toEqual([]);
+    expect(await kinds("varchar", cast)).toEqual([]);
+  });
   test("citext column: cast vs uncast is drift", async () => {
     expect((await checkChanges("citext")).map((c) => c.kind).sort()).toEqual(["add-check", "drop-check"]);
   });

server/typescript/packages/migrate-ts/test/integration/pg-regex-check-cast.test.ts

@@ -40,6 +40,25 @@ const meta = JSON.stringify({
   },
 });
 
+const lengthMeta = JSON.stringify({
+  "metadata.root": {
+    package: "acme",
+    children: [
+      {
+        "object.entity": {
+          name: "Space",
+          children: [
+            { "source.rdb": { "@table": "spaces" } },
+            { "field.long": { name: "id" } },
+            { "field.string": { name: "key", "@column": "key", children: [{ "validator.length": { name: "len", "@min": 2 } }] } },
+            { "identity.primary": { name: "pk", "@fields": ["id"], "@generation": "increment" } },
+          ],
+        },
+      },
+    ],
+  },
+});
+
 describe("regex CHECK vs Postgres's stored rewrite (live PG)", () => {
   if (!PG_URL) {
     test.skip("skipped — MIGRATE_TS_PG_URL not set", () => {});
@@ -105,6 +124,38 @@ describe("regex CHECK vs Postgres's stored rewrite (live PG)", () => {
     expect(r.kinds).toEqual(["add-check", "drop-check"]);
   });
 
+  // The same holds off the regex operator: `length(bpchar)` is its own function, so a stored
+  // `length((key)::text)` is a different constraint from the uncast `length("key")`, while a
+  // varchar column's cast is Postgres's own rewrite.
+  const lengthChanges = async (colType: string, authoredCheck: string) => {
+    await sql.raw("DROP TABLE IF EXISTS spaces CASCADE").execute(kysely);
+    await sql
+      .raw(`CREATE TABLE spaces (id bigserial PRIMARY KEY, "key" ${colType} NOT NULL,
+            CONSTRAINT spaces_key_length_chk CHECK (${authoredCheck}))`)
+      .execute(kysely);
+    const actual = await introspectPostgres(kysely);
+    const stored = actual.tables.find((t) => t.name === "spaces")?.checks.find((c) => c.name === "spaces_key_length_chk");
+    const loaded = await new MetaDataLoader().load([new InMemoryStringSource(lengthMeta)]);
+    expect(loaded.errors).toEqual([]);
+    const d = await diff({ expected: buildExpectedSchema(loaded.root, { dialect: "postgres" }), actual, dialect: "postgres" });
+    return { stored: stored?.expression, kinds: d.changes.filter((c) => c.kind.endsWith("-check")).map((c) => c.kind).sort() };
+  };
+  test("char(n) column: Postgres stores length() uncast and it is clean", async () => {
+    const r = await lengthChanges("char(8)", `length("key") >= 2`);
+    expect(r.stored).not.toContain("::text");
+    expect(r.kinds).toEqual([]);
+  });
+  test("char(n) column: a stored length((col)::text) is drift against the uncast length()", async () => {
+    const r = await lengthChanges("char(8)", `length(("key")::text) >= 2`);
+    expect(r.stored).toContain("(key)::text");
+    expect(r.kinds).toEqual(["add-check", "drop-check"]);
+  });
+  test("varchar column: Postgres's length((col)::text) rewrite is no drift", async () => {
+    const r = await lengthChanges("varchar(8)", `length("key") >= 2`);
+    expect(r.stored).toContain("(key)::text");
+    expect(r.kinds).toEqual([]);
+  });
+
   test("varchar column: a changed pattern still reads as drift", async () => {
     const r = await checkChanges("varchar(64)", `"key" ~ '^[a-z]+$'`);
     expect(r.kinds).toEqual(["add-check", "drop-check"]);