@malloy-publisher/server 0.0.137 → 0.0.138

package/dist/server.js

@@ -133002,6 +133002,18 @@ class ModelController {
     }
     return model.getNotebook();
   }
+  async executeNotebookCell(projectName, packageName, notebookPath, cellIndex) {
+    const project = await this.projectStore.getProject(projectName, false);
+    const p = await project.getPackage(packageName, false);
+    const model = p.getModel(notebookPath);
+    if (!model) {
+      throw new ModelNotFoundError(`${notebookPath} does not exist`);
+    }
+    if (model.getType() === "model") {
+      throw new ModelNotFoundError(`${notebookPath} is a model`);
+    }
+    return model.executeNotebookCell(cellIndex);
+  }
 }
 
 // src/controller/package.controller.ts
@@ -139036,7 +139048,14 @@ class Model {
       return new Model(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, runnableNotebookCells, undefined);
     } catch (error) {
       let computedError = error;
+      if (error instanceof Error && error.stack) {
+        console.error("Error stack", error.stack);
+      }
       if (error instanceof import_malloy2.MalloyError) {
+        const problems = error.problems;
+        for (const problem of problems) {
+          console.error("Problem", problem);
+        }
         computedError = new ModelCompilationError(error);
       }
       return new Model(packageName, modelPath, dataStyles, modelType, undefined, undefined, undefined, undefined, undefined, computedError);
@@ -139171,27 +139190,12 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     };
   }
   async getNotebookModel() {
-    const notebookCells = await Promise.all(this.runnableNotebookCells.map(async (cell) => {
-      let queryName = undefined;
-      let queryResult = undefined;
-      if (cell.runnable) {
-        try {
-          const rowLimit = (await cell.runnable.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
-          const result = await cell.runnable.run({ rowLimit });
-          const query = (await cell.runnable.getPreparedQuery())._query;
-          queryName = query.as || query.name;
-          queryResult = result?._queryResult && this.modelInfo && JSON.stringify(import_malloy2.API.util.wrapResult(result));
-        } catch {
-        }
-      }
+    const notebookCells = this.runnableNotebookCells.map((cell) => {
       return {
         type: cell.type,
-        text: cell.text,
-        queryName,
-        result: queryResult,
-        newSources: cell.newSources?.map((source) => JSON.stringify(source))
+        text: cell.text
       };
-    }));
+    });
     return {
       type: "notebook",
       packageName: this.packageName,
@@ -139203,6 +139207,57 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
       notebookCells
     };
   }
+  async executeNotebookCell(cellIndex) {
+    if (this.compilationError) {
+      throw this.compilationError;
+    }
+    if (!this.runnableNotebookCells) {
+      throw new BadRequestError("No notebook cells available");
+    }
+    if (cellIndex < 0 || cellIndex >= this.runnableNotebookCells.length) {
+      throw new BadRequestError(`Cell index ${cellIndex} out of range (0-${this.runnableNotebookCells.length - 1})`);
+    }
+    const cell = this.runnableNotebookCells[cellIndex];
+    if (cell.type === "markdown") {
+      return {
+        type: cell.type,
+        text: cell.text
+      };
+    }
+    let queryName = undefined;
+    let queryResult = undefined;
+    if (cell.runnable) {
+      try {
+        const rowLimit = (await cell.runnable.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
+        const result = await cell.runnable.run({ rowLimit });
+        const query = (await cell.runnable.getPreparedQuery())._query;
+        queryName = query.as || query.name;
+        queryResult = result?._queryResult && this.modelInfo && JSON.stringify(import_malloy2.API.util.wrapResult(result));
+      } catch (error) {
+        if (error instanceof import_malloy2.MalloyError) {
+          throw error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.trim() === "Model has no queries.") {
+          return {
+            type: "code",
+            text: cell.text
+          };
+        } else {
+          console.log("Error message: ", errorMessage);
+        }
+        console.log("Cell content: ", cellIndex, cell.type, cell.text);
+        throw new BadRequestError(`Cell execution failed: ${errorMessage}`);
+      }
+    }
+    return {
+      type: cell.type,
+      text: cell.text,
+      queryName,
+      result: queryResult,
+      newSources: cell.newSources?.map((source) => JSON.stringify(source))
+    };
+  }
   static async getModelRuntime(packagePath, modelPath, connections) {
     const fullModelPath = path4.join(packagePath, modelPath);
     try {
@@ -144712,8 +144767,8 @@ app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/models/*?`,
     return;
   }
   try {
-    const zero = 0;
-    res.status(200).json(await modelController.getModel(req.params.projectName, req.params.packageName, req.params[zero]));
+    const modelPath = req.params["0"];
+    res.status(200).json(await modelController.getModel(req.params.projectName, req.params.packageName, modelPath));
   } catch (error) {
     logger2.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);
@@ -144733,14 +144788,35 @@ app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/notebooks`,
     res.status(status).json(json2);
   }
 });
+app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/notebooks/*/cells/:cellIndex`, async (req, res) => {
+  if (req.query.versionId) {
+    setVersionIdError(res);
+    return;
+  }
+  try {
+    const cellIndex = parseInt(req.params.cellIndex, 10);
+    if (isNaN(cellIndex)) {
+      res.status(400).json({
+        error: "Invalid cell index"
+      });
+      return;
+    }
+    const notebookPath = req.params["0"];
+    res.status(200).json(await modelController.executeNotebookCell(req.params.projectName, req.params.packageName, notebookPath, cellIndex));
+  } catch (error) {
+    logger2.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
 app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/notebooks/*?`, async (req, res) => {
   if (req.query.versionId) {
     setVersionIdError(res);
     return;
   }
   try {
-    const zero = 0;
-    res.status(200).json(await modelController.getNotebook(req.params.projectName, req.params.packageName, req.params[zero]));
+    const notebookPath = req.params["0"];
+    res.status(200).json(await modelController.getNotebook(req.params.projectName, req.params.packageName, notebookPath));
   } catch (error) {
     logger2.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);
@@ -144753,8 +144829,8 @@ app.post(`${API_PREFIX2}/projects/:projectName/packages/:packageName/models/*?/q
     return;
   }
   try {
-    const zero = 0;
-    res.status(200).json(await queryController.getQuery(req.params.projectName, req.params.packageName, req.params[zero], req.body.sourceName, req.body.queryName, req.body.query));
+    const modelPath = req.params["0"];
+    res.status(200).json(await queryController.getQuery(req.params.projectName, req.params.packageName, modelPath, req.body.sourceName, req.body.queryName, req.body.query));
   } catch (error) {
     logger2.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);

package/package.json

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

package/src/controller/model.controller.ts

@@ -5,7 +5,7 @@ import { ProjectStore } from "../service/project_store";
 type ApiNotebook = components["schemas"]["Notebook"];
 type ApiModel = components["schemas"]["Model"];
 type ApiCompiledModel = components["schemas"]["CompiledModel"];
-type ApiCompiledNotebook = components["schemas"]["CompiledNotebook"];
+type ApiRawNotebook = components["schemas"]["RawNotebook"];
 export type ListModelsFilterEnum =
    components["parameters"]["ListModelsFilterEnum"];
 export class ModelController {
@@ -54,7 +54,7 @@ export class ModelController {
       projectName: string,
       packageName: string,
       notebookPath: string,
-   ): Promise<ApiCompiledNotebook> {
+   ): Promise<ApiRawNotebook> {
       const project = await this.projectStore.getProject(projectName, false);
       const p = await project.getPackage(packageName, false);
       const model = p.getModel(notebookPath);
@@ -67,4 +67,29 @@ export class ModelController {
 
       return model.getNotebook();
    }
+
+   public async executeNotebookCell(
+      projectName: string,
+      packageName: string,
+      notebookPath: string,
+      cellIndex: number,
+   ): Promise<{
+      type: "code" | "markdown";
+      text: string;
+      queryName?: string;
+      result?: string;
+      newSources?: string[];
+   }> {
+      const project = await this.projectStore.getProject(projectName, false);
+      const p = await project.getPackage(packageName, false);
+      const model = p.getModel(notebookPath);
+      if (!model) {
+         throw new ModelNotFoundError(`${notebookPath} does not exist`);
+      }
+      if (model.getType() === "model") {
+         throw new ModelNotFoundError(`${notebookPath} is a model`);
+      }
+
+      return model.executeNotebookCell(cellIndex);
+   }
 }

package/src/mcp/resources/notebook_resource.ts

@@ -82,9 +82,9 @@ export function registerNotebookResource(
                      throw new McpGetResourceError(errorDetails);
                   }
 
-                  // Now try to compile/get the actual notebook content
-                  const notebookContent: components["schemas"]["CompiledNotebook"] =
-                     await modelInstance.getNotebook(); // This can throw ModelCompilationError
+                  // Now try to get the actual notebook content
+                  const notebookContent: components["schemas"]["RawNotebook"] =
+                     await modelInstance.getNotebook();
                   return notebookContent;
                } catch (error) {
                   if (error instanceof McpGetResourceError) {

package/src/server.ts

@@ -653,12 +653,13 @@ app.get(
       }
 
       try {
-         const zero = 0 as unknown;
+         // Express stores wildcard matches in params['0']
+         const modelPath = (req.params as Record<string, string>)["0"];
          res.status(200).json(
             await modelController.getModel(
                req.params.projectName,
                req.params.packageName,
-               req.params[zero as keyof typeof req.params],
+               modelPath,
             ),
          );
       } catch (error) {
@@ -692,6 +693,44 @@ app.get(
    },
 );
 
+// Execute notebook cell route must come BEFORE the general get notebook route
+// to avoid the wildcard matching incorrectly
+app.get(
+   `${API_PREFIX}/projects/:projectName/packages/:packageName/notebooks/*/cells/:cellIndex`,
+   async (req, res) => {
+      if (req.query.versionId) {
+         setVersionIdError(res);
+         return;
+      }
+
+      try {
+         const cellIndex = parseInt(req.params.cellIndex, 10);
+         if (isNaN(cellIndex)) {
+            res.status(400).json({
+               error: "Invalid cell index",
+            });
+            return;
+         }
+
+         // Express stores wildcard matches in params['0']
+         const notebookPath = (req.params as Record<string, string>)["0"];
+
+         res.status(200).json(
+            await modelController.executeNotebookCell(
+               req.params.projectName,
+               req.params.packageName,
+               notebookPath,
+               cellIndex,
+            ),
+         );
+      } 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/notebooks/*?`,
    async (req, res) => {
@@ -701,12 +740,13 @@ app.get(
       }
 
       try {
-         const zero = 0 as unknown;
+         // Express stores wildcard matches in params['0']
+         const notebookPath = (req.params as Record<string, string>)["0"];
          res.status(200).json(
             await modelController.getNotebook(
                req.params.projectName,
                req.params.packageName,
-               req.params[zero as keyof typeof req.params],
+               notebookPath,
             ),
          );
       } catch (error) {
@@ -726,12 +766,13 @@ app.post(
       }
 
       try {
-         const zero = 0 as unknown;
+         // Express stores wildcard matches in params['0']
+         const modelPath = (req.params as Record<string, string>)["0"];
          res.status(200).json(
             await queryController.getQuery(
                req.params.projectName,
                req.params.packageName,
-               req.params[zero as keyof typeof req.params],
+               modelPath,
                req.body.sourceName as string,
                req.body.queryName as string,
                req.body.query as string,

package/src/service/model.ts

@@ -41,7 +41,7 @@ import { URL_READER } from "../utils";
 
 type ApiCompiledModel = components["schemas"]["CompiledModel"];
 type ApiNotebookCell = components["schemas"]["NotebookCell"];
-type ApiCompiledNotebook = components["schemas"]["CompiledNotebook"];
+type ApiRawNotebook = components["schemas"]["RawNotebook"];
 // @ts-expect-error TODO: Fix missing Source type in API
 type ApiSource = components["schemas"]["Source"];
 type ApiView = components["schemas"]["View"];
@@ -155,7 +155,15 @@ export class Model {
          );
       } catch (error) {
          let computedError = error;
+         if (error instanceof Error && error.stack) {
+            console.error("Error stack", error.stack);
+         }
+
          if (error instanceof MalloyError) {
+            const problems = error.problems;
+            for (const problem of problems) {
+               console.error("Problem", problem);
+            }
             computedError = new ModelCompilationError(error);
          }
          return new Model(
@@ -215,7 +223,7 @@ export class Model {
       return this.compilationError;
    }
 
-   public async getNotebook(): Promise<ApiCompiledNotebook> {
+   public async getNotebook(): Promise<ApiRawNotebook> {
       if (this.compilationError) {
          throw this.compilationError;
       }
@@ -341,42 +349,16 @@ export class Model {
       } as ApiCompiledModel;
    }
 
-   private async getNotebookModel(): Promise<ApiCompiledNotebook> {
-      const notebookCells: ApiNotebookCell[] = await Promise.all(
-         (this.runnableNotebookCells as RunnableNotebookCell[]).map(
-            async (cell) => {
-               let queryName: string | undefined = undefined;
-               let queryResult: string | undefined = undefined;
-               if (cell.runnable) {
-                  try {
-                     const rowLimit =
-                        (await cell.runnable.getPreparedResult()).resultExplore
-                           .limit || ROW_LIMIT;
-                     const result = await cell.runnable.run({ rowLimit });
-                     const query = (await cell.runnable.getPreparedQuery())
-                        ._query;
-                     queryName = (query as NamedQuery).as || query.name;
-                     queryResult =
-                        result?._queryResult &&
-                        this.modelInfo &&
-                        JSON.stringify(API.util.wrapResult(result));
-                  } catch {
-                     // Catch block intentionally left empty as per previous logic review.
-                     // Error handling for specific cases might be added here if needed.
-                  }
-               }
-               return {
-                  type: cell.type,
-                  text: cell.text,
-                  queryName: queryName,
-                  result: queryResult,
-                  newSources: cell.newSources?.map((source) =>
-                     JSON.stringify(source),
-                  ),
-               } as ApiNotebookCell;
-            },
-         ),
-      );
+   private async getNotebookModel(): Promise<ApiRawNotebook> {
+      // Return raw cell contents without executing them
+      const notebookCells: ApiNotebookCell[] = (
+         this.runnableNotebookCells as RunnableNotebookCell[]
+      ).map((cell) => {
+         return {
+            type: cell.type,
+            text: cell.text,
+         } as ApiNotebookCell;
+      });
 
       return {
          type: "notebook",
@@ -389,7 +371,82 @@ export class Model {
          sources: this.modelDef && this.sources,
          queries: this.modelDef && this.queries,
          notebookCells,
-      } as ApiCompiledModel;
+      } as ApiRawNotebook;
+   }
+
+   public async executeNotebookCell(cellIndex: number): Promise<{
+      type: "code" | "markdown";
+      text: string;
+      queryName?: string;
+      result?: string;
+      newSources?: string[];
+   }> {
+      if (this.compilationError) {
+         throw this.compilationError;
+      }
+
+      if (!this.runnableNotebookCells) {
+         throw new BadRequestError("No notebook cells available");
+      }
+
+      if (cellIndex < 0 || cellIndex >= this.runnableNotebookCells.length) {
+         throw new BadRequestError(
+            `Cell index ${cellIndex} out of range (0-${this.runnableNotebookCells.length - 1})`,
+         );
+      }
+
+      const cell = this.runnableNotebookCells[cellIndex];
+
+      if (cell.type === "markdown") {
+         return {
+            type: cell.type,
+            text: cell.text,
+         };
+      }
+
+      // For code cells, execute the runnable if available
+      let queryName: string | undefined = undefined;
+      let queryResult: string | undefined = undefined;
+
+      if (cell.runnable) {
+         try {
+            const rowLimit =
+               (await cell.runnable.getPreparedResult()).resultExplore.limit ||
+               ROW_LIMIT;
+            const result = await cell.runnable.run({ rowLimit });
+            const query = (await cell.runnable.getPreparedQuery())._query;
+            queryName = (query as NamedQuery).as || query.name;
+            queryResult =
+               result?._queryResult &&
+               this.modelInfo &&
+               JSON.stringify(API.util.wrapResult(result));
+         } catch (error) {
+            // Re-throw execution errors so the client knows about them
+            if (error instanceof MalloyError) {
+               throw error;
+            }
+            const errorMessage =
+               error instanceof Error ? error.message : String(error);
+            if (errorMessage.trim() === "Model has no queries.") {
+               return {
+                  type: "code",
+                  text: cell.text,
+               };
+            } else {
+               console.log("Error message: ", errorMessage);
+            }
+            console.log("Cell content: ", cellIndex, cell.type, cell.text);
+            throw new BadRequestError(`Cell execution failed: ${errorMessage}`);
+         }
+      }
+
+      return {
+         type: cell.type,
+         text: cell.text,
+         queryName: queryName,
+         result: queryResult,
+         newSources: cell.newSources?.map((source) => JSON.stringify(source)),
+      };
    }
 
    static async getModelRuntime(