@malloy-publisher/server 0.0.209 → 0.0.211

package/src/service/package_worker_path.spec.ts

@@ -28,10 +28,12 @@ import {
    describe,
    expect,
    it,
+   spyOn,
 } from "bun:test";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+import { logger } from "../logger";
 import {
    PackageLoadPool,
    __setPackageLoadPoolForTests,
@@ -280,14 +282,13 @@ source: gated is duckdb.sql("select 1 as id")`,
       }
    });
 
-   it("rejects a package whose view carries an invalid renderer tag", async () => {
+   it("logs a warning for a package whose view carries an invalid renderer tag", async () => {
       writeManifest();
       // `# big_value { sparkline=... }` is a child-only renderer config placed on
       // the view itself, with no activating big_value. The renderer declines to
-      // match it; without compile-time validation it renders as "[object Object]"
-      // at query time. Render-tag validation runs on the main thread after the
-      // worker hydrates the model, so the load must reject with a 424
-      // ModelCompilationError naming the offending view.
+      // match it. Render-tag validation runs on the main thread after the worker
+      // hydrates the model. The misconfiguration is logged as a warning naming
+      // the offending view; it does not fail the package load.
       fs.writeFileSync(
          path.join(tempDir, "bad_render.malloy"),
          `source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
@@ -302,21 +303,21 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("nums -> card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["bad_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("nums -> card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
@@ -341,7 +342,7 @@ source: gated is duckdb.sql("select 1 as id")`,
       }
    });
 
