@malloy-publisher/server 0.0.198-dev → 0.0.198

package/tests/integration/legacy_routes/legacy_routes.integration.spec.ts

@@ -0,0 +1,259 @@
+/// <reference types="bun-types" />
+
+// TODO: Remove this during projects cleanup
+/**
+ * Smoke tests for the legacy `/api/v0/projects/...` REST surface registered
+ * by `server-old.ts`. These routes exist purely to keep pre-rename SDK
+ * clients (e.g. `@malloydata/db-publisher`) working after the
+ * projects→environments rename.
+ *
+ * One test per route group: projects CRUD, packages, connections, models,
+ * notebooks, databases, queries, materializations, manifest. The
+ * materialization test additionally asserts the response field rename
+ * (`projectId` not `environmentId`). `/status` is no longer in the legacy
+ * surface — both old and new clients hit the single `/api/v0/status`
+ * handler in server.ts, which returns `environments`.
+ *
+ * This file is intentionally separate from the regular integration suite so
+ * it can be deleted in one motion when legacy support is dropped.
+ */
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import path from "path";
+import { fileURLToPath } from "url";
+import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Use a distinct project name so this suite doesn't collide with the
+// materialization integration suite (which also uses "test-project") if
+// they ever run in the same DB instance.
+const PROJECT_NAME = "legacy-routes-test-project";
+const PACKAGE_NAME = "persist-test";
+
+describe("Legacy /api/v0/projects/* REST routes (E2E)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+
+      // Create the test environment via the LEGACY route — proves POST
+      // /projects works end-to-end.
+      const fixtureDir = path.resolve(__dirname, "../../fixtures/persist-test");
+      const createRes = await fetch(`${baseUrl}/api/v0/projects`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: PROJECT_NAME,
+            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         const body = await createRes.text();
+         throw new Error(
+            `Failed to create test project via legacy route (${createRes.status}): ${body}`,
+         );
+      }
+
+      // Wait for the package to finish loading via the legacy GET path.
+      const deadline = Date.now() + 30_000;
+      let pkgReady = false;
+      while (!pkgReady && Date.now() < deadline) {
+         try {
+            const res = await fetch(
+               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}`,
+            );
+            if (res.ok) {
+               pkgReady = true;
+               break;
+            }
+         } catch {
+            // not ready yet
+         }
+         await new Promise((r) => setTimeout(r, 500));
+      }
+      if (!pkgReady) {
+         throw new Error("Test package did not become available in time");
+      }
+   });
+
+   afterAll(async () => {
+      if (baseUrl) {
+         try {
+            // Clean up via the legacy DELETE route.
+            await fetch(`${baseUrl}/api/v0/projects/${PROJECT_NAME}`, {
+               method: "DELETE",
+            });
+         } catch {
+            // best-effort cleanup
+         }
+      }
+      await env?.stop();
+      env = null;
+   });
+
+   describe("projects CRUD", () => {
+      it("GET /projects lists environments under the legacy URL", async () => {
+         const res = await fetch(`${baseUrl}/api/v0/projects`);
+         expect(res.status).toBe(200);
+         const body = (await res.json()) as Array<{ name?: string }>;
+         expect(Array.isArray(body)).toBe(true);
+         expect(body.some((e) => e.name === PROJECT_NAME)).toBe(true);
+      });
+
+      it("GET /projects/:projectName returns the project", async () => {
+         const res = await fetch(`${baseUrl}/api/v0/projects/${PROJECT_NAME}`);
+         expect(res.status).toBe(200);
+         const body = (await res.json()) as { name?: string };
+         expect(body.name).toBe(PROJECT_NAME);
+      });
+   });
+
+   describe("packages", () => {
+      it("GET /projects/:projectName/packages returns the package list", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages`,
+         );
+         expect(res.status).toBe(200);
+         const body = (await res.json()) as Array<{ name?: string }>;
+         expect(Array.isArray(body)).toBe(true);
+         expect(body.some((p) => p.name === PACKAGE_NAME)).toBe(true);
+      });
+
+      it("GET /projects/:projectName/packages/:packageName returns the package", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}`,
+         );
+         expect(res.status).toBe(200);
+         const body = (await res.json()) as { name?: string };
+         expect(body.name).toBe(PACKAGE_NAME);
+      });
+   });
+
+   describe("connections", () => {
+      it("GET /projects/:projectName/connections returns 200 (may be empty)", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/connections`,
+         );
+         expect(res.status).toBe(200);
+         const body = await res.json();
+         expect(Array.isArray(body)).toBe(true);
+      });
+   });
+
+   describe("models", () => {
+      it("GET /projects/:projectName/packages/:packageName/models returns the model list", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/models`,
+         );
+         expect(res.status).toBe(200);
+         const body = await res.json();
+         expect(Array.isArray(body)).toBe(true);
+      });
+   });
+
+   describe("notebooks", () => {
+      it("GET /projects/:projectName/packages/:packageName/notebooks returns 200", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/notebooks`,
+         );
+         expect(res.status).toBe(200);
+         const body = await res.json();
+         expect(Array.isArray(body)).toBe(true);
+      });
+   });
+
+   describe("databases", () => {
+      it("GET /projects/:projectName/packages/:packageName/databases returns 200", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/databases`,
+         );
+         expect(res.status).toBe(200);
+         const body = await res.json();
+         expect(Array.isArray(body)).toBe(true);
+      });
+   });
+
+   describe("queries", () => {
+      it("POST /projects/:projectName/packages/:packageName/models/.../query reaches the handler", async () => {
+         // Hit the route with a bogus model name. We only need to prove the
+         // legacy URL is wired up to the controller — a structured JSON
+         // error (not Express's HTML fall-through 404) is sufficient signal.
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/models/does-not-exist.malloy/query`,
+            {
+               method: "POST",
+               headers: { "Content-Type": "application/json" },
+               body: JSON.stringify({ query: "run: nothing" }),
+            },
+         );
+         expect(res.status).toBeGreaterThanOrEqual(400);
+         expect(res.status).toBeLessThan(600);
+         // Controller errors come back as JSON with a `message` field.
+         // An unhandled Express 404 returns HTML — that would fail here.
+         const body = (await res.json()) as Record<string, unknown>;
+         expect(typeof body.message).toBe("string");
+      });
+   });
+
+   describe("materializations", () => {
+      it("GET list and POST create return 'projectId' (not 'environmentId') under the legacy URL", async () => {
+         const listRes = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations`,
+         );
+         expect(listRes.status).toBe(200);
+         const list = (await listRes.json()) as unknown;
+         expect(Array.isArray(list)).toBe(true);
+
+         // Create one so we can assert the field rename on a populated payload.
+         const createRes = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations`,
+            {
+               method: "POST",
+               headers: { "Content-Type": "application/json" },
+               body: JSON.stringify({ autoLoadManifest: true }),
+            },
+         );
+         expect(createRes.status).toBe(201);
+         const created = (await createRes.json()) as Record<string, unknown>;
+
+         // Legacy contract: materialization payloads expose `projectId`, not
+         // `environmentId`. This is the response remapper in server-old.ts.
+         expect(created).toHaveProperty("projectId");
+         expect(created).not.toHaveProperty("environmentId");
+
+         const id = created.id as string;
+         // Best-effort cleanup so we don't leak a PENDING materialization
+         // into other tests. We don't poll-to-terminal; the suite teardown
+         // of the project will mop up.
+         try {
+            await fetch(
+               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations/${id}?action=stop`,
+               { method: "POST" },
+            );
+            await fetch(
+               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations/${id}`,
+               { method: "DELETE" },
+            );
+         } catch {
+            // ignore
+         }
+      });
+   });
+
+   describe("manifest", () => {
+      it("GET /projects/:projectName/packages/:packageName/manifest returns 200 or a structured 4xx", async () => {
+         const res = await fetch(
+            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/manifest`,
+         );
+         // Without a built materialization the manifest may be empty/404 —
+         // we only assert the legacy URL reaches the handler, not 404 from
+         // Express's catch-all.
+         expect([200, 400, 404]).toContain(res.status);
+      });
+   });
+});

package/tests/unit/duckdb/attached_databases.test.ts

@@ -855,7 +855,7 @@ describe("createEnvironmentConnections - DuckDB", () => {
 
          await expect(
             createEnvironmentConnections(connections, PROJECT_TEST_DIR),
-         ).rejects.toThrow("DuckDB connection name cannot be 'duckdb'");
+         ).rejects.toThrow(/'duckdb' is reserved/);
       });
 
       it("should throw when DuckDB connection name is 'duckdb' with attached databases", async () => {
@@ -885,10 +885,12 @@ describe("createEnvironmentConnections - DuckDB", () => {
 
          await expect(
             createEnvironmentConnections(connections, PROJECT_TEST_DIR),
-         ).rejects.toThrow("DuckDB connection name cannot be 'duckdb'");
+         ).rejects.toThrow(/'duckdb' is reserved/);
       });
 
       it("should throw when DuckDB connection has no attached databases", async () => {
+         // Env-level DuckDB requires at least one attached foreign db;
+         // the per-package "duckdb" sandbox covers the plain-in-memory case.
          const connections: ApiConnection[] = [
             {
                name: "no_attached_db",
@@ -901,9 +903,7 @@ describe("createEnvironmentConnections - DuckDB", () => {
 
          await expect(
             createEnvironmentConnections(connections, PROJECT_TEST_DIR),
-         ).rejects.toThrow(
-            "DuckDB connection must have at least one attached database",
-         );
+         ).rejects.toThrow(/has no attached databases/);
       });
 
       it("should throw on unsupported connection type", async () => {

package/tests/unit/duckdb/legacy_schema_migration.test.ts

@@ -0,0 +1,194 @@
+/// <reference types="bun-types" />
+
+// TODO: Remove this during projects cleanup
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { DuckDBConnection } from "../../../src/storage/duckdb/DuckDBConnection";
+import { initializeSchema } from "../../../src/storage/duckdb/schema";
+
+const TEST_DB_DIR = path.join(os.tmpdir(), "duckdb-legacy-migration-tests");
+
+// Seed a pre-rename schema on an *already-open* connection. We deliberately
+// avoid opening, closing, and reopening the same DuckDB file within a test:
+// on Windows runners the second `duckdb.Database(path)` call sometimes fails
+// with `Invalid Error` because the OS hasn't released the file handle yet.
+// Sharing one connection between seed and assertion sidesteps that entirely.
+async function seedLegacySchema(db: DuckDBConnection): Promise<void> {
+   // Seed a pre-rename schema: parent table named `projects` and child
+   // tables with `project_id` foreign-key columns. Mirrors what an existing
+   // installation looked like before the projects→environments rename.
+   await db.run(`
+      CREATE TABLE projects (
+         id VARCHAR PRIMARY KEY,
+         name VARCHAR NOT NULL UNIQUE,
+         path VARCHAR NOT NULL,
+         description VARCHAR,
+         metadata JSON,
+         created_at TIMESTAMP NOT NULL,
+         updated_at TIMESTAMP NOT NULL
+      )
+   `);
+   await db.run(`
+      CREATE TABLE packages (
+         id VARCHAR PRIMARY KEY,
+         project_id VARCHAR NOT NULL,
+         name VARCHAR NOT NULL,
+         description VARCHAR,
+         manifest_path VARCHAR NOT NULL,
+         metadata JSON,
+         created_at TIMESTAMP NOT NULL,
+         updated_at TIMESTAMP NOT NULL,
+         FOREIGN KEY (project_id) REFERENCES projects(id)
+      )
+   `);
+   await db.run(`
+      CREATE TABLE connections (
+         id VARCHAR PRIMARY KEY,
+         project_id VARCHAR NOT NULL,
+         name VARCHAR NOT NULL,
+         type VARCHAR NOT NULL,
+         config JSON NOT NULL,
+         created_at TIMESTAMP NOT NULL,
+         updated_at TIMESTAMP NOT NULL,
+         FOREIGN KEY (project_id) REFERENCES projects(id)
+      )
+   `);
+   await db.run(`
+      CREATE TABLE materializations (
+         id VARCHAR PRIMARY KEY,
+         project_id VARCHAR NOT NULL,
+         package_name VARCHAR NOT NULL,
+         status VARCHAR NOT NULL,
+         active_key VARCHAR,
+         started_at TIMESTAMP,
+         completed_at TIMESTAMP,
+         error TEXT,
+         metadata JSON,
+         created_at TIMESTAMP NOT NULL,
+         updated_at TIMESTAMP NOT NULL,
+         FOREIGN KEY (project_id) REFERENCES projects(id)
+      )
+   `);
+   await db.run(`
+      CREATE TABLE build_manifests (
+         id VARCHAR PRIMARY KEY,
+         project_id VARCHAR NOT NULL,
+         package_name VARCHAR NOT NULL,
+         build_id VARCHAR NOT NULL,
+         table_name VARCHAR NOT NULL,
+         source_name VARCHAR NOT NULL,
+         connection_name VARCHAR NOT NULL,
+         created_at TIMESTAMP NOT NULL,
+         updated_at TIMESTAMP NOT NULL,
+         FOREIGN KEY (project_id) REFERENCES projects(id)
+      )
+   `);
+
+   await db.run(
+      `INSERT INTO projects VALUES ('p1', 'proj-one', '/p1', 'd1', NULL,
+         TIMESTAMP '2024-01-01 00:00:00', TIMESTAMP '2024-01-01 00:00:00')`,
+   );
+   await db.run(
+      `INSERT INTO packages VALUES ('pkg1', 'p1', 'pkg-one', NULL, '/m', NULL,
+         TIMESTAMP '2024-01-01 00:00:00', TIMESTAMP '2024-01-01 00:00:00')`,
+   );
+}
+
+describe("DuckDB legacy projects schema cleanup", () => {
+   beforeEach(async () => {
+      await fs.mkdir(TEST_DB_DIR, { recursive: true });
+   });
+
+   afterEach(async () => {
+      try {
+         await fs.rm(TEST_DB_DIR, { recursive: true, force: true });
+      } catch {
+         // ignore
+      }
+   });
+
+   it("drops legacy projects schema and creates the new environments schema cleanly", async () => {
+      const dbPath = path.join(TEST_DB_DIR, "legacy.duckdb");
+      const db = new DuckDBConnection(dbPath);
+      await db.initialize();
+
+      // Seed the legacy schema on the same connection, then run the
+      // production schema-init path. This mirrors a server upgrade
+      // (legacy data on disk, new code starting up) without forcing a
+      // close+reopen, which is unreliable on Windows runners.
+      await seedLegacySchema(db);
+      await initializeSchema(db);
+
+      // Legacy parent table is gone.
+      const legacyProjects = await db.all<{ name: string }>(
+         "SELECT name FROM sqlite_master WHERE type='table' AND name='projects'",
+      );
+      expect(legacyProjects.length).toBe(0);
+
+      // New `environments` table exists and is empty (legacy data dropped).
+      const envs = await db.all<{ id: string }>("SELECT id FROM environments");
+      expect(envs.length).toBe(0);
+
+      // Child tables are queryable by `environment_id` (the new column),
+      // proving they were recreated with the new schema rather than left on
+      // the old `project_id` column.
+      const pkgs = await db.all<{ id: string }>(
+         "SELECT id FROM packages WHERE environment_id = ?",
+         ["p1"],
+      );
+      expect(pkgs.length).toBe(0);
+      const conns = await db.all<{ id: string }>(
+         "SELECT id FROM connections WHERE environment_id = ?",
+         ["p1"],
+      );
+      expect(conns.length).toBe(0);
+      const mats = await db.all<{ id: string }>(
+         "SELECT id FROM materializations WHERE environment_id = ?",
+         ["p1"],
+      );
+      expect(mats.length).toBe(0);
+      const manifests = await db.all<{ id: string }>(
+         "SELECT id FROM build_manifests WHERE environment_id = ?",
+         ["p1"],
+      );
+      expect(manifests.length).toBe(0);
+
+      await db.close();
+   });
+
+   it("is idempotent: running initializeSchema twice on a migrated DB is a no-op", async () => {
+      const dbPath = path.join(TEST_DB_DIR, "legacy_idempotent.duckdb");
+      const db = new DuckDBConnection(dbPath);
+      await db.initialize();
+
+      await seedLegacySchema(db);
+      await initializeSchema(db);
+      // Second call should hit the early-return path (isInitialized() === true).
+      await initializeSchema(db);
+
+      const envs = await db.all<{ id: string }>("SELECT id FROM environments");
+      expect(envs.length).toBe(0);
+
+      await db.close();
+   });
+
+   it("creates a fresh schema unchanged when no legacy projects table is present", async () => {
+      const dbPath = path.join(TEST_DB_DIR, "fresh.duckdb");
+      const db = new DuckDBConnection(dbPath);
+      await db.initialize();
+      await initializeSchema(db);
+
+      const envs = await db.all<{ id: string }>("SELECT id FROM environments");
+      expect(envs.length).toBe(0);
+
+      const legacy = await db.all<{ name: string }>(
+         "SELECT name FROM sqlite_master WHERE type='table' AND name='projects'",
+      );
+      expect(legacy.length).toBe(0);
+
+      await db.close();
+   });
+});

package/tests/unit/storage/StorageManager.test.ts

@@ -0,0 +1,166 @@
+// Unit tests for the catch-block wiring in
+// StorageManager.attachDuckLakeCatalog. The pure helpers from
+// `pg_helpers.ts` are tested directly in `pg_helpers.spec.ts`; this file
+// covers the integration — that the helpers are invoked in the right
+// order and the right places inside `initializeDuckLakeForEnvironment`.
+//
+// Stubs DuckDBConnection.run instead of using a real DuckDB so we can
+// inject libpq-style errors at the ATTACH boundary without standing up a
+// real Postgres.
+//
+// Lives under `tests/unit/` (not `src/`) on purpose: the `src/` unit-spec
+// process imports `service/environment_store.spec.ts`, which calls
+// `mock.module("../storage/StorageManager", ...)`. Bun's module mocks
+// persist process-wide across spec files, so a sibling spec in `src/` that
+// `import`s the real StorageManager would get the mock instead. Running
+// here puts us in the separate `test:integration` process with a clean
+// module cache.
+import { describe, expect, it } from "bun:test";
+import { ConnectionAuthError } from "../../../src/errors";
+import { StorageManager } from "../../../src/storage/StorageManager";
+
+interface PrivateStorageManager {
+   duckDbConnection: { run: (sql: string) => Promise<unknown> } | null;
+}
+
+const PG_CONFIG = {
+   catalogUrl: "postgres:host=h user=u password=hunter2 dbname=catalog",
+   dataPath: "gs://bucket/path",
+};
+
+function setupWithStubbedConn(runHandler: (sql: string) => Promise<unknown>): {
+   sm: StorageManager;
+   calls: string[];
+} {
+   const sm = new StorageManager({ type: "duckdb" });
+   const calls: string[] = [];
+   const stub = {
+      run: async (sql: string): Promise<unknown> => {
+         calls.push(sql);
+         return runHandler(sql);
+      },
+   };
+   (sm as unknown as PrivateStorageManager).duckDbConnection = stub;
+   return { sm, calls };
+}
+
+describe("StorageManager.attachDuckLakeCatalog wiring", () => {
+   it("classifies libpq auth failure on ATTACH as ConnectionAuthError", async () => {
+      const { sm } = setupWithStubbedConn(async (sql) => {
+         if (sql.startsWith("ATTACH")) {
+            throw new Error(
+               'IO Error: Unable to connect to Postgres at "host=h user=u password=hunter2 ...": FATAL:  password authentication failed for user "u"',
+            );
+         }
+         return undefined;
+      });
+
+      await expect(
+         sm.initializeDuckLakeForEnvironment("env-1", "env-name", PG_CONFIG),
+      ).rejects.toBeInstanceOf(ConnectionAuthError);
+   });
+
+   it("redacts the embedded password in the classified error", async () => {
+      const { sm } = setupWithStubbedConn(async (sql) => {
+         if (sql.startsWith("ATTACH")) {
+            throw new Error(
+               "password authentication failed: tried host=h password=hunter2",
+            );
+         }
+         return undefined;
+      });
+
+      try {
+         await sm.initializeDuckLakeForEnvironment(
+            "env-1",
+            "env-name",
+            PG_CONFIG,
+         );
+         throw new Error("expected ATTACH to throw");
+      } catch (e) {
+         expect(e).toBeInstanceOf(ConnectionAuthError);
+         expect((e as Error).message).toContain("password=***");
+         expect((e as Error).message).not.toContain("hunter2");
+      }
+   });
+
+   it("injects connect_timeout into PG catalogUrl before ATTACH", async () => {
+      const { sm, calls } = setupWithStubbedConn(async () => undefined);
+
+      await sm.initializeDuckLakeForEnvironment("env-1", "env-name", PG_CONFIG);
+
+      const attachSql = calls.find((s) => s.startsWith("ATTACH"));
+      expect(attachSql).toBeDefined();
+      expect(attachSql).toContain("connect_timeout=");
+   });
+
+   it("honors PG_CONNECT_TIMEOUT_SECONDS env override in the emitted SQL", async () => {
+      const original = process.env.PG_CONNECT_TIMEOUT_SECONDS;
+      process.env.PG_CONNECT_TIMEOUT_SECONDS = "17";
+      try {
+         const { sm, calls } = setupWithStubbedConn(async () => undefined);
+         await sm.initializeDuckLakeForEnvironment(
+            "env-1",
+            "env-name",
+            PG_CONFIG,
+         );
+         const attachSql = calls.find((s) => s.startsWith("ATTACH"));
+         expect(attachSql).toContain("connect_timeout=17");
+      } finally {
+         if (original === undefined) {
+            delete process.env.PG_CONNECT_TIMEOUT_SECONDS;
+         } else {
+            process.env.PG_CONNECT_TIMEOUT_SECONDS = original;
+         }
+      }
+   });
+
+   it("leaves a non-PG catalogUrl untouched (no connect_timeout)", async () => {
+      const { sm, calls } = setupWithStubbedConn(async () => undefined);
+      const sqliteConfig = {
+         catalogUrl: "sqlite:/tmp/x.db",
+         dataPath: "/tmp/data",
+      };
+
+      await sm.initializeDuckLakeForEnvironment(
+         "env-1",
+         "env-name",
+         sqliteConfig,
+      );
+
+      const attachSql = calls.find((s) => s.startsWith("ATTACH"));
+      expect(attachSql).toBeDefined();
+      expect(attachSql).not.toContain("connect_timeout");
+   });
+
+   it("rethrows non-auth errors from ATTACH unchanged (preserves cause)", async () => {
+      const original = new Error("disk I/O error: read failed");
+      const { sm } = setupWithStubbedConn(async (sql) => {
+         if (sql.startsWith("ATTACH")) throw original;
+         return undefined;
+      });
+
+      await expect(
+         sm.initializeDuckLakeForEnvironment("env-1", "env-name", PG_CONFIG),
+      ).rejects.toBe(original);
+   });
+
+   it("does not call connect_timeout injection when catalogUrl lacks postgres: prefix", async () => {
+      // Sanity: the isPostgres branch is detected purely by string prefix.
+      // A keyword-form string without the prefix shouldn't be misclassified.
+      const { sm, calls } = setupWithStubbedConn(async () => undefined);
+      const ambiguousConfig = {
+         catalogUrl: "host=h dbname=d", // no scheme prefix at all
+         dataPath: "/tmp/data",
+      };
+
+      await sm.initializeDuckLakeForEnvironment(
+         "env-1",
+         "env-name",
+         ambiguousConfig,
+      );
+
+      const attachSql = calls.find((s) => s.startsWith("ATTACH"));
+      expect(attachSql).not.toContain("connect_timeout");
+   });
+});

package/dist/app/assets/EnvironmentPage-1j6QDWAy.js

@@ -1 +0,0 @@
-import{d as r,t as a,j as e,E as i,J as o}from"./index-5K9YjIxF.js";function m(){const s=r(),{environmentName:n}=a();if(n){const t=i({environmentName:n});return e.jsx(o,{onSelectPackage:s,resourceUri:t})}else return e.jsx("div",{children:e.jsx("h2",{children:"Missing environment name"})})}export{m as default};

package/dist/app/assets/HomePage-DMop21VG.js

@@ -1 +0,0 @@
-import{d as n,j as t,a as o}from"./index-5K9YjIxF.js";function s(){const a=n();return t.jsx(o,{onClickEnvironment:a})}export{s as default};