@malloy-publisher/sdk 0.0.119 → 0.0.120

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/sdk",
    "description": "Malloy Publisher SDK",
-   "version": "0.0.119",
+   "version": "0.0.120",
    "type": "module",
    "main": "dist/index.cjs.js",
    "module": "dist/index.es.js",

package/src/components/Connections/common.ts

@@ -188,6 +188,7 @@ export const connectionFieldsByType: Record<
          type: "text",
       },
    ],
+   duckdb: [],
 };
 
 export const attributesFieldName: Record<ConnectionTypeEnum, string> = {
@@ -196,4 +197,5 @@ export const attributesFieldName: Record<ConnectionTypeEnum, string> = {
    snowflake: "snowflakeConnection",
    trino: "trinoConnection",
    mysql: "mysqlConnection",
+   duckdb: "duckdbConnection",
 };

package/src/components/Model/Model.tsx

@@ -1,4 +1,6 @@
-import { ApiErrorDisplay } from "../ApiErrorDisplay";
+import "@malloydata/malloy-explorer/styles.css";
+import LinkOutlinedIcon from "@mui/icons-material/LinkOutlined";
+import ZoomOutMapIcon from "@mui/icons-material/ZoomOutMap";
 import {
    Box,
    IconButton,
@@ -7,17 +9,15 @@ import {
    Tooltip,
    Typography,
 } from "@mui/material";
-import ZoomOutMapIcon from "@mui/icons-material/ZoomOutMap";
-import ShareIcon from "@mui/icons-material/Share";
-import "@malloydata/malloy-explorer/styles.css";
-import { QueryExplorerResult } from "./SourcesExplorer";
+import React, { useState } from "react";
+import { parseResourceUri } from "../../utils/formatting";
+import { ApiErrorDisplay } from "../ApiErrorDisplay";
 import { Loading } from "../Loading";
+import { ModelCell } from "./ModelCell";
 import { ModelExplorer } from "./ModelExplorer";
 import { ModelExplorerDialog } from "./ModelExplorerDialog";
-import { ModelCell } from "./ModelCell";
+import { QueryExplorerResult } from "./SourcesExplorer";
 import { useModelData } from "./useModelData";
-import React, { useState } from "react";
-import { parseResourceUri } from "../../utils/formatting";
 
 interface ModelProps {
    onChange?: (query: QueryExplorerResult) => void;
@@ -103,8 +103,8 @@ export default function Model({ onChange, resourceUri }: ModelProps) {
                         >
                            Sources
                         </Typography>
-                        <Tooltip title="Click to copy and share">
-                           <ShareIcon
+                        <Tooltip title="Click to copy link">
+                           <LinkOutlinedIcon
                               sx={{
                                  fontSize: "24px",
                                  color: "#666666",

package/src/components/Model/ModelCell.tsx

@@ -1,13 +1,13 @@
-import { Box, Typography, IconButton } from "@mui/material";
 import SearchIcon from "@mui/icons-material/Search";
+import { Box, IconButton, Typography } from "@mui/material";
 import React, { useEffect } from "react";
 import { useQueryWithApiError } from "../../hooks/useQueryWithApiError";
+import { parseResourceUri } from "../../utils/formatting";
 import { highlight } from "../highlighter";
 import ResultContainer from "../RenderedResult/ResultContainer";
 import ResultsDialog from "../ResultsDialog";
-import { CleanMetricCard, CleanNotebookCell } from "../styles";
-import { parseResourceUri } from "../../utils/formatting";
 import { useServer } from "../ServerProvider";
+import { CleanMetricCard, CleanNotebookCell } from "../styles";
 
 interface ModelCellProps {
    sourceName?: string;
@@ -37,14 +37,16 @@ export function ModelCell({
    } = useQueryWithApiError({
       queryKey: ["namedQueryResult", resourceUri, queryName],
       queryFn: () =>
-         apiClients.queryResults.executeQuery(
+         apiClients.models.executeQueryModel(
             projectName,
             packageName,
             modelPath,
-            undefined, // query
-            undefined, // sourceName
-            queryName, // queryName
-            versionId, // versionId
+            {
+               query: undefined,
+               sourceName: undefined,
+               queryName: queryName,
+               versionId: versionId,
+            },
          ),
       enabled: true, // Always execute
    });

package/src/components/Model/SourcesExplorer.tsx

@@ -173,15 +173,16 @@ function SourceExplorerComponentInner({
             ...query,
             query: malloy,
          });
-         return apiClients.queryResults.executeQuery(
+         return apiClients.models.executeQueryModel(
             projectName,
             packageName,
             sourceAndPath.modelPath,
-            malloy,
-            undefined,
-            // sourceInfo.name,
-            undefined,
-            versionId,
+            {
+               query: malloy,
+               sourceName: undefined,
+               queryName: undefined,
+               versionId: versionId,
+            },
          );
       },
       onSuccess: (data) => {

package/src/components/Notebook/NotebookCell.tsx

@@ -1,18 +1,18 @@
 import CloseIcon from "@mui/icons-material/Close";
 import CodeIcon from "@mui/icons-material/Code";
 import ContentCopyIcon from "@mui/icons-material/ContentCopy";
+import LinkOutlinedIcon from "@mui/icons-material/LinkOutlined";
 import SearchIcon from "@mui/icons-material/Search";
-import ShareIcon from "@mui/icons-material/Share";
 import {
    Box,
    Dialog,
    DialogContent,
    DialogTitle,
    IconButton,
+   Snackbar,
    Stack,
    Tooltip,
    Typography,
-   Snackbar,
 } from "@mui/material";
 import Markdown from "markdown-to-jsx";
 import React, { useEffect, useState } from "react";
@@ -176,8 +176,8 @@ export function NotebookCell({
                      justifyContent="space-between"
                   >
                      <Markdown>{cell.text}</Markdown>
-                     <Tooltip title="Click to copy and share">
-                        <ShareIcon
+                     <Tooltip title="Click to copy link">
+                        <LinkOutlinedIcon
                            sx={{
                               fontSize: "24px",
                               color: "#666666",

package/src/components/Package/Package.tsx

@@ -1,17 +1,16 @@
-import { Grid, Box } from "@mui/material";
+import { Box, Grid } from "@mui/material";
+import { encodeResourceUri, parseResourceUri } from "../../utils/formatting";
 import { Notebook } from "../Notebook";
-import Config from "./Config";
-import Connections from "./Connections";
-import Databases from "./Databases";
-import Models from "./Models";
-import Notebooks from "./Notebooks";
-import Schedules from "./Schedules";
 import {
    PackageCard,
    PackageCardContent,
    PackageSectionTitle,
 } from "../styles";
-import { encodeResourceUri, parseResourceUri } from "../../utils/formatting";
+import Config from "./Config";
+import Connections from "./Connections";
+import Databases from "./Databases";
+import Models from "./Models";
+import Notebooks from "./Notebooks";
 
 const README_NOTEBOOK = "README.malloynb";
 
@@ -59,9 +58,6 @@ export default function Package({
             <Grid size={{ xs: 12, md: 6 }}>
                <Connections resourceUri={resourceUri} />
             </Grid>
-            <Grid size={{ xs: 12, md: 12 }}>
-               <Schedules resourceUri={resourceUri} />
-            </Grid>
             <Grid size={{ xs: 12, md: 12 }}>
                <PackageCard>
                   <PackageCardContent>

package/src/components/Project/ConnectionExplorer.tsx

@@ -1,27 +1,26 @@
-import React from "react";
 import {
    Box,
+   Divider,
+   FormControlLabel,
+   Grid,
    List,
    ListItemButton,
    ListItemText,
-   Typography,
-   Divider,
    Paper,
-   Grid,
    Switch,
-   FormControlLabel,
    Table,
    TableBody,
    TableCell,
    TableContainer,
    TableHead,
    TableRow,
-   Tooltip,
+   Typography,
 } from "@mui/material";
-import { ApiErrorDisplay } from "../ApiErrorDisplay";
-import { Loading } from "../Loading";
+import React from "react";
 import { useQueryWithApiError } from "../../hooks/useQueryWithApiError";
 import { parseResourceUri } from "../../utils/formatting";
+import { ApiErrorDisplay } from "../ApiErrorDisplay";
+import { Loading } from "../Loading";
 import { useServer } from "../ServerProvider";
 
 interface ConnectionExplorerProps {
@@ -37,19 +36,30 @@ export default function ConnectionExplorer({
 }: ConnectionExplorerProps) {
    const { apiClients } = useServer();
    const { projectName: projectName } = parseResourceUri(resourceUri);
-   const [selectedTable, setSelectedTable] = React.useState<string | undefined>(
-      undefined,
-   );
+   const [selectedTable, setSelectedTable] = React.useState<
+      | { resource: string; columns: Array<{ name: string; type: string }> }
+      | undefined
+   >(undefined);
    const [selectedSchema, setSelectedSchema] = React.useState<string | null>(
       schema || null,
    );
    const [showHiddenSchemas, setShowHiddenSchemas] = React.useState(false);
-   const { data, isSuccess, isError, error, isLoading } = useQueryWithApiError({
-      queryKey: ["tablePath", projectName, connectionName],
+   const {
+      data: schemasData,
+      isError: schemasError,
+      isLoading: schemasLoading,
+      error: schemasErrorObj,
+   } = useQueryWithApiError({
+      queryKey: ["schemas", projectName, connectionName],
       queryFn: () =>
          apiClients.connections.listSchemas(projectName, connectionName),
    });
 
+   const availableSchemas =
+      schemasData?.data
+         ?.map((schema: { name: string }) => schema.name)
+         .sort() || [];
+
    return (
       <Grid container spacing={1}>
          {!schema && (
@@ -82,74 +92,39 @@ export default function ConnectionExplorer({
                   <Box
                      sx={{ mt: "2px", maxHeight: "600px", overflowY: "auto" }}
                   >
-                     {isLoading && <Loading text="Fetching Table Paths..." />}
-                     {isError && (
+                     {schemasLoading && <Loading text="Loading schemas..." />}
+                     {schemasError && (
                         <ApiErrorDisplay
-                           error={error}
-                           context={`${projectName} > ${connectionName}`}
+                           error={schemasErrorObj}
+                           context={`${projectName} > ${connectionName} > Schemas`}
                         />
                      )}
-                     {isSuccess && data.data.length === 0 && (
-                        <Typography variant="body2">No Schemas</Typography>
-                     )}
-                     {isSuccess && data.data.length > 0 && (
-                        <List dense disablePadding>
-                           {data.data
-                              .filter(
-                                 ({ isHidden }) =>
-                                    showHiddenSchemas || !isHidden,
-                              )
-                              .sort((a, b) => {
-                                 if (a.isDefault === b.isDefault) return 0;
-                                 return a.isDefault ? -1 : 1;
-                              })
-                              .map(
-                                 (schema: {
-                                    name: string;
-                                    isDefault: boolean;
-                                    description?: string;
-                                 }) => {
-                                    const fullDescription = (
-                                       schema.description || ""
-                                    ).trim();
-                                    const hasDescription =
-                                       fullDescription !== "";
-                                    const firstLine = hasDescription
-                                       ? fullDescription.split(/\r?\n/)[0]
-                                       : undefined;
-
-                                    const item = (
-                                       <ListItemButton
-                                          key={schema.name}
-                                          selected={
-                                             selectedSchema === schema.name
-                                          }
-                                          onClick={() =>
-                                             setSelectedSchema(schema.name)
-                                          }
-                                       >
-                                          <ListItemText
-                                             primary={schema.name}
-                                             secondary={firstLine}
-                                          />
-                                       </ListItemButton>
-                                    );
-
-                                    return hasDescription ? (
-                                       <Tooltip
-                                          key={schema.name}
-                                          title={fullDescription}
-                                          arrow
-                                       >
-                                          {item}
-                                       </Tooltip>
-                                    ) : (
-                                       item
-                                    );
-                                 },
-                              )}
-                        </List>
-                     )}
+                     {!schemasLoading &&
+                        !schemasError &&
+                        availableSchemas.length === 0 && (
+                           <Typography variant="body2">No Schemas</Typography>
+                        )}
+                     {!schemasLoading &&
+                        !schemasError &&
+                        availableSchemas.length > 0 && (
+                           <List dense disablePadding>
+                              {availableSchemas.map((schemaName: string) => {
+                                 const isSelected =
+                                    selectedSchema === schemaName;
+                                 return (
+                                    <ListItemButton
+                                       key={schemaName}
+                                       selected={isSelected}
+                                       onClick={() =>
+                                          setSelectedSchema(schemaName)
+                                       }
+                                    >
+                                       <ListItemText primary={schemaName} />
+                                    </ListItemButton>
+                                 );
+                              })}
+                           </List>
+                        )}
                   </Box>
                </Paper>
             </Grid>
@@ -160,8 +135,8 @@ export default function ConnectionExplorer({
                   <TablesInSchema
                      connectionName={connectionName}
                      schemaName={selectedSchema}
-                     onTableClick={(tableName) => {
-                        setSelectedTable(tableName);
+                     onTableClick={(table) => {
+                        setSelectedTable(table);
                      }}
                      resourceUri={resourceUri}
                   />
@@ -169,14 +144,9 @@ export default function ConnectionExplorer({
             )}
          </Grid>
          <Grid size={{ xs: 12, md: schema ? 6 : 4 }}>
-            {selectedTable && selectedSchema && (
+            {selectedTable && (
                <Paper sx={{ p: 1, m: 0 }}>
-                  <TableSchemaViewer
-                     connectionName={connectionName}
-                     schemaName={selectedSchema}
-                     tableName={selectedTable}
-                     resourceUri={resourceUri}
-                  />
+                  <TableSchemaViewer table={selectedTable} />
                </Paper>
             )}
          </Grid>
@@ -185,76 +155,42 @@ export default function ConnectionExplorer({
 }
 
 type TableSchemaViewerProps = {
-   connectionName: string;
-   schemaName: string;
-   tableName: string;
-   resourceUri: string;
+   table: { resource: string; columns: Array<{ name: string; type: string }> };
 };
 
-function TableSchemaViewer({
-   connectionName,
-   schemaName,
-   tableName,
-   resourceUri,
-}: TableSchemaViewerProps) {
-   const { apiClients } = useServer();
-   const { projectName: projectName } = parseResourceUri(resourceUri);
-   const { data, isSuccess, isError, error, isLoading } = useQueryWithApiError({
-      queryKey: [
-         "tablePathSchema",
-         projectName,
-         connectionName,
-         schemaName,
-         tableName,
-      ],
-      queryFn: () =>
-         apiClients.connections.getTablesource(
-            projectName,
-            connectionName,
-            tableName,
-            `${schemaName}.${tableName}`,
-         ),
-   });
-
+function TableSchemaViewer({ table }: TableSchemaViewerProps) {
    return (
       <>
          <Typography variant="overline" fontWeight="bold">
-            Schema: {schemaName}.{tableName}
+            Schema: {table.resource}
          </Typography>
          <Divider />
          <Box sx={{ mt: "10px", maxHeight: "600px", overflowY: "auto" }}>
-            {isLoading && <Loading text="Fetching Table Details..." />}
-            {isError && (
-               <ApiErrorDisplay
-                  error={error}
-                  context={`${projectName} > ${connectionName} > ${schemaName}.${tableName}`}
-               />
-            )}
-            {isSuccess && data && (
-               <TableContainer>
-                  <Table
-                     size="small"
-                     sx={{ "& .MuiTableCell-root": { padding: "10px" } }}
-                  >
-                     <TableHead>
-                        <TableRow>
-                           <TableCell>NAME</TableCell>
-                           <TableCell>TYPE</TableCell>
-                        </TableRow>
-                     </TableHead>
-                     <TableBody>
-                        {data.data.columns?.map(
-                           (column: { name: string; type: string }) => (
-                              <TableRow key={column.name}>
-                                 <TableCell>{column.name}</TableCell>
-                                 <TableCell>{column.type}</TableCell>
-                              </TableRow>
-                           ),
-                        )}
-                     </TableBody>
-                  </Table>
-               </TableContainer>
-            )}
+            <TableContainer>
+               <Table
+                  size="small"
+                  sx={{ "& .MuiTableCell-root": { padding: "10px" } }}
+               >
+                  <TableHead>
+                     <TableRow>
+                        <TableCell>NAME</TableCell>
+                        <TableCell>TYPE</TableCell>
+                     </TableRow>
+                  </TableHead>
+                  <TableBody>
+                     {table.columns
+                        ?.sort((a: { name: string }, b: { name: string }) =>
+                           a.name.localeCompare(b.name),
+                        )
+                        ?.map((column: { name: string; type: string }) => (
+                           <TableRow key={column.name}>
+                              <TableCell>{column.name}</TableCell>
+                              <TableCell>{column.type}</TableCell>
+                           </TableRow>
+                        ))}
+                  </TableBody>
+               </Table>
+            </TableContainer>
          </Box>
       </>
    );
@@ -263,7 +199,10 @@ function TableSchemaViewer({
 interface TablesInSchemaProps {
    connectionName: string;
    schemaName: string;
-   onTableClick: (tableName: string) => void;
+   onTableClick: (table: {
+      resource: string;
+      columns: Array<{ name: string; type: string }>;
+   }) => void;
    resourceUri: string;
 }
 
@@ -299,19 +238,43 @@ function TablesInSchema({
                   context={`${projectName} > ${connectionName} > ${schemaName}`}
                />
             )}
-            {isSuccess && data.data.length === 0 && (
+            {isSuccess && data?.data?.length === 0 && (
                <Typography variant="body2">No Tables</Typography>
             )}
-            {isSuccess && data.data.length > 0 && (
+            {isSuccess && data?.data && data.data.length > 0 && (
                <List dense disablePadding>
-                  {data.data.map((tableName: string) => (
-                     <ListItemButton
-                        key={tableName}
-                        onClick={() => onTableClick(tableName)}
-                     >
-                        <ListItemText primary={tableName} />
-                     </ListItemButton>
-                  ))}
+                  {data.data
+                     .sort(
+                        (a: { resource: string }, b: { resource: string }) => {
+                           // Extract table names for sorting
+                           const tableNameA =
+                              a.resource.split(".").pop() || a.resource;
+                           const tableNameB =
+                              b.resource.split(".").pop() || b.resource;
+                           return tableNameA.localeCompare(tableNameB);
+                        },
+                     )
+                     .map(
+                        (table: {
+                           resource: string;
+                           columns: Array<{ name: string; type: string }>;
+                        }) => {
+                           // Extract table name from resource path (e.g., "schema.table_name" -> "table_name")
+                           const tableName =
+                              table.resource.split(".").pop() || table.resource;
+                           return (
+                              <ListItemButton
+                                 key={table.resource}
+                                 onClick={() => onTableClick(table)}
+                              >
+                                 <ListItemText
+                                    primary={tableName}
+                                    secondary={`${table.columns.length} columns`}
+                                 />
+                              </ListItemButton>
+                           );
+                        },
+                     )}
                </List>
             )}
          </Box>

package/src/components/QueryResult/QueryResult.tsx

@@ -1,8 +1,8 @@
 import { Suspense, lazy } from "react";
-import { ApiErrorDisplay } from "../ApiErrorDisplay";
-import { Loading } from "../Loading";
 import { useQueryWithApiError } from "../../hooks/useQueryWithApiError";
 import { parseResourceUri } from "../../utils/formatting";
+import { ApiErrorDisplay } from "../ApiErrorDisplay";
+import { Loading } from "../Loading";
 import { useServer } from "../ServerProvider";
 
 const RenderedResult = lazy(() => import("../RenderedResult/RenderedResult"));
@@ -77,14 +77,16 @@ export default function QueryResult({
    const { data, isSuccess, isError, error } = useQueryWithApiError({
       queryKey: [resourceUri, query, sourceName, queryName],
       queryFn: () =>
-         apiClients.queryResults.executeQuery(
+         apiClients.models.executeQueryModel(
             projectName,
             packageName,
             modelPath,
-            query,
-            sourceName,
-            queryName,
-            versionId,
+            {
+               query: query,
+               sourceName: sourceName,
+               queryName: queryName,
+               versionId: versionId,
+            },
          ),
    });
 

package/src/components/ServerProvider.tsx

@@ -8,8 +8,6 @@ import {
    NotebooksApi,
    PackagesApi,
    ProjectsApi,
-   QueryresultsApi,
-   SchedulesApi,
    WatchModeApi,
 } from "../client";
 import { Configuration } from "../client/configuration";
@@ -65,14 +63,12 @@ const getApiClients = (
    const config = new Configuration({ basePath });
 
    return {
-      queryResults: new QueryresultsApi(config, basePath, axiosInstance),
       models: new ModelsApi(config, basePath, axiosInstance),
       projects: new ProjectsApi(config, basePath, axiosInstance),
       packages: new PackagesApi(config, basePath, axiosInstance),
       notebooks: new NotebooksApi(config, basePath, axiosInstance),
       connections: new ConnectionsApi(config, basePath, axiosInstance),
       databases: new DatabasesApi(config, basePath, axiosInstance),
-      schedules: new SchedulesApi(config, basePath, axiosInstance),
       watchMode: new WatchModeApi(config, basePath, axiosInstance),
    };
 };

package/src/hooks/useRawQueryData.ts

@@ -1,6 +1,6 @@
+import { useServer } from "../components/ServerProvider";
 import { parseResourceUri } from "../utils/formatting";
 import { useQueryWithApiError } from "./useQueryWithApiError";
-import { useServer } from "../components/ServerProvider";
 
 interface UseRawQueryDataProps {
    modelPath: string;
@@ -35,14 +35,16 @@ export function useRawQueryData({
          queryName,
       ],
       queryFn: () =>
-         apiClients.queryResults.executeQuery(
+         apiClients.models.executeQueryModel(
             projectName,
             packageName,
             modelPath,
-            query,
-            sourceName,
-            queryName,
-            versionId,
+            {
+               query: query,
+               sourceName: sourceName,
+               queryName: queryName,
+               versionId: versionId,
+            },
          ),
       enabled,
    });