@malloy-publisher/server 0.0.235 → 0.0.236

package/src/controller/database.controller.ts

@@ -1,24 +0,0 @@
-import { components } from "../api";
-import { EnvironmentStore } from "../service/environment_store";
-
-type ApiDatabase = components["schemas"]["Database"];
-
-export class DatabaseController {
-   private environmentStore: EnvironmentStore;
-
-   constructor(environmentStore: EnvironmentStore) {
-      this.environmentStore = environmentStore;
-   }
-
-   public async listDatabases(
-      environmentName: string,
-      packageName: string,
-   ): Promise<ApiDatabase[]> {
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      const p = await environment.getPackage(packageName, false);
-      return p.listDatabases();
-   }
-}

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

@@ -1,293 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import * as sinon from "sinon";
-import { BadRequestError } from "../errors";
-import type { MaterializationService } from "../service/materialization_service";
-import { MaterializationController } from "./materialization.controller";
-
-/**
- * Unit tests for {@link MaterializationController.createMaterialization}'s body
- * validation. The service is stubbed so each test asserts the parsed options
- * the controller forwards (or the rejection for a malformed body).
- */
-function build() {
-   const createMaterialization = sinon.stub().resolves({ id: "m1" });
-   const service = {
-      createMaterialization,
-   } as unknown as MaterializationService;
-   const controller = new MaterializationController(service);
-   return { controller, createMaterialization };
-}
-
-/** Parsed options the controller forwards for a given request body. */
-async function parse(body: Record<string, unknown>) {
-   const { controller, createMaterialization } = build();
-   await controller.createMaterialization("env", "pkg", body);
-   return createMaterialization.firstCall.args[2];
-}
-
-describe("MaterializationController.createMaterialization validation", () => {
-   it("forwards an empty body as empty options", async () => {
-      expect(await parse({})).toEqual({});
-   });
-
-   it("passes through forceRefresh and sourceNames", async () => {
-      expect(
-         await parse({ forceRefresh: true, sourceNames: ["a", "b"] }),
-      ).toEqual({ forceRefresh: true, sourceNames: ["a", "b"] });
-   });
-
-   it("never forwards a client-supplied trigger (SCHEDULER cannot be forged)", async () => {
-      // trigger is service-level-only: the controller must strip it so an API
-      // caller cannot mint a run that reads as scheduler-driven. The service
-      // then defaults it to ON_DEMAND.
-      const parsed = await parse({ forceRefresh: true, trigger: "SCHEDULER" });
-      expect(parsed).toEqual({ forceRefresh: true });
-      expect("trigger" in (parsed as object)).toBe(false);
-   });
-
-   it("rejects a non-boolean forceRefresh", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            forceRefresh: "yes",
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("rejects sourceNames that is not an array of strings", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            sourceNames: [1, 2],
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("flattens buildInstructions.sources into the instruction list", async () => {
-      const parsed = await parse({
-         buildInstructions: {
-            sources: [
-               {
-                  sourceEntityId: "b1",
-                  sourceID: "orders@m",
-                  materializedTableId: "mt-1",
-                  physicalTableName: "orders_v1",
-                  realization: "COPY",
-               },
-            ],
-         },
-      });
-      expect(parsed).toEqual({
-         buildInstructions: [
-            {
-               sourceEntityId: "b1",
-               sourceID: "orders@m",
-               materializedTableId: "mt-1",
-               physicalTableName: "orders_v1",
-               realization: "COPY",
-            },
-         ],
-      });
-   });
-
-   it("treats null buildInstructions as absent (auto-run)", async () => {
-      expect(await parse({ buildInstructions: null })).toEqual({});
-   });
-
-   it("parses referenceManifest and strictUpstreams alongside sources", async () => {
-      const parsed = await parse({
-         buildInstructions: {
-            sources: [
-               {
-                  sourceEntityId: "b2",
-                  materializedTableId: "mt-2",
-                  physicalTableName: "downstream_v1",
-                  realization: "COPY",
-               },
-            ],
-            referenceManifest: [
-               { sourceEntityId: "b1", physicalTableName: "upstream_table" },
-            ],
-            strictUpstreams: true,
-         },
-      });
-      expect(parsed).toEqual({
-         buildInstructions: [
-            {
-               sourceEntityId: "b2",
-               sourceID: undefined,
-               materializedTableId: "mt-2",
-               physicalTableName: "downstream_v1",
-               realization: "COPY",
-            },
-         ],
-         referenceManifest: [
-            { sourceEntityId: "b1", physicalTableName: "upstream_table" },
-         ],
-         strictUpstreams: true,
-      });
-   });
-
-   it("preserves the storage `destination` on a build instruction", async () => {
-      // Regression: `destination` is the orchestrated `storage=` axis. Dropping it
-      // here silently downgrades an orchestrated build to a colocated
-      // build, so it never materializes into the storage destination.
-      const parsed = await parse({
-         buildInstructions: {
-            sources: [
-               {
-                  sourceEntityId: "b2",
-                  materializedTableId: "mt-2",
-                  physicalTableName: "downstream_v1",
-                  realization: "COPY",
-                  destination: "lake",
-               },
-            ],
-         },
-      });
-      expect(parsed.buildInstructions).toEqual([
-         {
-            sourceEntityId: "b2",
-            sourceID: undefined,
-            materializedTableId: "mt-2",
-            physicalTableName: "downstream_v1",
-            realization: "COPY",
-            destination: "lake",
-         },
-      ]);
-   });
-
-   it("preserves the optional `connectionName` on a manifest reference", async () => {
-      // Regression: `connectionName` (added by #904) lets the seed loop dialect-
-      // quote the referenced upstream for a case-folding engine. Dropping it here
-      // silently reverts to an unquoted seed — the same manual-copy drift that
-      // dropped BuildInstruction.destination.
-      const parsed = await parse({
-         buildInstructions: {
-            sources: [
-               {
-                  sourceEntityId: "b2",
-                  materializedTableId: "mt-2",
-                  physicalTableName: "downstream_v1",
-                  realization: "COPY",
-               },
-            ],
-            referenceManifest: [
-               {
-                  sourceEntityId: "b1",
-                  physicalTableName: "upstream_table",
-                  connectionName: "sf",
-               },
-            ],
-         },
-      });
-      expect(parsed.referenceManifest).toEqual([
-         {
-            sourceEntityId: "b1",
-            physicalTableName: "upstream_table",
-            connectionName: "sf",
-         },
-      ]);
-   });
-
-   it("rejects a referenceManifest entry missing a required field", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            buildInstructions: {
-               sources: [
-                  {
-                     sourceEntityId: "b2",
-                     materializedTableId: "mt-2",
-                     physicalTableName: "downstream_v1",
-                     realization: "COPY",
-                  },
-               ],
-               referenceManifest: [{ sourceEntityId: "b1" }],
-            },
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("rejects a non-boolean strictUpstreams", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            buildInstructions: {
-               sources: [
-                  {
-                     sourceEntityId: "b2",
-                     materializedTableId: "mt-2",
-                     physicalTableName: "downstream_v1",
-                     realization: "COPY",
-                  },
-               ],
-               strictUpstreams: "yes",
-            },
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("rejects buildInstructions without a non-empty sources array", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            buildInstructions: { sources: [] },
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("rejects an instruction missing a required field", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            buildInstructions: {
-               sources: [{ sourceEntityId: "b1", materializedTableId: "mt-1" }],
-            },
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("rejects an unrecognized realization", async () => {
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            buildInstructions: {
-               sources: [
-                  {
-                     sourceEntityId: "b1",
-                     materializedTableId: "mt-1",
-                     physicalTableName: "orders_v1",
-                     realization: "MERGE",
-                  },
-               ],
-            },
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("rejects a runId the metadata contract cannot carry", async () => {
-      // runId becomes the `run_id` property on every statement of the build, so
-      // an over-long or unrenderable value is silently truncated and rewritten
-      // at dispatch — leaving the caller holding an id that joins to nothing.
-      // The neighbouring `trigger` is enum-validated; this is the same kind of
-      // boundary and gets the same treatment.
-      const { controller } = build();
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            runContext: { runId: "x".repeat(300) },
-         }),
-      ).rejects.toThrow(BadRequestError);
-      await expect(
-         controller.createMaterialization("env", "pkg", {
-            runContext: { runId: 'has "quotes"' },
-         }),
-      ).rejects.toThrow(BadRequestError);
-   });
-
-   it("still accepts a conforming runId", async () => {
-      expect(
-         await parse({ runContext: { trigger: "publish", runId: "run-42" } }),
-      ).toEqual({ runContext: { trigger: "publish", runId: "run-42" } });
-   });
-});

package/src/controller/materialization.controller.ts

@@ -1,319 +0,0 @@
-import type { components } from "../api";
-import { BadRequestError } from "../errors";
-import {
-   BuildInstruction,
-   ManifestReference,
-} from "../storage/DatabaseInterface";
-import { MaterializationService } from "../service/materialization_service";
-import { queryMetadataViolations } from "../service/query_metadata";
-
-type RunContext = components["schemas"]["RunContext"];
-
-const RUN_TRIGGERS = ["publish", "on_demand", "scheduler"] as const;
-
-export class MaterializationController {
-   constructor(private materializationService: MaterializationService) {}
-
-   async createMaterialization(
-      environmentName: string,
-      packageName: string,
-      body: Record<string, unknown>,
-   ) {
-      return this.materializationService.createMaterialization(
-         environmentName,
-         packageName,
-         this.validateCreateBody(body),
-      );
-   }
-
-   // Whitelist: only these fields are read off the client body. `trigger` is
-   // deliberately NOT accepted here — it is service-level-only, defaulted to
-   // `ON_DEMAND` and set to `SCHEDULER` solely by the in-process scheduler
-   // (which calls the service directly, not this HTTP path). Do not add
-   // `trigger` to this parser, or an API caller could forge a scheduled run.
-   private validateCreateBody(body: Record<string, unknown>): {
-      forceRefresh?: boolean;
-      sourceNames?: string[];
-      buildInstructions?: BuildInstruction[];
-      referenceManifest?: ManifestReference[];
-      strictUpstreams?: boolean;
-      runContext?: RunContext;
-   } {
-      const result: {
-         forceRefresh?: boolean;
-         sourceNames?: string[];
-         buildInstructions?: BuildInstruction[];
-         referenceManifest?: ManifestReference[];
-         strictUpstreams?: boolean;
-         runContext?: RunContext;
-      } = {};
-      if (body.runContext !== undefined && body.runContext !== null) {
-         result.runContext = this.validateRunContext(body.runContext);
-      }
-      if (
-         body.buildInstructions !== undefined &&
-         body.buildInstructions !== null
-      ) {
-         const parsed = this.validateBuildInstructions(body.buildInstructions);
-         result.buildInstructions = parsed.sources;
-         if (parsed.referenceManifest !== undefined) {
-            result.referenceManifest = parsed.referenceManifest;
-         }
-         if (parsed.strictUpstreams !== undefined) {
-            result.strictUpstreams = parsed.strictUpstreams;
-         }
-      }
-      if (body.forceRefresh !== undefined) {
-         if (typeof body.forceRefresh !== "boolean") {
-            throw new BadRequestError("forceRefresh must be a boolean");
-         }
-         result.forceRefresh = body.forceRefresh;
-      }
-      if (body.sourceNames !== undefined) {
-         if (
-            !Array.isArray(body.sourceNames) ||
-            body.sourceNames.some((n) => typeof n !== "string")
-         ) {
-            throw new BadRequestError(
-               "sourceNames must be an array of strings",
-            );
-         }
-         result.sourceNames = body.sourceNames as string[];
-      }
-      return result;
-   }
-
-   /**
-    * Validate `runContext`, the caller's observability context for one run.
-    * `trigger` is a closed enum here even though it feeds a metadata property:
-    * the whole point is that a reader can group runs by how they started, which a
-    * free-form value would quietly break.
-    *
-    * Note this is NOT the service-level `trigger` the parser above deliberately
-    * refuses. That one decides whether the run counts as scheduled; this one only
-    * labels the statements the run issues, so accepting `publish` from a caller
-    * forges nothing.
-    */
-   private validateRunContext(raw: unknown): RunContext {
-      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-         throw new BadRequestError("runContext must be an object");
-      }
-      const obj = raw as Record<string, unknown>;
-      const context: RunContext = {};
-      if (obj.trigger !== undefined && obj.trigger !== null) {
-         if (
-            typeof obj.trigger !== "string" ||
-            !RUN_TRIGGERS.includes(obj.trigger as (typeof RUN_TRIGGERS)[number])
-         ) {
-            throw new BadRequestError(
-               `runContext.trigger must be one of ${RUN_TRIGGERS.join(" | ")}`,
-            );
-         }
-         context.trigger = obj.trigger as RunContext["trigger"];
-      }
-      if (obj.runId !== undefined && obj.runId !== null) {
-         if (typeof obj.runId !== "string") {
-            throw new BadRequestError("runContext.runId must be a string");
-         }
-         // Held to the metadata contract like any other caller-supplied
-         // property: it becomes the `run_id` on every statement of the build,
-         // and a value the contract rejects would otherwise be truncated and
-         // rewritten in silence — leaving the caller with an id it cannot join
-         // on and no way to know why.
-         const violations = queryMetadataViolations({ run_id: obj.runId });
-         if (violations.length > 0) {
-            throw new BadRequestError(
-               `runContext.runId is attached to every statement as the run_id ` +
-                  `property: ${violations.join("; ")}`,
-            );
-         }
-         context.runId = obj.runId;
-      }
-      return context;
-   }
-
-   /**
-    * Validate the orchestrated `buildInstructions` payload (BuildInstructions:
-    * `{ sources: BuildInstruction[], referenceManifest?, strictUpstreams? }`)
-    * into the parts the service consumes: the flattened instruction list, the
-    * optional upstream reference manifest, and the strict flag.
-    */
-   private validateBuildInstructions(raw: unknown): {
-      sources: BuildInstruction[];
-      referenceManifest?: ManifestReference[];
-      strictUpstreams?: boolean;
-   } {
-      if (typeof raw !== "object" || raw === null) {
-         throw new BadRequestError("buildInstructions must be an object");
-      }
-      const obj = raw as Record<string, unknown>;
-      const sources = obj.sources;
-      if (!Array.isArray(sources) || sources.length === 0) {
-         throw new BadRequestError(
-            "buildInstructions requires a non-empty 'sources' array of BuildInstruction",
-         );
-      }
-      const result: {
-         sources: BuildInstruction[];
-         referenceManifest?: ManifestReference[];
-         strictUpstreams?: boolean;
-      } = {
-         sources: sources.map((instruction) =>
-            this.validateInstruction(instruction),
-         ),
-      };
-      if (
-         obj.referenceManifest !== undefined &&
-         obj.referenceManifest !== null
-      ) {
-         if (!Array.isArray(obj.referenceManifest)) {
-            throw new BadRequestError(
-               "buildInstructions.referenceManifest must be an array of ManifestReference",
-            );
-         }
-         result.referenceManifest = obj.referenceManifest.map((ref) =>
-            this.validateManifestReference(ref),
-         );
-      }
-      if (obj.strictUpstreams !== undefined) {
-         if (typeof obj.strictUpstreams !== "boolean") {
-            throw new BadRequestError(
-               "buildInstructions.strictUpstreams must be a boolean",
-            );
-         }
-         result.strictUpstreams = obj.strictUpstreams;
-      }
-      return result;
-   }
-
-   private validateManifestReference(raw: unknown): ManifestReference {
-      if (typeof raw !== "object" || raw === null) {
-         throw new BadRequestError("Each manifest reference must be an object");
-      }
-      const ref = raw as Record<string, unknown>;
-      for (const field of ["sourceEntityId", "physicalTableName"] as const) {
-         if (typeof ref[field] !== "string") {
-            throw new BadRequestError(
-               `Manifest reference is missing required string field '${field}'`,
-            );
-         }
-      }
-      return {
-         sourceEntityId: ref.sourceEntityId as string,
-         physicalTableName: ref.physicalTableName as string,
-         // The connection the upstream table lives on. Optional; carried through
-         // so the seed loop can dialect-quote the reference for a case-folding
-         // engine (#904). Dropping it silently reverts to an unquoted seed, which
-         // fails a downstream build on such an engine — the same manual-copy drift
-         // that dropped BuildInstruction.destination.
-         ...(typeof ref.connectionName === "string"
-            ? { connectionName: ref.connectionName }
-            : {}),
-      };
-   }
-
-   private validateInstruction(raw: unknown): BuildInstruction {
-      if (typeof raw !== "object" || raw === null) {
-         throw new BadRequestError("Each build instruction must be an object");
-      }
-      const instruction = raw as Record<string, unknown>;
-      const required = [
-         "sourceEntityId",
-         "materializedTableId",
-         "physicalTableName",
-         "realization",
-      ] as const;
-      for (const field of required) {
-         if (typeof instruction[field] !== "string") {
-            throw new BadRequestError(
-               `Build instruction is missing required string field '${field}'`,
-            );
-         }
-      }
-      if (
-         instruction.realization !== "COPY" &&
-         instruction.realization !== "SNAPSHOT"
-      ) {
-         throw new BadRequestError(
-            "Build instruction 'realization' must be COPY or SNAPSHOT",
-         );
-      }
-      return {
-         sourceEntityId: instruction.sourceEntityId as string,
-         sourceID:
-            typeof instruction.sourceID === "string"
-               ? instruction.sourceID
-               : undefined,
-         materializedTableId: instruction.materializedTableId as string,
-         physicalTableName: instruction.physicalTableName as string,
-         realization: instruction.realization,
-         // The `storage=` destination the orchestrator targets. Optional in the
-         // schema; must be carried through, or an orchestrated build silently
-         // falls back to a colocated build (isStorageBuild=false) and
-         // never materializes into the storage destination.
-         ...(typeof instruction.destination === "string"
-            ? { destination: instruction.destination }
-            : {}),
-      };
-   }
-
-   async stopMaterialization(
-      environmentName: string,
-      packageName: string,
-      materializationId: string,
-   ) {
-      return this.materializationService.stopMaterialization(
-         environmentName,
-         packageName,
-         materializationId,
-      );
-   }
-
-   async listMaterializations(
-      environmentName: string,
-      packageName: string,
-      options?: { limit?: number; offset?: number },
-   ) {
-      return this.materializationService.listMaterializations(
-         environmentName,
-         packageName,
-         options,
-      );
-   }
-
-   async listEnvironmentMaterializations(
-      environmentName: string,
-      options?: { limit?: number; offset?: number },
-   ) {
-      return this.materializationService.listEnvironmentMaterializations(
-         environmentName,
-         options,
-      );
-   }
-
-   async getMaterialization(
-      environmentName: string,
-      packageName: string,
-      materializationId: string,
-   ) {
-      return this.materializationService.getMaterialization(
-         environmentName,
-         packageName,
-         materializationId,
-      );
-   }
-
-   async deleteMaterialization(
-      environmentName: string,
-      packageName: string,
-      materializationId: string,
-      options: { dropTables?: boolean } = {},
-   ) {
-      return this.materializationService.deleteMaterialization(
-         environmentName,
-         packageName,
-         materializationId,
-         options,
-      );
-   }
-}