@malloy-publisher/server 0.0.226 → 0.0.227

package/src/mcp/resources/view_resource.ts

@@ -1,136 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { URL } from "url";
-import type { components } from "../../api"; // Need this for View definition type
-import { ModelCompilationError } from "../../errors";
-import { logger } from "../../logger";
-import { EnvironmentStore } from "../../service/environment_store";
-import {
-   getInternalError,
-   getMalloyErrorDetails,
-   getNotFoundError,
-} from "../error_messages";
-import {
-   getModelForQuery,
-   handleResourceGet,
-   McpGetResourceError,
-} from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// Define the expected parameter types
-type ViewParams = {
-   environmentName?: unknown;
-   packageName?: unknown;
-   modelPath?: unknown;
-   sourceName?: unknown;
-   viewName?: unknown;
-};
-
-/**
- * Registers the Malloy View resource type (nested within a Source).
- */
-export function registerViewResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.resource(
-      "view",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/sources/{sourceName}/views/{viewName}",
-         { list: undefined }, // Listing views is not supported via this template
-      ),
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params as ViewParams,
-            "view",
-            async (
-               {
-                  environmentName,
-                  packageName,
-                  modelPath,
-                  sourceName,
-                  viewName,
-               }: ViewParams,
-               uri: URL,
-            ) => {
-               if (
-                  typeof environmentName !== "string" ||
-                  typeof packageName !== "string" ||
-                  typeof modelPath !== "string" ||
-                  typeof sourceName !== "string" ||
-                  typeof viewName !== "string"
-               ) {
-                  throw new Error("Invalid parameters for view resource.");
-               }
-
-               try {
-                  const modelResult = await getModelForQuery(
-                     environmentStore,
-                     environmentName,
-                     packageName,
-                     modelPath,
-                  );
-                  if ("error" in modelResult) {
-                     throw new McpGetResourceError(modelResult.error);
-                  }
-                  const { model } = modelResult;
-
-                  const sources = await model.getSources();
-                  if (!sources) {
-                     throw new Error("Could not retrieve sources from model.");
-                  }
-                  const source = sources.find(
-                     (s: components["schemas"]["Source"]) =>
-                        s.name === sourceName,
-                  );
-                  if (!source) {
-                     throw new McpGetResourceError(
-                        getNotFoundError(
-                           `Source '${sourceName}' in model '${modelPath}' package '${packageName}' environment '${environmentName}'`,
-                        ),
-                     );
-                  }
-
-                  // Find the view within the source
-                  const view = source.views?.find(
-                     (v: components["schemas"]["View"]) => v.name === viewName,
-                  );
-
-                  if (!view) {
-                     // Specific "View not found" error
-                     const errorDetails = getNotFoundError(
-                        `View '${viewName}' in source '${sourceName}' model '${modelPath}' package '${packageName}' environment '${environmentName}'`,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  return view;
-               } catch (error) {
-                  if (error instanceof McpGetResourceError) {
-                     throw error; // Re-throw already formatted
-                  }
-                  if (error instanceof ModelCompilationError) {
-                     const errorDetails = getMalloyErrorDetails(
-                        "GetResource (view - model compilation)",
-                        `${environmentName}/${packageName}/${modelPath}`,
-                        error,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  logger.error(
-                     `[MCP Server Error] Error fetching view '${viewName}' from ${uri.href}:`,
-                     { error },
-                  );
-                  const fallbackErrorDetails = getInternalError(
-                     `GetResource (view: ${uri.href})`,
-                     error,
-                  );
-                  throw new McpGetResourceError(fallbackErrorDetails);
-               }
-            },
-            RESOURCE_METADATA.view,
-         ),
-   );
-}

package/src/mcp/tools/discovery_tools.ts

@@ -1,280 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { EnvironmentStore } from "../../service/environment_store";
-import { buildMalloyUri } from "../handler_utils";
-
-const listPackagesShape = {
-   environmentName: z
-      .string()
-      .describe(
-         "Environment name. Names are listed in the malloy_environmentList tool.",
-      ),
-};
-type listPackagesParams = z.infer<z.ZodObject<typeof listPackagesShape>>;
-
-const getModelsShape = {
-   environmentName: z
-      .string()
-      .describe(
-         "Environment name. Names are listed in the malloy_environmentList tool.",
-      ),
-   packageName: z
-      .string()
-      .describe(
-         "Package name. Package names are listed in the listPackages tool.",
-      ),
-};
-type getModelsParams = z.infer<z.ZodObject<typeof getModelsShape>>;
-
-const getModelTextShape = {
-   environmentName: z
-      .string()
-      .describe(
-         "Environment name. Names are listed in the malloy_environmentList tool.",
-      ),
-   packageName: z
-      .string()
-      .describe(
-         "Package name. Package names are listed in the listPackages tool.",
-      ),
-   modelPath: z
-      .string()
-      .describe(
-         "Model path. Model paths are listed in the malloy_packageGet tool.",
-      ),
-};
-type getModelTextParams = z.infer<z.ZodObject<typeof getModelTextShape>>;
-
-/**
- * Registers Malloy discovery tools with the MCP server.
- * Lists environments and packages for navigation.
- */
-export function registerTools(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.tool(
-      "malloy_environmentList",
-      "Lists all Malloy environments",
-      {},
-      async () => {
-         console.log(
-            "[MCP LOG] Entering ListResources (environment) handler (listing ALL packages)...",
-         );
-         const allEnvironments = await Promise.all(
-            (await environmentStore.listEnvironments())
-               .filter((environment) => environment.name)
-               .map((environment) => ({
-                  name: environment.name,
-                  environment: environmentStore.getEnvironment(
-                     environment.name!,
-                     false,
-                  ),
-               })),
-         );
-
-         console.log(
-            `[MCP LOG] Found ${allEnvironments.length} environments defined.`,
-         );
-
-         const mappedResources = await Promise.all(
-            allEnvironments.map(async (environment) => {
-               const name = environment.name;
-               const environmentInstance = await environment.environment;
-               const metadata =
-                  await environmentInstance.reloadEnvironmentMetadata();
-               const readme = metadata.readme;
-               return {
-                  name,
-                  type: "environment",
-                  description: readme || "NO Description available",
-               };
-            }),
-         );
-         console.log(
-            `[MCP LOG] ListResources (environment): Returning ${mappedResources.length} package resources.`,
-         );
-         return {
-            content: [
-               {
-                  type: "resource",
-                  resource: {
-                     type: "application/json",
-                     uri: buildMalloyUri({}, "environment"),
-                     text: JSON.stringify(mappedResources),
-                  },
-               },
-            ],
-         };
-      },
-   );
-
-   mcpServer.tool(
-      "malloy_packageList",
-      "Lists all Malloy packages within an environment",
-      listPackagesShape,
-      async (params: listPackagesParams) => {
-         const { environmentName } = params;
-         console.log(
-            "[MCP LOG] Entering ListResources (environment) handler (listing ALL packages)...",
-         );
-         const environment = await environmentStore.getEnvironment(
-            environmentName,
-            false,
-         );
-         const packages = await environment.listPackages();
-         console.log(`[MCP LOG] Found ${packages.length} packages defined.`);
-         const mappedResources = packages.map((pkg) => ({
-            modelPath: pkg.name,
-            type: "package",
-            description: pkg.description,
-         }));
-         console.log(
-            `[MCP LOG] ListResources (environment): Returning ${mappedResources.length} package resources.`,
-         );
-         return {
-            content: [
-               {
-                  type: "resource",
-                  resource: {
-                     type: "application/json",
-                     uri: buildMalloyUri(
-                        { environment: environmentName },
-                        "package",
-                     ),
-                     text: JSON.stringify(mappedResources),
-                  },
-               },
-            ],
-         };
-      },
-   );
-
-   mcpServer.tool(
-      "malloy_packageGet",
-      "Lists resources within a package",
-      getModelsShape,
-      async (params: getModelsParams) => {
-         const { environmentName, packageName } = params;
-         console.log(
-            "[MCP LOG] Entering GetResources (environment) handler (listing ALL packages)...",
-         );
-         const environment = await environmentStore.getEnvironment(
-            environmentName,
-            false,
-         );
-         const pkg = await environment.getPackage(packageName, false);
-         const models = await pkg.listModels();
-         console.log(`[MCP LOG] Found ${models.length} models defined.`);
-         const mappedResources = models.map((model) => ({
-            name: model.path,
-            type: "model",
-         }));
-         console.log(
-            `[MCP LOG] ListResources (environment): Returning ${mappedResources.length} package resources.`,
-         );
-         return {
-            content: [
-               {
-                  type: "resource",
-                  resource: {
-                     type: "application/json",
-                     uri: buildMalloyUri(
-                        {
-                           environment: environmentName,
-                           package: packageName,
-                        },
-                        "model",
-                     ),
-                     text: JSON.stringify(mappedResources),
-                  },
-               },
-            ],
-         };
-      },
-   );
-
-   mcpServer.tool(
-      "malloy_modelGetText",
-      "Gets the raw text content of a model file",
-      getModelTextShape,
-      async (params: getModelTextParams) => {
-         const { environmentName, packageName, modelPath } = params;
-         console.log(
-            `[MCP LOG] Entering GetModelText handler for ${environmentName}/${packageName}/${modelPath}...`,
-         );
-
-         try {
-            const environment = await environmentStore.getEnvironment(
-               environmentName,
-               false,
-            );
-            const pkg = await environment.getPackage(packageName, false);
-            const model = pkg.getModel(modelPath);
-
-            if (!model) {
-               console.log(
-                  "model not found",
-                  modelPath,
-                  "in ",
-                  pkg.listModels(),
-               );
-               throw new Error(`Model not found: ${modelPath}`);
-            }
-
-            // Route through the Environment so the disk read is serialized
-            // against installPackage / deletePackage.
-            const fileText = await environment.getModelFileText(
-               packageName,
-               modelPath,
-            );
-
-            console.log(
-               `[MCP LOG] Successfully retrieved model text for ${modelPath}`,
-            );
-            return {
-               content: [
-                  {
-                     type: "resource",
-                     resource: {
-                        type: "text/plain",
-                        uri: buildMalloyUri(
-                           {
-                              environment: environmentName,
-                              package: packageName,
-                              model: modelPath,
-                           },
-                           "model-text",
-                        ),
-                        text: fileText,
-                     },
-                  },
-               ],
-            };
-         } catch (error) {
-            console.error(`[MCP LOG] Error retrieving model text: ${error}`);
-            const errorMessage =
-               error instanceof Error ? error.message : "Unknown error";
-            return {
-               content: [
-                  {
-                     type: "resource",
-                     resource: {
-                        type: "text/plain",
-                        uri: buildMalloyUri(
-                           {
-                              environment: environmentName,
-                              package: packageName,
-                              model: modelPath,
-                           },
-                           "model-text",
-                        ),
-                        text: `Error: ${errorMessage}`,
-                     },
-                  },
-               ],
-            };
-         }
-      },
-   );
-}

package/src/storage/BaseRepository.ts

@@ -1,31 +0,0 @@
-import { DatabaseConnection } from "./DatabaseInterface";
-
-export abstract class BaseRepository {
-   constructor(protected db: DatabaseConnection) {}
-
-   protected generateId(): string {
-      return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-   }
-
-   protected now(): Date {
-      return new Date();
-   }
-
-   protected async executeQuery<T>(
-      _query: string,
-      _params?: unknown[],
-   ): Promise<T[]> {
-      // This will be implemented by specific database implementations
-      throw new Error(
-         "executeQuery must be implemented by database-specific class",
-      );
-   }
-
-   protected async executeOne<T>(
-      query: string,
-      params?: unknown[],
-   ): Promise<T | null> {
-      const results = await this.executeQuery<T>(query, params);
-      return results.length > 0 ? results[0] : null;
-   }
-}

package/src/storage/StorageManager.mock.ts

@@ -1,50 +0,0 @@
-type MockData = Record<string, unknown>;
-
-export class StorageManager {
-   async initialize(): Promise<void> {
-      return;
-   }
-
-   getRepository() {
-      return {
-         listEnvironments: async (): Promise<unknown[]> => [],
-         createEnvironment: async (data: MockData): Promise<MockData> => ({
-            id: "test-id",
-            ...data,
-         }),
-         updateEnvironment: async (
-            id: string,
-            data: MockData,
-         ): Promise<MockData> => ({
-            id,
-            ...data,
-         }),
-         getPackages: async (): Promise<unknown[]> => [],
-         createPackage: async (data: MockData): Promise<MockData> => ({
-            id: "test-id",
-            ...data,
-         }),
-         updatePackage: async (
-            id: string,
-            data: MockData,
-         ): Promise<MockData> => ({
-            id,
-            ...data,
-         }),
-         deletePackage: async (): Promise<void> => {},
-         getConnections: async (): Promise<unknown[]> => [],
-         createConnection: async (data: MockData): Promise<MockData> => ({
-            id: "test-id",
-            ...data,
-         }),
-         updateConnection: async (
-            id: string,
-            data: MockData,
-         ): Promise<MockData> => ({
-            id,
-            ...data,
-         }),
-         deleteConnection: async (): Promise<void> => {},
-      };
-   }
-}

package/tests/harness/e2e.ts

@@ -1,96 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type {
-   Notification,
-   Request,
-   Result,
-} from "@modelcontextprotocol/sdk/types.js";
-import http from "http";
-import path from "path";
-import { fileURLToPath } from "url";
-import { URL } from "url";
-
-/**
- * E2E environment descriptor returned by {@link startE2E}.
- */
-export interface E2EEnv {
-   httpServer: http.Server;
-   serverUrl: string;
-   mcpClient: Client<Request, Notification, Result>;
-}
-
-let originalServerRoot: string | undefined;
-
-/**
- * Spin-up the real Express app (via mcp/server.ts), expose its base URL and
- * return a fully-connected MCP client. The caller **must** invoke {@link stop}
- * once its suite finishes.
- */
-export async function startE2E(): Promise<E2EEnv & { stop(): Promise<void> }> {
-   //--------------------------------------------------------------------------
-   // 1.  Set SERVER_ROOT so EnvironmentStore loader finds publisher.config.json
-   //--------------------------------------------------------------------------
-   originalServerRoot = process.env.SERVER_ROOT;
-   // Use import.meta.url for cross-platform compatibility (works on Windows)
-   const __filename = fileURLToPath(import.meta.url);
-   const __dirname = path.dirname(__filename);
-   const serverPackageDir = path.resolve(__dirname, "../../../"); // packages/server
-   process.env.SERVER_ROOT = serverPackageDir;
-
-   //--------------------------------------------------------------------------
-   // 2.  Dynamically import the configured Express app AFTER env var mutation
-   //--------------------------------------------------------------------------
-   const { mcpApp } = await import("../../src/server");
-
-   //--------------------------------------------------------------------------
-   // 3.  Start HTTP server on a predictable high port (4042 by default)
-   //--------------------------------------------------------------------------
-   const TEST_PORT = Number(process.env.MCP_PORT || 4040) + 2;
-
-   const httpServer: http.Server = await new Promise<http.Server>(
-      (resolve, reject) => {
-         const srv = http
-            .createServer(mcpApp)
-            .listen(TEST_PORT, "127.0.0.1", () => resolve(srv));
-
-         srv.on("error", (err: NodeJS.ErrnoException) => {
-            /* c8 ignore next 3 */
-            console.error("[E2E] server listen error", err);
-            reject(err);
-         });
-      },
-   );
-
-   const serverUrl = `http://127.0.0.1:${TEST_PORT}`;
-
-   //--------------------------------------------------------------------------
-   // 4.  Connect MCP client over HTTP streaming bridge
-   //--------------------------------------------------------------------------
-   const mcpClient = new Client<Request, Notification, Result>({
-      name: "mcp-e2e-client",
-      version: "1.0",
-   });
-
-   const transport = new StreamableHTTPClientTransport(
-      new URL(`${serverUrl}/mcp`),
-   );
-
-   await mcpClient.connect(transport);
-
-   //--------------------------------------------------------------------------
-   // 5.  Return env + graceful stop helper
-   //--------------------------------------------------------------------------
-   const stop = async (): Promise<void> => {
-      try {
-         await mcpClient.close();
-      } finally {
-         httpServer.closeAllConnections?.();
-         await new Promise<void>((r) => httpServer.close(() => r()));
-         // Restore SERVER_ROOT
-         if (originalServerRoot === undefined) delete process.env.SERVER_ROOT;
-         else process.env.SERVER_ROOT = originalServerRoot;
-      }
-   };
-
-   return { httpServer, serverUrl, mcpClient, stop };
-}

package/tests/harness/mocks.ts

@@ -1,39 +0,0 @@
-import sinon from "sinon";
-import { EnvironmentStore } from "../../src/service/environment_store";
-
-/** Return a stubbed EnvironmentStore where every lookup throws or returns minimal objects. */
-export function fakeEnvironmentStore(): sinon.SinonStubbedInstance<EnvironmentStore> {
-   const es = sinon.createStubInstance(EnvironmentStore);
-   // For now just have getEnvironment reject; suites can stub more.
-   es.getEnvironment.rejects(
-      new Error("fakeEnvironmentStore: getEnvironment not stubbed"),
-   );
-   return es;
-}
-
-// The runtime implementation of `McpServer` lives in the MCP SDK package, which
-// is **not** required for unit/integration tests that only need a stubbed
-// instance. Importing it at runtime would fail when the dependency is not
-// present in the local workspace. Instead we define a minimal dummy class that
-// satisfies Sinon while keeping the public type surface the same for tests.
-//
-// NOTE: If we later add the real SDK as a dependency we can simply replace this
-// dummy class with:
-//   import { McpServer } from "@modelcontextprotocol/sdk";
-class DummyMcpServer {}
-
-// Re-export the symbol so downstream test files can continue to refer to the
-// name `McpServer` without changes.
-export type McpServer = DummyMcpServer;
-
-/** Convenience helper mimicking the old mocks used in integration specs. */
-export function createMalloyServiceMocks() {
-   return {
-      environmentStore: fakeEnvironmentStore(),
-   } as const;
-}
-
-/** Create a Sinon spy wrapper around a new DummyMcpServer instance. */
-export function spyMcpServer(): sinon.SinonStubbedInstance<DummyMcpServer> {
-   return sinon.createStubInstance(DummyMcpServer);
-}

package/tests/harness/uris.ts

@@ -1,31 +0,0 @@
-export interface FixtureUris {
-   project: string;
-   package: string;
-   flightsModel: string;
-   source: string;
-   view: string;
-   query: string;
-   notebook: string;
-}
-
-/**
- * Return canonical URIs used across integration tests, parametrised by project
- * and package. Most suites will call this with defaults.
- */
-export function malloyUris(
-   project = "malloy-samples",
-   pkg = "faa",
-): FixtureUris {
-   const base = `malloy://project/${project}`;
-   const pkgUri = `${base}/package/${pkg}`;
-   const model = `${pkgUri}/models/flights.malloy`;
-   return {
-      project: base,
-      package: pkgUri,
-      flightsModel: model,
-      source: `${model}/sources/flights`,
-      view: `${model}/sources/flights/views/flights_by_month`,
-      query: `${model}/queries/flights_by_carrier`,
-      notebook: `${pkgUri}/notebooks/overview.malloynb`,
-   };
-}