sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ SQL/ PostgresTls.test.ts

import {
  resolveConnectionOptions,
  resolvePoolConfig,
  resolveSsl,
} from "@alchemy.run/sql/PostgresTls";
import { describe, expect, it } from "@alchemy.run/test";
import * as PgClient from "@effect/sql-pg/PgClient";
import * as Effect from "effect/Effect";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";

const url = (s: string) => Redacted.make(s);

describe("SQL/PostgresTls resolveSsl", { tags: ["unit", "local"] }, () => {
  it("resolves sslmode=prefer|allow to TLS on when ssl is implicit", () => {
    for (const mode of ["prefer", "allow"]) {
      expect(resolveSsl(url(`postgres://u@ep-x.neon.tech/x?sslmode=${mode}`), undefined)).toBe(
        true,
      );
      expect(resolveSsl(url(`postgres://u@127.0.0.1:5432/x?sslmode=${mode}`), undefined)).toBe(
        true,
      );
    }
  });

  it("leaves every other URL to @effect/sql-pg", () => {
    expect(resolveSsl(url("postgres://u@db.example.com/x"), undefined)).toBeUndefined();
    for (const mode of ["disable", "require", "verify-ca", "verify-full"]) {
      expect(
        resolveSsl(url(`postgres://u@db.example.com/x?sslmode=${mode}`), undefined),
      ).toBeUndefined();
    }
  });

  it("never overrides an explicit ssl option", () => {
    const explicit = { rejectUnauthorized: false, servername: "override" };
    expect(resolveSsl(url("postgres://u@db.example.com/x?sslmode=prefer"), explicit)).toBe(
      explicit,
    );
    expect(resolveSsl(url("postgres://u@db.example.com/x?sslmode=prefer"), false)).toBe(false);
    expect(resolveSsl(url("postgres://u@db.example.com/x?sslmode=require"), true)).toBe(true);
  });

  it("passes malformed URLs through untouched", () => {
    expect(resolveSsl(url("not a url"), undefined)).toBeUndefined();
    expect(resolveSsl(url("not a url"), true)).toBe(true);
  });
});

describe("SQL/PostgresTls resolveConnectionOptions", { tags: ["unit", "local"] }, () => {
  const railwayUrl = url(
    "postgresql://user:p%40ss@db.railway.internal:5432/railway?sslmode=no-verify&connect_timeout=7&application_name=app",
  );

  it("preserves Railway no-verify TLS semantics in a driver-compatible URL", () => {
    const options = resolveConnectionOptions(railwayUrl);
    const parsed = new URL(Redacted.value(options.url));
    expect(parsed.searchParams.get("sslmode")).toBe("require");
    expect(parsed.searchParams.get("connect_timeout")).toBe("7");
    expect(parsed.searchParams.get("application_name")).toBe("app");
    expect(parsed.password).toBe("p%40ss");
    expect(options.ssl).toEqual({ rejectUnauthorized: false });
    expect(Redacted.value(railwayUrl)).toContain("sslmode=no-verify");
  });

  it("passes Railway URLs through the actual driver parser before opening a transport", async () => {
    const stopped = new Error("Local transport sentinel");
    let attempted = false;
    const result = await Effect.runPromise(
      Effect.gen(function* () {
        const sql = yield* PgClient.PgClient;
        return yield* sql`select 1`;
      }).pipe(
        Effect.provide(
          PgClient.layer({
            ...resolveConnectionOptions(railwayUrl),
            stream: () => {
              attempted = true;
              throw stopped;
            },
          }),
        ),
        Effect.scoped,
        Effect.result,
      ),
    );
    expect(attempted).toBe(true);
    expect(Result.isFailure(result)).toBe(true);
    if (Result.isFailure(result)) {
      expect(result.failure.reason.cause).toBe(stopped);
    }
  });

  it("keeps explicitly configured verification and SNI authoritative", () => {
    expect(resolveConnectionOptions(railwayUrl, true).ssl).toBe(true);
    expect(
      resolveConnectionOptions(railwayUrl, {
        rejectUnauthorized: true,
        servername: "custom.example.com",
        ca: "test-ca",
      }).ssl,
    ).toEqual({ rejectUnauthorized: true, servername: "custom.example.com", ca: "test-ca" });
    expect(resolveConnectionOptions(railwayUrl, false).ssl).toBe(false);
    expect(
      new URL(Redacted.value(resolveConnectionOptions(railwayUrl, false).url)).searchParams.get(
        "sslmode",
      ),
    ).toBe("require");
  });

  it("does not invent SNI for a no-verify IP connection", () => {
    expect(resolveConnectionOptions(url("postgres://u@[::1]/db?sslmode=no-verify")).ssl).toEqual({
      rejectUnauthorized: false,
    });
  });

  it("preserves unmodified and malformed URLs for driver validation", () => {
    for (const value of ["postgres://u@db.example/db?sslmode=verify-full", "not a url"]) {
      const original = url(value);
      expect(resolveConnectionOptions(original).url).toBe(original);
    }
  });
});

describe("SQL/PostgresTls resolvePoolConfig", { tags: ["unit", "local"] }, () => {
  it("passes client options through with the URL's TLS settings", () => {
    const config = resolvePoolConfig(url("postgres://u@127.0.0.1:5432/x?sslmode=prefer"), {
      prepare: false,
      maxConnections: 3,
    });
    expect(config.prepare).toBe(false);
    expect(config.maxConnections).toBe(3);
    expect(config.ssl).toBe(true);
    expect(Redacted.value(config.url!)).toBe("postgres://u@127.0.0.1:5432/x?sslmode=prefer");
  });

  it("keeps an explicit ssl option over the URL's sslmode", () => {
    const config = resolvePoolConfig(url("postgres://u@127.0.0.1:5432/x?sslmode=prefer"), {
      ssl: false,
    });
    expect(config.ssl).toBe(false);
  });

  it("leaves the driver defaults without options", () => {
    const config = resolvePoolConfig(url("postgres://u@db.example.com/x"));
    expect(config.prepare).toBeUndefined();
    expect(config.ssl).toBeUndefined();
  });
});