@malloy-publisher/sdk 0.0.80 → 0.0.82

package/src/components/Workbook/WorkbookList.tsx

@@ -0,0 +1,111 @@
+import {
+   Box,
+   Divider,
+   List,
+   ListItem,
+   ListItemText,
+   Typography,
+} from "@mui/material";
+import React from "react";
+import { useWorkbookStorage } from "./WorkbookStorageProvider";
+import { usePackage } from "../Package";
+import { WorkbookLocator } from "./WorkbookStorage";
+
+interface WorkbookListProps {
+   onWorkbookClick: (
+      workbook: WorkbookLocator,
+      event: React.MouseEvent,
+   ) => void;
+}
+
+export function WorkbookList({ onWorkbookClick }: WorkbookListProps) {
+   const { workbookStorage } = useWorkbookStorage();
+   const packageContext = usePackage();
+   const [workbooks, setWorkbooks] = React.useState<WorkbookLocator[]>([]);
+   const [lastError, setLastError] = React.useState<string | undefined>(
+      undefined,
+   );
+
+   React.useEffect(() => {
+      if (workbookStorage) {
+         workbookStorage
+            .listWorkspaces(packageContext, false)
+            .then((workspaces) => {
+               const allWorkbooks: WorkbookLocator[] = [];
+               Promise.all(
+                  workspaces.map(async (workspace) => {
+                     await workbookStorage
+                        .listWorkbooks(workspace, packageContext)
+                        .then((newWorkbooks) => {
+                           allWorkbooks.push(...newWorkbooks);
+                        })
+                        .catch((error) => {
+                           setLastError(
+                              `Error listing workbooks: ${error.message}`,
+                           );
+                        });
+                  }),
+               ).then(() => {
+                  setWorkbooks(allWorkbooks);
+                  setLastError(undefined);
+               });
+            });
+      }
+   }, [workbookStorage, packageContext]);
+
+   return (
+      <>
+         {lastError && (
+            <Box sx={{ mb: 2 }}>
+               <Typography color="error" variant="body2">
+                  {lastError}
+               </Typography>
+            </Box>
+         )}
+         <Divider />
+         <Box
+            sx={{
+               maxHeight: "300px",
+               overflow: "auto",
+               "&::-webkit-scrollbar": {
+                  width: "8px",
+               },
+               "&::-webkit-scrollbar-track": {
+                  background: "transparent",
+               },
+               "&::-webkit-scrollbar-thumb": {
+                  background: "rgba(0,0,0,0.2)",
+                  borderRadius: "4px",
+               },
+            }}
+         >
+            <List dense>
+               {workbooks.length === 0 && (
+                  <ListItem>
+                     <ListItemText
+                        primary="No workbooks found."
+                        sx={{ textAlign: "center" }}
+                     />
+                  </ListItem>
+               )}
+               {workbooks.map((workbook) => (
+                  <ListItem
+                     key={workbook.path}
+                     onClick={(event: React.MouseEvent) =>
+                        onWorkbookClick(workbook, event)
+                     }
+                     sx={{
+                        cursor: "pointer",
+                        "&:hover": {
+                           backgroundColor: "action.hover",
+                        },
+                     }}
+                  >
+                     <ListItemText primary={workbook.path} />
+                  </ListItem>
+               ))}
+            </List>
+         </Box>
+      </>
+   );
+}

package/src/components/Workbook/WorkbookManager.ts

