npm - @malloy-publisher/server - Versions diffs - 0.0.215 → 0.0.217 - Mend

@malloy-publisher/server 0.0.215 → 0.0.217

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/src/server.ts CHANGED Viewed

@@ -491,7 +491,32 @@ type PageItem = {
    packageName: string;
    path: string;
    title: string;
+   fit?: "viewport";
 };
+// The spots in an HTML head where a "<meta ...>" literal would NOT be a live
+// tag: HTML comments (terminated or unterminated) and raw-text/RCDATA elements
+// (script/style/title/textarea). One alternation so a single .replace covers
+// them all (and so the fixpoint loop below applies one self-referential
+// replace, which is the complete-sanitization shape CodeQL recognizes).
+const NON_TAG_TEXT_PATTERN =
+   /<!--[\s\S]*?-->|<!--[\s\S]*$|<(script|style|title|textarea)\b[\s\S]*?<\/\1\s*>/gi;
+// Remove those matches until the string stops changing. A single pass is
+// incomplete because removing one match can splice the surrounding text into a
+// new one (CWE-116), so re-apply the same pattern to its own output until a
+// fixpoint. Each pass only deletes, so the string strictly shrinks and the loop
+// terminates, bounded by the input length (callers pass at most the first 4KB).
+function stripNonTagText(input: string): string {
+   let current = input;
+   let previous: string;
+   do {
+      previous = current;
+      current = current.replace(NON_TAG_TEXT_PATTERN, "");
+   } while (current !== previous);
+   return current;
+}
 async function listPackagePages(
    environmentName: string,
    packageName: string,
@@ -539,8 +564,9 @@ async function listPackagePages(
             (entry.name.endsWith(".html") || entry.name.endsWith(".htm"))
          ) {
             const rel = path.relative(publicRoot, full).replace(/\\/g, "/");
-            // Cheap title extraction: read first 4KB and grep for <title>.
+            // Cheap metadata extraction: read first 4KB and grep the <head>.
             let title = rel;
+            let fit: "viewport" | undefined;
             try {
                const fh = await fs.open(full, "r");
                try {
@@ -549,6 +575,33 @@ async function listPackagePages(
                   const head = buf.slice(0, bytesRead).toString("utf8");
                   const m = head.match(/<title[^>]*>([^<]+)<\/title>/i);
                   if (m) title = m[1].trim();
+                  // Full-screen apps (e.g. slide decks) opt into a viewport-fill
+                  // embed with <meta name="publisher:fit" content="viewport">.
+                  // FIRST strip the spots where the literal string is NOT a live
+                  // tag (comments, script/style/title/textarea), THEN look at the
+                  // <head> region only (up to </head> or <body>). Order matters:
+                  // stripping before locating the boundary keeps a literal
+                  // "<body>"/"</head>" inside a comment or <script> from
+                  // truncating the scan and hiding a real tag. What's left and
+                  // matches is a genuine <meta> the browser would honor too, so a
+                  // documented/commented example or a string in a code block
+                  // can't opt the page in. Match by name (attribute order/quoting
+                  // vary), then confirm content="viewport"; the [\s"'] before
+                  // `name` keeps `data-name="publisher:fit"` out. Like the title,
+                  // the tag must sit within the first 4KB.
+                  const cleaned = stripNonTagText(head);
+                  const headEnd = cleaned.search(/<\/head\s*>|<body[\s>]/i);
+                  const headTags =
+                     headEnd === -1 ? cleaned : cleaned.slice(0, headEnd);
+                  const fitMeta = headTags.match(
+                     /<meta\b[^>]*[\s"']name\s*=\s*["']publisher:fit["'][^>]*>/i,
+                  );
+                  if (
+                     fitMeta &&
+                     /\bcontent\s*=\s*["']\s*viewport\s*["']/i.test(fitMeta[0])
+                  ) {
+                     fit = "viewport";
+                  }
                } finally {
                   await fh.close();
                }
@@ -560,6 +613,7 @@ async function listPackagePages(
                packageName,
                path: rel,
                title,
+               fit,
             });
          }
       }

package/src/service/build_plan.spec.ts CHANGED Viewed

@@ -229,6 +229,27 @@ describe("deriveBuildPlan", () => {
       expect(Object.keys(plan.sources)).toEqual(["a@m"]);
    });
+   it("carries the per-source package-relative modelPath", () => {
+      const a = fakeSource({ name: "a", buildId: "bid-a" });
+      const b = fakeSource({ name: "b", buildId: "bid-b" });
+      const plan = deriveBuildPlan(
+         [
+            {
+               connectionName: "duckdb",
+               nodes: [[{ sourceID: "a@m", dependsOn: [] }]],
+            },
+         ] as unknown as Parameters<typeof deriveBuildPlan>[0],
+         { "a@m": a, "b@m": b },
+         { duckdb: "dig" },
+         undefined,
+         { "a@m": "rollup.malloy" },
+      );
+      // Mapped source gets its model path; an unmapped source stays undefined.
+      expect(plan.sources["a@m"].modelPath).toBe("rollup.malloy");
+      expect(plan.sources["b@m"].modelPath).toBeUndefined();
+   });
 });
 describe("compilePackageBuildPlan", () => {

package/src/service/build_plan.ts CHANGED Viewed

@@ -42,6 +42,13 @@ export interface CompiledBuildPlan {
    sources: Record<string, PersistSource>;
    connectionDigests: Record<string, string>;
    connections: Map<string, MalloyConnection>;
+   /**
+    * sourceID -> the package-relative path of the `.malloy` model that declares
+    * the source (the only place that mapping is known, since a sourceID's
+    * embedded modelURL is an absolute `file://` path with no package boundary).
+    * Optional so existing fixtures/callers that don't track it still typecheck.
+    */
+   sourceModelPaths?: Record<string, string>;
 }
 /** Output columns of a persist source, degrading to [] if unavailable. */
@@ -192,6 +199,7 @@ export async function compilePackageBuildPlan(
 ): Promise<CompiledBuildPlan> {
    const allGraphs: MalloyBuildGraph[] = [];
    const allSources: Record<string, PersistSource> = {};
+   const sourceModelPaths: Record<string, string> = {};
    for (const modelPath of pkg.getModelPaths()) {
       // Only `.malloy` models declare persist sources. Skip `.malloynb`
@@ -225,6 +233,7 @@ export async function compilePackageBuildPlan(
       allGraphs.push(...buildPlan.graphs);
       for (const [sourceID, source] of Object.entries(buildPlan.sources)) {
          allSources[sourceID] = source;
+         sourceModelPaths[sourceID] = modelPath;
       }
    }
@@ -256,6 +265,7 @@ export async function compilePackageBuildPlan(
       sources: allSources,
       connectionDigests,
       connections,
+      sourceModelPaths,
    };
 }
@@ -265,6 +275,7 @@ export function deriveBuildPlan(
    sources: Record<string, PersistSource>,
    connectionDigests: Record<string, string>,
    sourceNames?: string[],
+   sourceModelPaths?: Record<string, string>,
 ): BuildPlan {
    const include = sourceNames ? new Set(sourceNames) : null;
@@ -290,6 +301,7 @@ export function deriveBuildPlan(
          sql: source.getSQL(),
          columns: deriveColumns(source),
          annotationFields: deriveAnnotationFields(source),
+         modelPath: sourceModelPaths?.[sourceID],
       };
    }
@@ -313,5 +325,7 @@ export async function computePackageBuildPlan(
       compiled.graphs,
       compiled.sources,
       compiled.connectionDigests,
+      undefined,
+      compiled.sourceModelPaths,
    );
 }

package/src/service/environment.ts CHANGED Viewed

@@ -1340,6 +1340,13 @@ export class Environment {
             explores,
             queryableSources,
             manifestLocation,
+            // Carry the manifest-derived materialization policy through the
+            // PATCH. `setPackageMetadata` replaces the whole object, so omitting
+            // this wipes the in-memory `materialization` until the next reload —
+            // which makes a later getPackage report no schedule and lets the
+            // control plane misread the gap as a schedule removal. It is not a
+            // PATCH-editable field, so always preserve the existing value.
+            materialization: existing.materialization,
          });
          // Strict-reject, symmetric with the publish path

package/src/service/materialization_schedule_surface.spec.ts ADDED Viewed

@@ -0,0 +1,103 @@
+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";
+/**
+ * The publisher must surface a non-null `materialization` object on a loaded
+ * package's metadata so the control plane can treat object-present as the
+ * authoritative manifest policy ("this is what the manifest says") and
+ * object-absent as "metadata not loaded this request" — never as a schedule
+ * removal. A metadata PATCH must not drop that policy from the in-memory
+ * metadata. Regression coverage for the re-materialization schedule self-wipe
+ * (docs/bugs/materialization-schedule-self-wipe.md).
+ *
+ * Runs against a real `Environment` + real `Package.create` over temp dirs.
+ */
+describe("materialization schedule surfacing", () => {
+   const MODEL = `source: ones is duckdb.sql("SELECT 1 as x")\n`;
+   let rootDir: string;
+   let envPath: string;
+   async function writePackageDir(
+      manifest: Record<string, unknown>,
+   ): Promise<void> {
+      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", ...manifest }),
+      );
+      await fs.writeFile(path.join(dir, "model.malloy"), MODEL);
+   }
+   beforeEach(async () => {
+      rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "publisher-mat-"));
+      envPath = path.join(rootDir, "env");
+      await fs.mkdir(envPath, { recursive: true });
+   });
+   afterEach(async () => {
+      await fs.rm(rootDir, { recursive: true, force: true }).catch(() => {});
+   });
+   it(
+      "surfaces the manifest's materialization.schedule on load",
+      async () => {
+         const env = await Environment.create("testEnv", envPath, []);
+         await writePackageDir({ materialization: { schedule: "0 6 * * *" } });
+         await env.addPackage("pkg");
+         const pkg = await env.getPackage("pkg", false);
+         expect(pkg.getPackageMetadata().materialization).toEqual({
+            schedule: "0 6 * * *",
+         });
+      },
+      { timeout: 20000 },
+   );
+   it(
+      "surfaces a non-null materialization object even when the manifest declares none",
+      async () => {
+         const env = await Environment.create("testEnv", envPath, []);
+         await writePackageDir({});
+         await env.addPackage("pkg");
+         // Object present with a null schedule — NOT a null object — so the
+         // control plane reads it as an authoritative "no schedule declared",
+         // not as "metadata unavailable".
+         const pkg = await env.getPackage("pkg", false);
+         expect(pkg.getPackageMetadata().materialization).toEqual({
+            schedule: null,
+         });
+      },
+      { timeout: 20000 },
+   );
+   it(
+      "preserves the materialization policy across a metadata PATCH",
+      async () => {
+         const env = await Environment.create("testEnv", envPath, []);
+         await writePackageDir({ materialization: { schedule: "0 6 * * *" } });
+         await env.addPackage("pkg");
+         // A description-only PATCH must not wipe the schedule from the
+         // in-memory metadata. The bug: setPackageMetadata replaces the whole
+         // object, so a later getPackage reported no schedule and the control
+         // plane misread the gap as a removal and cleared the cadence.
+         const updated = await env.updatePackage("pkg", {
+            name: "pkg",
+            description: "updated",
+         });
+         expect(updated.materialization).toEqual({ schedule: "0 6 * * *" });
+         const pkg = await env.getPackage("pkg", false);
+         expect(pkg.getPackageMetadata().materialization).toEqual({
+            schedule: "0 6 * * *",
+         });
+      },
+      { timeout: 20000 },
+   );
+});

