@magemetrics/core 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Client } from 'openapi-fetch';
 import { DefaultChatTransport } from 'ai';
+import { GoTrueClientOptions } from '@supabase/auth-js';
 import { HttpChatTransportInitOptions } from 'ai';
 import type { InferUITool } from 'ai';
 import type { Simplify } from 'type-fest';
@@ -78,6 +79,11 @@ export declare class BrowserStorageAdapter implements AsyncStorage {
 
 export declare const CHECK_KEY = "mm-ai-check-key";
 
+export declare interface ColumnSort {
+    desc: boolean;
+    id: string;
+}
+
 declare interface components {
     schemas: {
         VisualizationData: {
@@ -508,7 +514,11 @@ export declare class MageMetricsClient {
     private userId;
     private storageAdapter;
     private events;
-    constructor(config: MageMetricsClientConfig);
+    private authOptions;
+    constructor(config: MageMetricsClientConfig, auth?: Pick<GoTrueClientOptions, "fetch">);
+    toJSON(): {
+        config: string;
+    };
     /**
      * Add an event listener for authentication state changes
      * @param type the type of the event
@@ -528,9 +538,13 @@ export declare class MageMetricsClient {
     waitForAuth(): Promise<void>;
     updateExternalJwt(jwt: string): Promise<void>;
     get state(): AuthState;
-    getAuthHeaders(): Promise<Record<string, string>>;
+    getHeaders(): Promise<Record<string, string>>;
     private clearStorage;
     logout(): Promise<void>;
+    auth: {
+        startAutoRefresh: () => Promise<void> | undefined;
+        stopAuthRefresh: () => Promise<void> | undefined;
+    };
     /**
      * Public API methods that automatically wait for authentication
      */
@@ -547,7 +561,22 @@ export declare class MageMetricsClient {
             data: Blob | string;
         }>;
         generateContextualInsight: (payload: GenerateInsightParam) => Promise<ExtractInsightResponse>;
-        getChat: (flowId: string, options?: MageMetricsChatTransportOptions) => MageMetricsChatTransport;
+        getChatTransport: (flowId: string, options?: MageMetricsChatTransportOptions) => MageMetricsChatTransport;
+        getChatMessages: (flowId: string) => Promise<MMChatUIMessage[]>;
+        fetchReportData: (reportId: number, { columns, limit, sorting, filters, cursor }: ReportDataFilters) => Promise<Record<string, unknown>[]>;
+        getReport: (reportId: number) => Promise<{
+            columns: {
+                name: string;
+                data_type: string;
+                dataType: string;
+                renderType?: string;
+                unit?: string;
+            }[];
+            rowCount: {
+                count: number;
+            };
+            data: (reportId: number, { columns, limit, sorting, filters, cursor }: ReportDataFilters) => Promise<Record<string, unknown>[]>;
+        }>;
     };
     /**
      * Perform the complete authentication flow
@@ -624,7 +653,7 @@ export declare class MemoryStorageAdapter implements AsyncStorage {
     removeItem(key: string): Promise<void>;
 }
 
-declare type MMChatUIMessage = UIMessage<unknown, CustomDataParts, MMUiTools>;
+export declare type MMChatUIMessage = UIMessage<unknown, CustomDataParts, MMUiTools>;
 
 declare type MMUiTools = {
     generateDataReport: UiTool;
@@ -4152,6 +4181,14 @@ declare type RemoveParamsConfig = Simplify<{
     cookie?: string;
 }>;
 
+declare type ReportDataFilters = {
+    columns?: string[];
+    limit: number;
+    sorting: SortingState;
+    filters: TableFilters;
+    cursor?: number;
+};
+
 declare const SignalWithReportIdSchema: z.ZodObject<{
     rule: z.ZodString;
     metric: z.ZodString;
@@ -4173,6 +4210,10 @@ declare const SignalWithReportIdSchema: z.ZodObject<{
     reportId: number;
 }>;
 
+declare type SortingState = ColumnSort[];
+
+declare type TableFilters = Record<string, string | number>;
+
 /**
  * Token storage keys
  */

package/dist/index.js

@@ -305,10 +305,6 @@ var Edge = z.object({
   source: z.string(),
   target: z.string()
 });
-z.object({
-  score: z.number(),
-  reason: z.string()
-});
 var LLMColumnsLineageResponse = z.record(z.string(), z.object({
   nodes: z.array(Node3),
   edges: z.array(Edge)
@@ -995,7 +991,7 @@ var RetrieveRecentFlows = createRoute({
     }
   }
 });
-createRoute({
+var GetReportColumns = createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/columns",
   operationId: "getDataReportColumns",
@@ -1118,7 +1114,7 @@ createRoute({
     }
   }
 });
-createRoute({
+var GetReportData = createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/data",
   operationId: "getDataReportData",
@@ -1211,7 +1207,7 @@ createRoute({
     }
   }
 });
-createRoute({
+var GetReportRowCount = createRoute({
   method: "get",
   path: "/api/v1/data-reports/{report_id}/count",
   operationId: "getDataReportRowCount",
@@ -2367,10 +2363,216 @@ var hashString = (value) => {
   const hash = sha256(data);
   return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
 };
+var QuickActionSchema = z.object({
+  label: z.string(),
+  explanation: z.string()
+});
+var QuickActionsSchema = QuickActionSchema.array();
+var FrontendTimelineItemSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("dataReport"),
+    flowDataId: z.number(),
+    flowId: z.string(),
+    title: z.string(),
+    bookmarked: z.boolean(),
+    answer: z.string().nullable()
+  }),
+  z.object({
+    type: z.literal("visualization"),
+    flowId: z.string(),
+    flowDataId: z.number(),
+    flowDataVisualizationId: z.number(),
+    title: z.string(),
+    bookmarked: z.boolean()
+  }),
+  z.object({
+    type: z.literal("message")
+  })
+]);
+
+// ../shared/dist/src/endpoints/companion/chat.routes.js
+createRoute({
+  hide: true,
+  method: "get",
+  path: "/api/v1/chat/{flowId}/timeline",
+  operationId: "retrieveChatTimeline",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam
+  },
+  responses: {
+    200: {
+      description: "The timeline of generated insights for the flow",
+      content: {
+        "application/json": {
+          schema: FrontendTimelineItemSchema.array()
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var ChatMessages = createRoute({
+  method: "get",
+  path: "/api/v1/chat/{flowId}/messages",
+  operationId: "retrieveChatMessages",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam
+  },
+  responses: {
+    200: {
+      description: "The messages from the given flow",
+      content: {
+        "application/json": {
+          // we don't want to have to write a parser for Vercel AI messages
+          schema: z.object({ messages: z.object({}).passthrough().array() })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  hide: true,
+  method: "post",
+  path: "/api/v1/chat/{flowId}/quick-actions",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam,
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            content: z.string()
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "The quick actions for the given message",
+      content: {
+        "application/json": {
+          schema: QuickActionsSchema
+        }
+      }
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "The provided content is invalid"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var DataTableSchema = z.object({
+  id: z.number(),
+  dataset: z.string(),
+  table_name: z.string(),
+  description: z.string().nullable(),
+  primary_key_names: z.string().array(),
+  row_count: z.number().nullable(),
+  created_at: z.string(),
+  updated_at: z.string(),
+  source_id: z.number(),
+  parent_table_id: z.number().nullable()
+});
+var DataTableColumnSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  data_type: z.string().nullable(),
+  description: z.string().nullable(),
+  null_percentage: z.number().nullable(),
+  unique_values: z.number().nullable(),
+  sample_values: z.array(z.unknown()).nullable()
+});
+DataTableSchema.extend({
+  columns: z.array(DataTableColumnSchema)
+});
+var toSearchParams = ({ cursor, filters, sorting, limit }) => {
+  const params = {};
+  if (limit !== void 0) {
+    params.limit = limit;
+  }
+  if (cursor !== void 0) {
+    params.cursor = cursor;
+  }
+  const sortingParams = sorting?.map((c) => `${c.id}:${c.desc ? "DESC" : "ASC"}`).join(",");
+  if (sortingParams) {
+    params.order = sortingParams;
+  }
+  if (filters) {
+    const filterParams = Object.entries(filters).flatMap(([key, value]) => {
+      if (!(typeof value === "string" || typeof value === "boolean" || typeof value === "number"))
+        return [];
+      return `${key}:${encodeURIComponent(value)}`;
+    }).join(",");
+    if (filterParams.length > 0) {
+      params.filter = filterParams;
+    }
+  }
+  return params;
+};
 
 // package.json
 var package_default = {
-  version: "0.1.4"};
+  version: "0.1.5"};
 var MageMetricsChatTransport = class extends DefaultChatTransport {
   constructor(apiUrl, flowId, options) {
     super({
@@ -2458,7 +2660,8 @@ var MageMetricsClient = class {
   userId = null;
   storageAdapter;
   events = new MageMetricsEventEmitter();
-  constructor(config) {
+  authOptions;
+  constructor(config, auth) {
     this.config = config;
     this.storageAdapter = config.storageAdapter || createStorageAdapter();
     this.internalApiClient = createApiClient({
@@ -2466,7 +2669,12 @@ var MageMetricsClient = class {
     });
     this.internalApiClient.use(throwOnError);
     this.internalApiClient.use(this.createSupabaseHeaderMiddleware());
-    this.internalApiClient.use(addVersionHeader(MM_CLIENT_VERSION));
+    this.authOptions = auth || {};
+  }
+  toJSON() {
+    return {
+      config: this.encodeCheckKey(this.config.apiKey, this.config.apiUrl)
+    };
   }
   /**
    * Add an event listener for authentication state changes
@@ -2507,7 +2715,7 @@ var MageMetricsClient = class {
   get state() {
     return this.authState;
   }
-  async getAuthHeaders() {
+  async getHeaders() {
     await this.waitForAuth();
     if (!this.supabaseClient) {
       return {};
@@ -2518,6 +2726,7 @@ var MageMetricsClient = class {
     }
     const { access_token } = session.data.session;
     return {
+      [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION,
       "sp-access-token": access_token
     };
   }
@@ -2534,6 +2743,10 @@ var MageMetricsClient = class {
     }
     await this.clearStorage();
   }
+  auth = {
+    startAutoRefresh: () => this.supabaseClient?.startAutoRefresh(),
+    stopAuthRefresh: () => this.supabaseClient?.startAutoRefresh()
+  };
   /**
    * Public API methods that automatically wait for authentication
    */
@@ -2674,19 +2887,102 @@ var MageMetricsClient = class {
       }
       return data;
     },
-    getChat: (flowId, options) => {
+    getChatTransport: (flowId, options) => {
       return new MageMetricsChatTransport(this.config.apiUrl, flowId, {
         ...options,
         headers: async () => {
-          const authHeaders = await this.getAuthHeaders();
+          const authHeaders = await this.getHeaders();
           const headers = await resolve(options?.headers);
           return {
             ...headers,
-            ...authHeaders,
-            [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION
+            ...authHeaders
           };
         }
       });
+    },
+    getChatMessages: async (flowId) => {
+      const { data, error, response } = await this.internalApiClient.GET(
+        ChatMessages.path,
+        {
+          params: {
+            path: {
+              flowId
+            }
+          }
+        }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
+    fetchReportData: async (reportId, { columns, limit, sorting, filters, cursor }) => {
+      const params = toSearchParams({ limit, sorting, filters, cursor });
+      const { data, error } = await this.internalApiClient.GET(
+        GetReportData.path,
+        {
+          params: {
+            path: {
+              report_id: reportId.toString()
+            },
+            query: {
+              columns: columns?.join(","),
+              limit: params.limit,
+              order: params.order,
+              cursor: params.cursor,
+              filter: params.filter
+            }
+          }
+        }
+      );
+      if (error) {
+        console.error(
+          `Failed to fetch data for report ${reportId}: ${error.error}`
+        );
+        throw new Error(`Failed to fetch data for flow data ${reportId}`);
+      }
+      return data;
+    },
+    getReport: async (reportId) => {
+      const params = { params: { path: { report_id: String(reportId) } } };
+      const columnsPromise = this.internalApiClient.GET(
+        GetReportColumns.path,
+        params
+      );
+      const rowCountPromise = this.internalApiClient.GET(
+        GetReportRowCount.path,
+        params
+      );
+      const [
+        { data: columns, error: columnsError, response: columnsResponse },
+        { data: rowCount, error: rowCountError, response: rowCountResponse }
+      ] = await Promise.all([columnsPromise, rowCountPromise]);
+      if (columnsError) {
+        throw new ApiError(columnsError.error, columnsResponse, {
+          status: columnsResponse.status,
+          statusText: columnsResponse.statusText,
+          url: columnsResponse.url,
+          method: "GET"
+        });
+      }
+      if (rowCountError) {
+        throw new ApiError(rowCountError.error, rowCountResponse, {
+          status: rowCountResponse.status,
+          statusText: rowCountResponse.statusText,
+          url: rowCountResponse.url,
+          method: "GET"
+        });
+      }
+      return {
+        columns,
+        rowCount,
+        data: this.api.fetchReportData
+      };
     }
   };
   /**
@@ -2735,7 +3031,9 @@ var MageMetricsClient = class {
         storageKey: TOKEN_STORAGE_KEY,
         headers: {
           apiKey: anonKey
-        }
+        },
+        storage: this.storageAdapter,
+        ...this.authOptions
       });
       this.supabaseClient.onAuthStateChange((event, session) => {
         console.debug("Supabase auth state change:", event, !!session);
@@ -2829,7 +3127,7 @@ var MageMetricsClient = class {
   createSupabaseHeaderMiddleware() {
     return {
       onRequest: async ({ request }) => {
-        const headers = await this.getAuthHeaders();
+        const headers = await this.getHeaders();
         if (!this.supabaseClient) {
           return request;
         }