@malloy-publisher/server 0.0.203 → 0.0.205

package/src/service/materialized_table_gc.spec.ts

@@ -174,7 +174,7 @@ describe("dropManifestEntries", () => {
       );
    });
 
-   it("skips DROP and records an error when the dialect is unknown", async () => {
+   it("drops regardless of connection dialect — DDL uses table names verbatim", async () => {
       const ctx2 = makeCtx("martian-sql");
       const entry = makeEntry();
 
@@ -184,10 +184,11 @@ describe("dropManifestEntries", () => {
          environmentId: "proj-1",
       });
 
-      expect(result.dropped).toHaveLength(0);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0].error).toMatch(/martian-sql/);
-      expect(ctx2.conn.runSQL.called).toBe(false);
+      // GC no longer needs a per-dialect quoter: table names are used
+      // verbatim, so an unrecognized dialect is no longer a special case.
+      expect(result.dropped).toHaveLength(1);
+      expect(result.errors).toHaveLength(0);
+      expect(ctx2.conn.runSQL.callCount).toBe(2);
    });
 
    it("dryRun lists what would drop without issuing SQL or deleting rows", async () => {

package/src/service/materialized_table_gc.ts

@@ -1,37 +1,8 @@
 import type { Connection } from "@malloydata/malloy";
-import {
-   DatabricksDialect,
-   DuckDBDialect,
-   MySQLDialect,
-   PostgresDialect,
-   SnowflakeDialect,
-   StandardSQLDialect,
-   TrinoDialect,
-} from "@malloydata/malloy";
 import { logger } from "../logger";
 import { ManifestEntry } from "../storage/DatabaseInterface";
 import { ManifestService } from "./manifest_service";
 import { stagingSuffix } from "./materialization_service";
-import { type Quoter, quoteTablePath } from "./quoting";
-
-/**
- * Registry of built-in dialects keyed by `Connection.dialectName`. Malloy's
- * internal `getDialect` helper isn't part of the package's public exports,
- * so we assemble our own registry from the exported dialect classes.
- *
- * Note: `presto` (extends `TrinoDialect`) is not re-exported publicly and
- * is niche enough to omit; if/when it ships as a publisher connection type,
- * add it here.
- */
-const DIALECTS: Readonly<Record<string, Quoter>> = Object.freeze({
-   duckdb: new DuckDBDialect(),
-   standardsql: new StandardSQLDialect(),
-   trino: new TrinoDialect(),
-   postgres: new PostgresDialect(),
-   snowflake: new SnowflakeDialect(),
-   mysql: new MySQLDialect(),
-   databricks: new DatabricksDialect(),
-});
 
 /** Build a stable key for a `(connectionName, tableName)` tuple. */
 export function liveTableKey(
@@ -154,19 +125,6 @@ async function processOneEntry(
       };
    }
 
-   // ── Unknown dialect ───────────────────────────────────────────
-   const dialect = DIALECTS[connection.dialectName];
-   if (!dialect) {
-      return {
-         error: {
-            buildId: entry.buildId,
-            tableName: entry.tableName,
-            connectionName: entry.connectionName,
-            error: `No dialect registered for '${connection.dialectName}'`,
-         },
-      };
-   }
-
    // ── Dry run ───────────────────────────────────────────────────
    if (ctx.dryRun) {
       return {
@@ -181,8 +139,6 @@ async function processOneEntry(
    }
 
    // ── Live run: delete manifest row first ───────────────────────
-   const quoted = (p: string) => quoteTablePath(p, dialect);
-
    try {
       await ctx.manifestService.deleteEntry(ctx.environmentId, entry.id);
    } catch (err) {
@@ -214,9 +170,7 @@ async function processOneEntry(
       );
    } else {
       try {
-         await connection.runSQL(
-            `DROP TABLE IF EXISTS ${quoted(entry.tableName)}`,
-         );
+         await connection.runSQL(`DROP TABLE IF EXISTS ${entry.tableName}`);
       } catch (err) {
          logger.warn(
             "GC: deleted manifest row but failed to drop materialized table (orphaned)",
@@ -231,9 +185,7 @@ async function processOneEntry(
 
    // ── Best-effort drop staging companion ────────────────────────
    try {
-      await connection.runSQL(
-         `DROP TABLE IF EXISTS ${quoted(stagingTableName)}`,
-      );
+      await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
    } catch (err) {
       logger.warn("GC: failed to drop staging table (best-effort)", {
          stagingTableName,

package/src/service/model.spec.ts

@@ -191,6 +191,84 @@ describe("service/model", () => {
 
             sinon.restore();
          });
+
+         it("embeds model-level givens in each newSources SourceInfo", async () => {
+            const sourceInfo = {
+               name: "carriers",
+               schema: { fields: [] },
+            };
+            const givens = [
+               {
+                  name: "region",
+                  type: "string",
+                  annotations: ["#(doc) Region"],
+               },
+            ];
+            const model = new Model(
+               packageName,
+               "test.malloynb",
+               {},
+               "notebook",
+               undefined, // modelMaterializer
+               undefined, // modelDef
+               undefined, // sources
+               undefined, // queries
+               undefined, // sourceInfos
+               [
+                  {
+                     type: "code",
+                     text: "import 'carriers.malloy'",
+                     newSources: [sourceInfo],
+                  },
+               ], // runnableNotebookCells
+               undefined, // compilationError
+               undefined, // filterMap
+               givens, // givens
+            );
+
+            const notebook = await model.getNotebook();
+            expect(notebook.notebookCells).toHaveLength(1);
+            const parsed = JSON.parse(
+               notebook.notebookCells![0].newSources![0],
+            );
+            expect(parsed.name).toBe("carriers");
+            // SourceInfo fields are preserved untouched.
+            expect(parsed.schema).toEqual({ fields: [] });
+            // Givens ride along verbatim — no second getModel round-trip needed.
+            expect(parsed.givens).toEqual(givens);
+         });
+
+         it("omits givens from newSources when the model declares none", async () => {
+            const sourceInfo = { name: "carriers", schema: { fields: [] } };
+            const model = new Model(
+               packageName,
+               "test.malloynb",
+               {},
+               "notebook",
+               undefined,
+               undefined,
+               undefined,
+               undefined,
+               undefined,
+               [
+                  {
+                     type: "code",
+                     text: "import 'carriers.malloy'",
+                     newSources: [sourceInfo],
+                  },
+               ],
+               undefined,
+               undefined,
+               undefined, // no givens
+            );
+
+            const notebook = await model.getNotebook();
+            const parsed = JSON.parse(
+               notebook.notebookCells![0].newSources![0],
+            );
+            expect(parsed.name).toBe("carriers");
+            expect(parsed).not.toHaveProperty("givens");
+         });
       });
 
       describe("getQueryResults", () => {
@@ -239,6 +317,78 @@ describe("service/model", () => {
             sinon.restore();
          });
 
+         // Both caller-driven compile paths — the free-form `query` text and the
+         // `run: source->view` string built from `sourceName`/`queryName` — must
+         // go through restricted mode. The trusted `loadQuery` is reserved for
+         // author-curated content (notebook cells) and must never be reached from
+         // `getQueryResults`. These tests pin the dispatch so a regression that
+         // re-routes either path back to `loadQuery` is caught.
+         describe("compile dispatch", () => {
+            function buildDispatchModel(): {
+               model: Model;
+               loadQuery: sinon.SinonStub;
+               loadRestrictedQuery: sinon.SinonStub;
+            } {
+               // getPreparedResult rejects so execution stops right after the
+               // loader call; we only assert which loader was invoked.
+               const runnableStub = {
+                  getPreparedResult: sinon
+                     .stub()
+                     .rejects(new MalloyError("stub-stop", [])),
+                  run: sinon.stub().rejects(new MalloyError("stub-stop", [])),
+               };
+               const loadQuery = sinon.stub().returns(runnableStub);
+               const loadRestrictedQuery = sinon.stub().returns(runnableStub);
+               const modelMaterializer = { loadQuery, loadRestrictedQuery };
+               const model = new Model(
+                  packageName,
+                  mockModelPath,
+                  {},
+                  "model",
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  modelMaterializer as any,
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  { contents: {}, exports: [], queryList: [] } as any,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+                  undefined,
+               );
+               return { model, loadQuery, loadRestrictedQuery };
+            }
+
+            afterEach(() => sinon.restore());
+
+            it("compiles ad-hoc query text in restricted mode, never trusted loadQuery", async () => {
+               const { model, loadQuery, loadRestrictedQuery } =
+                  buildDispatchModel();
+
+               await expect(
+                  model.getQueryResults(
+                     undefined,
+                     undefined,
+                     "run: orders -> { aggregate: c is count() }",
+                  ),
+               ).rejects.toThrow(MalloyError);
+
+               expect(loadRestrictedQuery.calledOnce).toBe(true);
+               expect(loadQuery.called).toBe(false);
+            });
+
+            it("compiles the named source/view path in restricted mode, never trusted loadQuery", async () => {
+               const { model, loadQuery, loadRestrictedQuery } =
+                  buildDispatchModel();
+
+               await expect(
+                  model.getQueryResults("orders", "summary"),
+               ).rejects.toThrow(MalloyError);
+
+               expect(loadRestrictedQuery.calledOnce).toBe(true);
+               expect(loadQuery.called).toBe(false);
+            });
+         });
+
          it("forwards givens to runnable.getPreparedResult and .run", async () => {
             const givensArg = { region: "EU" };
             const preparedResultStub = sinon
@@ -247,11 +397,13 @@ describe("service/model", () => {
             const runStub = sinon
                .stub()
                .rejects(new MalloyError("stub-stop", []));
+            const runnableStub = {
+               getPreparedResult: preparedResultStub,
+               run: runStub,
+            };
             const modelMaterializer = {
-               loadQuery: sinon.stub().returns({
-                  getPreparedResult: preparedResultStub,
-                  run: runStub,
-               }),
+               loadQuery: sinon.stub().returns(runnableStub),
+               loadRestrictedQuery: sinon.stub().returns(runnableStub),
             };
 
             const model = new Model(
@@ -347,11 +499,13 @@ describe("service/model", () => {
                         typeof API.util.wrapResult
                      >,
                   );
+               const runnableStub = {
+                  getPreparedResult: preparedResultStub,
+                  run: runStub,
+               };
                const modelMaterializer = {
-                  loadQuery: sinon.stub().returns({
-                     getPreparedResult: preparedResultStub,
-                     run: runStub,
-                  }),
+                  loadQuery: sinon.stub().returns(runnableStub),
+                  loadRestrictedQuery: sinon.stub().returns(runnableStub),
                };
                const model = new Model(
                   packageName,
@@ -529,6 +683,47 @@ describe("service/model", () => {
 
             sinon.restore();
          });
+
+         it("embeds model-level givens in executed cell newSources", async () => {
+            const sourceInfo = { name: "carriers", schema: { fields: [] } };
+            const givens = [
+               {
+                  name: "region",
+                  type: "string",
+                  annotations: ["#(doc) Region"],
+               },
+            ];
+            // A source-only code cell (no runnable) still emits newSources.
+            const runnableCells = [
+               {
+                  type: "code" as const,
+                  text: "import 'carriers.malloy'",
+                  newSources: [sourceInfo],
+               },
+            ];
+
+            const model = new Model(
+               packageName,
+               "test.malloynb",
+               {},
+               "notebook",
+               undefined, // modelMaterializer
+               undefined, // modelDef
+               undefined, // sources
+               undefined, // queries
+               undefined, // sourceInfos
+               // eslint-disable-next-line @typescript-eslint/no-explicit-any
+               runnableCells as any, // runnableNotebookCells
+               undefined, // compilationError
+               undefined, // filterMap
+               givens, // givens
+            );
+
+            const result = await model.executeNotebookCell(0);
+            const parsed = JSON.parse(result.newSources![0]);
+            expect(parsed.name).toBe("carriers");
+            expect(parsed.givens).toEqual(givens);
+         });
       });
    });