package/src/service/package.ts CHANGED Viewed

@@ -331,7 +331,16 @@ export class Package {
          explores: outcome.packageMetadata.explores,
          queryableSources: outcome.packageMetadata.queryableSources,
          manifestLocation: outcome.packageMetadata.manifestLocation ?? null,
-         materialization: outcome.packageMetadata.materialization ?? null,
+         // Always surface a non-null `materialization` object once the package
+         // has loaded (schedule null when the manifest declares no policy). The
+         // control plane treats object-present as the authoritative "this is
+         // what the manifest says" signal and object-absent as "metadata not
+         // available this request" — so it must never be dropped to null on a
+         // successfully loaded package, or the CP can misread a transient
+         // absence as a schedule removal. See `parsePackageMaterialization`.
+         materialization: outcome.packageMetadata.materialization ?? {
+            schedule: null,
+         },
       };
       // Build live `Model`s from worker output. Any per-model compile

package/tests/fixtures/html-pages-test/public/barehtml.html ADDED Viewed

@@ -0,0 +1,4 @@
+<!doctype html>
+<title>Bare HTML</title>
+<!-- example only, must NOT opt in: <meta name="publisher:fit" content="viewport"> -->
+<h1>No head or body tags; the tag appears only in a comment.</h1>

package/tests/fixtures/html-pages-test/public/bodymeta.html ADDED Viewed

