@malloy-publisher/server 0.0.223 → 0.0.225

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.223",
+   "version": "0.0.225",
    "main": "dist/server.mjs",
    "bin": {
       "malloy-publisher": "dist/server.mjs"
@@ -36,17 +36,17 @@
       "@azure/storage-blob": "^12.26.0",
       "@duckdb/node-api": "1.5.3-r.2",
       "@google-cloud/storage": "^7.16.0",
-      "@malloydata/db-bigquery": "^0.0.421",
-      "@malloydata/db-databricks": "^0.0.421",
-      "@malloydata/db-duckdb": "^0.0.421",
-      "@malloydata/db-mysql": "^0.0.421",
-      "@malloydata/db-postgres": "^0.0.421",
-      "@malloydata/db-publisher": "^0.0.421",
-      "@malloydata/db-snowflake": "^0.0.421",
-      "@malloydata/db-trino": "^0.0.421",
-      "@malloydata/malloy": "^0.0.421",
-      "@malloydata/malloy-sql": "^0.0.421",
-      "@malloydata/render-validator": "^0.0.421",
+      "@malloydata/db-bigquery": "^0.0.422",
+      "@malloydata/db-databricks": "^0.0.422",
+      "@malloydata/db-duckdb": "^0.0.422",
+      "@malloydata/db-mysql": "^0.0.422",
+      "@malloydata/db-postgres": "^0.0.422",
+      "@malloydata/db-publisher": "^0.0.422",
+      "@malloydata/db-snowflake": "^0.0.422",
+      "@malloydata/db-trino": "^0.0.422",
+      "@malloydata/malloy": "^0.0.422",
+      "@malloydata/malloy-sql": "^0.0.422",
+      "@malloydata/render-validator": "^0.0.422",
       "@modelcontextprotocol/sdk": "^1.13.2",
       "@opentelemetry/api": "^1.9.0",
       "@opentelemetry/auto-instrumentations-node": "^0.57.0",

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

@@ -85,6 +85,78 @@ describe("MaterializationController.createMaterialization validation", () => {
       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("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(

package/src/controller/materialization.controller.ts

@@ -1,5 +1,8 @@
 import { BadRequestError } from "../errors";
-import { BuildInstruction } from "../storage/DatabaseInterface";
+import {
+   BuildInstruction,
+   ManifestReference,
+} from "../storage/DatabaseInterface";
 import { MaterializationService } from "../service/materialization_service";
 
 export class MaterializationController {
@@ -21,19 +24,28 @@ export class MaterializationController {
       forceRefresh?: boolean;
       sourceNames?: string[];
       buildInstructions?: BuildInstruction[];
+      referenceManifest?: ManifestReference[];
+      strictUpstreams?: boolean;
    } {
       const result: {
          forceRefresh?: boolean;
          sourceNames?: string[];
          buildInstructions?: BuildInstruction[];
+         referenceManifest?: ManifestReference[];
+         strictUpstreams?: boolean;
       } = {};
       if (
          body.buildInstructions !== undefined &&
          body.buildInstructions !== null
       ) {
-         result.buildInstructions = this.validateBuildInstructions(
-            body.buildInstructions,
-         );
+         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") {
@@ -57,22 +69,74 @@ export class MaterializationController {
 
    /**
     * Validate the orchestrated `buildInstructions` payload (BuildInstructions:
-    * `{ sources: BuildInstruction[] }`) and flatten it to the instruction list
-    * the service consumes.
+    * `{ 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): BuildInstruction[] {
+   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 sources = (raw as Record<string, unknown>).sources;
+      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",
          );
       }
-      return sources.map((instruction) =>
-         this.validateInstruction(instruction),
-      );
+      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,
+      };
    }
 
    private validateInstruction(raw: unknown): BuildInstruction {