@malloy-publisher/server 0.0.204 → 0.0.205

package/tests/unit/duckdb/duckdb_connection.test.ts

@@ -0,0 +1,181 @@
+/// <reference types="bun-types" />
+
+// Direct unit tests for the storage-layer DuckDBConnection -- the embedded
+// metadata DAO (publisher.db) that was migrated from the legacy `duckdb`
+// callback binding to `@duckdb/node-api` (the "neo" promise API). The
+// repositories depend on this class's public surface, so these assert it
+// behaves identically across the migration: lifecycle, parameterized CRUD with
+// `?` placeholders, row-shape parity, and error wrapping.
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { DuckDBConnection } from "../../../src/storage/duckdb/DuckDBConnection";
+
+describe("DuckDBConnection (storage DAO over @duckdb/node-api)", () => {
+   let dbDir: string;
+   let conn: DuckDBConnection;
+
+   beforeEach(async () => {
+      // Unique dir per test so file handles never collide across tests
+      // (Windows runners are sensitive to reopening the same DuckDB file).
+      dbDir = await fs.mkdtemp(path.join(os.tmpdir(), "duckdb-conn-"));
+      conn = new DuckDBConnection(path.join(dbDir, "test.db"));
+      await conn.initialize();
+   });
+
+   afterEach(async () => {
+      try {
+         await conn.close();
+      } catch {
+         // already closed / never opened
+      }
+      await fs.rm(dbDir, { recursive: true, force: true });
+   });
+
+   describe("lifecycle", () => {
+      it("initializes and reports a usable connection", async () => {
+         const rows = await conn.all<{ answer: number }>("SELECT 42 AS answer");
+         expect(rows[0].answer).toBe(42);
+      });
+
+      it("isInitialized is false before the schema exists", async () => {
+         // Fresh DB with no `environments` table yet.
+         expect(await conn.isInitialized()).toBe(false);
+      });
+
+      it("isInitialized becomes true once the environments table exists", async () => {
+         await conn.run("CREATE TABLE environments (id VARCHAR PRIMARY KEY)");
+         expect(await conn.isInitialized()).toBe(true);
+      });
+
+      it("close() is idempotent and a second close does not throw", async () => {
+         await conn.close();
+         await expect(conn.close()).resolves.toBeUndefined();
+      });
+   });
+
+   describe("run / all / get with ? placeholders", () => {
+      beforeEach(async () => {
+         await conn.run(`
+            CREATE TABLE t (
+               id VARCHAR PRIMARY KEY,
+               name VARCHAR,
+               flag BOOLEAN,
+               metadata JSON,
+               created_at TIMESTAMP
+            )
+         `);
+      });
+
+      it("binds positional ? parameters on INSERT and reads them back", async () => {
+         const now = new Date().toISOString();
+         await conn.run(
+            "INSERT INTO t (id, name, flag, metadata, created_at) VALUES (?, ?, ?, ?, ?)",
+            ["a", "alpha", true, JSON.stringify({ k: 1 }), now],
+         );
+
+         const row = await conn.get<{
+            id: string;
+            name: string;
+            flag: boolean;
+            metadata: string;
+            created_at: unknown;
+         }>("SELECT * FROM t WHERE id = ?", ["a"]);
+
+         expect(row).not.toBeNull();
+         expect(row!.id).toBe("a");
+         expect(row!.name).toBe("alpha");
+         // BOOLEAN round-trips as a JS boolean.
+         expect(row!.flag).toBe(true);
+         // JSON is stored/returned as a string the repositories JSON.parse().
+         expect(typeof row!.metadata).toBe("string");
+         expect(JSON.parse(row!.metadata)).toEqual({ k: 1 });
+         // TIMESTAMP is consumable by `new Date(...)` (repositories do exactly this).
+         expect(new Date(row!.created_at as string).toISOString()).toBe(now);
+      });
+
+      it("all() returns every matching row", async () => {
+         await conn.run("INSERT INTO t (id, name) VALUES (?, ?)", ["a", "x"]);
+         await conn.run("INSERT INTO t (id, name) VALUES (?, ?)", ["b", "y"]);
+
+         const rows = await conn.all<{ id: string }>(
+            "SELECT id FROM t ORDER BY id",
+         );
+         expect(rows.map((r) => r.id)).toEqual(["a", "b"]);
+      });
+
+      it("get() returns null when no row matches", async () => {
+         const row = await conn.get("SELECT * FROM t WHERE id = ?", [
+            "missing",
+         ]);
+         expect(row).toBeNull();
+      });
+
+      it("all() returns an empty array when no row matches", async () => {
+         const rows = await conn.all("SELECT * FROM t WHERE id = ?", ["nope"]);
+         expect(rows).toEqual([]);
+      });
+
+      it("supports statements with no parameters", async () => {
+         await conn.run("INSERT INTO t (id) VALUES ('solo')");
+         const rows = await conn.all<{ n: number | bigint }>(
+            "SELECT count(*) AS n FROM t",
+         );
+         expect(Number(rows[0].n)).toBe(1);
+      });
+
+      it("UPDATE and DELETE bind ? parameters", async () => {
+         await conn.run("INSERT INTO t (id, name) VALUES (?, ?)", ["a", "old"]);
+         await conn.run("UPDATE t SET name = ? WHERE id = ?", ["new", "a"]);
+         expect(
+            (await conn.get<{ name: string }>(
+               "SELECT name FROM t WHERE id = ?",
+               ["a"],
+            ))!.name,
+         ).toBe("new");
+
+         await conn.run("DELETE FROM t WHERE id = ?", ["a"]);
+         expect(
+            await conn.get("SELECT * FROM t WHERE id = ?", ["a"]),
+         ).toBeNull();
+      });
+   });
+
+   describe("error handling", () => {
+      it("run() wraps a failing query with the query text", async () => {
+         await expect(
+            conn.run("INSERT INTO does_not_exist VALUES (1)"),
+         ).rejects.toThrow(/Query execution failed[\s\S]*does_not_exist/);
+      });
+
+      it("all() wraps a failing query with the query text", async () => {
+         await expect(conn.all("SELECT * FROM does_not_exist")).rejects.toThrow(
+            /Query execution failed[\s\S]*does_not_exist/,
+         );
+      });
+
+      it("run() throws when the connection is not initialized", async () => {
+         const fresh = new DuckDBConnection(path.join(dbDir, "uninit.db"));
+         await expect(fresh.run("SELECT 1")).rejects.toThrow(/not initialized/);
+      });
+   });
+
+   describe("durability", () => {
+      it("persists data to the file across reopen", async () => {
+         const dbPath = path.join(dbDir, "persist.db");
+         const first = new DuckDBConnection(dbPath);
+         await first.initialize();
+         await first.run("CREATE TABLE k (v VARCHAR)");
+         await first.run("INSERT INTO k VALUES (?)", ["kept"]);
+         await first.close();
+
+         const second = new DuckDBConnection(dbPath);
+         await second.initialize();
+         const rows = await second.all<{ v: string }>("SELECT v FROM k");
+         await second.close();
+         expect(rows.map((r) => r.v)).toEqual(["kept"]);
+      });
+   });
+});

