@malloy-publisher/server 0.0.210 → 0.0.212

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,79 @@
+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"');
+   });
+});
+
+// Cross-repo conformance (PR ms2data/service#5272 review item 1). The publisher
+// keys identifier quoting off the Malloy `dialectName`; the control plane keys
+// the SAME fact off the publisher *connection type* in
+// `PhysicalTableName.BACKTICK_TYPES` ({bigquery, mysql, databricks}). The two
+// must stay byte-compatible — a name the publisher CREATEs with backticks the CP
+// must DROP with backticks — but they live in different repos under different key
+// vocabularies (`standardsql` the dialect vs `bigquery` the connection type), so
+// drift produces malformed DDL with no compile error. This table pins the full
+// connection-type → dialect → quote-char correspondence; if it changes, update
+// `PhysicalTableName.BACKTICK_TYPES` in the control plane in lockstep.
+describe("dialect/connection-type quoting conformance", () => {
+   const QUOTING = [
+      { connectionType: "bigquery", dialect: "standardsql", quote: "`" },
+      { connectionType: "mysql", dialect: "mysql", quote: "`" },
+      { connectionType: "databricks", dialect: "databricks", quote: "`" },
+      { connectionType: "postgres", dialect: "postgres", quote: '"' },
+      { connectionType: "snowflake", dialect: "snowflake", quote: '"' },
+      { connectionType: "trino", dialect: "trino", quote: '"' },
+      { connectionType: "duckdb", dialect: "duckdb", quote: '"' },
+      { connectionType: "motherduck", dialect: "duckdb", quote: '"' },
+   ] as const;
+
+   for (const { connectionType, dialect, quote } of QUOTING) {
+      it(`${connectionType} (${dialect}) quotes with ${quote}`, () => {
+         expect(quoteIdentifier("x", dialect)).toBe(`${quote}x${quote}`);
+      });
+   }
+});
+
+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,45 @@
 /**
- * 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`. The control
+// plane encodes the same fact keyed by connection type
+// (`PhysicalTableName.BACKTICK_TYPES` = {bigquery, mysql, databricks}); the two
+// must stay byte-compatible. See the conformance table in quoting.spec.ts.
+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};