@@ -0,0 +1,8 @@
+<!doctype html>
+<html>
+   <title>Body Meta</title>
+   <body>
+      <meta name="publisher:fit" content="viewport" />
+      <h1>A real fit meta in &lt;body&gt;; the head-only scan means no opt-in.</h1>
+   </body>
+</html>

package/tests/fixtures/html-pages-test/public/fitcomment.html ADDED Viewed

@@ -0,0 +1,11 @@
+<!doctype html>
+<html>
+   <head>
+      <!-- this deck does <body> styling tricks; the literal must not truncate the scan -->
+      <meta name="publisher:fit" content="viewport" />
+      <title>Fit After Comment</title>
+   </head>
+   <body style="height: 100vh; margin: 0; overflow: hidden">
+      <section style="height: 100%">A full-screen slide</section>
+   </body>
+</html>

package/tests/fixtures/html-pages-test/public/nohead.html ADDED Viewed

@@ -0,0 +1,8 @@
+<!doctype html>
+<html>
+   <title>No Head Close Tag</title>
+   <body>
+      <h1>Omits the optional &lt;/head&gt; end tag</h1>
+      <!-- shown in body, must NOT opt in: <meta name="publisher:fit" content="viewport"> -->
+   </body>
+</html>

package/tests/fixtures/html-pages-test/public/notfit.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html>
+   <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta data-name="publisher:fit" content="viewport" />
+      <title>Tall Dashboard</title>
+   </head>
+   <body>
+      <h1>A normal dashboard that hugs its content</h1>
+      <!-- shown in body, must NOT opt in: <meta name="publisher:fit" content="viewport"> -->
+   </body>
+</html>