-   it("rejects a package whose backtick-quoted (hyphenated) source has a bad view render tag", async () => {
+   it("logs a warning for a backtick-quoted (hyphenated) source with a bad view render tag", async () => {
       writeManifest();
       // A source whose name needs Malloy backtick-quoting (here, a hyphen). The
       // validation target must quote the identifier; otherwise `run: bad-source
@@ -363,26 +364,26 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("bad-source -> card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["hyphen_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("bad-source -> card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("rejects a package whose source name contains an escaped backtick with a bad view render tag", async () => {
+   it("logs a warning for a source name containing an escaped backtick with a bad view render tag", async () => {
       writeManifest();
       // Source name with a literal backtick (written escaped in Malloy as
       // `wei\`rd`). The validation target must re-escape it; a bare wrap would
@@ -403,26 +404,26 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["backtick_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("rejects a .malloynb notebook whose source view carries an invalid renderer tag", async () => {
+   it("logs a warning for a .malloynb notebook whose source view carries an invalid renderer tag", async () => {
       writeManifest();
       fs.writeFileSync(
          path.join(tempDir, "bad_render.malloynb"),
@@ -439,18 +440,22 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         await expect(
-            Package.create("env", "pkg", tempDir, malloyConfig),
-         ).rejects.toBeInstanceOf(ModelCompilationError);
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["bad_render.malloynb"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some((m) => m.includes("Invalid renderer configuration")),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("re-validates renderer tags on reload, recording a model that develops a bad tag as a per-model error", async () => {
+   it("re-validates renderer tags on reload, logging a warning for a model that develops a bad tag", async () => {
       writeManifest();
       // Start valid so Package.create succeeds.
       fs.writeFileSync(
@@ -463,13 +468,15 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
       );
 
       const { malloyConfig, duckdb } = await makeMalloyConfig();
+      const warnSpy = spyOn(logger, "warn");
       try {
          const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
          expect(pkg.getModel("m.malloy")).toBeDefined();
+         warnSpy.mockClear();
 
-         // The model now develops a misconfigured render tag. Reload must catch
-         // it (not just Package.create) and surface it as the model's error,
-         // without aborting the whole reload.
+         // The model now develops a misconfigured render tag. Reload re-validates
+         // (not just Package.create) and logs a warning for it, without aborting
+         // the reload or failing the model.
          fs.writeFileSync(
             path.join(tempDir, "m.malloy"),
             `source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
@@ -487,10 +494,13 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
 
          const reloaded = pkg.getModel("m.malloy");
          expect(reloaded).toBeDefined();
-         await expect(reloaded!.getModel()).rejects.toThrow(
-            "Invalid renderer configuration",
-         );
+         await expect(reloaded!.getModel()).resolves.toBeDefined();
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some((m) => m.includes("Invalid renderer configuration")),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });

package/src/service/persist_annotation_validation.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "bun:test";
+import { ModelCompilationError } from "../errors";
+import { assertPersistNamesQuoted } from "./persist_annotation_validation";
+
+describe("assertPersistNamesQuoted", () => {
+   it("throws ModelCompilationError on a bare (unquoted) persist name", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist name=engaged_events\nsource: engaged_events is x -> { select: * }`,
+            "m.malloy",
+         ),
+      ).toThrow(ModelCompilationError);
+   });
+
+   it("tolerates whitespace around = but still flags an unquoted value", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist name = engaged_events`,
+            "m.malloy",
+         ),
+      ).toThrow(/must be quoted/);
+   });
+
+   it("accepts a double-quoted name", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist name="engaged_events"`,
+            "m.malloy",
+         ),
+      ).not.toThrow();
+   });
+
+   it("accepts a single-quoted name", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist name='engaged_events'`,
+            "m.malloy",
+         ),
+      ).not.toThrow();
+   });
+
+   it("accepts a dotted, quoted dialect path", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist name="my_dataset.engaged_events"`,
+            "m.malloy",
+         ),
+      ).not.toThrow();
+   });
+
+   it("ignores non-persist annotations and persist lines with no name field", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `# number=2\n#@ persist realization="COPY"\nsource: x is y -> { select: * }`,
+            "m.malloy",
+         ),
+      ).not.toThrow();
+   });
+
+   it("does not mistake a neighbouring key for the name field", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist tablename=foo name="bar"`,
+            "m.malloy",
+         ),
+      ).not.toThrow();
+   });
+
+   it("reports every offending annotation in the message", () => {
+      expect(() =>
+         assertPersistNamesQuoted(
+            `#@ persist name=a\nsource: a is x -> { select: * }\n#@ persist name=b\nsource: b is x -> { select: * }`,
+            "m.malloy",
+         ),
+      ).toThrow(/name=a.*name=b/s);
+   });
+});

package/src/service/persist_annotation_validation.ts

@@ -0,0 +1,54 @@
+import { ModelCompilationError } from "../errors";
+
+/** A line whose first non-whitespace content is a `#@ persist` directive. */
+const PERSIST_LINE_PATTERN = /^\s*#@\s+persist\b/;
+/**
+ * A `name=` key whose value is NOT immediately opened by a single or double
+ * quote — i.e. a bare `name=engaged_events` (whitespace around `=` tolerated).
+ * `name="..."` and `name='...'` pass. The `\bname` word boundary requires a
+ * standalone key, so neighbours like `tablename=` / `realization_name=` are
+ * never mistaken for it.
+ */
+const UNQUOTED_NAME_PATTERN = /\bname\s*=\s*(?!["'])/;
+
+/**
+ * Reject `#@ persist name=<value>` annotations whose name is unquoted.
+ *
+ * The persist build plan requires a quoted name — a dialect-style table path
+ * (`name="engaged_events"`, or `name="my_dataset.engaged_events"`). A bare
+ * value is dropped from the build plan, so the source publishes and serves but
+ * is never materialized, with no error anywhere. Throwing a
+ * `ModelCompilationError` (HTTP 424) fails the publish/load with a clear,
+ * actionable message — the same hard-stop `Model.validateRenderTags` applies to
+ * a misconfigured render tag.
+ *
+ * Scans the raw model source line-by-line rather than the compiled annotation
+ * objects: the check must fire regardless of how the compiler attaches the
+ * annotation, and the raw text is the ground truth for whether the author
+ * quoted the value (the tag parser discards quote information once parsed).
+ *
+ * @throws {ModelCompilationError} listing every offending annotation.
+ */
+export function assertPersistNamesQuoted(
+   modelSource: string,
+   modelPath: string,
+): void {
+   const offenders: string[] = [];
+   for (const rawLine of modelSource.split("\n")) {
+      if (!PERSIST_LINE_PATTERN.test(rawLine)) continue;
+      if (UNQUOTED_NAME_PATTERN.test(rawLine)) {
+         offenders.push(rawLine.trim());
+      }
+   }
+   if (offenders.length > 0) {
+      throw new ModelCompilationError({
+         message:
+            `${modelPath}: persist annotation name must be quoted. Write a quoted ` +
+            `value like name="engaged_events" (or a dialect table path such as ` +
+            `name="my_dataset.engaged_events"), not a bare value — an unquoted ` +
+            `persist name is dropped from the build plan, so the source would ` +
+            `publish but never materialize. Offending annotation(s): ` +
+            `${offenders.join("; ")}.`,
+      });
+   }
+}

package/src/service/quoting.spec.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "bun:test";
+import { bareTableName, quoteIdentifier, quoteTablePath } from "./quoting";
+
+describe("bareTableName", () => {
+   it("returns the segment after the last dot for a qualified name", () => {
+      expect(bareTableName("my_schema.my_table")).toBe("my_table");
+   });
+
+   it("returns the name unchanged when it is unqualified", () => {
+      expect(bareTableName("my_table")).toBe("my_table");
+   });
+});
+
+describe("quoteIdentifier", () => {
+   it("backticks for backtick dialects (BigQuery / MySQL / Databricks)", () => {
+      expect(quoteIdentifier("my-table", "standardsql")).toBe("`my-table`");
+      expect(quoteIdentifier("t", "mysql")).toBe("`t`");
+      expect(quoteIdentifier("t", "databricks")).toBe("`t`");
+   });
+
+   it("double-quotes for everything else (Postgres / DuckDB / Snowflake)", () => {
+      expect(quoteIdentifier("my-table", "postgres")).toBe('"my-table"');
+      expect(quoteIdentifier("t", "duckdb")).toBe('"t"');
+      expect(quoteIdentifier("t", "snowflake")).toBe('"t"');
+   });
+
+   it("escapes an embedded quote char by doubling it", () => {
+      expect(quoteIdentifier("a`b", "standardsql")).toBe("`a``b`");
+      expect(quoteIdentifier('a"b', "postgres")).toBe('"a""b"');
+   });
+});
+
+describe("quoteTablePath", () => {
+   it("quotes each segment of a container path independently", () => {
+      expect(
+         quoteTablePath(
+            "my-proj.mydataset.engaged_events_ab12_v0",
+            "standardsql",
+         ),
+      ).toBe("`my-proj`.`mydataset`.`engaged_events_ab12_v0`");
+      expect(quoteTablePath("mydataset.t_ab12_v0", "postgres")).toBe(
+         '"mydataset"."t_ab12_v0"',
+      );
+   });
+
+   it("quotes a bare (unqualified) name", () => {
+      expect(quoteTablePath("t_ab12_v0", "standardsql")).toBe("`t_ab12_v0`");
+      expect(quoteTablePath("t_ab12_v0", "postgres")).toBe('"t_ab12_v0"');
+   });
+});

package/src/service/quoting.ts

@@ -1,21 +1,42 @@
 /**
- * Split a possibly schema-qualified table name into its schema prefix
- * (including the trailing dot) and the bare table name.
- *
- * Examples:
- *   "my_schema.my_table" -> { schemaPrefix: "my_schema.", bareName: "my_table" }
- *   "my_table"           -> { schemaPrefix: "", bareName: "my_table" }
+ * The bare (unqualified) name of a possibly container-qualified table path:
+ * the segment after the last dot, e.g. `my_schema.my_table` -> `my_table` and
+ * `my_table` -> `my_table`. Used as the RENAME target, which names a table
+ * within its existing schema rather than re-stating the full path.
  */
-export function splitTablePath(tableName: string): {
-   schemaPrefix: string;
-   bareName: string;
-} {
+export function bareTableName(tableName: string): string {
    const lastDot = tableName.lastIndexOf(".");
-   if (lastDot >= 0) {
-      return {
-         schemaPrefix: tableName.substring(0, lastDot + 1),
-         bareName: tableName.substring(lastDot + 1),
-      };
+   return lastDot >= 0 ? tableName.substring(lastDot + 1) : tableName;
+}
+
+// Dialects whose identifier quote character is a backtick; everything else uses
+// the SQL-standard double quote. Keyed by Malloy `dialectName`.
+const BACKTICK_DIALECTS = new Set(["standardsql", "mysql", "databricks"]);
+
+/**
+ * Quote a single SQL identifier for {@code dialect}, escaping any embedded quote
+ * character by doubling it.
+ */
+export function quoteIdentifier(identifier: string, dialect: string): string {
+   if (BACKTICK_DIALECTS.has(dialect)) {
+      return "`" + identifier.replace(/`/g, "``") + "`";
    }
-   return { schemaPrefix: "", bareName: tableName };
+   return '"' + identifier.replace(/"/g, '""') + '"';
+}
+
+/**
+ * Dialect-quote a (possibly container-qualified) table path so it can be inlined
+ * into DDL. Each dot segment is quoted independently and rejoined with dots, so
+ * a path like {@code my-proj.mydataset.engaged_events_v0} becomes
+ * `` `my-proj`.`mydataset`.`engaged_events_v0` `` on BigQuery or
+ * {@code "my-proj"."mydataset"."engaged_events_v0"} on Postgres — handling
+ * container hierarchies and quote-requiring names (e.g. hyphenated BigQuery
+ * project ids) uniformly. The control plane provides the logical (unquoted) path
+ * in `physicalTableName`; quoting for the warehouse is the publisher's job.
+ */
+export function quoteTablePath(tableName: string, dialect: string): string {
+   return tableName
+      .split(".")
+      .map((segment) => quoteIdentifier(segment, dialect))
+      .join(".");
 }

package/src/utils.ts

@@ -22,3 +22,8 @@ export const URL_READER: URLReader = {
 export function ignoreDotfiles(file: string): boolean {
    return path.basename(file).startsWith(".");
 }
+
+/** The message of a thrown value, stringifying non-Error throws. */
+export function errMessage(err: unknown): string {
+   return err instanceof Error ? err.message : String(err);
+}

package/dist/app/assets/HomePage-DQzgkiMI.js

@@ -1 +0,0 @@
-import{$ as s,j as t,s as o}from"./index-DuqTjxM_.js";function e(){const n=s();return t.jsx(o,{onClickEnvironment:n})}export{e as default};