@malloy-publisher/server 0.0.198 → 0.0.200

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.198",
+   "version": "0.0.200",
    "main": "dist/server.mjs",
    "bin": {
       "malloy-publisher": "dist/server.mjs"
@@ -51,7 +51,6 @@
       "@opentelemetry/sdk-metrics": "^2.0.0",
       "@opentelemetry/sdk-node": "^0.200.0",
       "@opentelemetry/sdk-trace-node": "^2.0.0",
-      "adm-zip": "^0.5.16",
       "async-mutex": "^0.5.0",
       "aws-sdk": "^2.1692.0",
       "body-parser": "^1.20.2",
@@ -61,6 +60,7 @@
       "cors": "^2.8.5",
       "duckdb": "1.4.4",
       "express": "^4.21.0",
+      "extract-zip": "^2.0.1",
       "globals": "^15.9.0",
       "handlebars": "^4.7.8",
       "http-proxy-middleware": "^3.0.5",
@@ -76,7 +76,6 @@
       "@eslint/eslintrc": "^3.3.1",
       "@eslint/js": "^9.23.0",
       "@faker-js/faker": "^9.4.0",
-      "@types/adm-zip": "^0.5.7",
       "@types/bun": "^1.2.20",
       "@types/cors": "^2.8.12",
       "@types/express": "^4.17.14",

package/src/config.spec.ts

@@ -1162,3 +1162,249 @@ describe("getMemoryGovernorConfig", () => {
       expect(() => getMemoryGovernorConfig()).toThrow();
    });
 });
