@malloy-publisher/server 0.0.137 → 0.0.139

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,25 @@ 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) => {
+      console.log("cell.queryInfo", cell.queryInfo);
       return {
         type: cell.type,
         text: cell.text,
-        queryName,
-        result: queryResult,
-        newSources: cell.newSources?.map((source) => JSON.stringify(source))
+        newSources: cell.newSources?.map((source) => JSON.stringify(source)),
+        queryInfo: cell.queryInfo ? JSON.stringify(cell.queryInfo) : undefined
       };
-    }));
+    });
+    const allAnnotations = [];
+    if (this.modelDef) {
+      let currentAnnotation = this.modelDef.annotation;
+      while (currentAnnotation) {
+        if (currentAnnotation.notes) {
+          allAnnotations.push(...currentAnnotation.notes.map((note) => note.text));
+        }
+        currentAnnotation = currentAnnotation.inherits;
+      }
+    }
     return {
       type: "notebook",
       packageName: this.packageName,
@@ -139200,9 +139217,61 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
       modelInfo: JSON.stringify(this.modelDef ? import_malloy2.modelDefToModelInfo(this.modelDef) : {}),
       sources: this.modelDef && this.sources,
       queries: this.modelDef && this.queries,
+      annotations: allAnnotations,
       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 {
@@ -139324,11 +139393,30 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
           oldSources[source.name] = source;
         }
         const runnable = localMM.loadFinalQuery();
+        let queryInfo = undefined;
+        try {
+          const preparedQuery = await runnable.getPreparedQuery();
+          const query = preparedQuery._query;
+          const queryName = query.as || query.name;
+          const anonymousQuery = currentModelInfo.anonymous_queries[currentModelInfo.anonymous_queries.length - 1];
+          if (anonymousQuery) {
+            queryInfo = {
+              name: queryName,
+              schema: anonymousQuery.schema,
+              annotations: anonymousQuery.annotations,
+              definition: anonymousQuery.definition,
+              code: anonymousQuery.code,
+              location: anonymousQuery.location
+            };
+          }
+        } catch (_error) {
+        }
         return {
           type: "code",
           text: stmt.text,
           runnable,
-          newSources
+          newSources,
+          queryInfo
         };
       } else if (stmt.type === import_malloy_sql.MalloySQLStatementType.MARKDOWN) {
         return {
@@ -144712,8 +144800,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 +144821,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 +144862,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);
@@ -144782,7 +144891,7 @@ app.use((err, _req, res, _next) => {
   const { json: json2, status } = internalErrorToHttpError(err);
   res.status(status).json(json2);
 });
-var mainServer = http2.createServer(app);
+var mainServer = http2.createServer({ maxHeaderSize: 262144 }, app);
 mainServer.timeout = 600000;
 mainServer.keepAliveTimeout = 600000;
 mainServer.headersTimeout = 600000;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@malloy-publisher/server",
   "description": "Malloy Publisher Server",
-  "version": "0.0.137",
+  "version": "0.0.139",
   "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,
@@ -786,7 +827,7 @@ app.use(
    },
 );
 
-const mainServer = http.createServer(app);
+const mainServer = http.createServer({ maxHeaderSize: 262144 }, app);
 
 mainServer.timeout = 600000;
 mainServer.keepAliveTimeout = 600000;

package/src/service/model.ts

@@ -1,9 +1,12 @@
 import {
+   Annotation,
    API,
    Connection,
    FixedConnectionMap,
+   isSourceDef,
    MalloyError,
    ModelDef,
+   modelDefToModelInfo,
    ModelMaterializer,
    NamedModelObject,
    NamedQuery,
@@ -11,8 +14,6 @@ import {
    Runtime,
    StructDef,
    TurtleDef,
-   isSourceDef,
-   modelDefToModelInfo,
 } from "@malloydata/malloy";
 import * as Malloy from "@malloydata/malloy-interfaces";
 import {
@@ -41,7 +42,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"];
@@ -61,6 +62,7 @@ interface RunnableNotebookCell {
    text: string;
    runnable?: QueryMaterializer;
    newSources?: Malloy.SourceInfo[];
+   queryInfo?: Malloy.QueryInfo;
 }
 
 export class Model {
@@ -155,7 +157,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 +225,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 +351,42 @@ 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) => {
+         console.log("cell.queryInfo", cell.queryInfo);
+         return {
+            type: cell.type,
+            text: cell.text,
+            newSources: cell.newSources?.map((source) =>
+               JSON.stringify(source),
+            ),
+            queryInfo: cell.queryInfo
+               ? JSON.stringify(cell.queryInfo)
+               : undefined,
+         } as ApiNotebookCell;
+      });
+
+      // Collect all annotations from the inherits chain
+      const allAnnotations: string[] = [];
+      if (this.modelDef) {
+         // Traverse the inherits chain to collect all annotations
+         // Type as Annotation to handle the inherits chain properly
+         let currentAnnotation: Annotation | undefined =
+            this.modelDef.annotation;
+
+         while (currentAnnotation) {
+            if (currentAnnotation.notes) {
+               allAnnotations.push(
+                  ...currentAnnotation.notes.map((note) => note.text),
+               );
+            }
+            // Navigate to the inherited annotation if it exists
+            currentAnnotation = currentAnnotation.inherits;
+         }
+      }
 
       return {
          type: "notebook",
@@ -388,8 +398,84 @@ export class Model {
          ),
          sources: this.modelDef && this.sources,
          queries: this.modelDef && this.queries,
+         annotations: allAnnotations,
          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(
@@ -644,11 +730,38 @@ export class Model {
 
                   const runnable = localMM.loadFinalQuery();
 
+                  // Extract QueryInfo from the runnable
+                  let queryInfo: Malloy.QueryInfo | undefined = undefined;
+                  try {
+                     const preparedQuery = await runnable.getPreparedQuery();
+                     const query = preparedQuery._query as NamedQuery;
+                     const queryName = query.as || query.name;
+                     const anonymousQuery =
+                        currentModelInfo.anonymous_queries[
+                           currentModelInfo.anonymous_queries.length - 1
+                        ];
+
+                     if (anonymousQuery) {
+                        queryInfo = {
+                           name: queryName,
+                           schema: anonymousQuery.schema,
+                           annotations: anonymousQuery.annotations,
+                           definition: anonymousQuery.definition,
+                           code: anonymousQuery.code,
+                           location: anonymousQuery.location,
+                        } as Malloy.QueryInfo;
+                     }
+                  } catch (_error) {
+                     // If we can't extract query info (e.g., no query in cell), that's okay
+                     // This can happen for cells that only define sources
+                  }
+
                   return {
                      type: "code",
                      text: stmt.text,
                      runnable: runnable,
                      newSources,
+                     queryInfo,
                   } as RunnableNotebookCell;
                } else if (stmt.type === MalloySQLStatementType.MARKDOWN) {
                   return {

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

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