@malloy-publisher/server 0.0.235 → 0.0.237

package/src/service/duckdb_instance_isolation.spec.ts

@@ -1,137 +0,0 @@
-import { DuckDBConnection } from "@malloydata/db-duckdb";
-import { afterEach, describe, expect, it } from "bun:test";
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-
-/**
- * Pins the DuckDB instance-isolation contract that same-named connections depend
- * on for multi-tenant safety.
- *
- * `@malloydata/db-duckdb` pools DuckDB instances in a process-global cache keyed
- * by a share key that deliberately EXCLUDES the connection name, and it caches a
- * `:memory:` primary like any other. Meanwhile the DuckLake attach aliases by
- * connection name (`ATTACH OR REPLACE … AS <name>`). Put those together and two
- * same-named connections that land on ONE pooled instance clobber each other's
- * attach: one ends up reading the other's database.
- *
- * `createIsolatedBuildSession` prevents that by giving every build session a
- * unique `workingDirectory`, relying on it participating in the share key. That
- * is an upstream implementation detail, so nothing here asserted it — and the
- * failure mode is silent: no error, just the wrong data. This spec asserts the
- * behaviour instead of the mechanism, so it holds however upstream achieves it.
- *
- * Deliberately NOT asserted: the converse (same name AND same working directory
- * DO share an instance). That is the pooling artifact, not a property we want; if
- * upstream ever made pooling connection-aware, asserting it would fail on an
- * improvement.
- *
- * Each connection creates and populates its OWN attached store rather than
- * reopening a pre-seeded file. Handing a file from one connection to another
- * requires the first to have released its OS lock, and `close()` is refcount-only
- * — which fails outright under Windows' mandatory locking. Attaching a store the
- * connection itself owns avoids the handoff, and matches how a DuckLake
- * destination is actually used.
- */
-describe("DuckDB instance isolation", () => {
-   const tempDirs: string[] = [];
-   const openConnections: DuckDBConnection[] = [];
-
-   const tempDir = async (label: string): Promise<string> => {
-      const dir = await fs.mkdtemp(
-         path.join(os.tmpdir(), `duckdb-iso-${label}-`),
-      );
-      tempDirs.push(dir);
-      return dir;
-   };
-
-   afterEach(async () => {
-      for (const connection of openConnections) {
-         await connection.close().catch(() => undefined);
-      }
-      openConnections.length = 0;
-      for (const dir of tempDirs) {
-         // Best-effort: a still-locked file must not fail the test.
-         await fs
-            .rm(dir, { recursive: true, force: true })
-            .catch(() => undefined);
-      }
-      tempDirs.length = 0;
-   });
-
-   /**
-    * A connection with the given name and its own working directory, which
-    * attaches its own private store under `alias` and writes one distinguishing
-    * value into it.
-    */
-   const connectionWithOwnStore = async (
-      name: string,
-      label: string,
-      alias: string,
-      value: number,
-   ): Promise<DuckDBConnection> => {
-      const sessionDir = await tempDir(`session-${label}`);
-      const connection = new DuckDBConnection(name, ":memory:", sessionDir);
-      openConnections.push(connection);
-      const storeDir = await tempDir(`store-${label}`);
-      const storeFile = path.join(storeDir, `${label}.duckdb`);
-      // OR REPLACE mirrors the DuckLake attach: on a shared instance the second
-      // caller silently replaces the first caller's alias.
-      await connection.runSQL(`ATTACH OR REPLACE '${storeFile}' AS ${alias};`);
-      await connection.runSQL(
-         `CREATE OR REPLACE TABLE ${alias}.t AS SELECT ${value} AS x;`,
-      );
-      return connection;
-   };
-
-   const readValue = async (
-      connection: DuckDBConnection,
-      alias: string,
-   ): Promise<number> => {
-      const result = await connection.runSQL(`SELECT x FROM ${alias}.t;`);
-      return Number(Object.values(result.rows[0])[0]);
-   };
-
-   it("keeps same-named connections apart when their working directories differ", async () => {
-      // Identical connection NAME and identical `:memory:` primary — only the
-      // working directory differs. That is exactly the shape a build session
-      // uses, and the only thing standing between it and a shared instance.
-      //
-      // ORDERING IS LOAD-BEARING FOR THIS TEST. The instance cache is consulted
-      // inside an async `init()`, so constructing both connections before either
-      // is used lets both race past the cache miss and each create a private
-      // instance — isolation for the wrong reason, and a test that could never
-      // fail. Each helper call fully initializes its connection (the ATTACH
-      // forces it) before the next is built, so a shared share key really would
-      // hand back the cached instance. Verified: with identical working
-      // directories this ordering yields 2 for both connections — the clobber.
-      const a = await connectionWithOwnStore("store", "a", "lake", 1);
-      const b = await connectionWithOwnStore("store", "b", "lake", 2);
-
-      expect(await readValue(a, "lake")).toBe(1);
-      expect(await readValue(b, "lake")).toBe(2);
-   });
-
-   it("keeps a build-session-shaped connection apart from a long-lived one", async () => {
-      // The pairing the build-session comment calls out specifically: a transient
-      // build session overlapping a long-lived serve connection. Same name, same
-      // alias, both `:memory:` — distinct only by working directory.
-      const serve = await connectionWithOwnStore(
-         "credible",
-         "serve",
-         "lake",
-         10,
-      );
-      const build = await connectionWithOwnStore(
-         "credible",
-         "build",
-         "lake",
-         20,
-      );
-
-      // The serve connection must still see its own store after the build
-      // session attaches a different one under the same alias.
-      expect(await readValue(serve, "lake")).toBe(10);
-      expect(await readValue(build, "lake")).toBe(20);
-   });
-});

