@malloy-publisher/server 0.0.167 → 0.0.169

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.167",
+   "version": "0.0.169",
    "main": "dist/server.js",
    "bin": {
       "malloy-publisher": "dist/server.js"
@@ -30,15 +30,15 @@
    "dependencies": {
       "@aws-sdk/client-s3": "^3.958.0",
       "@google-cloud/storage": "^7.16.0",
-      "@malloydata/db-bigquery": "^0.0.333",
-      "@malloydata/db-duckdb": "^0.0.333",
-      "@malloydata/db-mysql": "^0.0.333",
-      "@malloydata/db-postgres": "^0.0.333",
-      "@malloydata/db-snowflake": "^0.0.333",
-      "@malloydata/db-trino": "^0.0.333",
-      "@malloydata/malloy": "^0.0.333",
-      "@malloydata/malloy-sql": "^0.0.333",
-      "@malloydata/render": "^0.0.333",
+      "@malloydata/db-bigquery": "^0.0.354",
+      "@malloydata/db-duckdb": "^0.0.354",
+      "@malloydata/db-mysql": "^0.0.354",
+      "@malloydata/db-postgres": "^0.0.354",
+      "@malloydata/db-snowflake": "^0.0.354",
+      "@malloydata/db-trino": "^0.0.354",
+      "@malloydata/malloy": "^0.0.354",
+      "@malloydata/malloy-sql": "^0.0.354",
+      "@malloydata/render-validator": "^0.0.354",
       "@modelcontextprotocol/sdk": "^1.13.2",
       "@opentelemetry/api": "^1.9.0",
       "@opentelemetry/auto-instrumentations-node": "^0.57.0",

package/src/controller/connection.controller.ts

@@ -155,17 +155,37 @@ export class ConnectionController {
    public async getTable(
       projectName: string,
       connectionName: string,
-      _schemaName: string,
+      schemaName: string,
       tablePath: string,
    ): Promise<ApiTable> {
       const malloyConnection = await this.getMalloyConnection(
          projectName,
          connectionName,
       );
+      const connection = await this.getConnection(projectName, connectionName);
+
+      if (connection.type === "ducklake") {
+         if (tablePath.split(".").length === 1) {
+            // tablePath is just the table name, construct full path
+            tablePath = `${connectionName}.${schemaName}.${tablePath}`;
+         } else if (
+            tablePath.split(".").length === 2 &&
+            !tablePath.startsWith(connectionName)
+         ) {
+            // tablePath is schemaName.tableName but missing connection prefix
+            tablePath = `${connectionName}.${tablePath}`;
+         }
+         // If tablePath already has 3+ parts or starts with connection name, use as-is
+      }
+
+      const tableKey = tablePath.split(".").pop();
+      if (!tableKey) {
+         throw new Error(`Invalid tablePath: ${tablePath}`);
+      }
 
       const tableSource = await getConnectionTableSource(
          malloyConnection,
-         tablePath.split(".").pop()!, // tableKey is the table name
+         tableKey, // tableKey is the table name
          tablePath,
       );
 

package/src/controller/query.controller.ts

@@ -41,11 +41,18 @@ export class QueryController {
             queryName,
             query,
          );
+         // Lazy import since this creates a FakeDOM global which
+         // can confuse other imports.
+         const { validateRenderTags } = await import(
+            "@malloydata/render-validator"
+         );
+         const renderLogs = validateRenderTags(result);
          return {
             result: compactJson
                ? JSON.stringify(compactResult, bigIntReplacer)
                : JSON.stringify(result),
             resource: `${API_PREFIX}/projects/${projectName}/packages/${packageName}/models/${modelPath}/query`,
+            renderLogs: renderLogs.length > 0 ? renderLogs : undefined,
          } as ApiQuery;
       }
    }

package/src/mcp/tools/execute_query_tool.ts

@@ -121,8 +121,11 @@ export function registerExecuteQueryTool(
                   undefined,
                   query,
                );
+               const { validateRenderTags } = await import(
+                  "@malloydata/render-validator"
+               );
+               const renderLogs = validateRenderTags(result);
 
-               // --- Format Success Response (Duplicated for now, could refactor) ---
                const baseUriComponents = {
                   project: projectName,
                   package: packageName,
@@ -131,29 +134,43 @@ export function registerExecuteQueryTool(
                };
                const resultUri = buildMalloyUri(baseUriComponents, "result");
                const resultString = JSON.stringify(result, null, 2);
-               return {
-                  isError: false,
-                  content: [
-                     {
-                        type: "resource",
-                        resource: {
-                           type: "application/json",
-                           uri: resultUri,
-                           text: resultString,
-                        },
+
+               const content = [
+                  {
+                     type: "resource" as const,
+                     resource: {
+                        type: "application/json",
+                        uri: resultUri,
+                        text: resultString,
                      },
-                  ],
-               };
+                  },
+               ];
+
+               if (renderLogs.length > 0) {
+                  return {
+                     isError: false,
+                     content: [
+                        ...content,
+                        {
+                           type: "text" as const,
+                           text: `Render tag warnings:\n${JSON.stringify(renderLogs, null, 2)}`,
+                        },
+                     ],
+                  };
+               }
+
+               return { isError: false, content };
             } else if (queryName) {
-               // Otherwise, use sourceName/queryName in 1st/2nd args
                const { result } = await model.getQueryResults(
                   sourceName,
                   queryName,
                   undefined,
                );
+               const { validateRenderTags } = await import(
+                  "@malloydata/render-validator"
+               );
+               const renderLogs = validateRenderTags(result);
 
-               // --- Format Success Response ---
-               // Use the helper function to build valid URIs
                const baseUriComponents = {
                   project: projectName,
                   package: packageName,
@@ -161,22 +178,33 @@ export function registerExecuteQueryTool(
                   resourceName: modelPath,
                };
                const resultUri = buildMalloyUri(baseUriComponents, "result");
-
                const resultString = JSON.stringify(result, null, 2);
 
-               return {
-                  isError: false,
-                  content: [
-                     {
-                        type: "resource",
-                        resource: {
-                           type: "application/json",
-                           uri: resultUri,
-                           text: resultString,
-                        },
+               const content = [
+                  {
+                     type: "resource" as const,
+                     resource: {
+                        type: "application/json",
+                        uri: resultUri,
+                        text: resultString,
                      },
-                  ],
-               };
+                  },
+               ];
+
+               if (renderLogs.length > 0) {
+                  return {
+                     isError: false,
+                     content: [
+                        ...content,
+                        {
+                           type: "text" as const,
+                           text: `Render tag warnings:\n${JSON.stringify(renderLogs, null, 2)}`,
+                        },
+                     ],
+                  };
+               }
+
+               return { isError: false, content };
             }
 
             // If execution reaches this point, something has gone wrong with

package/src/server.ts

@@ -131,6 +131,9 @@ const compileController = new CompileController(projectStore);
 
 export const mcpApp = express();
 
+// Register health endpoints on mcpApp (for E2E tests)
+registerHealthEndpoints(mcpApp);
+
 mcpApp.use(MCP_ENDPOINT, express.json());
 mcpApp.use(MCP_ENDPOINT, cors());
 
@@ -253,7 +256,8 @@ app.use(
 );
 app.use(bodyParser.json());
 
-// Register health check endpoints
+// Register health check endpoints on main app:
+// - Required for production/Kubernetes monitoring (main server on PUBLISHER_PORT)
 registerHealthEndpoints(app);
 
 // Register Prometheus metrics endpoint

package/src/service/connection.spec.ts

@@ -975,6 +975,111 @@ describe("connection integration tests", () => {
       });
 
       describe("error handling", () => {
+         describe("DuckLake connection type", () => {
+            it(
+               "should create DuckLake connection",
+               async () => {
+                  if (!hasPostgresCredentials() || !hasS3Credentials()) {
+                     console.log(
+                        "Skipping: PostgreSQL and S3 credentials not configured",
+                     );
+                     return;
+                  }
+
+                  const { malloyConnections } = await createProjectConnections(
+                     [
+                        {
+                           name: "ducklake_test",
+                           type: "ducklake",
+                           ducklakeConnection: {
+                              catalog: {
+                                 postgresConnection: {
+                                    host: process.env.POSTGRES_TEST_HOST,
+                                    port: parseInt(
+                                       process.env.POSTGRES_TEST_PORT || "5432",
+                                    ),
+                                    userName: process.env.POSTGRES_TEST_USER!,
+                                    password:
+                                       process.env.POSTGRES_TEST_PASSWORD!,
+                                    databaseName:
+                                       process.env.POSTGRES_TEST_DATABASE,
+                                 },
+                              },
+                              storage: {
+                                 bucketUrl:
+                                    process.env.S3_TEST_BUCKET_URL ||
+                                    "s3://test-bucket",
+                                 s3Connection: {
+                                    accessKeyId:
+                                       process.env.S3_TEST_ACCESS_KEY_ID!,
+                                    secretAccessKey:
+                                       process.env.S3_TEST_SECRET_ACCESS_KEY!,
+                                 },
+                              },
+                           },
+                        },
+                     ],
+                     testProjectPath,
+                  );
+
+                  const connection = malloyConnections.get(
+                     "ducklake_test",
+                  ) as DuckDBConnection;
+                  createdConnections.push(connection);
+                  expect(connection).toBeDefined();
+
+                  // Verify DuckLake database is attached
+                  const databases = await connection.runSQL("SHOW DATABASES");
+                  const dbNames = databases.rows.map(
+                     (row) => Object.values(row)[0],
+                  );
+                  expect(dbNames).toContain("ducklake_test");
+               },
+               { timeout: 30000 },
+            );
+
+            it("should throw error if DuckLake catalog connection is missing", async () => {
+               await expect(
+                  createProjectConnections(
+                     [
+                        {
+                           name: "ducklake_no_catalog",
+                           type: "ducklake",
+                           ducklakeConnection: {
+                              storage: {
+                                 bucketUrl: "s3://test-bucket",
+                                 s3Connection: {
+                                    accessKeyId: "test",
+                                    secretAccessKey: "test",
+                                 },
+                              },
+                           },
+                        } as ApiConnection,
+                     ],
+                     testProjectPath,
+                  ),
+               ).rejects.toThrow(
+                  /PostgreSQL connection configuration is required/,
+               );
+            });
+
+            it("should throw error if DuckLake connection config is missing", async () => {
+               await expect(
+                  createProjectConnections(
+                     [
+                        {
+                           name: "ducklake_missing_config",
+                           type: "ducklake",
+                        },
+                     ],
+                     testProjectPath,
+                  ),
+               ).rejects.toThrow(
+                  /DuckLake connection configuration is missing/,
+               );
+            });
+         });
+
          it("should throw error if DuckDB connection name conflicts with attached database", async () => {
             await expect(
                createProjectConnections(