@@ -0,0 +1,230 @@
+import { PackageContextProps } from "../Package";
+import type { WorkbookLocator, WorkbookStorage } from "./WorkbookStorage";
+
+/**
+ * Interface representing the data structure of a Mutable Workbook
+ * @interface WorkbookData
+ * @property {string[]} models - Array of model paths used in the workbook
+ * @property {WorkbookCellValue[]} cells - Array of cells in the workbook
+ * @property {WorkbookLocator} workbookPath - Path to the workbook file (relative to project/package)
+ */
+export interface WorkbookData {
+   models: string[];
+   cells: WorkbookCellValue[];
+   workbookPath: WorkbookLocator;
+}
+
+/**
+ * Interface representing a cell in the workbook
+ * @interface WorkbookCellValue
+ * @property {boolean} isMarkdown - Whether the cell is a markdown cell
+ * @property {string} [value] - The content of the cell
+ * @property {string} [result] - The result of executing the cell
+ * @property {string} [modelPath] - modelPath associated with the query in the cell
+ * @property {string} [sourceName] - Name of the source associated with the cell
+ * @property {string} [queryInfo] - Information about the query in the cell
+ */
+export interface WorkbookCellValue {
+   isMarkdown: boolean;
+   value?: string;
+   result?: string;
+   modelPath?: string;
+   sourceName?: string;
+   queryInfo?: string;
+}
+
+/**
+ * Class for managing workbook operations
+ * @class WorkbookManager
+ */
+export class WorkbookManager {
+   private isSaved: boolean;
+   private workbookStorage: WorkbookStorage;
+   private packageContext: PackageContextProps;
+
+   /**
+    * Creates a new WorkbookManager instance
+    * @param {WorkbookStorage} workbookStorage - Storage implementation
+    * @param {PackageContextProps} packageContext - Package context for storage
+    * @param {WorkbookData} workbookData - Initial workbook data
+    */
+   constructor(
+      workbookStorage: WorkbookStorage,
+      packageContext: PackageContextProps,
+      private workbookData: WorkbookData,
+   ) {
+      this.workbookStorage = workbookStorage;
+      this.packageContext = packageContext;
+      if (this.workbookData) {
+         this.isSaved = true;
+      } else {
+         this.workbookData = {
+            models: [],
+            cells: [],
+            workbookPath: undefined,
+         };
+         this.isSaved = false;
+      }
+   }
+
+   /**
+    * Gets the current workbook data
+    * @returns {WorkbookData} The current workbook data
+    */
+   getWorkbookData(): WorkbookData {
+      return this.workbookData;
+   }
+
+   /**
+    * Gets the current workbook path
+    * @returns {string} The path to the workbook
+    */
+   getWorkbookPath(): WorkbookLocator {
+      return this.workbookData.workbookPath;
+   }
+
+   /**
+    * Renames the workbook and updates storage
+    * @param {string} workbookPath - New path for the workbook
+    * @returns {WorkbookManager} The updated WorkbookManager instance
+    */
+   async renameWorkbook(workbookPath: string): Promise<WorkbookManager> {
+      if (this.workbookData.workbookPath.path !== workbookPath) {
+         try {
+            await this.workbookStorage.moveWorkbook(
+               this.packageContext,
+               this.workbookData.workbookPath,
+               {
+                  path: workbookPath,
+                  workspace: this.workbookData.workbookPath.workspace,
+               },
+            );
+         } catch {
+            // ignore if not found
+         }
+      }
+      this.workbookData.workbookPath.path = workbookPath;
+      this.isSaved = false;
+      return await this.saveWorkbook();
+   }
+
+   getCells(): WorkbookCellValue[] {
+      return this.workbookData.cells;
+   }
+   deleteCell(index: number): WorkbookManager {
+      this.workbookData.cells = [
+         ...this.workbookData.cells.slice(0, index),
+         ...this.workbookData.cells.slice(index + 1),
+      ];
+      this.isSaved = false;
+      return this;
+   }
+   insertCell(index: number, cell: WorkbookCellValue): WorkbookManager {
+      this.workbookData.cells = [
+         ...this.workbookData.cells.slice(0, index),
+         cell,
+         ...this.workbookData.cells.slice(index),
+      ];
+      this.isSaved = false;
+      return this;
+   }
+   setCell(index: number, cell: WorkbookCellValue): WorkbookManager {
+      this.workbookData.cells[index] = cell;
+      this.isSaved = false;
+      return this;
+   }
+   setModels(models: string[]): WorkbookManager {
+      this.workbookData.models = models;
+      this.isSaved = false;
+      return this;
+   }
+   getModels(): string[] {
+      return this.workbookData.models;
+   }
+
+   updateWorkbookData(workbookData: WorkbookData): WorkbookManager {
+      this.workbookData = workbookData;
+      this.isSaved = false;
+      return this;
+   }
+
+   async saveWorkbook(): Promise<WorkbookManager> {
+      if (!this.isSaved) {
+         if (!this.workbookData.workbookPath) {
+            throw new Error("Workbook path is not set");
+         }
+         await this.workbookStorage.saveWorkbook(
+            this.packageContext,
+            this.workbookData.workbookPath,
+            JSON.stringify(this.workbookData),
+         );
+         this.isSaved = true;
+      }
+      return new WorkbookManager(
+         this.workbookStorage,
+         this.packageContext,
+         this.workbookData,
+      );
+   }
+
+   /**
+    * Converts the workbook data to a Malloy workbook string.
+    * @returns {string} The Malloy workbook string
+    */
+   toMalloyWorkbook(): string {
+      return this.workbookData.cells
+         .map((cell) => {
+            if (cell.isMarkdown) {
+               return ">>>markdown\n" + cell.value;
+            } else {
+               return (
+                  ">>>malloy\n" +
+                  `import {${cell.sourceName}}" from '${cell.modelPath}'"\n` +
+                  cell.value +
+                  "\n"
+               );
+            }
+         })
+         .join("\n");
+   }
+
+   static newWorkbook(
+      workbookStorage: WorkbookStorage,
+      packageContext: PackageContextProps,
+   ): WorkbookManager {
+      return new WorkbookManager(workbookStorage, packageContext, undefined);
+   }
+
+   /**
+    * Creates a new workbook manager by loading from local storage.
+    * Returns an empty instance if the workbook is not found.
+    * @param workbookStorage - The storage implementation
+    * @param userContext - The user context for storage
+    * @param workbookPath - The path to the workbook file (relative to project/package)
+    */
+   static async loadWorkbook(
+      workbookStorage: WorkbookStorage,
+      packageContext: PackageContextProps,
+      workbookPath: WorkbookLocator,
+   ): Promise<WorkbookManager> {
+      let workbookData: WorkbookData | undefined = undefined;
+      console.log("loadWorkbook", workbookPath);
+      try {
+         const saved = await workbookStorage.getWorkbook(
+            packageContext,
+            workbookPath,
+         );
+         if (saved) {
+            workbookData = JSON.parse(saved);
+         }
+      } catch {
+         // Not found, create a new workbook
+         workbookData = {
+            models: [],
+            cells: [],
+            workbookPath: workbookPath,
+         };
+      }
+      return new WorkbookManager(workbookStorage, packageContext, workbookData);
+   }
+}

