@malloy-publisher/server 0.0.193 → 0.0.195

package/src/service/connection_config.ts

@@ -1,3 +1,4 @@
+import { createPrivateKey } from "crypto";
 import path from "path";
 import { components } from "../api";
 
@@ -48,6 +49,12 @@ export function normalizeSnowflakePrivateKey(privateKey: string): string {
             beginMarker: "-----BEGIN PRIVATE KEY-----",
             endMarker: "-----END PRIVATE KEY-----",
          },
+         {
+            beginRegex: /-----BEGIN\s+RSA\s+PRIVATE\s+KEY-----/i,
+            endRegex: /-----END\s+RSA\s+PRIVATE\s+KEY-----/i,
+            beginMarker: "-----BEGIN RSA PRIVATE KEY-----",
+            endMarker: "-----END RSA PRIVATE KEY-----",
+         },
       ];
 
       for (const pattern of keyPatterns) {
@@ -73,6 +80,28 @@ export function normalizeSnowflakePrivateKey(privateKey: string): string {
       privateKeyContent += "\n";
    }
 
+   // Snowflake's Node SDK requires PKCS#8 ("BEGIN PRIVATE KEY"). Convert
+   // PKCS#1 ("BEGIN RSA PRIVATE KEY") so users can paste either format.
+   if (/-----BEGIN\s+RSA\s+PRIVATE\s+KEY-----/i.test(privateKeyContent)) {
+      try {
+         privateKeyContent = createPrivateKey({
+            key: privateKeyContent,
+            format: "pem",
+         })
+            .export({ type: "pkcs8", format: "pem" })
+            .toString();
+      } catch (err) {
+         throw new Error(
+            `Failed to convert Snowflake RSA private key (PKCS#1) to PKCS#8: ${
+               err instanceof Error ? err.message : String(err)
+            }`,
+         );
+      }
+      if (!privateKeyContent.endsWith("\n")) {
+         privateKeyContent += "\n";
+      }
+   }
+
    return privateKeyContent;
 }
 
@@ -139,6 +168,13 @@ function getStaticConnectionAttributes(
             canPersist: true,
             canStream: false,
          };