package/tests/fixtures/html-pages-test/public/slides.html ADDED Viewed

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+   <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="publisher:fit" content="viewport" />
+      <title>FY27 Slide Deck</title>
+   </head>
+   <body style="height: 100vh; margin: 0; overflow: hidden">
+      <section style="height: 100%">A full-screen slide</section>
+   </body>
+</html>

package/tests/fixtures/html-pages-test/public/unterminated.html ADDED Viewed

@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+   <head>
+      <title>Unterminated Comment</title>
+      <!-- never closed, must NOT opt in: <meta name="publisher:fit" content="viewport">
+   </head>
+   <body>
+      <h1>An unterminated comment swallows the tag.</h1>
+   </body>
+</html>

package/tests/integration/html_pages/html_pages.integration.spec.ts CHANGED Viewed

@@ -66,6 +66,7 @@ interface PageItem {
    packageName?: string;
    path?: string;
    title?: string;
+   fit?: "viewport";
 }
 // Creating a symlink that escapes the package needs privileges the Windows CI
@@ -322,7 +323,17 @@ describe("In-package HTML data apps (E2E)", () => {
       const paths = pages.map((p) => p.path).sort();
       // Only HTML files under public/ are listed; the toEqual pins the exact
       // set, so non-public files (manifest, models, data) can't appear.
-      expect(paths).toEqual(["index.html", "sub/page2.html"]);
+      expect(paths).toEqual([
+         "barehtml.html",
+         "bodymeta.html",
+         "fitcomment.html",
+         "index.html",
+         "nohead.html",
+         "notfit.html",
+         "slides.html",
+         "sub/page2.html",
+         "unterminated.html",
+      ]);
       const index = pages.find((p) => p.path === "index.html");
       expect(index?.title).toBe("Carrier Dashboard");
@@ -332,6 +343,57 @@ describe("In-package HTML data apps (E2E)", () => {
       );
    });
+   it("surfaces fit=viewport only for pages that opt in via <meta name=publisher:fit>", async () => {
+      const res = await fetch(apiUrl("/pages"));
+      expect(res.status).toBe(200);
+      const pages = (await res.json()) as PageItem[];
+      // slides.html opts in with <meta name="publisher:fit" content="viewport">
+      // (alongside a standard charset + viewport meta) → fill the embedded viewer.
+      expect(pages.find((p) => p.path === "slides.html")?.fit).toBe("viewport");
+      // fitcomment.html has a real <meta publisher:fit> AFTER a comment that
+      // contains the literal "<body>"; stripping comments before locating the
+      // </head>/<body> boundary must keep that literal from truncating the scan
+      // and hiding the real tag (it must still opt in).
+      expect(pages.find((p) => p.path === "fitcomment.html")?.fit).toBe(
+         "viewport",
+      );
+      // notfit.html carries the STANDARD <meta name="viewport"> (device-width),
+      // a decoy <meta data-name="publisher:fit"> in <head>, and the real tag as
+      // text in a <body> comment. None is a genuine <head> name=publisher:fit,
+      // so it must NOT be mistaken for an opt-in.
+      expect(pages.find((p) => p.path === "notfit.html")?.fit).toBeUndefined();
+      // A page with no relevant meta keeps content-height auto-sizing (the
+      // field is omitted, never `null`/`"content"`).
+      expect(pages.find((p) => p.path === "index.html")?.fit).toBeUndefined();
+      // nohead.html omits the optional </head> end tag and shows the tag in a
+      // <body> comment; the scan stops at <body>, so it must NOT opt in.
+      expect(pages.find((p) => p.path === "nohead.html")?.fit).toBeUndefined();
+      // barehtml.html omits BOTH </head> and <body> and shows the tag only in
+      // an HTML comment; comment-stripping must keep it from opting in.
+      expect(
+         pages.find((p) => p.path === "barehtml.html")?.fit,
+      ).toBeUndefined();
+      // bodymeta.html has a REAL (uncommented) <meta publisher:fit> but in
+      // <body> and omits </head>, so the head-only scan must stop at <body>
+      // and not opt in (locks the <body> boundary).
+      expect(
+         pages.find((p) => p.path === "bodymeta.html")?.fit,
+      ).toBeUndefined();
+      // unterminated.html wraps the tag in a comment with no closing -->; the
+      // unterminated-comment strip must still keep it from opting in.
+      expect(
+         pages.find((p) => p.path === "unterminated.html")?.fit,
+      ).toBeUndefined();
+   });
    it("400s a malformed environment/package name on /pages", async () => {
       // getEnvironment runs assertSafePackageName, so a name outside
       // IdentifierPattern is a 400 (now documented on list-pages in api-doc).