+
+describe("getMaxQueryRows", () => {
+   beforeEach(() => {
+      delete process.env.PUBLISHER_MAX_QUERY_ROWS;
+   });
+   afterEach(() => {
+      delete process.env.PUBLISHER_MAX_QUERY_ROWS;
+   });
+
+   it("returns DEFAULT_MAX_QUERY_ROWS when the env var is unset", async () => {
+      const { getMaxQueryRows } = await import("./config");
+      const { DEFAULT_MAX_QUERY_ROWS } = await import("./constants");
+      expect(getMaxQueryRows()).toBe(DEFAULT_MAX_QUERY_ROWS);
+   });
+
+   it("returns DEFAULT_MAX_QUERY_ROWS when the env var is empty", async () => {
+      process.env.PUBLISHER_MAX_QUERY_ROWS = "";
+      const { getMaxQueryRows } = await import("./config");
+      const { DEFAULT_MAX_QUERY_ROWS } = await import("./constants");
+      expect(getMaxQueryRows()).toBe(DEFAULT_MAX_QUERY_ROWS);
+   });
+
+   it("returns the override when the env var is set", async () => {
+      process.env.PUBLISHER_MAX_QUERY_ROWS = "5000";
+      const { getMaxQueryRows } = await import("./config");
+      expect(getMaxQueryRows()).toBe(5000);
+   });
+
+   it("accepts 0 (used to opt out of row cap)", async () => {
+      process.env.PUBLISHER_MAX_QUERY_ROWS = "0";
+      const { getMaxQueryRows } = await import("./config");
+      expect(getMaxQueryRows()).toBe(0);
+   });
+
+   it("rejects a negative override", async () => {
+      process.env.PUBLISHER_MAX_QUERY_ROWS = "-1";
+      const { getMaxQueryRows } = await import("./config");
+      expect(() => getMaxQueryRows()).toThrow();
+   });
+
+   it("rejects a non-integer override", async () => {
+      process.env.PUBLISHER_MAX_QUERY_ROWS = "1.5";
+      const { getMaxQueryRows } = await import("./config");
+      expect(() => getMaxQueryRows()).toThrow();
+   });
+
+   it("rejects a non-numeric override", async () => {
+      process.env.PUBLISHER_MAX_QUERY_ROWS = "lots";
+      const { getMaxQueryRows } = await import("./config");
+      expect(() => getMaxQueryRows()).toThrow();
+   });
+});
+
+describe("getMaxResponseBytes", () => {
+   beforeEach(() => {
+      delete process.env.PUBLISHER_MAX_RESPONSE_BYTES;
+   });
+   afterEach(() => {
+      delete process.env.PUBLISHER_MAX_RESPONSE_BYTES;
+   });
+
+   it("returns DEFAULT_MAX_RESPONSE_BYTES when the env var is unset", async () => {
+      const { getMaxResponseBytes } = await import("./config");
+      const { DEFAULT_MAX_RESPONSE_BYTES } = await import("./constants");
+      expect(getMaxResponseBytes()).toBe(DEFAULT_MAX_RESPONSE_BYTES);
+   });
+
+   it("returns DEFAULT_MAX_RESPONSE_BYTES when the env var is empty", async () => {
+      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "";
+      const { getMaxResponseBytes } = await import("./config");
+      const { DEFAULT_MAX_RESPONSE_BYTES } = await import("./constants");
+      expect(getMaxResponseBytes()).toBe(DEFAULT_MAX_RESPONSE_BYTES);
+   });
+
+   it("returns the override when the env var is set", async () => {
+      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "1048576";
+      const { getMaxResponseBytes } = await import("./config");
+      expect(getMaxResponseBytes()).toBe(1048576);
+   });
+
+   it("accepts 0 (used to opt out of byte cap)", async () => {
+      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "0";
+      const { getMaxResponseBytes } = await import("./config");
+      expect(getMaxResponseBytes()).toBe(0);
+   });
+
+   it("rejects a negative override", async () => {
+      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "-1";
+      const { getMaxResponseBytes } = await import("./config");
+      expect(() => getMaxResponseBytes()).toThrow();
+   });
+
+   it("rejects a non-integer override", async () => {
+      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "1.5";
+      const { getMaxResponseBytes } = await import("./config");
+      expect(() => getMaxResponseBytes()).toThrow();
+   });
+
+   it("rejects a non-numeric override", async () => {
+      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "big";
+      const { getMaxResponseBytes } = await import("./config");
+      expect(() => getMaxResponseBytes()).toThrow();
+   });
+});
+
+describe("getDefaultQueryRowLimit", () => {
+   beforeEach(() => {
+      delete process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT;
+   });
+   afterEach(() => {
+      delete process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT;
+   });
+
+   it("returns DEFAULT_QUERY_ROW_LIMIT when the env var is unset", async () => {
+      const { getDefaultQueryRowLimit } = await import("./config");
+      const { DEFAULT_QUERY_ROW_LIMIT } = await import("./constants");
+      expect(getDefaultQueryRowLimit()).toBe(DEFAULT_QUERY_ROW_LIMIT);
+   });
+
+   it("returns DEFAULT_QUERY_ROW_LIMIT when the env var is empty", async () => {
+      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "";
+      const { getDefaultQueryRowLimit } = await import("./config");
+      const { DEFAULT_QUERY_ROW_LIMIT } = await import("./constants");
+      expect(getDefaultQueryRowLimit()).toBe(DEFAULT_QUERY_ROW_LIMIT);
+   });
+
+   it("returns the override when the env var is set", async () => {
+      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "250";
+      const { getDefaultQueryRowLimit } = await import("./config");
+      expect(getDefaultQueryRowLimit()).toBe(250);
+   });
+
+   it("rejects 0 (a default of 'zero rows' is always a misconfiguration)", async () => {
+      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "0";
+      const { getDefaultQueryRowLimit } = await import("./config");
+      expect(() => getDefaultQueryRowLimit()).toThrow();
+   });
+
+   it("rejects a negative override", async () => {
+      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "-1";
+      const { getDefaultQueryRowLimit } = await import("./config");
+      expect(() => getDefaultQueryRowLimit()).toThrow();
+   });
+
+   it("rejects a non-integer override", async () => {
+      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "1.5";
+      const { getDefaultQueryRowLimit } = await import("./config");
+      expect(() => getDefaultQueryRowLimit()).toThrow();
+   });
+
+   it("rejects a non-numeric override", async () => {
+      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "lots";
+      const { getDefaultQueryRowLimit } = await import("./config");
+      expect(() => getDefaultQueryRowLimit()).toThrow();
+   });
+});
+
+describe("getQueryTimeoutMs", () => {
+   beforeEach(() => {
+      delete process.env.PUBLISHER_QUERY_TIMEOUT_MS;
+   });
+   afterEach(() => {
+      delete process.env.PUBLISHER_QUERY_TIMEOUT_MS;
+   });
+
+   it("returns DEFAULT_QUERY_TIMEOUT_MS when the env var is unset", async () => {
+      const { getQueryTimeoutMs } = await import("./config");
+      const { DEFAULT_QUERY_TIMEOUT_MS } = await import("./constants");
+      expect(getQueryTimeoutMs()).toBe(DEFAULT_QUERY_TIMEOUT_MS);
+   });
+
+   it("returns the override when the env var is set", async () => {
+      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "30000";
+      const { getQueryTimeoutMs } = await import("./config");
+      expect(getQueryTimeoutMs()).toBe(30000);
+   });
+
+   it("accepts 0 (used to opt out of the timeout)", async () => {
+      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "0";
+      const { getQueryTimeoutMs } = await import("./config");
+      expect(getQueryTimeoutMs()).toBe(0);
+   });
+
+   it("rejects a negative override", async () => {
+      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "-1";
+      const { getQueryTimeoutMs } = await import("./config");
+      expect(() => getQueryTimeoutMs()).toThrow();
+   });
+
+   it("rejects a non-integer override", async () => {
+      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "1.5";
+      const { getQueryTimeoutMs } = await import("./config");
+      expect(() => getQueryTimeoutMs()).toThrow();
+   });
+
+   it("rejects a non-numeric override", async () => {
+      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "slow";
+      const { getQueryTimeoutMs } = await import("./config");
+      expect(() => getQueryTimeoutMs()).toThrow();
+   });
+});
+
+describe("getMaxConcurrentQueries", () => {
+   beforeEach(() => {
+      delete process.env.PUBLISHER_MAX_CONCURRENT_QUERIES;
+   });
+   afterEach(() => {
+      delete process.env.PUBLISHER_MAX_CONCURRENT_QUERIES;
+   });
+
+   it("returns DEFAULT_MAX_CONCURRENT_QUERIES when the env var is unset", async () => {
+      const { getMaxConcurrentQueries } = await import("./config");
+      const { DEFAULT_MAX_CONCURRENT_QUERIES } = await import("./constants");
+      expect(getMaxConcurrentQueries()).toBe(DEFAULT_MAX_CONCURRENT_QUERIES);
+   });
+
+   it("returns the override when the env var is set", async () => {
+      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "8";
+      const { getMaxConcurrentQueries } = await import("./config");
+      expect(getMaxConcurrentQueries()).toBe(8);
+   });
+
+   it("accepts 0 (used to opt out of the cap)", async () => {
+      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "0";
+      const { getMaxConcurrentQueries } = await import("./config");
+      expect(getMaxConcurrentQueries()).toBe(0);
+   });
+
+   it("rejects a negative override", async () => {
+      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "-1";
+      const { getMaxConcurrentQueries } = await import("./config");
+      expect(() => getMaxConcurrentQueries()).toThrow();
+   });
+
+   it("rejects a non-integer override", async () => {
+      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "1.5";
+      const { getMaxConcurrentQueries } = await import("./config");
+      expect(() => getMaxConcurrentQueries()).toThrow();
+   });
+
+   it("rejects a non-numeric override", async () => {
+      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "many";
+      const { getMaxConcurrentQueries } = await import("./config");
+      expect(() => getMaxConcurrentQueries()).toThrow();
+   });
+});