+      case "databricks":
+         return {
+            dialectName: "databricks",
+            isPool: false,
+            canPersist: true,
+            canStream: false,
+         };
       case "mysql":
          return {
             dialectName: "mysql",
@@ -245,6 +281,31 @@ function validateConnectionShape(connection: ApiConnection): void {
             throw new Error("Trino connection configuration is missing.");
          }
          break;
+      case "databricks": {
+         const databricks = connection.databricksConnection;
+         if (!databricks) {
+            throw new Error("Databricks connection configuration is missing.");
+         }
+         if (!databricks.host) {
+            throw new Error("Databricks host is required.");
+         }
+         if (!databricks.path) {
+            throw new Error("Databricks SQL warehouse HTTP path is required.");
+         }
+         const hasToken = !!databricks.token;
+         const hasOAuth =
+            !!databricks.oauthClientId && !!databricks.oauthClientSecret;
+         if (!hasToken && !hasOAuth) {
+            throw new Error(
+               "Databricks requires either a personal access token or OAuth M2M client ID and secret.",
+            );
+         }
+         const hasDefaultCatalog = !!databricks.defaultCatalog;
+         if (!hasDefaultCatalog) {
+            throw new Error("Databricks default catalog is required.");
+         }
+         break;
+      }
       case "snowflake": {
          const snowflakeConnection = connection.snowflakeConnection;
          if (!snowflakeConnection) {
@@ -410,6 +471,22 @@ export function assembleProjectConnections(
             break;
          }
 
+         case "databricks": {
+            const databricks = connection.databricksConnection;
+            pojo.connections[connection.name] = {
+               is: "databricks",
+               host: databricks?.host,
+               path: databricks?.path,
+               token: databricks?.token,
+               oauthClientId: databricks?.oauthClientId,
+               oauthClientSecret: databricks?.oauthClientSecret,
+               defaultCatalog: databricks?.defaultCatalog,
+               defaultSchema: databricks?.defaultSchema,
+               setupSQL: databricks?.setupSQL,
+            };
+            break;
+         }
+
          case "duckdb": {
             if (
                attachedDatabases.some(

package/src/service/db_utils.spec.ts

@@ -262,6 +262,61 @@ describe("listTablesForSchema", () => {
       });
    });
 
+   describe("databricks", () => {
+      it("uses defaultCatalog-prefixed information_schema.columns", async () => {
+         const conn: ApiConnection = {
+            name: "test",
+            type: "databricks",
+            databricksConnection: {
+               host: "dbc.cloud.databricks.com",
+               path: "/sql/1.0/warehouses/abc",
+               token: "dapi",
+               defaultCatalog: "main",
+            },
+         };
+         const m = mockConnection(columnRows);
+         const tables = await listTablesForSchema(conn, "default", m.conn);
+
+         expect(m.lastSQL).toContain("main.information_schema.columns");
+         expect(m.lastSQL).toContain("table_schema = 'default'");
+         expect(tables[0].resource).toBe("main.default.orders");
+      });
+
+      it("extracts catalog from schemaName when no defaultCatalog", async () => {
+         const conn: ApiConnection = {
+            name: "test",
+            type: "databricks",
+            databricksConnection: {
+               host: "dbc.cloud.databricks.com",
+               path: "/sql/1.0/warehouses/abc",
+               token: "dapi",
+            },
+         };
+         const m = mockConnection(columnRows);
+         const tables = await listTablesForSchema(conn, "main.default", m.conn);
+
+         expect(m.lastSQL).toContain("main.information_schema.columns");
+         expect(m.lastSQL).toContain("table_schema = 'default'");
+         expect(tables[0].resource).toBe("main.default.orders");
+      });
+
+      it("includes IN filter when tableNames provided", async () => {
+         const conn: ApiConnection = {
+            name: "test",
+            type: "databricks",
+            databricksConnection: {
+               host: "dbc.cloud.databricks.com",
+               path: "/sql/1.0/warehouses/abc",
+               token: "dapi",
+               defaultCatalog: "main",
+            },
+         };
+         const m = mockConnection(columnRows);
+         await listTablesForSchema(conn, "default", m.conn, ["orders"]);
+         expect(m.lastSQL).toContain("table_name IN ('orders')");
+      });
+   });
+
    describe("duckdb", () => {
       const conn: ApiConnection = {
          name: "test",
@@ -674,6 +729,112 @@ describe("getSchemasForConnection", () => {
       });
    });
 
+   describe("databricks", () => {
+      it("queries catalog.information_schema.schemata when defaultCatalog is set", async () => {
+         const conn: ApiConnection = {
+            name: "test",
+            type: "databricks",
+            databricksConnection: {
+               host: "dbc.cloud.databricks.com",
+               path: "/sql/1.0/warehouses/abc",
+               token: "dapi",
+               defaultCatalog: "main",
+               defaultSchema: "default",
+            },
+         };
+         const rows = [
+            { schema_name: "default" },
+            { schema_name: "information_schema" },
+         ];
+         const m = mockConnection(rows);
+         const schemas = await getSchemasForConnection(conn, m.conn);
+
+         expect(m.lastSQL).toContain("main.information_schema.schemata");
+         expect(schemas).toHaveLength(2);
+         expect(schemas.find((s) => s.name === "default")?.isDefault).toBe(
+            true,
+         );
+         expect(
+            schemas.find((s) => s.name === "information_schema")?.isHidden,
+         ).toBe(true);
+      });
+
+      it("falls back to SHOW CATALOGS when defaultCatalog is unset", async () => {
+         const conn: ApiConnection = {
+            name: "test",
+            type: "databricks",
+            databricksConnection: {
+               host: "dbc.cloud.databricks.com",
+               path: "/sql/1.0/warehouses/abc",
+               token: "dapi",
+            },
+         };
+         // First runSQL returns catalog list; subsequent runSQL calls (one
+         // per catalog) return schema rows. We use a dedicated mock so we
+         // can switch behavior across calls.
+         let callIndex = 0;
+         const calls: string[] = [];
+         const fakeConn = {
+            runSQL: async (sql: string) => {
+               calls.push(sql);
+               if (callIndex++ === 0) {
+                  return {
+                     rows: [{ catalog: "main" }, { catalog: "samples" }],
+                  };
+               }
+               return { rows: [{ schema_name: "default" }] };
+            },
+         } as unknown as Connection;
+
+         const schemas = await getSchemasForConnection(conn, fakeConn);
+
+         expect(calls[0]).toContain("SHOW CATALOGS");
+         expect(
+            calls.some((c) => c.includes("main.information_schema.schemata")),
+         ).toBe(true);
+         expect(
+            calls.some((c) =>
+               c.includes("samples.information_schema.schemata"),
+            ),
+         ).toBe(true);
+         // Two catalogs each contribute one schema → catalog-qualified names.
+         expect(schemas.map((s) => s.name)).toEqual([
+            "main.default",
+            "samples.default",
+         ]);
+      });
+
+      it("warns and continues when a catalog rejects information_schema", async () => {
+         const conn: ApiConnection = {
+            name: "test",
+            type: "databricks",
+            databricksConnection: {
+               host: "dbc.cloud.databricks.com",
+               path: "/sql/1.0/warehouses/abc",
+               token: "dapi",
+            },
+         };
+         let callIndex = 0;
+         const fakeConn = {
+            runSQL: async (sql: string) => {
+               if (callIndex++ === 0) {
+                  return { rows: [{ catalog: "denied" }, { catalog: "ok" }] };
+               }
+               if (sql.includes("denied")) {
+                  throw new Error("USE CATALOG denied");
+               }
+               return { rows: [{ schema_name: "default" }] };
+            },
+         } as unknown as Connection;
+
+         const schemas = await getSchemasForConnection(conn, fakeConn);
+
+         // Denied catalog is skipped, ok catalog contributes its schema.
+         expect(schemas).toHaveLength(1);
+         expect(schemas[0].name).toBe("ok.default");
+      });
+   });
+
    it("throws for unsupported connection type", async () => {
       const conn = {
          name: "test",

package/src/service/db_utils.ts

@@ -353,6 +353,82 @@ async function getSchemasForTrino(
    }
 }
 
+async function getSchemasForDatabricks(
+   connection: ApiConnection,
+   malloyConnection: Connection,
+): Promise<ApiSchema[]> {
+   if (!connection.databricksConnection) {
+      throw new Error("Databricks connection is required");
+   }
+   try {
+      const configuredSchema = connection.databricksConnection.defaultSchema;
+      let allRows: { catalog: string; schema: string }[] = [];
+
+      if (connection.databricksConnection.defaultCatalog) {
+         const catalog = connection.databricksConnection.defaultCatalog;
+         const result = await malloyConnection.runSQL(
+            `SELECT schema_name FROM ${catalog}.information_schema.schemata ORDER BY schema_name`,
+         );
+         const rows = standardizeRunSQLResult(result);
+         allRows = rows.map((row: unknown) => {
+            const r = row as Record<string, unknown>;
+            return {
+               catalog,
+               schema: String(r.schema_name ?? r.Schema ?? ""),
+            };
+         });
+      } else {
+         const catalogsResult = await malloyConnection.runSQL(`SHOW CATALOGS`);
+         const catalogNames = standardizeRunSQLResult(catalogsResult).map(
+            (row: unknown) => {
+               const r = row as Record<string, unknown>;
+               return String(r.catalog ?? r.Catalog ?? r.catalog_name ?? "");
+            },
+         );
+
+         for (const catalog of catalogNames) {
+            try {
+               const result = await malloyConnection.runSQL(
+                  `SELECT schema_name FROM ${catalog}.information_schema.schemata ORDER BY schema_name`,
+               );
+               const rows = standardizeRunSQLResult(result);
+               for (const row of rows) {
+                  const r = row as Record<string, unknown>;
+                  allRows.push({
+                     catalog,
+                     schema: String(r.schema_name ?? r.Schema ?? ""),
+                  });
+               }
+            } catch (catalogError) {
+               logger.warn(
+                  `Failed to list schemas for Databricks catalog ${catalog}`,
+                  { error: catalogError },
+               );
+            }
+         }
+      }
+      logger.info("allRows for Schemas for Databricks", { allRows });
+      return allRows.map(({ catalog, schema }) => {
+         const name = connection.databricksConnection?.defaultCatalog
+            ? schema
+            : `${catalog}.${schema}`;
+         return {
+            name,
+            isHidden: ["information_schema"].includes(schema),
+            isDefault: configuredSchema ? schema === configuredSchema : false,
+         };
+      });
+   } catch (error) {
+      logger.error(
+         `Error getting schemas for Databricks connection ${connection.name}`,
+         { error },
+      );
+      throw new Error(
+         `Failed to get schemas for Databricks connection ${connection.name}: ${(error as Error).message}`,
+      );
+   }
+}
+
 async function getSchemasForDuckDB(
    connection: ApiConnection,
    malloyConnection: Connection,
@@ -533,6 +609,8 @@ export async function getSchemasForConnection(
          return getSchemasForSnowflake(connection, malloyConnection);
       case "trino":
          return getSchemasForTrino(connection, malloyConnection);
+      case "databricks":
+         return getSchemasForDatabricks(connection, malloyConnection);
       case "duckdb":
          return getSchemasForDuckDB(connection, malloyConnection);
       case "motherduck":
@@ -823,6 +901,13 @@ export async function listTablesForSchema(
             malloyConnection,
             tableNames,
          );
+      case "databricks":
+         return listTablesForDatabricks(
+            connection,
+            schemaName,
+            malloyConnection,
+            tableNames,
+         );
       case "duckdb":
          return listTablesForDuckDB(
             connection,
@@ -1057,6 +1142,52 @@ async function listTablesForTrino(
    }
 }
 
+async function listTablesForDatabricks(
+   connection: ApiConnection,
+   schemaName: string,
+   malloyConnection: Connection,
+   tableNames?: string[],
+): Promise<ApiTable[]> {
+   if (!connection.databricksConnection) {
+      throw new Error("Databricks connection is required");
+   }
+   try {
+      let catalogPrefix: string;
+      let schemaOnly: string;
+      let resourcePrefix: string;
+
+      if (connection.databricksConnection.defaultCatalog) {
+         catalogPrefix = `${connection.databricksConnection.defaultCatalog}.`;
+         schemaOnly = schemaName;
+         resourcePrefix = `${connection.databricksConnection.defaultCatalog}.${schemaName}`;
+      } else {
+         const dotIdx = schemaName.indexOf(".");
+         if (dotIdx > 0) {
+            catalogPrefix = `${schemaName.substring(0, dotIdx)}.`;
+            schemaOnly = schemaName.substring(dotIdx + 1);
+         } else {
+            catalogPrefix = "";
+            schemaOnly = schemaName;
+         }
+         resourcePrefix = schemaName;
+      }
+
+      const result = await malloyConnection.runSQL(
+         `SELECT table_name, column_name, data_type FROM ${catalogPrefix}information_schema.columns WHERE table_schema = '${schemaOnly}' ${sqlInFilter("table_name", tableNames)} ORDER BY table_name, ordinal_position`,
+      );
+      const rows = standardizeRunSQLResult(result);
+      return groupColumnRowsIntoTables(rows, (t) => `${resourcePrefix}.${t}`);
+   } catch (error) {
+      logger.error(
+         `Error getting tables for Databricks schema ${schemaName} in connection ${connection.name}`,
+         { error },
+      );
+      throw new Error(
+         `Failed to get tables for Databricks schema ${schemaName} in connection ${connection.name}: ${(error as Error).message}`,
+      );
+   }
+}
+
 async function listTablesForDuckDB(
    connection: ApiConnection,
    schemaName: string,

package/src/service/project.ts

@@ -99,6 +99,10 @@ export class Project {
          await this.writeProjectReadme(payload.readme);
       }
 
+      if (payload.materializationStorage !== undefined) {
+         this.metadata.materializationStorage = payload.materializationStorage;
+      }
+
       // Handle connections update
       // TODO: Update project connections should have its own API endpoint
       if (payload.connections) {

package/src/service/project_store.spec.ts

@@ -10,6 +10,11 @@ import { ProjectStore } from "./project_store";
 
 type MockData = Record<string, unknown>;
 
+const initializeDuckLakeCalls: Array<{
+   projectId: string;
+   config: { catalogUrl: string; dataPath: string };
+}> = [];
+
 mock.module("../storage/StorageManager", () => {
    return {
       StorageManager: class MockStorageManager {
@@ -17,6 +22,13 @@ mock.module("../storage/StorageManager", () => {
             return;
          }
 
+         async initializeDuckLakeForProject(
+            projectId: string,
+            config: { catalogUrl: string; dataPath: string },
+         ): Promise<void> {
+            initializeDuckLakeCalls.push({ projectId, config });
+         }
+
          getRepository() {
             return {
                // ===== PROJECT METHODS =====
@@ -467,6 +479,69 @@ describe("ProjectStore Service", () => {
       expect(readmeContent).toBe("Updated README content");
    });
 
+   it("should propagate materializationStorage on addProject for new project", async () => {
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({ frozenConfig: false, projects: [] }),
+      );
+
+      await projectStore.finishedInitialization;
+
+      const materializationStorage = {
+         catalogUrl:
+            "postgres:host=localhost port=5432 dbname=ducklake user=u password=p",
+         dataPath: "gs://test-bucket",
+      };
+
+      initializeDuckLakeCalls.length = 0;
+      const project = await projectStore.addProject({
+         name: projectName,
+         materializationStorage,
+      });
+
+      expect(project.metadata.materializationStorage).toEqual(
+         materializationStorage,
+      );
+      expect(initializeDuckLakeCalls).toHaveLength(1);
+      expect(initializeDuckLakeCalls[0].config).toEqual(materializationStorage);
+   });
+
+   it("should propagate materializationStorage on update", async () => {
+      const projectPath = path.join(serverRootPath, projectName);
+      mkdirSync(projectPath, { recursive: true });
+      writeFileSync(
+         path.join(projectPath, "publisher.json"),
+         JSON.stringify({ name: projectName, description: "Test package" }),
+      );
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            projects: [
+               {
+                  name: projectName,
+                  packages: [{ name: projectName, location: projectPath }],
+               },
+            ],
+         }),
+      );
+
+      await projectStore.finishedInitialization;
+      const project = await projectStore.getProject(projectName);
+
+      const materializationStorage = {
+         catalogUrl:
+            "postgres:host=localhost port=5432 dbname=ducklake user=u password=p",
+         dataPath: "gs://test-bucket",
+      };
+
+      await project.update({ name: projectName, materializationStorage });
+
+      expect(project.metadata.materializationStorage).toEqual(
+         materializationStorage,
+      );
+   });
+
    it(
       "should handle project reload",
       async () => {

package/src/service/project_store.ts

@@ -807,6 +807,10 @@ export class ProjectStore {
 
       if (!newProject.metadata) newProject.metadata = {};
       newProject.metadata.location = absoluteProjectPath;
+      if (project.materializationStorage !== undefined) {
+         newProject.metadata.materializationStorage =
+            project.materializationStorage;
+      }
 
       this.projects.set(projectName, newProject);
 

package/dist/app/assets/MainPage-yZQo2HSL.js

@@ -1,2 +0,0 @@
-import{u as V,g as F,r as g,R as _,a as X,b as S,c as M,e as A,j as t,s as m,f as w,h as v,k as I,P as Y,m as R,l as J,n as z,B as K,o as N,p as Z,T as U,q,t as oo,d as eo,v as b,C as j,w as ro,x as to,I as so,M as ao,y as $,S as no,z as lo,A as io,O as co}from"./index-CVHzPJwN.js";function po(o,e,r,s,n){const[a,i]=g.useState(()=>n&&r?r(o).matches:s?s(o).matches:e);return X(()=>{if(!r)return;const p=r(o),u=()=>{i(p.matches)};return u(),p.addEventListener("change",u),()=>{p.removeEventListener("change",u)}},[o,r]),a}const uo={..._},L=uo.useSyncExternalStore;function go(o,e,r,s,n){const a=g.useCallback(()=>e,[e]),i=g.useMemo(()=>{if(n&&r)return()=>r(o).matches;if(s!==null){const{matches:c}=s(o);return()=>c}return a},[a,o,s,n,r]),[p,u]=g.useMemo(()=>{if(r===null)return[a,()=>()=>{}];const c=r(o);return[()=>c.matches,l=>(c.addEventListener("change",l),()=>{c.removeEventListener("change",l)})]},[a,r,o]);return L(u,p,i)}function O(o={}){const{themeId:e}=o;return function(s,n={}){let a=V();a&&e&&(a=a[e]||a);const i=typeof window<"u"&&typeof window.matchMedia<"u",{defaultMatches:p=!1,matchMedia:u=i?window.matchMedia:null,ssrMatchMedia:d=null,noSsr:c=!1}=F({name:"MuiUseMediaQuery",props:n,theme:a});let l=typeof s=="function"?s(a):s;return l=l.replace(/^@media( ?)/m,""),l.includes("print")&&console.warn(["MUI: You have provided a `print` query to the `useMediaQuery` hook.","Using the print media query to modify print styles can lead to unexpected results.","Consider using the `displayPrint` field in the `sx` prop instead.","More information about `displayPrint` on our docs: https://mui.com/system/display/#display-in-print."].join(`
-`)),(L!==void 0?go:po)(l,p,u,d,c)}}O();function xo(o){return S("MuiAppBar",o)}M("MuiAppBar",["root","positionFixed","positionAbsolute","positionSticky","positionStatic","positionRelative","colorDefault","colorPrimary","colorSecondary","colorInherit","colorTransparent","colorError","colorInfo","colorSuccess","colorWarning"]);const mo=o=>{const{color:e,position:r,classes:s}=o,n={root:["root",`color${v(e)}`,`position${v(r)}`]};return I(n,xo,s)},D=(o,e)=>o?`${o?.replace(")","")}, ${e})`:e,bo=m(Y,{name:"MuiAppBar",slot:"Root",overridesResolver:(o,e)=>{const{ownerState:r}=o;return[e.root,e[`position${v(r.position)}`],e[`color${v(r.color)}`]]}})(R(({theme:o})=>({display:"flex",flexDirection:"column",width:"100%",boxSizing:"border-box",flexShrink:0,variants:[{props:{position:"fixed"},style:{position:"fixed",zIndex:(o.vars||o).zIndex.appBar,top:0,left:"auto",right:0,"@media print":{position:"absolute"}}},{props:{position:"absolute"},style:{position:"absolute",zIndex:(o.vars||o).zIndex.appBar,top:0,left:"auto",right:0}},{props:{position:"sticky"},style:{position:"sticky",zIndex:(o.vars||o).zIndex.appBar,top:0,left:"auto",right:0}},{props:{position:"static"},style:{position:"static"}},{props:{position:"relative"},style:{position:"relative"}},{props:{color:"inherit"},style:{"--AppBar-color":"inherit"}},{props:{color:"default"},style:{"--AppBar-background":o.vars?o.vars.palette.AppBar.defaultBg:o.palette.grey[100],"--AppBar-color":o.vars?o.vars.palette.text.primary:o.palette.getContrastText(o.palette.grey[100]),...o.applyStyles("dark",{"--AppBar-background":o.vars?o.vars.palette.AppBar.defaultBg:o.palette.grey[900],"--AppBar-color":o.vars?o.vars.palette.text.primary:o.palette.getContrastText(o.palette.grey[900])})}},...Object.entries(o.palette).filter(J(["contrastText"])).map(([e])=>({props:{color:e},style:{"--AppBar-background":(o.vars??o).palette[e].main,"--AppBar-color":(o.vars??o).palette[e].contrastText}})),{props:e=>e.enableColorOnDark===!0&&!["inherit","transparent"].includes(e.color),style:{backgroundColor:"var(--AppBar-background)",color:"var(--AppBar-color)"}},{props:e=>e.enableColorOnDark===!1&&!["inherit","transparent"].includes(e.color),style:{backgroundColor:"var(--AppBar-background)",color:"var(--AppBar-color)",...o.applyStyles("dark",{backgroundColor:o.vars?D(o.vars.palette.AppBar.darkBg,"var(--AppBar-background)"):null,color:o.vars?D(o.vars.palette.AppBar.darkColor,"var(--AppBar-color)"):null})}},{props:{color:"transparent"},style:{"--AppBar-background":"transparent","--AppBar-color":"inherit",backgroundColor:"var(--AppBar-background)",color:"var(--AppBar-color)",...o.applyStyles("dark",{backgroundImage:"none"})}}]}))),fo=g.forwardRef(function(e,r){const s=A({props:e,name:"MuiAppBar"}),{className:n,color:a="primary",enableColorOnDark:i=!1,position:p="fixed",...u}=s,d={...s,color:a,position:p,enableColorOnDark:i},c=mo(d);return t.jsx(bo,{square:!0,component:"header",ownerState:d,elevation:4,className:w(c.root,n,p==="fixed"&&"mui-fixed"),ref:r,...u})}),ho=z(t.jsx("path",{d:"M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"})),yo=m(K,{name:"MuiBreadcrumbCollapsed"})(R(({theme:o})=>({display:"flex",marginLeft:`calc(${o.spacing(1)} * 0.5)`,marginRight:`calc(${o.spacing(1)} * 0.5)`,...o.palette.mode==="light"?{backgroundColor:o.palette.grey[100],color:o.palette.grey[700]}:{backgroundColor:o.palette.grey[700],color:o.palette.grey[100]},borderRadius:2,"&:hover, &:focus":{...o.palette.mode==="light"?{backgroundColor:o.palette.grey[200]}:{backgroundColor:o.palette.grey[600]}},"&:active":{boxShadow:o.shadows[0],...o.palette.mode==="light"?{backgroundColor:N(o.palette.grey[200],.12)}:{backgroundColor:N(o.palette.grey[600],.12)}}}))),vo=m(ho)({width:24,height:16});function Bo(o){const{slots:e={},slotProps:r={},...s}=o,n=o;return t.jsx("li",{children:t.jsx(yo,{focusRipple:!0,...s,ownerState:n,children:t.jsx(vo,{as:e.CollapsedIcon,ownerState:n,...r.collapsedIcon})})})}function ko(o){return S("MuiBreadcrumbs",o)}const Co=M("MuiBreadcrumbs",["root","ol","li","separator"]),jo=o=>{const{classes:e}=o;return I({root:["root"],li:["li"],ol:["ol"],separator:["separator"]},ko,e)},So=m(U,{name:"MuiBreadcrumbs",slot:"Root",overridesResolver:(o,e)=>[{[`& .${Co.li}`]:e.li},e.root]})({}),Mo=m("ol",{name:"MuiBreadcrumbs",slot:"Ol"})({display:"flex",flexWrap:"wrap",alignItems:"center",padding:0,margin:0,listStyle:"none"}),Ao=m("li",{name:"MuiBreadcrumbs",slot:"Separator"})({display:"flex",userSelect:"none",marginLeft:8,marginRight:8});function wo(o,e,r,s){return o.reduce((n,a,i)=>(i<o.length-1?n=n.concat(a,t.jsx(Ao,{"aria-hidden":!0,className:e,ownerState:s,children:r},`separator-${i}`)):n.push(a),n),[])}const Io=g.forwardRef(function(e,r){const s=A({props:e,name:"MuiBreadcrumbs"}),{children:n,className:a,component:i="nav",slots:p={},slotProps:u={},expandText:d="Show path",itemsAfterCollapse:c=1,itemsBeforeCollapse:l=1,maxItems:h=8,separator:B="/",...Q}=s,[T,W]=g.useState(!1),f={...s,component:i,expanded:T,expandText:d,itemsAfterCollapse:c,itemsBeforeCollapse:l,maxItems:h,separator:B},y=jo(f),H=Z({elementType:p.CollapsedIcon,externalSlotProps:u.collapsedIcon,ownerState:f}),P=g.useRef(null),G=x=>{const C=()=>{W(!0);const E=P.current.querySelector("a[href],button,[tabindex]");E&&E.focus()};return l+c>=x.length?x:[...x.slice(0,l),t.jsx(Bo,{"aria-label":d,slots:{CollapsedIcon:p.CollapsedIcon},slotProps:{collapsedIcon:H},onClick:C},"ellipsis"),...x.slice(x.length-c,x.length)]},k=g.Children.toArray(n).filter(x=>g.isValidElement(x)).map((x,C)=>t.jsx("li",{className:y.li,children:x},`child-${C}`));return t.jsx(So,{ref:r,component:i,color:"textSecondary",className:w(y.root,a),ownerState:f,...Q,children:t.jsx(Mo,{className:y.ol,ref:P,ownerState:f,children:wo(T||h&&k.length<=h?k:G(k),y.separator,B,f)})})});function Ro(o){return S("MuiToolbar",o)}M("MuiToolbar",["root","gutters","regular","dense"]);const zo=o=>{const{classes:e,disableGutters:r,variant:s}=o;return I({root:["root",!r&&"gutters",s]},Ro,e)},To=m("div",{name:"MuiToolbar",slot:"Root",overridesResolver:(o,e)=>{const{ownerState:r}=o;return[e.root,!r.disableGutters&&e.gutters,e[r.variant]]}})(R(({theme:o})=>({position:"relative",display:"flex",alignItems:"center",variants:[{props:({ownerState:e})=>!e.disableGutters,style:{paddingLeft:o.spacing(2),paddingRight:o.spacing(2),[o.breakpoints.up("sm")]:{paddingLeft:o.spacing(3),paddingRight:o.spacing(3)}}},{props:{variant:"dense"},style:{minHeight:48}},{props:{variant:"regular"},style:o.mixins.toolbar}]}))),Po=g.forwardRef(function(e,r){const s=A({props:e,name:"MuiToolbar"}),{className:n,component:a="div",disableGutters:i=!1,variant:p="regular",...u}=s,d={...s,component:a,disableGutters:i,variant:p},c=zo(d);return t.jsx(To,{as:a,className:w(c.root,n),ref:r,ownerState:d,...u})}),Eo=O({themeId:q}),No=z(t.jsx("path",{d:"M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"})),$o=z(t.jsx("path",{d:"M3 18h18v-2H3zm0-5h18v-2H3zm0-7v2h18V6z"}));function Do(){const o=oo(),e=o["*"],r=eo();return t.jsx(b,{sx:{display:"flex",alignItems:"center"},children:t.jsxs(Io,{"aria-label":"breadcrumb",separator:t.jsx(No,{sx:{fontSize:14,color:"text.secondary"}}),sx:{"& .MuiBreadcrumbs-separator":{margin:"0 6px"}},children:[o.projectName&&t.jsx(j,{onClick:s=>r(`/${o.projectName}/`,s),label:o.projectName,size:"medium",sx:{backgroundColor:"white",color:"primary.main",fontWeight:500,height:"32px",fontSize:"1rem",cursor:"pointer","&:hover":{backgroundColor:"primary.100"}}}),o.packageName&&t.jsx(j,{onClick:s=>r(`/${o.projectName}/${o.packageName}/`,s),label:o.packageName,size:"medium",sx:{backgroundColor:"white",color:"primary.main",fontWeight:500,height:"32px",fontSize:"1rem",cursor:"pointer","&:hover":{backgroundColor:"secondary.100"}}}),e&&t.jsx(j,{onClick:s=>r(`/${o.projectName}/${o.packageName}/${e}`,s),label:e,size:"medium",sx:{backgroundColor:"white",color:"primary.main",fontWeight:500,height:"32px",fontSize:"1rem",cursor:"pointer","&:hover":{backgroundColor:"grey.200"}}})]})})}function Uo({logoHeader:o,endCap:e}){const r=ro(),s=to(),n=Eo(s.breakpoints.down("sm")),[a,i]=g.useState(null),p=!!a,u=l=>{i(l.currentTarget)},d=()=>i(null),c=[{label:"Malloy Docs",link:"https://docs.malloydata.dev/documentation/",sx:{color:"#14b3cb"}},{label:"Publisher Docs",link:"https://github.com/malloydata/publisher/blob/main/README.md",sx:{color:"#14b3cb"}},{label:"Publisher API",link:"/api-doc.html",sx:{color:"#14b3cb"}}];return t.jsxs(fo,{position:"sticky",elevation:0,sx:{backgroundColor:"background.paper",borderBottom:"1px solid",borderColor:"divider"},children:[t.jsxs(Po,{sx:{justifyContent:"space-between",flexWrap:"nowrap",minHeight:44},children:[o||t.jsxs(b,{sx:{display:"flex",alignItems:"center",gap:1,cursor:"pointer"},onClick:()=>r("/"),children:[t.jsx(b,{component:"img",src:"/logo.svg",alt:"Malloy",sx:{width:28,height:28}}),t.jsx(U,{variant:"h6",sx:{color:"text.primary",fontWeight:700,letterSpacing:"-0.025em",fontSize:{xs:"1.1rem",sm:"1.25rem"}},children:"Malloy Publisher"})]}),n?t.jsxs(t.Fragment,{children:[t.jsx(so,{color:"inherit",onClick:u,children:t.jsx($o,{})}),t.jsxs(ao,{anchorEl:a,open:p,onClose:d,anchorOrigin:{vertical:"bottom",horizontal:"right"},children:[c.map(l=>t.jsx($,{onClick:()=>{d(),window.location.href=l.link},sx:l.sx,children:l.label},l.label)),e&&t.jsx($,{children:e})]})]}):t.jsxs(no,{direction:"row",spacing:2,alignItems:"center",children:[c.map(l=>t.jsx(lo,{href:l.link,sx:l.sx,children:l.label},l.label)),e]})]}),t.jsx(b,{sx:{borderTop:"1px solid white",paddingLeft:"16px",paddingRight:"16px",marginBottom:"1px",overflowX:"auto"},children:t.jsx(Do,{})})]})}function Oo({headerProps:o}){return t.jsxs(b,{sx:{display:"flex",flexDirection:"column",minHeight:"100vh"},children:[t.jsx(Uo,{...o}),t.jsx(io,{maxWidth:"xl",component:"main",sx:{flex:1,display:"flex",flexDirection:"column",py:2,gap:2},children:t.jsx(b,{sx:{flex:1},children:t.jsx(co,{})})})]})}export{Oo as default};