@malloy-publisher/server 0.0.195 → 0.0.196

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/integration/materialization/materialization_lifecycle.integration.spec.ts

@@ -10,7 +10,7 @@ const __dirname = path.dirname(__filename);
 
 const PROJECT_NAME = "test-project";
 const PACKAGE_NAME = "persist-test";
-const API = `/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
+const API = `/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
 
 describe("Materialization & Manifest REST API (E2E)", () => {
    let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
@@ -23,7 +23,7 @@ describe("Materialization & Manifest REST API (E2E)", () => {
       // Create the test project via the REST API using an absolute
       // path to the fixture so it works regardless of SERVER_ROOT.
       const fixtureDir = path.resolve(__dirname, "../../fixtures/persist-test");
-      const createRes = await fetch(`${baseUrl}/api/v0/projects`, {
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
@@ -45,7 +45,7 @@ describe("Materialization & Manifest REST API (E2E)", () => {
       while (!pkgReady && Date.now() < deadline) {
          try {
             const res = await fetch(
-               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}`,
+               `${baseUrl}/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`,
             );
             if (res.ok) {
                pkgReady = true;
@@ -65,7 +65,7 @@ describe("Materialization & Manifest REST API (E2E)", () => {
       // Tear down the test project, then the HTTP server.
       if (baseUrl) {
          try {
-            await fetch(`${baseUrl}/api/v0/projects/${PROJECT_NAME}`, {
+            await fetch(`${baseUrl}/api/v0/environments/${PROJECT_NAME}`, {
                method: "DELETE",
             });
          } catch {

package/tests/integration/mcp/mcp_execute_query_tool.integration.spec.ts

@@ -19,11 +19,11 @@ import {
 } from "../../harness/mcp_test_setup";
 
 // --- Test Suite ---
-describe("MCP Tool Handlers (E2E Integration)", () => {
+describe.serial("MCP Tool Handlers (E2E Integration)", () => {
    let env: McpE2ETestEnvironment | null = null;
    let mcpClient: Client;
 
-   const PROJECT_NAME = "malloy-samples";
+   const ENVIRONMENT_NAME = "malloy-samples";
    const PACKAGE_NAME = "faa";
 
    beforeAll(async () => {
@@ -47,7 +47,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
             const result = await mcpClient.callTool({
                name: "malloy_executeQuery",
                arguments: {
-                  projectName: "malloy-samples",
+                  environmentName: ENVIRONMENT_NAME,
                   packageName: PACKAGE_NAME,
                   modelPath: "flights.malloy",
                   query: "run: flights->{ aggregate: c is count() }",
@@ -95,7 +95,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
          async () => {
             if (!env) throw new Error("Test environment not initialized");
             const params = {
-               projectName: PROJECT_NAME,
+               environmentName: ENVIRONMENT_NAME,
                packageName: PACKAGE_NAME,
                modelPath: "flights.malloy",
                sourceName: "flights", // Added sourceName
@@ -140,7 +140,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
          async () => {
             if (!env) throw new Error("Test environment not initialized");
             const params = {
-               projectName: PROJECT_NAME,
+               environmentName: ENVIRONMENT_NAME,
                packageName: PACKAGE_NAME,
                modelPath: "flights.malloy",
                query: "run: flights->{BAD SYNTAX aggregate: flight_count is count()}",
@@ -179,7 +179,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
       it("should RESOLVE with InvalidParams for conflicting parameters (query and queryName)", async () => {
          if (!env) throw new Error("Test environment not initialized");
          const params = {
-            projectName: PROJECT_NAME,
+            environmentName: ENVIRONMENT_NAME,
             packageName: PACKAGE_NAME,
             modelPath: "flights.malloy",
             query: "run: flights->{aggregate: c is count()}",
@@ -207,7 +207,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
       it("should RESOLVE with InvalidParams if required params are missing (e.g., query or queryName)", async () => {
          if (!env) throw new Error("Test environment not initialized");
          const params = {
-            projectName: PROJECT_NAME,
+            environmentName: ENVIRONMENT_NAME,
             packageName: PACKAGE_NAME,
             modelPath: "flights.malloy",
             // Missing query AND queryName
@@ -235,7 +235,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
          if (!env) throw new Error("Test environment not initialized");
          const params = {
             // Missing modelPath
-            projectName: PROJECT_NAME,
+            environmentName: ENVIRONMENT_NAME,
             packageName: PACKAGE_NAME,
             query: "run: flights->{aggregate: flight_count is count()}",
          };
@@ -257,7 +257,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
       it("should return application error if package not found", async () => {
          if (!env) throw new Error("Test environment not initialized");
          const params = {
-            projectName: PROJECT_NAME,
+            environmentName: ENVIRONMENT_NAME,
             packageName: "nonexistent_package", // Use a package that doesn't exist
             modelPath: "flights.malloy",
             query: "run: flights->{aggregate: c is count()}",
@@ -292,7 +292,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
          expect(errorPayloadPkgNotFound.suggestions.length).toBeGreaterThan(0);
 
          // Check the specific error message within the parsed object
-         const expectedErrorMessageNotFound = `Resource not found: package '${params.packageName}' in project '${params.projectName}'`;
+         const expectedErrorMessageNotFound = `Resource not found: package '${params.packageName}' in environment '${params.environmentName}'`;
          expect(errorPayloadPkgNotFound.error).toEqual(
             expectedErrorMessageNotFound,
          );
@@ -301,7 +301,7 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
       it("should return application error if model not found within package", async () => {
          if (!env) throw new Error("Test environment not initialized");
          const params = {
-            projectName: PROJECT_NAME,
+            environmentName: ENVIRONMENT_NAME,
             packageName: PACKAGE_NAME,
             modelPath: "nonexistent_model.malloy", // Use a model that doesn't exist
             query: "run: flights->{aggregate: c is count()}",
@@ -335,68 +335,47 @@ describe("MCP Tool Handlers (E2E Integration)", () => {
          expect(errorPayloadModel.suggestions.length).toBeGreaterThan(0);
 
          // Check the specific error message within the parsed object
-         const expectedErrorMessageModel = `Resource not found: model '${params.modelPath}' in package '${params.packageName}' for project '${params.projectName}'`;
+         const expectedErrorMessageModel = `Resource not found: model '${params.modelPath}' in package '${params.packageName}' for environment '${params.environmentName}'`;
          expect(errorPayloadModel.error).toEqual(expectedErrorMessageModel);
 
          // Check for the specific model name and context in the message
          expect(errorPayloadModel.error).toMatch(/Resource not found/i);
       });
 
-      // Added from mcp_query_tool.spec.ts
-      it("should handle query cancellation via client close", async () => {
+      // Stateless HTTP + fast queries make true in-flight cancellation flaky
+      // (the response often completes before close wins the race). Assert the
+      // transport contract instead: a closed client cannot issue further tools.
+      it("should reject malloy_executeQuery after the MCP client is closed", async () => {
          if (!env) throw new Error("Test environment not initialized");
 
-         // Create a new client *specifically* for this test so we can close it
-         // without affecting other tests running concurrently (if any).
-         const cancelClient = new Client<Request, Notification, Result>({
-            name: "cancel-test-client",
+         const closedClient = new Client<Request, Notification, Result>({
+            name: "closed-client-test",
             version: "1.0",
          });
-         // Corrected: Use StreamableHTTPClientTransport with the server URL + /mcp endpoint
-         const cancelTransport = new StreamableHTTPClientTransport(
+         const transport = new StreamableHTTPClientTransport(
             new URL(env.serverUrl + "/mcp"),
          );
-         await cancelClient.connect(cancelTransport);
+         await closedClient.connect(transport);
+         await closedClient.close();
 
-         expect.assertions(2); // Expecting two assertions: instanceof Error and message match
-         let toolPromise;
-         try {
-            toolPromise = cancelClient.callTool({
+         await expect(
+            closedClient.callTool({
                name: "malloy_executeQuery",
                arguments: {
-                  projectName: PROJECT_NAME,
+                  environmentName: ENVIRONMENT_NAME,
                   packageName: PACKAGE_NAME,
                   modelPath: "flights.malloy",
-                  // Use a query known to take a little time if possible, otherwise a simple one
-                  query: "run: flights->{aggregate: c is count() for 100}",
+                  query: "run: flights->{aggregate: c is count()}",
                },
-            });
-
-            // Give the request a moment to start on the server
-            await new Promise((resolve) => setTimeout(resolve, 100));
-
-            // Close the client to trigger cancellation
-            await cancelClient.close();
-
-            // Await the promise - it should reject due to the closure
-            await toolPromise;
-
-            throw new Error("Promise should have rejected due to cancellation");
-         } catch (error) {
-            // Check that the error is an Error instance and the message indicates closure/cancellation
-            expect(error).toBeInstanceOf(Error);
-            expect((error as Error).message).toMatch(/cancel|closed/i);
-         } finally {
-            // Ensure the temporary client is closed even if the test failed unexpectedly
-            await cancelClient.close().catch(() => {}); // Ignore errors on final cleanup
-         }
+            }),
+         ).rejects.toThrow();
       });
 
       // Test invalid usage - nested view called without sourceName
       it("should return application error for nested view without sourceName", async () => {
          if (!env) throw new Error("Test environment not initialized");
          const params = {
-            projectName: PROJECT_NAME,
+            environmentName: ENVIRONMENT_NAME,
             packageName: PACKAGE_NAME,
             modelPath: "flights.malloy",
             queryName: "top_carriers", // Nested view, but sourceName is missing