package/tests/unit/duckdb/repositories.test.ts

@@ -0,0 +1,208 @@
+/// <reference types="bun-types" />
+
+// Round-trip tests for the DuckDB storage repositories against a REAL
+// DuckDBConnection (no mocks). The repositories were untested at the storage
+// layer -- existing service specs mock the repository methods -- so these run
+// their actual SQL through the connection migrated to @duckdb/node-api. They
+// guard the migration-sensitive behaviors: parameterized writes, JSON-column
+// round-trips (config/metadata via JSON.stringify -> JSON.parse), TIMESTAMP ->
+// Date mapping, and foreign-key relationships between the tables.
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { DuckDBConnection } from "../../../src/storage/duckdb/DuckDBConnection";
+import { initializeSchema } from "../../../src/storage/duckdb/schema";
+import { EnvironmentRepository } from "../../../src/storage/duckdb/EnvironmentRepository";
+import { PackageRepository } from "../../../src/storage/duckdb/PackageRepository";
+import { ConnectionRepository } from "../../../src/storage/duckdb/ConnectionRepository";
+
+describe("DuckDB storage repositories (real connection)", () => {
+   let dbDir: string;
+   let db: DuckDBConnection;
+   let environments: EnvironmentRepository;
+   let packages: PackageRepository;
+   let connections: ConnectionRepository;
+
+   beforeEach(async () => {
+      dbDir = await fs.mkdtemp(path.join(os.tmpdir(), "duckdb-repos-"));
+      db = new DuckDBConnection(path.join(dbDir, "test.db"));
+      await db.initialize();
+      await initializeSchema(db);
+      environments = new EnvironmentRepository(db);
+      packages = new PackageRepository(db);
+      connections = new ConnectionRepository(db);
+   });
+
+   afterEach(async () => {
+      try {
+         await db.close();
+      } catch {
+         // ignore
+      }
+      await fs.rm(dbDir, { recursive: true, force: true });
+   });
+
+   describe("EnvironmentRepository", () => {
+      it("creates and reads back an environment with metadata", async () => {
+         const created = await environments.createEnvironment({
+            name: "env-a",
+            path: "/tmp/env-a",
+            description: "first",
+            metadata: { team: "data", tier: 2 },
+         });
+
+         expect(created.id).toBeTruthy();
+         expect(created.createdAt).toBeInstanceOf(Date);
+
+         const byId = await environments.getEnvironmentById(created.id);
+         expect(byId).not.toBeNull();
+         expect(byId!.name).toBe("env-a");
+         expect(byId!.description).toBe("first");
+         // metadata survives the JSON round-trip (stringify on write, parse on read)
+         expect(byId!.metadata).toEqual({ team: "data", tier: 2 });
+         // TIMESTAMP columns come back as Date
+         expect(byId!.createdAt).toBeInstanceOf(Date);
+         expect(byId!.updatedAt).toBeInstanceOf(Date);
+      });
+
+      it("looks up an environment by name", async () => {
+         await environments.createEnvironment({
+            name: "env-b",
+            path: "/tmp/b",
+         });
+         const byName = await environments.getEnvironmentByName("env-b");
+         expect(byName?.name).toBe("env-b");
+         expect(await environments.getEnvironmentByName("nope")).toBeNull();
+      });
+
+      it("lists, updates, and deletes environments", async () => {
+         const e = await environments.createEnvironment({
+            name: "env-c",
+            path: "/tmp/c",
+         });
+
+         expect(
+            (await environments.listEnvironments()).map((x) => x.name),
+         ).toContain("env-c");
+
+         const updated = await environments.updateEnvironment(e.id, {
+            description: "updated",
+            metadata: { changed: true },
+         });
+         expect(updated.description).toBe("updated");
+         expect(updated.metadata).toEqual({ changed: true });
+
+         await environments.deleteEnvironment(e.id);
+         expect(await environments.getEnvironmentById(e.id)).toBeNull();
+      });
+   });
+
+   describe("PackageRepository", () => {
+      it("creates a package under an environment and reads it back", async () => {
+         const env = await environments.createEnvironment({
+            name: "env-pkg",
+            path: "/tmp/env-pkg",
+         });
+
+         const pkg = await packages.createPackage({
+            environmentId: env.id,
+            name: "pkg-1",
+            manifestPath: "/tmp/env-pkg/pkg-1/publisher.json",
+            metadata: { source: "test" },
+         });
+
+         const byId = await packages.getPackageById(pkg.id);
+         expect(byId?.name).toBe("pkg-1");
+         expect(byId?.manifestPath).toBe("/tmp/env-pkg/pkg-1/publisher.json");
+         expect(byId?.metadata).toEqual({ source: "test" });
+
+         const byName = await packages.getPackageByName(env.id, "pkg-1");
+         expect(byName?.id).toBe(pkg.id);
+
+         const list = await packages.listPackages(env.id);
+         expect(list.map((p) => p.name)).toEqual(["pkg-1"]);
+
+         await packages.deletePackage(pkg.id);
+         expect(await packages.getPackageById(pkg.id)).toBeNull();
+      });
+   });
+
+   describe("ConnectionRepository", () => {
+      it("round-trips a connection's JSON config", async () => {
+         const env = await environments.createEnvironment({
+            name: "env-conn",
+            path: "/tmp/env-conn",
+         });
+
+         const config = {
+            account: "acct",
+            warehouse: "wh",
+            nested: { a: 1, b: ["x", "y"] },
+         };
+         const created = await connections.createConnection({
+            environmentId: env.id,
+            name: "snow",
+            type: "snowflake",
+            config,
+         });
+
+         const byId = await connections.getConnectionById(created.id);
+         expect(byId).not.toBeNull();
+         expect(byId!.type).toBe("snowflake");
+         // The config column is stored as JSON and must deserialize identically.
+         expect(byId!.config).toEqual(config);
+
+         const byName = await connections.getConnectionByName(env.id, "snow");
+         expect(byName?.id).toBe(created.id);
+      });
+
+      it("lists and deletes connections, including by environment", async () => {
+         const env = await environments.createEnvironment({
+            name: "env-conn2",
+            path: "/tmp/env-conn2",
+         });
+         await connections.createConnection({
+            environmentId: env.id,
+            name: "c1",
+            type: "postgres",
+            config: { host: "h" },
+         });
+         await connections.createConnection({
+            environmentId: env.id,
+            name: "c2",
+            type: "duckdb",
+            config: {},
+         });
+
+         expect(
+            (await connections.listConnections(env.id)).map((c) => c.name),
+         ).toEqual(["c1", "c2"]);
+
+         await connections.deleteConnectionsByEnvironmentId(env.id);
+         expect(await connections.listConnections(env.id)).toEqual([]);
+      });
+
+      it("updates a connection's config", async () => {
+         const env = await environments.createEnvironment({
+            name: "env-conn3",
+            path: "/tmp/env-conn3",
+         });
+         const c = await connections.createConnection({
+            environmentId: env.id,
+            name: "c",
+            type: "postgres",
+            config: { host: "old" },
+         });
+
+         const updated = await connections.updateConnection(c.id, {
+            config: { host: "new", port: 5432 },
+         });
+         expect(updated.config).toEqual({ host: "new", port: 5432 });
+
+         const reread = await connections.getConnectionById(c.id);
+         expect(reread!.config).toEqual({ host: "new", port: 5432 });
+      });
+   });
+});

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

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

