@malloy-publisher/server 0.0.175 → 0.0.177

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.175",
+   "version": "0.0.177",
    "main": "dist/server.js",
    "bin": {
       "malloy-publisher": "dist/server.js"

package/src/controller/connection.controller.ts

@@ -1,4 +1,4 @@
-import { Connection, RunSQLOptions } from "@malloydata/malloy";
+import { Connection, RunSQLOptions, TableSourceDef } from "@malloydata/malloy";
 import { PersistSQLResults } from "@malloydata/malloy/connection";
 import { components } from "../api";
 import { BadRequestError, ConnectionError } from "../errors";
@@ -6,16 +6,14 @@ import { logger } from "../logger";
 import { testConnectionConfig } from "../service/connection";
 import { ConnectionService } from "../service/connection_service";
 import {
-   getConnectionTableSource,
    getSchemasForConnection,
-   getTablesForSchema,
+   listTablesForSchema,
 } from "../service/db_utils";
 import { ProjectStore } from "../service/project_store";
 
 type ApiConnection = components["schemas"]["Connection"];
 type ApiConnectionStatus = components["schemas"]["ConnectionStatus"];
 type ApiSqlSource = components["schemas"]["SqlSource"];
-type ApiTableSource = components["schemas"]["TableSource"];
 type ApiTable = components["schemas"]["Table"];
 type ApiQueryData = components["schemas"]["QueryData"];
 type ApiTemporaryTable = components["schemas"]["TemporaryTable"];
@@ -29,28 +27,6 @@ const AZURE_DATA_EXTENSIONS = [
    ".ndjson",
 ];
 
-/**
- * `fetchTableSchema` query param: default true when omitted, null, or empty.
- * Only explicit false/0 disables schema fetch.
- */
-export function parseFetchTableSchemaQueryParam(raw: unknown): boolean {
-   if (raw === undefined || raw === null) {
-      return true;
-   }
-   const v = Array.isArray(raw) ? raw[0] : raw;
-   if (v === "" || v === undefined) {
-      return true;
-   }
-   if (typeof v === "boolean") {
-      return v;
-   }
-   const s = String(v).trim().toLowerCase();
-   if (s === "false" || s === "0") {
-      return false;
-   }
-   return true;
-}
-
 /**
  * Validates an Azure URL against the three supported patterns:
  *   1. Single file:         path/file.parquet
@@ -144,6 +120,52 @@ export class ConnectionController {
       }
    }
 
+   /**
+    * Fetches a table's schema via the Malloy connection's fetchTableSchema,
+    * returning an ApiTable with columns and the raw source JSON.
+    */
+   private async fetchTable(
+      malloyConnection: Connection,
+      tableKey: string,
+      tablePath: string,
+   ): Promise<ApiTable> {
+      try {
+         const source = await (
+            malloyConnection as Connection & {
+               fetchTableSchema: (
+                  tableKey: string,
+                  tablePath: string,
+               ) => Promise<TableSourceDef | undefined>;
+            }
+         ).fetchTableSchema(tableKey, tablePath);
+         if (!source) {
+            throw new ConnectionError(`Table ${tablePath} not found`);
+         }
+
+         return {
+            source: JSON.stringify(source),
+            resource: tablePath,
+            columns: (source.fields || []).map((f) => ({
+               name: f.name,
+               type: f.type,
+            })),
+         };
+      } catch (error) {
+         const errorMessage =
+            error instanceof Error
+               ? error.message
+               : typeof error === "string"
+                 ? error
+                 : JSON.stringify(error);
+         logger.error("fetchTableSchema error", {
+            error,
+            tableKey,
+            tablePath,
+         });
+         throw new ConnectionError(errorMessage);
+      }
+   }
+
    public async getConnection(
       projectName: string,
       connectionName: string,
@@ -183,7 +205,7 @@ export class ConnectionController {
       projectName: string,
       connectionName: string,
       schemaName: string,
-      fetchTableSchema = true,
+      tableNames?: string[],
    ): Promise<ApiTable[]> {
       const project = await this.projectStore.getProject(projectName, false);
       const connection = project.getApiConnection(connectionName);
@@ -192,11 +214,11 @@ export class ConnectionController {
          connectionName,
       );
 
-      return getTablesForSchema(
+      return listTablesForSchema(
          connection,
          schemaName,
          malloyConnection,
-         fetchTableSchema,
+         tableNames,
       );
    }
 
@@ -231,20 +253,6 @@ export class ConnectionController {
       }
    }
 
-   public async getConnectionTableSource(
-      projectName: string,
-      connectionName: string,
-      tableKey: string,
-      tablePath: string,
-   ): Promise<ApiTableSource> {
-      const malloyConnection = await this.getMalloyConnection(
-         projectName,
-         connectionName,
-      );
-
-      return getConnectionTableSource(malloyConnection, tableKey, tablePath);
-   }
-
    public async getTable(
       projectName: string,
       connectionName: string,
@@ -259,6 +267,8 @@ export class ConnectionController {
       const project = await this.projectStore.getProject(projectName, false);
       const connection = project.getApiConnection(connectionName);
 
+      // TODO: Move this database connection logic to the db_utils.ts file -- and
+      // ultimately into a connection-specific class.
       if (connection.type === "ducklake") {
          if (tablePath.split(".").length === 1) {
             // tablePath is just the table name, construct full path
@@ -306,16 +316,12 @@ export class ConnectionController {
                );
                const fullFileUrl = `${dirPath}${fileName}${queryString}`;
 
-               const tableSource = await getConnectionTableSource(
+               const table = await this.fetchTable(
                   malloyConnection,
                   fileName,
                   fullFileUrl,
                );
-               return {
-                  resource: tablePath,
-                  columns: tableSource.columns,
-                  source: tableSource.source,
-               };
+               return { ...table, resource: tablePath };
             }
          }
       }
@@ -325,17 +331,7 @@ export class ConnectionController {
          throw new Error(`Invalid tablePath: ${tablePath}`);
       }
 
-      const tableSource = await getConnectionTableSource(
-         malloyConnection,
-         tableKey, // tableKey is the table name
-         tablePath,
-      );
-
-      return {
-         resource: tablePath,
-         columns: tableSource.columns,
-         source: tableSource.source,
-      };
+      return this.fetchTable(malloyConnection, tableKey, tablePath);
    }
 
    public async getConnectionQueryData(

package/src/server.ts

@@ -14,10 +14,7 @@ import { createProxyMiddleware } from "http-proxy-middleware";
 import { AddressInfo } from "net";
 import * as path from "path";
 import { CompileController } from "./controller/compile.controller";
-import {
-   ConnectionController,
-   parseFetchTableSchemaQueryParam,
-} from "./controller/connection.controller";
+import { ConnectionController } from "./controller/connection.controller";
 import { DatabaseController } from "./controller/database.controller";
 import { ModelController } from "./controller/model.controller";
 import { PackageController } from "./controller/package.controller";
@@ -33,6 +30,14 @@ import { logger, loggerMiddleware } from "./logger";
 
 import { initializeMcpServer } from "./mcp/server";
 import { ProjectStore } from "./service/project_store";
+
+/** Normalize an Express query param into a string[] or undefined. */
+export function normalizeQueryArray(value: unknown): string[] | undefined {
+   if (value === undefined || value === null) return undefined;
+   if (Array.isArray(value)) return value.map(String);
+   return [String(value)];
+}
+
 // Parse command line arguments
 function parseArgs() {
    const args = process.argv.slice(2);
@@ -470,7 +475,7 @@ app.get(
             req.params.projectName,
             req.params.connectionName,
             req.params.schemaName,
-            parseFetchTableSchemaQueryParam(req.query.fetchTableSchema),
+            normalizeQueryArray(req.query.tableNames),
          );
          res.status(200).json(results);
       } catch (error) {
@@ -542,26 +547,6 @@ app.post(
    },
 );
 
-app.get(
-   `${API_PREFIX}/projects/:projectName/connections/:connectionName/tableSource`,
-   async (req, res) => {
-      try {
-         res.status(200).json(
-            await connectionController.getConnectionTableSource(
-               req.params.projectName,
-               req.params.connectionName,
-               req.query.tableKey as string,
-               req.query.tablePath as string,
-            ),
-         );
-      } catch (error) {
-         logger.error(error);
-         const { json, status } = internalErrorToHttpError(error as Error);
-         res.status(status).json(json);
-      }
-   },
-);
-
 /**
  * @deprecated Use /projects/:projectName/connections/:connectionName/queryData POST method instead
  */