@malloy-publisher/server 0.0.235 → 0.0.237

package/src/controller/model.controller.ts

@@ -1,164 +0,0 @@
-import { components } from "../api";
-import { getQueryTimeoutMs } from "../config";
-import { ModelNotFoundError } from "../errors";
-import { logger } from "../logger";
-import { runWithQueryTimeout } from "../query_timeout";
-import { EnvironmentStore } from "../service/environment_store";
-import type { FilterParams } from "../service/filter";
-import type { GivenValue } from "@malloydata/malloy";
-
-type ApiNotebook = components["schemas"]["Notebook"];
-type ApiModel = components["schemas"]["Model"];
-type ApiCompiledModel = components["schemas"]["CompiledModel"];
-type ApiRawNotebook = components["schemas"]["RawNotebook"];
-export class ModelController {
-   private environmentStore: EnvironmentStore;
-
-   constructor(environmentStore: EnvironmentStore) {
-      this.environmentStore = environmentStore;
-   }
-
-   public async listModels(
-      environmentName: string,
-      packageName: string,
-   ): Promise<ApiModel[]> {
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      const p = await environment.getPackage(packageName, false);
-      return p.listModels();
-   }
-
-   public async listNotebooks(
-      environmentName: string,
-      packageName: string,
-   ): Promise<ApiNotebook[]> {
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      const p = await environment.getPackage(packageName, false);
-      return p.listNotebooks();
-   }
-
-   public async getModel(
-      environmentName: string,
-      packageName: string,
-      modelPath: string,
-   ): Promise<ApiCompiledModel> {
-      try {
-         const environment = await this.environmentStore.getEnvironment(
-            environmentName,
-            false,
-         );
-         const p = await environment.getPackage(packageName, false);
-         const model = p.getModel(modelPath);
-         if (!model) {
-            throw new ModelNotFoundError(`${modelPath} does not exist`);
-         }
-         if (model.getType() === "notebook") {
-            throw new ModelNotFoundError(`${modelPath} is a notebook`);
-         }
-         return await model.getModel();
-      } catch (error) {
-         // Re-throw ModelNotFoundError as-is
-         if (error instanceof ModelNotFoundError) {
-            throw error;
-         }
-         // Wrap other errors with more context
-         throw new Error(
-            `Failed to get model ${modelPath} from package ${packageName} in environment ${environmentName}: ${error}`,
-         );
-      }
-   }
-
-   public async getNotebook(
-      environmentName: string,
-      packageName: string,
-      notebookPath: string,
-   ): Promise<ApiRawNotebook> {
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      const p = await environment.getPackage(packageName, false);
-      const model = p.getModel(notebookPath);
-      if (!model) {
-         throw new ModelNotFoundError(`${notebookPath} does not exist`);
-      }
-      if (model.getType() === "model") {
-         throw new ModelNotFoundError(`${notebookPath} is a model`);
-      }
-
-      return model.getNotebook();
-   }
-
-   public async executeNotebookCell(
-      environmentName: string,
-      packageName: string,
-      notebookPath: string,
-      cellIndex: number,
-      filterParams?: FilterParams,
-      bypassFilters?: boolean,
-      givens?: Record<string, GivenValue>,
-   ): Promise<{
-      type: "code" | "markdown";
-      text: string;
-      queryName?: string;
-      result?: string;
-      newSources?: string[];
-   }> {
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      // Shed load before any disk / DB work; same rationale as
-      // QueryController.getQuery — already-loaded packages bypass the
-      // package-load admission gate.
-      environment.assertCanAdmitQuery();
-      const p = await environment.getPackage(packageName, false);
-      const model = p.getModel(notebookPath);
-      if (!model) {
-         throw new ModelNotFoundError(`${notebookPath} does not exist`);
-      }
-      if (model.getType() === "model") {
-         throw new ModelNotFoundError(`${notebookPath} is a model`);
-      }
-
-      return runWithQueryTimeout(
-         (abortSignal) =>
-            model.executeNotebookCell(
-               cellIndex,
-               filterParams,
-               bypassFilters,
-               givens,
-               abortSignal,
-               {
-                  environment: environmentName,
-                  // The environment owns the connection configs, so the default
-                  // and enforced layers are read here rather than from the model.
-                  connectionMetadata: (connectionName) => {
-                     try {
-                        const connection =
-                           environment.getApiConnection(connectionName);
-                        return {
-                           default: connection.queryMetadata,
-                           enforced: connection.queryMetadataEnforced,
-                        };
-                     } catch (error) {
-                        // Fails open, and says so: what an unreadable
-                        // connection costs is the enforced layer.
-                        logger.debug(
-                           "No query-metadata layers for connection",
-                           { connectionName, error },
-                        );
-                        return null;
-                     }
-                  },
-               },
-            ),
-         getQueryTimeoutMs(),
-      );
-   }
-}

package/src/controller/package.controller.spec.ts