package/src/components/Workbook/WorkbookStorage.ts

@@ -0,0 +1,54 @@
+import { PackageContextProps } from "../Package";
+
+export interface Workspace {
+   name: string;
+   writeable: boolean;
+   description: string;
+}
+
+export interface WorkbookLocator {
+   path: string;
+   workspace: string;
+}
+
+export interface WorkbookStorage {
+   // Lists all available workspaces for the context.
+   listWorkspaces(
+      context: PackageContextProps,
+      writeableOnly: boolean,
+   ): Promise<Workspace[]>;
+
+   // Lists all available workbooks for the context.
+   // Workbooks names are like S3 paths- / denote hierarchical
+   // folders, but otherwise folders are not "real" objects
+   listWorkbooks(
+      workspace: Workspace,
+      context: PackageContextProps,
+   ): Promise<WorkbookLocator[]>;
+
+   // Returns the workbook at the specific path, throws an exception if no such workbook exists (or cannot be accessed)
+   getWorkbook(
+      context: PackageContextProps,
+      path: WorkbookLocator,
+   ): Promise<string>;
+
+   // Deletes the workbook at the specified path, or throws an
+   // Exception on failure
+   deleteWorkbook(
+      context: PackageContextProps,
+      path: WorkbookLocator,
+   ): Promise<void>;
+
+   saveWorkbook(
+      context: PackageContextProps,
+      path: WorkbookLocator,
+      workbook: string,
+   ): Promise<void>;
+
+   // Moves workbook from the "from" path to the "to" path
+   moveWorkbook(
+      context: PackageContextProps,
+      from: WorkbookLocator,
+      to: WorkbookLocator,
+   ): Promise<void>;
+}

