@malloy-publisher/server 0.0.225 → 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/service/materialization_cron_gate.spec.ts

@@ -1,181 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
-
-import { Environment } from "./environment";
-import type { Package } from "./package";
-
-/**
- * The publish gate for materialization crons (Phase A carve-out,
- * persistence.md §9.4). A cron is the power tier of artifact-anchored
- * scheduling and is valid only over `sharing="private"` artifacts:
- *
- *  - a package-level cron (`materialization.schedule`) is valid only when
- *    EVERY governed persist source resolves to explicit `sharing="private"`;
- *  - a per-source cron (`#@ persist ... schedule=`) is valid only when THAT
- *    source resolves to explicit `sharing="private"`;
- *  - a cron on a shared/unset artifact is rejected, pointing at
- *    `freshness.window` as the shared-tier replacement.
- *
- * These tests run a real `Environment` + `Package.create` over temp dirs, so
- * they also prove end-to-end that the pinned compiler ACCEPTS `sharing=` /
- * `refresh=` / `schedule=` / `freshness.*` keys in the `#@ persist` annotation
- * and that the values survive to the wire build plan verbatim (unset stays null
- * — never defaulted to "shared").
- */
-describe("materialization cron gate", () => {
-   let rootDir: string;
-   let envPath: string;
-
-   async function loadPackage(model: string, schedule?: string) {
-      const dir = path.join(envPath, "pkg");
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(
-         path.join(dir, "publisher.json"),
-         JSON.stringify({
-            name: "pkg",
-            description: "fixture",
-            ...(schedule ? { materialization: { schedule } } : {}),
-         }),
-      );
-      await fs.writeFile(path.join(dir, "model.malloy"), model);
-      const env = await Environment.create("testEnv", envPath, []);
-      await env.addPackage("pkg");
-      return env.getPackage("pkg", false);
-   }
-
-   function sourceByName(pkg: Package, name: string) {
-      const sources = pkg.getBuildPlan()?.sources ?? {};
-      const found = Object.values(sources).find((s) => s.name === name);
-      if (!found) throw new Error(`persist source '${name}' not in build plan`);
-      return found;
-   }
-
-   beforeEach(async () => {
-      rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "publisher-cron-"));
-      envPath = path.join(rootDir, "env");
-      await fs.mkdir(envPath, { recursive: true });
-   });
-
-   afterEach(async () => {
-      await fs.rm(rootDir, { recursive: true, force: true }).catch(() => {});
-   });
-
-   const MIXED_MODEL = `##! experimental.persistence
-
-#@ persist name="priv_table" sharing=private refresh=incremental
-source: priv is duckdb.sql("SELECT 1 as x")
-
-#@ persist name="open_table" sharing=shared
-source: open is duckdb.sql("SELECT 2 as x")
-
-#@ persist name="unset_table"
-source: unspecified is duckdb.sql("SELECT 3 as x")
-`;
-
-   const ALL_PRIVATE_MODEL = `##! experimental.persistence
-
-#@ persist name="a_table" sharing=private
-source: a is duckdb.sql("SELECT 1 as x")
-
-#@ persist name="b_table" sharing=private refresh=full
-source: b is duckdb.sql("SELECT 2 as x")
-`;
-
-   // Per-source crons: valid on the private source, rejected on the shared and
-   // the unset (⇒ shared) sources.
-   const PER_SOURCE_CRON_MODEL = `##! experimental.persistence
-
-#@ persist name="p_table" sharing=private schedule="0 */6 * * *"
-source: p is duckdb.sql("SELECT 1 as x")
-
-#@ persist name="s_table" sharing=shared schedule="0 0 * * *"
-source: s is duckdb.sql("SELECT 2 as x")
-
-#@ persist name="u_table" schedule="0 0 * * *"
-source: u is duckdb.sql("SELECT 3 as x")
-`;
-
-   it(
-      "surfaces declared sharing/refresh verbatim on the build plan (null when unset)",
-      async () => {
-         const pkg = await loadPackage(MIXED_MODEL);
-
-         const priv = sourceByName(pkg, "priv");
-         expect(priv.sharing).toBe("private");
-         expect(priv.refresh).toBe("incremental");
-
-         const open = sourceByName(pkg, "open");
-         expect(open.sharing).toBe("shared");
-         expect(open.refresh).toBeNull();
-
-         // Unset must be reported as null — distinguishable from an explicit
-         // "shared" — because the control plane applies the platform default
-         // (unset => shared) itself.
-         const unspecified = sourceByName(pkg, "unspecified");
-         expect(unspecified.sharing).toBeNull();
-         expect(unspecified.refresh).toBeNull();
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "rejects a package cron on a mixed package, pointing at freshness.window",
-      async () => {
-         // Phase A: a package cron governs every persist source, so it is valid
-         // only when all resolve to explicit private. MIXED has a shared and an
-         // unset source, so the package cron is rejected.
-         const pkg = await loadPackage(MIXED_MODEL, "0 6 * * *");
-
-         const warnings = pkg.scheduleWarnings();
-         expect(warnings).toHaveLength(1);
-         const joined = pkg.formatInvalidSchedule();
-         expect(joined).toContain("materialization.schedule");
-         expect(joined).toContain("materialization.freshness.window");
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "accepts a package cron when every persist source is private",
-      async () => {
-         // Phase A carve-out: an all-private package legitimately carries a
-         // package-level cron (the power tier for its own private artifacts).
-         const pkg = await loadPackage(ALL_PRIVATE_MODEL, "0 6 * * *");
-         expect(pkg.scheduleWarnings()).toEqual([]);
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "rejects a per-source cron unless that source resolves to private",
-      async () => {
-         // No package cron here — only per-source `schedule=` declarations. The
-         // private source's cron is accepted; the shared and unset sources' are
-         // rejected, each pointing at freshness.window.
-         const pkg = await loadPackage(PER_SOURCE_CRON_MODEL);
-
-         const warnings = pkg.scheduleWarnings();
-         expect(warnings).toHaveLength(2);
-         const joined = warnings.join("\n");
-         expect(joined).toContain('"s"');
-         expect(joined).toContain('"u"');
-         expect(joined).not.toContain('"p"');
-         expect(joined).toContain("freshness.window");
-
-         // The resolved per-source schedule is surfaced verbatim on the plan.
-         expect(sourceByName(pkg, "p").schedule).toBe("0 */6 * * *");
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "is inert when no cron is declared, whatever the sources' sharing",
-      async () => {
-         const pkg = await loadPackage(MIXED_MODEL);
-         expect(pkg.scheduleWarnings()).toEqual([]);
-      },
-      { timeout: 30000 },
-   );
-});

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> => {},
-      };
-   }
-}