@@ -1,273 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import sinon from "sinon";
-
-import { BadRequestError } from "../errors";
-import type { EnvironmentStore } from "../service/environment_store";
-import { PackageController } from "./package.controller";
-
-describe("PackageController.addPackage explores validation", () => {
-   afterEach(() => {
-      sinon.restore();
-   });
-
-   it("no-location: rejects invalid explores and rolls back via unloadPackage (NOT deletePackage)", async () => {
-      // The no-location path registers a PRE-EXISTING user directory, so a bad
-      // manifest must unload it from memory — never deletePackage, which would
-      // delete the user's files.
-      const invalidMsg =
-         "Invalid explores entry 'missing.malloy' in publisher.json: file not found";
-      const mockPackage = {
-         formatInvalidExplores: () => invalidMsg,
-         formatInvalidPersistencePolicy: () => "",
-         formatPersistenceCollisionRejections: () => "",
-      };
-      const unloadPackage = sinon.stub().resolves(undefined);
-      const deletePackage = sinon.stub().resolves(undefined);
-      const addPackage = sinon.stub().resolves(mockPackage);
-      const environment = { addPackage, unloadPackage, deletePackage };
-      const getEnvironment = sinon.stub().resolves(environment);
-      const addPackageToDatabase = sinon.stub().resolves(undefined);
-      const environmentStore = {
-         publisherConfigIsFrozen: false,
-         getEnvironment,
-         addPackageToDatabase,
-      } as unknown as EnvironmentStore;
-
-      const controller = new PackageController(environmentStore);
-
-      await expect(
-         controller.addPackage("env", {
-            name: "pkg",
-            description: "test",
-            explores: ["missing.malloy"],
-         }),
-      ).rejects.toBeInstanceOf(BadRequestError);
-
-      expect(unloadPackage.calledOnceWith("pkg")).toBe(true);
-      expect(deletePackage.called).toBe(false);
-      expect(addPackageToDatabase.called).toBe(false);
-   });
-
-   it("location: validation runs inside installPackage's rollback window, not as a controller delete", async () => {
-      // For the location path the tree was freshly downloaded, so validation is
-      // delegated to installPackage (which rolls the swap back on failure). The
-      // controller passes a validator and does NOT call delete/unload itself.
-      const invalidMsg =
-         "Invalid explores entry 'missing.malloy' in publisher.json: file not found";
-      const mockPackage = {
-         formatInvalidExplores: () => invalidMsg,
-         formatInvalidPersistencePolicy: () => "",
-         formatPersistenceCollisionRejections: () => "",
-      };
-      // installPackage mimics the real contract: invoke the validator and, if it
-      // returns a message, throw BadRequestError (after its internal rollback).
-      const installPackage = sinon
-         .stub()
-         .callsFake(
-            async (
-               _name: string,
-               _downloader: unknown,
-               validate?: (pkg: unknown) => string | undefined,
-            ) => {
-               const msg = validate?.(mockPackage);
-               if (msg) throw new BadRequestError(msg);
-               return mockPackage;
-            },
-         );
-      const unloadPackage = sinon.stub().resolves(undefined);
-      const deletePackage = sinon.stub().resolves(undefined);
-      const environment = { installPackage, unloadPackage, deletePackage };
-      const getEnvironment = sinon.stub().resolves(environment);
-      const addPackageToDatabase = sinon.stub().resolves(undefined);
-      const environmentStore = {
-         publisherConfigIsFrozen: false,
-         getEnvironment,
-         addPackageToDatabase,
-      } as unknown as EnvironmentStore;
-
-      const controller = new PackageController(environmentStore);
-
-      await expect(
-         controller.addPackage("env", {
-            name: "pkg",
-            description: "test",
-            location: "gs://bucket/pkg.zip",
-            explores: ["missing.malloy"],
-         }),
-      ).rejects.toBeInstanceOf(BadRequestError);
-
-      expect(installPackage.calledOnce).toBe(true);
-      expect(typeof installPackage.firstCall.args[2]).toBe("function");
-      expect(deletePackage.called).toBe(false);
-      expect(unloadPackage.called).toBe(false);
-      expect(addPackageToDatabase.called).toBe(false);
-   });
-
-   it("persists when explores are valid (no-location)", async () => {
-      const mockPackage = {
-         formatInvalidExplores: () => "",
-         formatInvalidPersistencePolicy: () => "",
-         formatPersistenceCollisionRejections: () => "",
-      };
-      const addPackage = sinon.stub().resolves(mockPackage);
-      const getEnvironment = sinon.stub().resolves({ addPackage });
-      const addPackageToDatabase = sinon.stub().resolves(undefined);
-      const environmentStore = {
-         publisherConfigIsFrozen: false,
-         getEnvironment,
-         addPackageToDatabase,
-      } as unknown as EnvironmentStore;
-
-      const controller = new PackageController(environmentStore);
-
-      await controller.addPackage("env", {
-         name: "pkg",
-         description: "test",
-         explores: ["index.malloy"],
-      });
-
-      expect(addPackageToDatabase.calledOnceWith("env", "pkg")).toBe(true);
-   });
-});
-
-describe("PackageController.addPackage persistence policy validation", () => {
-   afterEach(() => {
-      sinon.restore();
-   });
-
-   it("rejects a publish whose persistence policy is invalid (no-location path)", async () => {
-      // Valid explores but an invalid persistence policy (e.g. a schedule on a
-      // package-scoped package): the publish must still 400 (strict-at-publish,
-      // same split as explores — load merely warns) and roll back via
-      // unloadPackage.
-      const cronMsg =
-         'materialization.schedule (cron) in publisher.json requires "scope": ' +
-         '"version".';
-      const mockPackage = {
-         formatInvalidExplores: () => "",
-         formatInvalidPersistencePolicy: () => cronMsg,
-         formatPersistenceCollisionRejections: () => "",
-      };
-      const unloadPackage = sinon.stub().resolves(undefined);
-      const addPackage = sinon.stub().resolves(mockPackage);
-      const environment = { addPackage, unloadPackage };
-      const getEnvironment = sinon.stub().resolves(environment);
-      const addPackageToDatabase = sinon.stub().resolves(undefined);
-      const environmentStore = {
-         publisherConfigIsFrozen: false,
-         getEnvironment,
-         addPackageToDatabase,
-      } as unknown as EnvironmentStore;
-
-      const controller = new PackageController(environmentStore);
-
-      await expect(
-         controller.addPackage("env", { name: "pkg", description: "test" }),
-      ).rejects.toThrow(cronMsg);
-
-      expect(unloadPackage.calledOnceWith("pkg")).toBe(true);
-      expect(addPackageToDatabase.called).toBe(false);
-   });
-
-   it("location path: the persistence-policy gate runs inside installPackage's rollback window", async () => {
-      const cronMsg =
-         'materialization.schedule (cron) in publisher.json requires "scope": ' +
-         '"version".';
-      const mockPackage = {
-         formatInvalidExplores: () => "",
-         formatInvalidPersistencePolicy: () => cronMsg,
-         formatPersistenceCollisionRejections: () => "",
-      };
-      const installPackage = sinon
-         .stub()
-         .callsFake(
-            async (
-               _name: string,
-               _downloader: unknown,
-               validate?: (pkg: unknown) => string | undefined,
-            ) => {
-               const msg = validate?.(mockPackage);
-               if (msg) throw new BadRequestError(msg);
-               return mockPackage;
-            },
-         );
-      const environment = { installPackage };
-      const getEnvironment = sinon.stub().resolves(environment);
-      const addPackageToDatabase = sinon.stub().resolves(undefined);
-      const environmentStore = {
-         publisherConfigIsFrozen: false,
-         getEnvironment,
-         addPackageToDatabase,
-      } as unknown as EnvironmentStore;
-
-      const controller = new PackageController(environmentStore);
-
-      await expect(
-         controller.addPackage("env", {
-            name: "pkg",
-            description: "test",
-            location: "gs://bucket/pkg.zip",
-         }),
-      ).rejects.toThrow(cronMsg);
-
-      expect(addPackageToDatabase.called).toBe(false);
-   });
-});
-
-describe("PackageController.updatePackage explores validation", () => {
-   afterEach(() => {
-      sinon.restore();
-   });
-
-   it("location update: validates the EFFECTIVE explores (body override) before the swap commits", async () => {
-      // body.location triggers a reinstall (atomic swap). The effective explores
-      // — the body override here — must be validated inside installPackage so a
-      // bad update rolls back to the previous tree instead of swapping in the
-      // rejected one and 400-ing after the fact.
-      const invalidMsg =
-         "Invalid explores entry 'nope.malloy' in publisher.json: file not found";
-      // The mock package validates whatever override it's handed.
-      const mockPackage = {
-         formatInvalidExplores: (override?: string[]) =>
-            override?.includes("nope.malloy") ? invalidMsg : "",
-         formatInvalidPersistencePolicy: () => "",
-         formatPersistenceCollisionRejections: () => "",
-      };
-      const installPackage = sinon
-         .stub()
-         .callsFake(
-            async (
-               _name: string,
-               _downloader: unknown,
-               validate?: (pkg: unknown) => string | undefined,
-            ) => {
-               const msg = validate?.(mockPackage);
-               if (msg) throw new BadRequestError(msg);
-               return mockPackage;
-            },
-         );
-      const updatePackage = sinon.stub().resolves(mockPackage);
-      const environment = { installPackage, updatePackage };
-      const getEnvironment = sinon.stub().resolves(environment);
-      const addPackageToDatabase = sinon.stub().resolves(undefined);
-      const environmentStore = {
-         publisherConfigIsFrozen: false,
-         getEnvironment,
-         addPackageToDatabase,
-      } as unknown as EnvironmentStore;
-
-      const controller = new PackageController(environmentStore);
-
-      await expect(
-         controller.updatePackage("env", "pkg", {
-            name: "pkg",
-            location: "gs://bucket/pkg.zip",
-            explores: ["nope.malloy"],
-         }),
-      ).rejects.toBeInstanceOf(BadRequestError);
-
-      // The rejected swap never reached the metadata-apply / persist steps.
-      expect(updatePackage.called).toBe(false);
-      expect(addPackageToDatabase.called).toBe(false);
-   });
-});