package/src/components/Workbook/WorkbookStorageProvider.tsx

@@ -0,0 +1,37 @@
+import React, { createContext, useContext, useMemo } from "react";
+import type { WorkbookStorage } from "./WorkbookStorage";
+
+export interface WorkbookStorageProviderProps {
+   children: React.ReactNode;
+   workbookStorage: WorkbookStorage;
+}
+
+interface WorkbookStorageContextValue {
+   workbookStorage: WorkbookStorage;
+}
+
+const WorkbookStorageContext = createContext<
+   WorkbookStorageContextValue | undefined
+>(undefined);
+
+export function WorkbookStorageProvider({
+   children,
+   workbookStorage,
+}: WorkbookStorageProviderProps) {
+   const value = useMemo(() => ({ workbookStorage }), [workbookStorage]);
+   return (
+      <WorkbookStorageContext.Provider value={value}>
+         {children}
+      </WorkbookStorageContext.Provider>
+   );
+}
+
+export function useWorkbookStorage() {
+   const context = useContext(WorkbookStorageContext);
+   if (!context) {
+      throw new Error(
+         "useWorkbookStorage must be used within a WorkbookStorageProvider",
+      );
+   }
+   return context;
+}

package/src/components/Workbook/index.ts

@@ -0,0 +1,7 @@
+export type { WorkbookStorage } from "./WorkbookStorage";
+export { default as Workbook } from "./Workbook";
+export { WorkbookList } from "./WorkbookList";
+export { WorkbookStorageProvider } from "./WorkbookStorageProvider";
+export type { WorkbookLocator, Workspace } from "./WorkbookStorage";
+export { BrowserWorkbookStorage } from "./BrowserWorkbookStorage";
+export { WorkbookManager } from "./WorkbookManager";

package/src/components/index.ts

@@ -1,6 +1,6 @@
 export * from "./Model";
 export * from "./Notebook";
-export * from "./MutableNotebook";
+export * from "./Workbook";
 export * from "./Package";
 export * from "./Project";
 export * from "./QueryResult";
@@ -10,3 +10,5 @@ export { useRouterClickHandler } from "./click_helper";
 export { ServerProvider, useServer } from "./ServerProvider";
 export type { ServerContextValue, ServerProviderProps } from "./ServerProvider";
 export { AnalyzePackageButton } from "./AnalyzePackageButton";
+export type { PackageContextProps } from "./Package";
+export type { WorkbookStorage } from "./Workbook";

package/src/components/styles.ts

@@ -18,8 +18,6 @@ export const StyledCardMedia = styled(CardMedia)({
 });
 
 export const StyledExplorerPage = styled("div")({
-   display: "flex",
-   flexDirection: "column",
    height: "100%",
 });
 