package/src/service/ducklake_lazy_attach.spec.ts

@@ -1,110 +0,0 @@
-import { DuckDBConnection } from "@malloydata/db-duckdb";
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import fs from "fs/promises";
-import path from "path";
-import sinon from "sinon";
-import { components } from "../api";
-import { buildEnvironmentMalloyConfig } from "./connection";
-
-type ApiConnection = components["schemas"]["Connection"];
-
-// A DuckLake connection whose Postgres catalog points at an unroutable host.
-// If anything on the boot path tried to reach the catalog, these tests would
-// hang or fail — which is precisely the regression they guard against.
-const UNREACHABLE_DUCKLAKE: ApiConnection = {
-   name: "ducklake_lazy",
-   type: "ducklake",
-   ducklakeConnection: {
-      catalog: {
-         postgresConnection: {
-            host: "192.0.2.1", // TEST-NET-1: guaranteed non-routable
-            port: 5432,
-            userName: "nobody",
-            password: "nobody",
-            databaseName: "catalog",
-         },
-      },
-      storage: {
-         bucketUrl: "s3://test-bucket",
-         s3Connection: {
-            accessKeyId: "test",
-            secretAccessKey: "test",
-         },
-      },
-   },
-} as ApiConnection;
-
-describe("DuckLake lazy attach", () => {
-   const envPath = path.join(process.cwd(), "test-ducklake-lazy-attach");
-
-   beforeEach(async () => {
-      await fs.mkdir(envPath, { recursive: true });
-   });
-
-   afterEach(async () => {
-      sinon.restore();
-      await fs.rm(envPath, { recursive: true, force: true }).catch(() => {});
-   });
-
-   it("does not attach the catalog while building the environment config (boot path)", async () => {
-      // Stub the DuckDB session so no real database or network work happens; the
-      // stub also lets us observe whether ANY SQL ran during config build.
-      const runSQL = sinon
-         .stub(DuckDBConnection.prototype, "runSQL")
-         .resolves({ rows: [] } as never);
-
-      // Building the config is the worker boot path. It must be synchronous and
-      // must not open, construct, or touch the DuckLake session at all.
-      const config = buildEnvironmentMalloyConfig(
-         [UNREACHABLE_DUCKLAKE],
-         envPath,
-      );
-
-      expect(config.apiConnections.map((c) => c.name)).toContain(
-         "ducklake_lazy",
-      );
-      // The definitive assertion: zero SQL was issued building the config, so
-      // the (unreachable) catalog could not have been contacted on boot.
-      expect(runSQL.callCount).toBe(0);
-   });
-
-   it("cannot let an unavailable catalog block startup", async () => {
-      sinon
-         .stub(DuckDBConnection.prototype, "runSQL")
-         .resolves({ rows: [] } as never);
-
-      // Even with an unreachable catalog, constructing the environment config
-      // resolves promptly and never awaits the catalog. If attach were on the
-      // boot path, this would hang against 192.0.2.1 until a connect timeout.
-      const config = buildEnvironmentMalloyConfig(
-         [UNREACHABLE_DUCKLAKE],
-         envPath,
-      );
-      expect(config).toBeDefined();
-      expect(config.malloyConfig).toBeDefined();
-   });
-
-   it("attaches the catalog only on first connection lookup (serve path)", async () => {
-      const runSQL = sinon
-         .stub(DuckDBConnection.prototype, "runSQL")
-         .resolves({ rows: [] } as never);
-
-      const config = buildEnvironmentMalloyConfig(
-         [UNREACHABLE_DUCKLAKE],
-         envPath,
-      );
-      expect(runSQL.callCount).toBe(0);
-
-      // The lazy attach fires here, on the first lookup — not before.
-      await config.malloyConfig.connections.lookupConnection("ducklake_lazy");
-
-      const issued = runSQL.getCalls().map((c) => String(c.args[0]));
-      const attachedDuckLake = issued.some((sql) =>
-         sql.includes("ducklake:postgres:"),
-      );
-      expect(runSQL.callCount).toBeGreaterThan(0);
-      expect(attachedDuckLake).toBe(true);
-
-      await config.releaseConnections().catch(() => {});
-   });
-});