package/dist/app/assets/MaterializationsPage-B5goxVXW.js

@@ -1 +0,0 @@
-import{F as r,N as t,j as e,_ as c,a2 as o}from"./index-DqiJ0bWp.js";function m(){const{environmentName:a,packageName:n}=r(),s=t();if(a)if(n){const i=c({environmentName:a,packageName:n});return e.jsx(o,{onClickPackageFile:s,resourceUri:i})}else return e.jsx("div",{children:e.jsx("h2",{children:"Missing package name"})});else return e.jsx("div",{children:e.jsx("h2",{children:"Missing environment name"})})}export{m as default};

package/dist/app/assets/ModelPage-Ba7Xh4lL.js

@@ -1 +0,0 @@
-import{F as t,j as e,_ as m,G as r,$ as x,a0 as o}from"./index-DqiJ0bWp.js";function d(){const n=t(),a=n["*"];if(!n.environmentName)return e.jsx("div",{children:e.jsx("h2",{children:"Missing environment name"})});if(!n.packageName)return e.jsx("div",{children:e.jsx("h2",{children:"Missing package name"})});const i=m({environmentName:n.environmentName,packageName:n.packageName,modelPath:a}),s={p:3,maxWidth:1200,mx:"auto"};return a?.endsWith(".malloy")?e.jsx(r,{sx:s,children:e.jsx(x,{resourceUri:i,runOnDemand:!0,maxResultSize:512*1024})}):a?.endsWith(".malloynb")?e.jsx(r,{sx:s,children:e.jsx(o,{resourceUri:i,maxResultSize:1024*1024})}):e.jsx(r,{sx:s,children:e.jsxs("h2",{children:["Unrecognized file type: ",a]})})}export{d as default};