@@ -32,7 +30,6 @@ export const StyledExplorerBanner = styled("div")({
 });
 
 export const StyledExplorerContent = styled("div")({
-   display: "flex",
    height: "75vh",
    width: "100%",
    overflowY: "auto",

package/dist/components/MutableNotebook/BrowserNotebookStorage.d.ts

@@ -1,9 +0,0 @@
-import { NotebookStorage, UserContext } from './NotebookStorage';
-export declare class BrowserNotebookStorage implements NotebookStorage {
-    private makeKey;
-    listNotebooks(context: UserContext): string[];
-    getNotebook(context: UserContext, path: string): string;
-    deleteNotebook(context: UserContext, path: string): void;
-    saveNotebook(context: UserContext, path: string, notebook: string): void;
-    moveNotebook(context: UserContext, from: string, to: string): void;
-}

package/dist/components/MutableNotebook/MutableNotebook.d.ts

@@ -1,8 +0,0 @@
-interface MutableNotebookProps {
-    notebookPath?: string;
-    expandCodeCells?: boolean;
-    expandEmbeddings?: boolean;
-    hideEmbeddingIcons?: boolean;
-}
-export default function MutableNotebook({ notebookPath, expandCodeCells, expandEmbeddings, hideEmbeddingIcons, }: MutableNotebookProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/components/MutableNotebook/MutableNotebookList.d.ts

@@ -1,6 +0,0 @@
-import { default as React } from 'react';
-interface MutableNotebookListProps {
-    onNotebookClick: (notebook: string, event: React.MouseEvent) => void;
-}
-export declare function MutableNotebookList({ onNotebookClick, }: MutableNotebookListProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/components/MutableNotebook/NotebookStorage.d.ts

@@ -1,11 +0,0 @@
-export interface UserContext {
-    project: string;
-    package: string;
-}
-export interface NotebookStorage {
-    listNotebooks(context: UserContext): string[];
-    getNotebook(context: UserContext, path: string): string;
-    deleteNotebook(context: UserContext, path: string): void;
-    saveNotebook(context: UserContext, path: string, notebook: string): void;
-    moveNotebook(context: UserContext, from: string, to: string): void;
-}

package/dist/components/MutableNotebook/NotebookStorageProvider.d.ts

@@ -1,14 +0,0 @@
-import { default as React } from 'react';
-import { NotebookStorage, UserContext } from './NotebookStorage';
-interface NotebookStorageProviderProps {
-    children: React.ReactNode;
-    userContext: UserContext;
-    notebookStorage: NotebookStorage;
-}
-interface NotebookStorageContextValue {
-    notebookStorage: NotebookStorage;
-    userContext: UserContext;
-}
-export default function NotebookStorageProvider({ children, userContext, notebookStorage, }: NotebookStorageProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useNotebookStorage(): NotebookStorageContextValue;
-export {};

package/dist/components/MutableNotebook/index.d.ts

@@ -1,5 +0,0 @@
-export { BrowserNotebookStorage } from './BrowserNotebookStorage';
-export { default as MutableNotebook } from './MutableNotebook';
-export type { NotebookStorage, UserContext } from './NotebookStorage';
-export { MutableNotebookList } from './MutableNotebookList';
-export { default as NotebookStorageProvider, useNotebookStorage, } from './NotebookStorageProvider';

package/dist/components/NotebookManager.d.ts

@@ -1,86 +0,0 @@
-import { NotebookStorage, UserContext } from './MutableNotebook/NotebookStorage';
-/**
- * Interface representing the data structure of a Mutable Notebook
- * @interface NotebookData
- * @property {string[]} models - Array of model paths used in the notebook
- * @property {NotebookCellValue[]} cells - Array of cells in the notebook
- * @property {string} notebookPath - Path to the notebook file (relative to project/package)
- */
-export interface NotebookData {
-    models: string[];
-    cells: NotebookCellValue[];
-    notebookPath: string;
-}
-/**
- * Interface representing a cell in the notebook
- * @interface NotebookCellValue
- * @property {boolean} isMarkdown - Whether the cell is a markdown cell
- * @property {string} [value] - The content of the cell
- * @property {string} [result] - The result of executing the cell
- * @property {string} [modelPath] - modelPath associated with the query in the cell
- * @property {string} [sourceName] - Name of the source associated with the cell
- * @property {string} [queryInfo] - Information about the query in the cell
- */
-export interface NotebookCellValue {
-    isMarkdown: boolean;
-    value?: string;
-    result?: string;
-    modelPath?: string;
-    sourceName?: string;
-    queryInfo?: string;
-}
-/**
- * Class for managing notebook operations
- * @class NotebookManager
- */
-export declare class NotebookManager {
-    private notebookData;
-    private isSaved;
-    private notebookStorage;
-    private userContext;
-    /**
-     * Creates a new NotebookManager instance
-     * @param {NotebookStorage} notebookStorage - Storage implementation
-     * @param {UserContext} userContext - User context for storage
-     * @param {NotebookData} notebookData - Initial notebook data
-     */
-    constructor(notebookStorage: NotebookStorage, userContext: UserContext, notebookData: NotebookData);
-    /**
-     * Gets the current notebook data
-     * @returns {NotebookData} The current notebook data
-     */
-    getNotebookData(): NotebookData;
-    /**
-     * Gets the current notebook path
-     * @returns {string} The path to the notebook
-     */
-    getNotebookPath(): string;
-    /**
-     * Renames the notebook and updates storage
-     * @param {string} notebookPath - New path for the notebook
-     * @returns {NotebookManager} The updated NotebookManager instance
-     */
-    renameNotebook(notebookPath: string): NotebookManager;
-    getCells(): NotebookCellValue[];
-    deleteCell(index: number): NotebookManager;
-    insertCell(index: number, cell: NotebookCellValue): NotebookManager;
-    setCell(index: number, cell: NotebookCellValue): NotebookManager;
-    setModels(models: string[]): NotebookManager;
-    getModels(): string[];
-    updateNotebookData(notebookData: NotebookData): NotebookManager;
-    saveNotebook(): NotebookManager;
-    /**
-     * Converts the notebook data to a Malloy notebook string.
-     * @returns {string} The Malloy notebook string
-     */
-    toMalloyNotebook(): string;
-    static newNotebook(notebookStorage: NotebookStorage, userContext: UserContext): NotebookManager;
-    /**
-     * Creates a new notebook manager by loading from local storage.
-     * Returns an empty instance if the notebook is not found.
-     * @param notebookStorage - The storage implementation
-     * @param userContext - The user context for storage
-     * @param notebookPath - The path to the notebook file (relative to project/package)
-     */
-    static loadNotebook(notebookStorage: NotebookStorage, userContext: UserContext, notebookPath: string): NotebookManager;
-}

package/src/components/MutableNotebook/BrowserNotebookStorage.ts

@@ -1,58 +0,0 @@
-import type { NotebookStorage, UserContext } from "./NotebookStorage";
-
-export class BrowserNotebookStorage implements NotebookStorage {
-   private makeKey(context: UserContext, path?: string): string {
-      let key = `BROWSER_NOTEBOOK_STORAGE__${context.project}/${context.package}`;
-      if (path) {
-         key += `/${path}`;
-      }
-      return key;
-   }
-
-   listNotebooks(context: UserContext): string[] {
-      const prefix = this.makeKey(context);
-      const keys: string[] = [];
-      for (let i = 0; i < localStorage.length; i++) {
-         const key = localStorage.key(i);
-         if (key && key.startsWith(prefix + "/")) {
-            // Extract the notebook path after the prefix
-            const notebookPath = key.substring(prefix.length + 1);
-            keys.push(notebookPath);
-         }
-      }
-      return keys;
-   }
-
-   getNotebook(context: UserContext, path: string): string {
-      const key = this.makeKey(context, path);
-      const notebook = localStorage.getItem(key);
-      if (notebook === null) {
-         throw new Error(`Notebook not found at path: ${path}`);
-      }
-      return notebook;
-   }
-
-   deleteNotebook(context: UserContext, path: string): void {
-      const key = this.makeKey(context, path);
-      if (localStorage.getItem(key) === null) {
-         throw new Error(`Notebook not found at path: ${path}`);
-      }
-      localStorage.removeItem(key);
-   }
-
-   saveNotebook(context: UserContext, path: string, notebook: string): void {
-      const key = this.makeKey(context, path);
-      localStorage.setItem(key, notebook);
-   }
-
-   moveNotebook(context: UserContext, from: string, to: string): void {
-      const fromKey = this.makeKey(context, from);
-      const toKey = this.makeKey(context, to);
-      const notebook = localStorage.getItem(fromKey);
-      if (notebook === null) {
-         throw new Error(`Notebook not found at path: ${from}`);
-      }
-      localStorage.setItem(toKey, notebook);
-      localStorage.removeItem(fromKey);
-   }
-}