@magemetrics/core 0.1.3 → 0.1.5

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,227 @@ 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.3"};
+  version: "0.1.5"};
+var MageMetricsChatTransport = class extends DefaultChatTransport {
+  constructor(apiUrl, flowId, options) {
+    super({
+      ...options,
+      api: `${apiUrl}/api/v1/chat/${flowId}`,
+      prepareSendMessagesRequest({ messages, id: chatId }) {
+        return { body: { message: messages.at(-1), id: chatId } };
+      }
+    });
+  }
+};
 
 // src/core/MageMetricsEventEmitter.ts
 var MageMetricsEventEmitter = class {
@@ -2414,26 +2627,20 @@ var MageMetricsEventEmitter = class {
   }
 };
 
+// src/core/resolvable.ts
+var resolve = (value) => {
+  if (typeof value === "function") {
+    return Promise.resolve(value());
+  }
+  return Promise.resolve(value);
+};
+
 // src/core/types.ts
 var TOKEN_STORAGE_KEY = "mm-ai-sp-token";
 var CHECK_KEY = "mm-ai-check-key";
 
 // src/core/MageMetricsClient.ts
 var MM_CLIENT_VERSION = package_default.version;
-var MageMetricsChatTransport = class extends DefaultChatTransport {
-  constructor(apiUrl, flowId, options) {
-    super({
-      ...options,
-      headers: {
-        [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION
-      },
-      api: `${apiUrl}/api/v1/chat/${flowId}`,
-      prepareSendMessagesRequest({ messages, id: chatId }) {
-        return { body: { message: messages.at(-1), id: chatId } };
-      }
-    });
-  }
-};
 var getPublicApiClient = (apiUrl, apiKey) => {
   const client = createApiClient({ baseUrl: apiUrl });
   client.use(throwOnError);
@@ -2445,17 +2652,29 @@ var MageMetricsClient = class {
   config;
   authState = "initializing";
   supabaseClient = null;
-  internalApiClient = null;
+  internalApiClient;
   noAuthApiClient = null;
   authApiResponse = null;
   authPromise = null;
   processedJwt = Symbol("initial");
+  userId = null;
   storageAdapter;
   events = new MageMetricsEventEmitter();
-  constructor(config) {
+  authOptions;
+  constructor(config, auth) {
     this.config = config;
     this.storageAdapter = config.storageAdapter || createStorageAdapter();
-    void this.initializeAuth();
+    this.internalApiClient = createApiClient({
+      baseUrl: this.config.apiUrl
+    });
+    this.internalApiClient.use(throwOnError);
+    this.internalApiClient.use(this.createSupabaseHeaderMiddleware());
+    this.authOptions = auth || {};
+  }
+  toJSON() {
+    return {
+      config: this.encodeCheckKey(this.config.apiKey, this.config.apiUrl)
+    };
   }
   /**
    * Add an event listener for authentication state changes
@@ -2482,10 +2701,10 @@ var MageMetricsClient = class {
     if (this.authState === "error") {
       throw new Error("Authentication failed");
     }
-    if (this.authPromise) {
-      return this.authPromise;
+    if (!this.authPromise) {
+      this.authPromise = this.performAuthFlow();
     }
-    throw new Error("Authentication not initialized");
+    return this.authPromise;
   }
   async updateExternalJwt(jwt) {
     if (this.config.externalJwt === jwt) return;
@@ -2496,7 +2715,7 @@ var MageMetricsClient = class {
   get state() {
     return this.authState;
   }
-  async getAuthHeaders() {
+  async getHeaders() {
     await this.waitForAuth();
     if (!this.supabaseClient) {
       return {};
@@ -2506,11 +2725,10 @@ var MageMetricsClient = class {
       return {};
     }
     const { access_token } = session.data.session;
-    const headers = {};
-    if (access_token) {
-      headers["sp-access-token"] = access_token;
-    }
-    return headers;
+    return {
+      [HEADER_CLIENT_VERSION]: MM_CLIENT_VERSION,
+      "sp-access-token": access_token
+    };
   }
   async clearStorage() {
     try {
@@ -2525,13 +2743,16 @@ var MageMetricsClient = class {
     }
     await this.clearStorage();
   }
+  auth = {
+    startAutoRefresh: () => this.supabaseClient?.startAutoRefresh(),
+    stopAuthRefresh: () => this.supabaseClient?.startAutoRefresh()
+  };
   /**
    * Public API methods that automatically wait for authentication
    */
   api = {
     getRecentFlows: async (params = {}) => {
       await this.waitForAuth();
-      if (!this.internalApiClient) throw new Error("API client not ready");
       const { data, error, response } = await this.internalApiClient.GET(
         RetrieveRecentFlows.path,
         {
@@ -2554,7 +2775,6 @@ var MageMetricsClient = class {
     },
     createFlow: async (request) => {
       await this.waitForAuth();
-      if (!this.internalApiClient) throw new Error("API client not ready");
       if ("query" in request) {
         const { data, error, response } = await this.internalApiClient.POST(
           CreateFlow.path,
@@ -2601,7 +2821,6 @@ var MageMetricsClient = class {
     },
     getDashboard: async (dashboardId) => {
       await this.waitForAuth();
-      if (!this.internalApiClient) throw new Error("API client not ready");
       const { data, error, response } = await this.internalApiClient.GET(
         RetrieveDashboard.path,
         {
@@ -2624,7 +2843,6 @@ var MageMetricsClient = class {
     },
     exportReportData: async (reportId, format = "blob") => {
       await this.waitForAuth();
-      if (!this.internalApiClient) throw new Error("API client not ready");
       const { data, error, response } = await this.internalApiClient.GET(
         ExportReportData.path,
         {
@@ -2650,7 +2868,6 @@ var MageMetricsClient = class {
     },
     generateContextualInsight: async (payload) => {
       await this.waitForAuth();
-      if (!this.internalApiClient) throw new Error("API client not ready");
       const { data, error, response } = await this.internalApiClient.POST(
         GenerateInsight.path,
         {
@@ -2669,19 +2886,105 @@ var MageMetricsClient = class {
         });
       }
       return data;
+    },
+    getChatTransport: (flowId, options) => {
+      return new MageMetricsChatTransport(this.config.apiUrl, flowId, {
+        ...options,
+        headers: async () => {
+          const authHeaders = await this.getHeaders();
+          const headers = await resolve(options?.headers);
+          return {
+            ...headers,
+            ...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
+      };
     }
   };
-  /**
-   * Initialize authentication flow
-   */
-  async initializeAuth() {
-    this.authPromise = this.performAuthFlow();
-    try {
-      await this.authPromise;
-    } catch (error) {
-      console.error("Failed to initialize authentication:", error);
-    }
-  }
   /**
    * Perform the complete authentication flow
    */
@@ -2690,7 +2993,6 @@ var MageMetricsClient = class {
       this.setState("initializing");
       const apiInfo = await this.getApiInformation();
       this.initializeSupabaseClient(apiInfo.anonKey, apiInfo.apiUrl);
-      this.initializeApiClient();
       await this.handleAuthentication();
       if (this.config.externalJwt) {
         await this.saveCheckKey(this.config.externalJwt, this.config.apiKey);
@@ -2729,10 +3031,18 @@ 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);
+        if (event === "SIGNED_IN" && session?.user) {
+          if (this.userId !== session.user.id && this.userId !== null) {
+            this.events.dispatch("userChange", { id: session.user.id });
+          }
+          this.userId = session.user.id;
+        }
         if (event === "TOKEN_REFRESHED" && session) {
           console.debug("Token refreshed successfully");
           this.setState("ready");
@@ -2744,27 +3054,8 @@ var MageMetricsClient = class {
       });
     }
   }
-  /* This method always waits for authentication to complete before returning the client */
-  async client() {
-    await this.waitForAuth();
-    if (this.authState === "ready") {
-      if (!this.internalApiClient) {
-        throw new Error(
-          "Client is ready but API client not available. This should never happen"
-        );
-      }
-      return this.internalApiClient;
-    }
-    throw new Error(`Client is not available in auth state: ${this.authState}`);
-  }
-  /**
-   * Initialize the API client with Supabase headers
-   */
-  initializeApiClient() {
-    this.internalApiClient = createApiClient({ baseUrl: this.config.apiUrl });
-    this.internalApiClient.use(throwOnError);
-    this.internalApiClient.use(this.createSupabaseHeaderMiddleware());
-    this.internalApiClient.use(addVersionHeader(MM_CLIENT_VERSION));
+  client() {
+    return this.internalApiClient;
   }
   /**
    * Handle the authentication logic (check session or exchange token)
@@ -2834,19 +3125,18 @@ var MageMetricsClient = class {
     console.debug("Token exchange successful, session set");
   }
   createSupabaseHeaderMiddleware() {
-    const supabaseClient = this.supabaseClient;
     return {
-      async onRequest({ request }) {
-        if (!supabaseClient) {
+      onRequest: async ({ request }) => {
+        const headers = await this.getHeaders();
+        if (!this.supabaseClient) {
           return request;
         }
-        const session = await supabaseClient.getSession();
+        const session = await this.supabaseClient.getSession();
         if (!session.data.session) {
           return request;
         }
-        const { access_token } = session.data.session;
-        if (access_token) {
-          request.headers.set("sp-access-token", access_token);
+        for (const [key, value] of Object.entries(headers)) {
+          request.headers.set(key, value);
         }
         return request;
       }
@@ -2879,6 +3169,6 @@ var MageMetricsClient = class {
   }
 };
 
-export { BrowserStorageAdapter, CHECK_KEY, MageMetricsChatTransport, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, TOKEN_STORAGE_KEY, getPublicApiClient };
+export { BrowserStorageAdapter, CHECK_KEY, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, TOKEN_STORAGE_KEY, getPublicApiClient };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map