package/src/service/embedding_provider.spec.ts

@@ -1,329 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import {
-   EmbeddingProvider,
-   MAX_EMBED_BATCH_SIZE,
-   MAX_EMBED_INPUT_CHARS,
-   _clearEmbeddingProviderForTests,
-   embeddingConfigured,
-   getEmbeddingProvider,
-   prepareEmbeddingInput,
-} from "./embedding_provider";
-import { EmbeddingConfig } from "../config";
-
-const CONFIG: EmbeddingConfig = {
-   apiKey: "test-key",
-   model: "test-model",
-   baseUrl: "https://embeddings.example.com/v1",
-};
-
-interface CapturedRequest {
-   url: string;
-   body: Record<string, unknown>;
-   authorization: string | undefined;
-}
-
-/** A fetch stub that records requests and answers with unit vectors. */
-function stubFetch(
-   captured: CapturedRequest[],
-   respond?: (inputs: string[]) => Response,
-): typeof fetch {
-   return (async (url: RequestInfo | URL, init?: RequestInit) => {
-      const body = JSON.parse(String(init?.body)) as Record<string, unknown>;
-      captured.push({
-         url: String(url),
-         body,
-         authorization: (init?.headers as Record<string, string>)?.[
-            "Authorization"
-         ],
-      });
-      const inputs = body.input as string[];
-      if (respond) return respond(inputs);
-      return new Response(
-         JSON.stringify({
-            data: inputs.map((_, index) => ({ index, embedding: [index, 1] })),
-         }),
-         { status: 200 },
-      );
-   }) as typeof fetch;
-}
-
-describe("prepareEmbeddingInput", () => {
-   it("collapses whitespace and newlines", () => {
-      expect(prepareEmbeddingInput("a\nb\t c  d")).toBe("a b c d");
-   });
-
-   it("caps input length", () => {
-      const long = "x".repeat(MAX_EMBED_INPUT_CHARS + 500);
-      expect(prepareEmbeddingInput(long).length).toBe(MAX_EMBED_INPUT_CHARS);
-   });
-
-   it("never returns an empty string (providers 400 on empty inputs)", () => {
-      expect(prepareEmbeddingInput("")).toBe("-");
-      expect(prepareEmbeddingInput("   ")).toBe("-");
-      expect(prepareEmbeddingInput("\n\t")).toBe("-");
-   });
-});
-
-describe("EmbeddingProvider", () => {
-   it("embeds a batch and returns vectors in input order", async () => {
-      const captured: CapturedRequest[] = [];
-      const provider = new EmbeddingProvider(CONFIG, stubFetch(captured));
-      const vectors = await provider.embedBatch(["a", "b"], 1000);
-      expect(vectors).toEqual([
-         [0, 1],
-         [1, 1],
-      ]);
-      expect(captured).toHaveLength(1);
-      expect(captured[0].url).toBe(
-         "https://embeddings.example.com/v1/embeddings",
-      );
-      expect(captured[0].body.model).toBe("test-model");
-      expect(captured[0].authorization).toBe("Bearer test-key");
-   });
-
-   it("places vectors by the response's index fields, not response order", async () => {
-      const captured: CapturedRequest[] = [];
-      const provider = new EmbeddingProvider(
-         CONFIG,
-         stubFetch(
-            captured,
-            () =>
-               new Response(
-                  JSON.stringify({
-                     data: [
-                        { index: 1, embedding: [2, 2] },
-                        { index: 0, embedding: [1, 1] },
-                     ],
-                  }),
-                  { status: 200 },
-               ),
-         ),
-      );
-      const vectors = await provider.embedBatch(["a", "b"], 1000);
-      expect(vectors).toEqual([
-         [1, 1],
-         [2, 2],
-      ]);
-   });
-
-   it("splits large inputs into batches", async () => {
-      const captured: CapturedRequest[] = [];
-      const provider = new EmbeddingProvider(CONFIG, stubFetch(captured));
-      const texts = Array.from(
-         { length: MAX_EMBED_BATCH_SIZE + 1 },
-         (_, i) => `t${i}`,
-      );
-      const vectors = await provider.embedBatch(texts, 1000);
-      expect(vectors).toHaveLength(texts.length);
-      expect(captured).toHaveLength(2);
-      expect((captured[0].body.input as string[]).length).toBe(
-         MAX_EMBED_BATCH_SIZE,
-      );
-      expect((captured[1].body.input as string[]).length).toBe(1);
-   });
-
-   it("sends the dimensions param only when configured", async () => {
-      const captured: CapturedRequest[] = [];
-      const without = new EmbeddingProvider(CONFIG, stubFetch(captured));
-      await without.embedBatch(["a"], 1000);
-      expect(captured[0].body.dimensions).toBeUndefined();
-
-      const withDims = new EmbeddingProvider(
-         { ...CONFIG, dimensions: 512 },
-         stubFetch(captured),
-      );
-      await withDims.embedBatch(["a"], 1000);
-      expect(captured[1].body.dimensions).toBe(512);
-   });
-
-   it("reports HTTP failures with a truncated body and no header echo", async () => {
-      const provider = new EmbeddingProvider(
-         CONFIG,
-         stubFetch(
-            [],
-            () => new Response("boom ".repeat(100), { status: 429 }),
-         ),
-      );
-      const err = await provider.embedBatch(["a"], 1000).then(
-         () => undefined,
-         (e: Error) => e,
-      );
-      expect(err).toBeDefined();
-      expect(err!.message).toContain("(429)");
-      expect(err!.message.length).toBeLessThan(400);
-      expect(err!.message).not.toContain("test-key");
-   });
-
-   it("drops auth-failure bodies entirely (they can reflect the key)", async () => {
-      const provider = new EmbeddingProvider(
-         CONFIG,
-         stubFetch(
-            [],
-            () =>
-               new Response("Incorrect API key provided: test-key", {
-                  status: 401,
-               }),
-         ),
-      );
-      const err = await provider.embedBatch(["a"], 1000).then(
-         () => undefined,
-         (e: Error) => e,
-      );
-      expect(err!.message).toContain("(401)");
-      expect(err!.message).toContain("authentication failed");
-      expect(err!.message).not.toContain("test-key");
-   });
-
-   it("scrubs literal key occurrences from non-auth error bodies", async () => {
-      const provider = new EmbeddingProvider(
-         CONFIG,
-         stubFetch(
-            [],
-            () =>
-               new Response(
-                  "proxy error while forwarding token test-key upstream",
-                  {
-                     status: 502,
-                  },
-               ),
-         ),
-      );
-      const err = await provider.embedBatch(["a"], 1000).then(
-         () => undefined,
-         (e: Error) => e,
-      );
-      expect(err!.message).toContain("(502)");
-      expect(err!.message).toContain("[REDACTED]");
-      expect(err!.message).not.toContain("test-key");
-   });
-
-   it("names a timeout in the failure message", async () => {
-      const timeoutFetch = (async () => {
-         const error = new Error("The operation timed out");
-         error.name = "TimeoutError";
-         throw error;
-      }) as unknown as typeof fetch;
-      const provider = new EmbeddingProvider(CONFIG, timeoutFetch);
-      const err = await provider.embedBatch(["a"], 1234).then(
-         () => undefined,
-         (e: Error) => e,
-      );
-      expect(err!.message).toContain("timed out after 1234ms");
-   });
-
-   it("rejects a response with the wrong number of embeddings", async () => {
-      const provider = new EmbeddingProvider(
-         CONFIG,
-         stubFetch(
-            [],
-            () =>
-               new Response(
-                  JSON.stringify({ data: [{ index: 0, embedding: [1] }] }),
-                  { status: 200 },
-               ),
-         ),
-      );
-      await expect(provider.embedBatch(["a", "b"], 1000)).rejects.toThrow(
-         "malformed",
-      );
-   });
-
-   it("rejects a vector with non-finite or non-numeric contents", async () => {
-      const provider = new EmbeddingProvider(
-         CONFIG,
-         stubFetch(
-            [],
-            () =>
-               new Response(
-                  JSON.stringify({
-                     data: [{ index: 0, embedding: [1, null, "x"] }],
-                  }),
-                  { status: 200 },
-               ),
-         ),
-      );
-      await expect(provider.embedBatch(["a"], 1000)).rejects.toThrow(
-         "malformed",
-      );
-   });
-});
-
-describe("getEmbeddingProvider / embeddingConfigured", () => {
-   const ENV_KEYS = [
-      "EMBEDDING_API_KEY",
-      "EMBEDDING_MODEL",
-      "EMBEDDING_API_BASE",
-      "EMBEDDING_DIMENSIONS",
-   ];
-   const saved: Record<string, string | undefined> = {};
-
-   beforeEach(() => {
-      for (const key of ENV_KEYS) {
-         saved[key] = process.env[key];
-         delete process.env[key];
-      }
-      _clearEmbeddingProviderForTests();
-   });
-
-   afterEach(() => {
-      for (const key of ENV_KEYS) {
-         if (saved[key] === undefined) delete process.env[key];
-         else process.env[key] = saved[key];
-      }
-      _clearEmbeddingProviderForTests();
-   });
-
-   it("returns null (feature off) without EMBEDDING_API_KEY", () => {
-      expect(getEmbeddingProvider()).toBeNull();
-      expect(embeddingConfigured()).toBe(false);
-   });
-
-   it("ignores an ambient OPENAI_API_KEY", () => {
-      const before = process.env.OPENAI_API_KEY;
-      process.env.OPENAI_API_KEY = "ambient";
-      try {
-         expect(getEmbeddingProvider()).toBeNull();
-         expect(embeddingConfigured()).toBe(false);
-      } finally {
-         if (before === undefined) delete process.env.OPENAI_API_KEY;
-         else process.env.OPENAI_API_KEY = before;
-      }
-   });
-
-   it("builds a provider with defaults when the key is set", () => {
-      process.env.EMBEDDING_API_KEY = "k";
-      const provider = getEmbeddingProvider();
-      expect(provider).not.toBeNull();
-      expect(provider!.model).toBe("text-embedding-3-small");
-      expect(embeddingConfigured()).toBe(true);
-   });
-
-   it("rebuilds the provider when the configuration changes", () => {
-      process.env.EMBEDDING_API_KEY = "k";
-      const first = getEmbeddingProvider();
-      expect(getEmbeddingProvider()).toBe(first);
-      process.env.EMBEDDING_MODEL = "other-model";
-      const second = getEmbeddingProvider();
-      expect(second).not.toBe(first);
-      expect(second!.model).toBe("other-model");
-   });
-
-   it("does not stick to null after the key appears", () => {
-      expect(getEmbeddingProvider()).toBeNull();
-      process.env.EMBEDDING_API_KEY = "k";
-      expect(getEmbeddingProvider()).not.toBeNull();
-   });
-
-   it("throws on a malformed base URL but still reports configured", () => {
-      process.env.EMBEDDING_API_KEY = "k";
-      process.env.EMBEDDING_API_BASE = "not a url";
-      expect(() => getEmbeddingProvider()).toThrow("EMBEDDING_API_BASE");
-      expect(embeddingConfigured()).toBe(true);
-   });
-
-   it("throws on a malformed EMBEDDING_DIMENSIONS", () => {
-      process.env.EMBEDDING_API_KEY = "k";
-      process.env.EMBEDDING_DIMENSIONS = "lots";
-      expect(() => getEmbeddingProvider()).toThrow("EMBEDDING_DIMENSIONS");
-   });
-});