package/src/config.ts

@@ -2,7 +2,15 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { components } from "./api";
-import { API_PREFIX, PUBLISHER_CONFIG_NAME } from "./constants";
+import {
+   API_PREFIX,
+   DEFAULT_MAX_CONCURRENT_QUERIES,
+   DEFAULT_MAX_QUERY_ROWS,
+   DEFAULT_MAX_RESPONSE_BYTES,
+   DEFAULT_QUERY_ROW_LIMIT,
+   DEFAULT_QUERY_TIMEOUT_MS,
+   PUBLISHER_CONFIG_NAME,
+} from "./constants";
 import { logger } from "./logger";
 
 /**
@@ -225,6 +233,118 @@ export const getMemoryGovernorConfig = (): MemoryGovernorConfig | null => {
    };
 };
 
+/**
+ * Resolve the row cap applied to ad-hoc connection SQL queries.
+ * Reads `PUBLISHER_MAX_QUERY_ROWS`; falls back to
+ * {@link DEFAULT_MAX_QUERY_ROWS} when unset or empty.
+ *
+ * Throws at startup on malformed input (matching the loud-failure
+ * stance of {@link getMemoryGovernorConfig}) so a typo in a k8s
+ * manifest surfaces immediately instead of silently disabling the
+ * cap. A value of `0` is accepted and disables wrapping entirely;
+ * use it only when you intend to opt out of the row cap (e.g. when
+ * Step 2's byte budget is the only thing you want enforcing the
+ * bound).
+ */
+export const getMaxQueryRows = (): number => {
+   const raw = parseIntEnv("PUBLISHER_MAX_QUERY_ROWS");
+   if (raw === undefined) return DEFAULT_MAX_QUERY_ROWS;
+   if (raw < 0) {
+      throw new Error(
+         `PUBLISHER_MAX_QUERY_ROWS must be a non-negative integer (got ${raw})`,
+      );
+   }
+   return raw;
+};
+
+/**
+ * Resolve the byte cap applied to ad-hoc connection SQL responses
+ * when the underlying connection implements `StreamingConnection`.
+ * Reads `PUBLISHER_MAX_RESPONSE_BYTES`; falls back to
+ * {@link DEFAULT_MAX_RESPONSE_BYTES} when unset or empty.
+ *
+ * Mirrors {@link getMaxQueryRows}'s loud-failure semantics: throws
+ * at startup on malformed input so a typo in a k8s manifest surfaces
+ * immediately. A value of `0` is accepted and disables the byte cap
+ * entirely; use it only when you intend to rely on the row cap alone
+ * (e.g. for benchmarking).
+ */
+export const getMaxResponseBytes = (): number => {
+   const raw = parseIntEnv("PUBLISHER_MAX_RESPONSE_BYTES");
+   if (raw === undefined) return DEFAULT_MAX_RESPONSE_BYTES;
+   if (raw < 0) {
+      throw new Error(
+         `PUBLISHER_MAX_RESPONSE_BYTES must be a non-negative integer (got ${raw})`,
+      );
+   }
+   return raw;
+};
+
+/**
+ * Resolve the default row limit applied to Malloy model queries
+ * (the `runnable.run` path used by `getQueryResults` and notebook
+ * cell execution) when the user's query doesn't carry its own
+ * `LIMIT`. Reads `PUBLISHER_DEFAULT_QUERY_ROW_LIMIT`; falls back to
+ * {@link DEFAULT_QUERY_ROW_LIMIT} when unset or empty.
+ *
+ * Unlike {@link getMaxQueryRows}, `0` is rejected — a default of
+ * "return zero rows" is almost certainly a misconfiguration (it
+ * would silently break every notebook), and the operator probably
+ * wanted `PUBLISHER_MAX_QUERY_ROWS=0` to opt out of the *hard cap*
+ * instead. Loud failure surfaces the typo at startup.
+ */
+export const getDefaultQueryRowLimit = (): number => {
+   const raw = parseIntEnv("PUBLISHER_DEFAULT_QUERY_ROW_LIMIT");
+   if (raw === undefined) return DEFAULT_QUERY_ROW_LIMIT;
+   if (raw <= 0) {
+      throw new Error(
+         `PUBLISHER_DEFAULT_QUERY_ROW_LIMIT must be a positive integer (got ${raw})`,
+      );
+   }
+   return raw;
+};
+
+/**
+ * Resolve the per-query wall-clock timeout (milliseconds). Reads
+ * `PUBLISHER_QUERY_TIMEOUT_MS`; falls back to
+ * {@link DEFAULT_QUERY_TIMEOUT_MS} when unset or empty.
+ *
+ * `0` is accepted and disables the timeout entirely. Loud-failure
+ * on bad input (negative, non-integer, non-numeric) so a typo in a
+ * k8s manifest surfaces at startup.
+ */
+export const getQueryTimeoutMs = (): number => {
+   const raw = parseIntEnv("PUBLISHER_QUERY_TIMEOUT_MS");
+   if (raw === undefined) return DEFAULT_QUERY_TIMEOUT_MS;
+   if (raw < 0) {
+      throw new Error(
+         `PUBLISHER_QUERY_TIMEOUT_MS must be a non-negative integer (got ${raw})`,
+      );
+   }
+   return raw;
+};
+
+/**
+ * Resolve the per-pod inbound query concurrency cap. Reads
+ * `PUBLISHER_MAX_CONCURRENT_QUERIES`; falls back to
+ * {@link DEFAULT_MAX_CONCURRENT_QUERIES} when unset or empty.
+ *
+ * `0` is accepted and disables the cap entirely (use only when you
+ * have another concurrency control upstream, e.g. an explicit
+ * connection pool sized at the load balancer). Loud-failure on bad
+ * input.
+ */
+export const getMaxConcurrentQueries = (): number => {
+   const raw = parseIntEnv("PUBLISHER_MAX_CONCURRENT_QUERIES");
+   if (raw === undefined) return DEFAULT_MAX_CONCURRENT_QUERIES;
+   if (raw < 0) {
+      throw new Error(
+         `PUBLISHER_MAX_CONCURRENT_QUERIES must be a non-negative integer (got ${raw})`,
+      );
+   }
+   return raw;
+};
+
 function substituteEnvVars(value: string): string {
    const envVarPattern = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
 

package/src/constants.ts

@@ -5,6 +5,89 @@ export const PUBLISHER_CONFIG_NAME = "publisher.config.json";
 export const PACKAGE_MANIFEST_NAME = "publisher.json";
 export const MODEL_FILE_SUFFIX = ".malloy";
 export const NOTEBOOK_FILE_SUFFIX = ".malloynb";
-export const ROW_LIMIT = 1000;
+/**
+ * Default row cap applied to Malloy model queries (the `runnable.run`
+ * path used by `getQueryResults` and notebook cell execution) when
+ * the user's query doesn't carry its own `LIMIT`. Override at startup
+ * via `PUBLISHER_DEFAULT_QUERY_ROW_LIMIT`.
+ *
+ * This is *the default*, not a hard ceiling. A Malloy query that
+ * carries `LIMIT 50000` overrides this. The hard ceiling is
+ * {@link DEFAULT_MAX_QUERY_ROWS} (env-tuned via
+ * `PUBLISHER_MAX_QUERY_ROWS`), which the model-query path now also
+ * enforces — preventing a user `LIMIT 10000000` from blowing up the
+ * process.
+ *
+ * Tuned conservatively (1000) because notebook UIs typically render
+ * tabular previews; operators who need larger ad-hoc exports can
+ * raise it.
+ */
+export const DEFAULT_QUERY_ROW_LIMIT = 1000;
+/**
+ * Maximum number of rows the ad-hoc connection SQL endpoints
+ * (`/environments/.../connections/.../sqlQuery`) will return in a
+ * single response before failing with HTTP 413. Override at startup
+ * via `PUBLISHER_MAX_QUERY_ROWS`.
+ *
+ * Tuned high enough to handle typical interactive SQL exploration
+ * without truncating, while still bounding memory: 100k narrow rows
+ * is ~tens of MB of buffered result + a same-order JSON.stringify
+ * copy, comfortably under any reasonable pod memory budget. Wide
+ * rows (large strings, JSON blobs) are bounded separately by the
+ * Step 2 byte budget.
+ */
+export const DEFAULT_MAX_QUERY_ROWS = 100_000;
+/**
+ * Maximum aggregate JSON-serialized byte size of an ad-hoc
+ * connection SQL response before failing with HTTP 413. Override at
+ * startup via `PUBLISHER_MAX_RESPONSE_BYTES`.
+ *
+ * This is the actual memory bound: row count alone is a poor proxy
+ * for memory pressure because a single 10 MB JSON column blows past
+ * the 100k-row cap's safe envelope. Enforced only when the
+ * underlying connection implements `StreamingConnection` (Postgres,
+ * DuckDB, ...) since byte counting requires iterating row-at-a-time
+ * — on non-streaming connections the driver has already buffered
+ * the whole result by the time we see it, so client-side byte
+ * counting gains nothing.
+ *
+ * 50 MB picked as a middle ground: comfortably accommodates wide
+ * exploratory results (50k rows × 1 KB, or 5k rows × 10 KB) while
+ * keeping a single pod able to serve a handful of concurrent
+ * requests under a typical 1-2 GB memory budget.
+ */
+export const DEFAULT_MAX_RESPONSE_BYTES = 50_000_000;
+/**
+ * Default wall-clock timeout (milliseconds) applied to a single query
+ * — whether it's an ad-hoc connection SQL call or a Malloy model
+ * query. Override at startup via `PUBLISHER_QUERY_TIMEOUT_MS`; `0`
+ * disables the timeout entirely.
+ *
+ * 5 minutes is generous enough to let ad-hoc materializations and
+ * larger interactive queries finish, while still well under the
+ * 10-minute HTTP socket timeout so the publisher returns a clean
+ * `504 Gateway Timeout` instead of letting the load balancer
+ * disconnect mid-stream. Operators running long-tail analytical
+ * jobs should raise this; operators running a high-RPS API surface
+ * may want to lower it.
+ */
+export const DEFAULT_QUERY_TIMEOUT_MS = 300_000;
+/**
+ * Default upper bound on the number of inbound query requests a
+ * single publisher pod will handle concurrently. Excess requests
+ * are rejected with `503 Service Unavailable` so the upstream load
+ * balancer can retry / shed load instead of letting them pile up
+ * and stampede memory. Override at startup via
+ * `PUBLISHER_MAX_CONCURRENT_QUERIES`; `0` disables the limit.
+ *
+ * 32 picked as a safe out-of-the-box value: it bounds aggregate
+ * memory usage at ~32× the per-query byte cap
+ * ({@link DEFAULT_MAX_RESPONSE_BYTES}, i.e. ~1.5 GB at the default
+ * 50 MB) while leaving substantial headroom for the API surface,
+ * notebook execution, and background materializations. Pods sized
+ * larger than the default should raise it; pods running on tight
+ * memory budgets should lower it.
+ */
+export const DEFAULT_MAX_CONCURRENT_QUERIES = 32;
 export const TEMP_DIR_PATH = os.tmpdir();
 export const PUBLISHER_DATA_DIR = "publisher_data";

package/src/controller/compile.controller.ts

@@ -1,4 +1,4 @@
-import type { LogMessage } from "@malloydata/malloy";
+import type { GivenValue, LogMessage } from "@malloydata/malloy";
 import { EnvironmentStore } from "../service/environment_store";
 
 export class CompileController {
@@ -14,6 +14,7 @@ export class CompileController {
       modelName: string,
       source: string,
       includeSql: boolean = false,
+      givens?: Record<string, GivenValue>,
    ): Promise<{ status: string; problems: LogMessage[]; sql?: string }> {
       const environment = await this.environmentStore.getEnvironment(
          environmentName,
@@ -24,6 +25,7 @@ export class CompileController {
          modelName,
          source,
          includeSql,
+         givens,
       );
 
       // Determine overall status based on presence of errors