@malloy-publisher/server 0.0.119 → 0.0.121

package/k6-tests/common.ts

@@ -1,5 +1,5 @@
-import http from "k6/http";
 import { check } from "k6";
+import http from "k6/http";
 
 type ApiPackage = {
    name: string;
@@ -137,7 +137,16 @@ export const queryModelView = (
    const encodedModelPath = encodeURIComponent(modelPath);
    const encodedSourceName = encodeURIComponent(sourceName);
    const encodedQueryName = encodeURIComponent(queryName);
-   return http.get(
-      `${PUBLISHER_URL}/api/v0/projects/home/packages/${encodedPackageName}/queryResults/${encodedModelPath}?sourceName=${encodedSourceName}&queryName=${encodedQueryName}`,
+   return http.post(
+      `${PUBLISHER_URL}/api/v0/projects/home/packages/${encodedPackageName}/models/${encodedModelPath}/query`,
+      JSON.stringify({
+         sourceName: sourceName,
+         queryName: queryName,
+      }),
+      {
+         headers: {
+            "Content-Type": "application/json",
+         },
+      },
    );
 };

package/package.json

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

package/src/controller/connection.controller.ts

@@ -1,25 +1,23 @@
-import {
-   RunSQLOptions,
-   TableSourceDef,
-   TestableConnection,
-} from "@malloydata/malloy";
-import { Connection, PersistSQLResults } from "@malloydata/malloy/connection";
+import { Connection, RunSQLOptions } from "@malloydata/malloy";
+import { PersistSQLResults } from "@malloydata/malloy/connection";
+import { components } from "../api";
 import { BadRequestError, ConnectionError } from "../errors";
 import { logger } from "../logger";
-import { components } from "../api";
+import { testConnectionConfig } from "../service/connection";
 import {
+   getConnectionTableSource,
    getSchemasForConnection,
    getTablesForSchema,
 } from "../service/db_utils";
 import { ProjectStore } from "../service/project_store";
-import { testConnectionConfig } from "../service/connection";
 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"];
-type ApiSchemaName = components["schemas"]["SchemaName"];
+type ApiSchema = components["schemas"]["Schema"];
 export class ConnectionController {
    private projectStore: ProjectStore;
 
@@ -27,6 +25,37 @@ export class ConnectionController {
       this.projectStore = projectStore;
    }
 
+   /**
+    * Gets the appropriate Malloy connection for a given connection name.
+    * For DuckDB connections, retrieves from package level; for others, from project level.
+    */
+   private async getMalloyConnection(
+      projectName: string,
+      connectionName: string,
+   ): Promise<Connection> {
+      const project = await this.projectStore.getProject(projectName, false);
+      const connection = project.getApiConnection(connectionName);
+
+      // For DuckDB connections, get the connection from a package
+      if (connection.type === "duckdb") {
+         const packages = await project.listPackages();
+         if (packages.length === 0) {
+            throw new ConnectionError(
+               "No packages found for DuckDB connection",
+            );
+         }
+         // For now, use the first package's DuckDB connection
+         const packageName = packages[0].name;
+         if (!packageName) {
+            throw new ConnectionError("Package name is undefined");
+         }
+         const pkg = await project.getPackage(packageName);
+         return pkg.getMalloyConnection(connectionName);
+      } else {
+         return project.getMalloyConnection(connectionName);
+      }
+   }
+
    public async getConnection(
       projectName: string,
       connectionName: string,
@@ -44,10 +73,15 @@ export class ConnectionController {
    public async listSchemas(
       projectName: string,
       connectionName: string,
-   ): Promise<ApiSchemaName[]> {
+   ): Promise<ApiSchema[]> {
       const project = await this.projectStore.getProject(projectName, false);
       const connection = project.getApiConnection(connectionName);
-      return getSchemasForConnection(connection);
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
+         connectionName,
+      );
+
+      return getSchemasForConnection(connection, malloyConnection);
    }
 
    // Lists tables available in a schema. For postgres the schema is usually "public"
@@ -55,35 +89,15 @@ export class ConnectionController {
       projectName: string,
       connectionName: string,
       schemaName: string,
-   ): Promise<string[]> {
+   ): Promise<ApiTable[]> {
       const project = await this.projectStore.getProject(projectName, false);
       const connection = project.getApiConnection(connectionName);
-      return getTablesForSchema(connection, schemaName);
-   }
-
-   public async testConnection(
-      projectName: string,
-      connectionName: string,
-   ): Promise<ApiConnectionStatus> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const connection = project.getMalloyConnection(
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
          connectionName,
-      ) as Connection;
-      try {
-         await (connection as TestableConnection).test();
-         return {
-            status: "ok",
-            errorMessage: "",
-         };
-      } catch (error) {
-         if (error instanceof ConnectionError) {
-            return {
-               status: "failed",
-               errorMessage: error.message,
-            };
-         }
-         throw error;
-      }
+      );
+
+      return getTablesForSchema(connection, schemaName, malloyConnection);
    }
 
    public async getConnectionSqlSource(
@@ -91,12 +105,22 @@ export class ConnectionController {
       connectionName: string,
       sqlStatement: string,
    ): Promise<ApiSqlSource> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const connection = project.getMalloyConnection(connectionName);
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
+         connectionName,
+      );
+
       try {
          return {
             source: JSON.stringify(
-               await connection.fetchSelectSchema({
+               await (
+                  malloyConnection as Connection & {
+                     fetchSelectSchema: (params: {
+                        connection: string;
+                        selectStr: string;
+                     }) => Promise<unknown>;
+                  }
+               ).fetchSelectSchema({
                   connection: connectionName,
                   selectStr: sqlStatement,
                }),
@@ -113,29 +137,12 @@ export class ConnectionController {
       tableKey: string,
       tablePath: string,
    ): Promise<ApiTableSource> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const connection = project.getMalloyConnection(connectionName);
-      try {
-         const source = await connection.fetchTableSchema(tableKey, tablePath);
-         if (source === undefined) {
-            throw new ConnectionError(`Table ${tablePath} not found`);
-         }
-         const malloyFields = (source as TableSourceDef).fields;
-         const fields = malloyFields.map((field) => {
-            return {
-               name: field.name,
-               type: field.type,
-            };
-         });
-         return {
-            source: JSON.stringify(source),
-            resource: tablePath,
-            columns: fields,
-         };
-      } catch (error) {
-         logger.error("error", { error });
-         throw new ConnectionError((error as Error).message);
-      }
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
+         connectionName,
+      );
+
+      return getConnectionTableSource(malloyConnection, tableKey, tablePath);
    }
 
    public async getConnectionQueryData(
@@ -144,8 +151,11 @@ export class ConnectionController {
       sqlStatement: string,
       options: string,
    ): Promise<ApiQueryData> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const connection = project.getMalloyConnection(connectionName);
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
+         connectionName,
+      );
+
       let runSQLOptions: RunSQLOptions = {};
       if (options) {
          runSQLOptions = JSON.parse(options) as RunSQLOptions;
@@ -159,7 +169,7 @@ export class ConnectionController {
       try {
          return {
             data: JSON.stringify(
-               await connection.runSQL(sqlStatement, runSQLOptions),
+               await malloyConnection.runSQL(sqlStatement, runSQLOptions),
             ),
          };
       } catch (error) {
@@ -172,17 +182,17 @@ export class ConnectionController {
       connectionName: string,
       sqlStatement: string,
    ): Promise<ApiTemporaryTable> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const connection = project.getMalloyConnection(
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
          connectionName,
-      ) as Connection;
+      );
 
       try {
          return {
             table: JSON.stringify(
-               await (connection as PersistSQLResults).manifestTemporaryTable(
-                  sqlStatement,
-               ),
+               await (
+                  malloyConnection as PersistSQLResults
+               ).manifestTemporaryTable(sqlStatement),
             ),
          };
       } catch (error) {

package/src/controller/query.controller.ts

@@ -34,7 +34,7 @@ export class QueryController {
          );
          return {
             result: JSON.stringify(result),
-            resource: `${API_PREFIX}/projects/${projectName}/packages/${packageName}/queryResults/${modelPath}`,
+            resource: `${API_PREFIX}/projects/${projectName}/packages/${packageName}/models/${modelPath}/query`,
          } as ApiQuery;
       }
    }

package/src/server.ts

@@ -11,7 +11,6 @@ import { DatabaseController } from "./controller/database.controller";
 import { ModelController } from "./controller/model.controller";
 import { PackageController } from "./controller/package.controller";
 import { QueryController } from "./controller/query.controller";
-import { ScheduleController } from "./controller/schedule.controller";
 import { WatchModeController } from "./controller/watch-mode.controller";
 import { internalErrorToHttpError, NotImplementedError } from "./errors";
 import { logger, loggerMiddleware } from "./logger";
@@ -89,7 +88,6 @@ const modelController = new ModelController(projectStore);
 const packageController = new PackageController(projectStore);
 const databaseController = new DatabaseController(projectStore);
 const queryController = new QueryController(projectStore);
-const scheduleController = new ScheduleController(projectStore);
 
 export const mcpApp = express();
 
@@ -327,23 +325,6 @@ app.post(`${API_PREFIX}/connections/test`, async (req, res) => {
    }
 });
 
-app.get(
-   `${API_PREFIX}/projects/:projectName/connections/:connectionName/test`,
-   async (req, res) => {
-      try {
-         const connectionStatus = await connectionController.testConnection(
-            req.params.projectName,
-            req.params.connectionName,
-         );
-         res.status(200).json(connectionStatus);
-      } catch (error) {
-         logger.error(error);
-         const { json, status } = internalErrorToHttpError(error as Error);
-         res.status(status).json(json);
-      }
-   },
-);
-
 app.get(
    `${API_PREFIX}/projects/:projectName/connections/:connectionName/schemas`,
    async (req, res) => {
@@ -715,10 +696,10 @@ app.get(
    },
 );
 
-app.get(
-   `${API_PREFIX}/projects/:projectName/packages/:packageName/queryResults/*?`,
+app.post(
+   `${API_PREFIX}/projects/:projectName/packages/:packageName/models/*?/query`,
    async (req, res) => {
-      if (req.query.versionId) {
+      if (req.body.versionId) {
          setVersionIdError(res);
          return;
       }
@@ -730,32 +711,9 @@ app.get(
                req.params.projectName,
                req.params.packageName,
                req.params[zero as keyof typeof req.params],
-               req.query.sourceName as string,
-               req.query.queryName as string,
-               req.query.query as string,
-            ),
-         );
-      } catch (error) {
-         logger.error(error);
-         const { json, status } = internalErrorToHttpError(error as Error);
-         res.status(status).json(json);
-      }
-   },
-);
-
-app.get(
-   `${API_PREFIX}/projects/:projectName/packages/:packageName/schedules`,
-   async (req, res) => {
-      if (req.query.versionId) {
-         setVersionIdError(res);
-         return;
-      }
-
-      try {
-         res.status(200).json(
-            await scheduleController.listSchedules(
-               req.params.projectName,
-               req.params.packageName,
+               req.body.sourceName as string,
+               req.body.queryName as string,
+               req.body.query as string,
             ),
          );
       } catch (error) {