@magemetrics/core 0.1.8 → 0.2.0

package/dist/index.js

@@ -745,11 +745,11 @@ var VisualizationMetadataSchema = z.object({
   originalCount: z.number(),
   sampledCount: z.number()
 }).optional();
-V1FrontendVisualizationSchema.extend({
+var V1FrontendVisualizationWithDataSchema = V1FrontendVisualizationSchema.extend({
   data: VisualizationDataSchema,
   _metadata: VisualizationMetadataSchema
 });
-FrontendVisualizationSchema.extend({
+var FrontendVisualizationWithDataSchema = FrontendVisualizationSchema.extend({
   data: VisualizationDataSchema,
   _metadata: VisualizationMetadataSchema
 });
@@ -759,7 +759,7 @@ var FlowIdParam = z.object({ flowId: z.string().uuid() }).openapi("FlowId", { ty
 var FlowDataIdParam = z.object({ flowDataId: z.string().pipe(z.coerce.number()) }).openapi("FlowDataId", { type: "integer" });
 var ReportId = z.string().pipe(z.coerce.number());
 var ReportIdParam = z.object({ report_id: ReportId }).openapi("ReportId", { type: "integer" });
-createRoute({
+var RetrieveFlowDataReports = createRoute({
   method: "get",
   path: "/api/v1/flows/{flowId}/data-reports",
   operationId: "retrieveFlowDataReports",
@@ -2080,89 +2080,6 @@ var ExchangeExternalToken = createRoute({
   }
 });
 
-// ../shared/dist/src/schemas/dashboard.js
-var DashboardTileSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("data-report"),
-    flowId: z.string(),
-    flowDataId: z.number(),
-    title: z.string(),
-    col: z.number(),
-    colSpan: z.number(),
-    rowSpan: z.number()
-  }),
-  z.object({
-    type: z.literal("visualization"),
-    visualizationId: z.number(),
-    title: z.string(),
-    col: z.number(),
-    colSpan: z.number(),
-    rowSpan: z.number()
-  })
-]);
-var DashboardSchema = z.object({
-  company_id: z.number(),
-  created_at: z.string(),
-  description: z.string().nullable(),
-  id: z.string().uuid(),
-  name: z.string(),
-  positions: z.array(DashboardTileSchema),
-  updated_at: z.string(),
-  is_removed: z.boolean(),
-  is_public: z.boolean()
-});
-var DashboardIdParam = DashboardSchema.shape.id.openapi("DashboardId", {
-  type: "string",
-  format: "uuid"
-});
-var FrontendDashboardSchema = DashboardSchema.omit({
-  company_id: true,
-  created_at: true,
-  updated_at: true,
-  is_removed: true
-});
-
-// ../shared/dist/src/endpoints/companion/dashboards.routes.js
-var RetrieveDashboard = createRoute({
-  method: "get",
-  path: "/api/v1/dashboard/{dashboard_id}",
-  operationId: "retrieveDashboard",
-  request: {
-    headers: SupabaseHeaderSchema,
-    params: z.object({
-      dashboard_id: DashboardIdParam
-    })
-  },
-  responses: {
-    200: {
-      description: "The dashboard with the given id",
-      content: {
-        "application/json": {
-          schema: FrontendDashboardSchema
-        }
-      }
-    },
-    404: {
-      content: {
-        "application/json": {
-          schema: z.object({ error: z.string() })
-        }
-      },
-      description: "Unable to retrieve dashboard with this id"
-    },
-    500: {
-      description: "Something wrong happened",
-      content: {
-        "application/json": {
-          schema: z.object({
-            error: z.string()
-          })
-        }
-      }
-    }
-  }
-});
-
 // ../shared/dist/src/endpoints/end2end/run.routes.js
 var End2EndApiResponseSchema = z.discriminatedUnion("status", [
   z.object({
@@ -2363,6 +2280,289 @@ var hashString = (value) => {
   const hash = sha256(data);
   return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
 };
+
+// ../shared/dist/src/schemas/canvas.js
+var CanvasSchema = z.object({
+  company_id: z.number(),
+  created_at: z.string(),
+  id: z.string().uuid(),
+  title: z.string().nullable(),
+  updated_at: z.string(),
+  is_removed: z.boolean(),
+  is_public: z.boolean(),
+  nodes: z.array(z.any()),
+  edges: z.array(z.any())
+});
+var FrontendCanvasSchema = CanvasSchema.omit({
+  company_id: true,
+  created_at: true,
+  updated_at: true,
+  is_removed: true
+});
+var UpdateCanvasSchema = z.object({
+  id: CanvasSchema.shape.id,
+  title: CanvasSchema.shape.title.optional(),
+  nodes: CanvasSchema.shape.nodes.optional(),
+  edges: CanvasSchema.shape.edges.optional(),
+  is_public: CanvasSchema.shape.is_public.optional()
+});
+var CreateCanvasSchema = CanvasSchema.omit({
+  id: true,
+  created_at: true,
+  updated_at: true,
+  company_id: true,
+  is_removed: true
+}).extend({
+  flow_id: z.string().optional()
+});
+var CanvasIdParam = CanvasSchema.shape.id.openapi("CanvasId", {
+  type: "string",
+  format: "uuid"
+});
+
+// ../shared/dist/src/endpoints/companion/canvas.routes.js
+var ListCanvases = createRoute({
+  method: "get",
+  path: "/api/v1/canvases",
+  operationId: "listCanvases",
+  request: {
+    headers: SupabaseHeaderSchema,
+    query: z.object({
+      search: z.string().optional()
+    })
+  },
+  responses: {
+    200: {
+      description: "A list of canvases",
+      content: {
+        "application/json": {
+          schema: z.array(FrontendCanvasSchema.extend({
+            canvas_flows: z.object({
+              flow_id: z.string()
+            }).array()
+          }))
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var RetrieveCanvas = createRoute({
+  method: "get",
+  path: "/api/v1/canvas/{canvas_id}",
+  operationId: "retrieveCanvas",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: z.object({
+      canvas_id: CanvasIdParam
+    })
+  },
+  responses: {
+    200: {
+      description: "The canvas with the given id",
+      content: {
+        "application/json": {
+          schema: FrontendCanvasSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve canvas with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var CreateCanvas = createRoute({
+  method: "post",
+  path: "/api/v1/canvas/",
+  operationId: "createCanvas",
+  request: {
+    headers: SupabaseHeaderSchema,
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: CreateCanvasSchema
+        }
+      }
+    }
+  },
+  responses: {
+    201: {
+      description: "The created canvas",
+      content: {
+        "application/json": {
+          schema: z.object({
+            id: z.string()
+          })
+        }
+      }
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid request"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var UpdateCanvas = createRoute({
+  method: "put",
+  path: "/api/v1/canvas/{canvas_id}",
+  operationId: "updateCanvas",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: z.object({
+      canvas_id: CanvasIdParam
+    }),
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: UpdateCanvasSchema.omit({ id: true })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "The updated canvas",
+      content: {
+        "application/json": {
+          schema: z.object({
+            success: z.literal(true)
+          })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve canvas with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var DeleteCanvas = createRoute({
+  method: "delete",
+  path: "/api/v1/canvas/{canvas_id}",
+  operationId: "deleteCanvas",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: z.object({
+      canvas_id: CanvasIdParam
+    })
+  },
+  responses: {
+    204: {
+      description: "Canvas deleted successfully"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to delete canvas with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var GetCanvasForFlow = createRoute({
+  method: "get",
+  path: "/api/v1/canvas/flow/{flow_id}",
+  operationId: "getCanvasForFlow",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: z.object({
+      flow_id: z.string().uuid()
+    })
+  },
+  responses: {
+    200: {
+      description: "The canvas for the given flow",
+      content: {
+        "application/json": {
+          schema: FrontendCanvasSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve canvas for this flow"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
 var QuickActionSchema = z.object({
   label: z.string(),
   explanation: z.string()
@@ -2521,6 +2721,103 @@ createRoute({
     }
   }
 });
+
+// ../shared/dist/src/endpoints/visualizations.routes.js
+var VisualizationWithDataResponse = z.union([
+  FrontendVisualizationWithDataSchema,
+  V1FrontendVisualizationWithDataSchema
+]).openapi("VisualizationWithData");
+createRoute({
+  method: "get",
+  path: "/api/v1/visualizations/{visualization_id}",
+  operationId: "fetchVisualization",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: z.object({ visualization_id: z.string().pipe(z.coerce.number()) }).openapi("VisualizationId", { type: "number" })
+  },
+  responses: {
+    200: {
+      description: "The content of the visualization",
+      content: {
+        "application/json": {
+          schema: VisualizationWithDataResponse
+        }
+      }
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid arguments to fetch visualization"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to fetch visualization with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var ListVisualizationsForFlow = createRoute({
+  method: "get",
+  path: "/api/v1/flows/{flowId}/visualizations",
+  operationId: "listVisualizationsForFlow",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam,
+    query: FlowDataIdParam.partial()
+  },
+  responses: {
+    200: {
+      description: "List visualizations for a given flow. Can be filtered by flow data id as well",
+      content: {
+        "application/json": {
+          schema: FrontendVisualizationSchema.array()
+        }
+      }
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid arguments to fetch visualization"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to list visualizations"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
 var DataTableSchema = z.object({
   id: z.number(),
   dataset: z.string(),
@@ -2572,7 +2869,7 @@ var toSearchParams = ({ cursor, filters, sorting, limit }) => {
 
 // package.json
 var package_default = {
-  version: "0.1.8"};
+  version: "0.2.0"};
 var MageMetricsChatTransport = class extends DefaultChatTransport {
   constructor(apiUrl, flowId, options) {
     super({
@@ -2757,6 +3054,38 @@ var MageMetricsClient = class {
    * Public API methods that automatically wait for authentication
    */
   api = {
+    getFlowVisualizations: async (flowId) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        ListVisualizationsForFlow.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;
+    },
+    getFlowDataReports: async (flowId) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        RetrieveFlowDataReports.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;
+    },
     getRecentFlows: async (params = {}) => {
       await this.waitForAuth();
       const { data, error, response } = await this.internalApiClient.GET(
@@ -2825,27 +3154,135 @@ var MageMetricsClient = class {
         return { flowId: data.flowId };
       }
     },
-    getDashboard: async (dashboardId) => {
-      await this.waitForAuth();
-      const { data, error, response } = await this.internalApiClient.GET(
-        RetrieveDashboard.path,
-        {
-          params: {
-            path: {
-              dashboard_id: dashboardId
+    canvas: {
+      list: async (query) => {
+        await this.waitForAuth();
+        const { data, error, response } = await this.internalApiClient.GET(
+          ListCanvases.path,
+          {
+            params: {
+              query: {
+                search: query
+              }
             }
           }
+        );
+        if (error) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "GET"
+          });
         }
-      );
-      if (error) {
-        throw new ApiError(error.error, response, {
-          status: response.status,
-          statusText: response.statusText,
-          url: response.url,
-          method: "GET"
-        });
+        return FrontendCanvasSchema.extend({
+          canvas_flows: z.object({
+            flow_id: z.string()
+          }).array()
+        }).array().parse(data);
+      },
+      get: async (canvasId) => {
+        await this.waitForAuth();
+        const { data, error, response } = await this.internalApiClient.GET(
+          RetrieveCanvas.path,
+          {
+            params: {
+              path: {
+                canvas_id: canvasId
+              }
+            }
+          }
+        );
+        if (error) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "GET"
+          });
+        }
+        return FrontendCanvasSchema.parse(data);
+      },
+      create: async (body) => {
+        await this.waitForAuth();
+        const { data, error, response } = await this.internalApiClient.POST(
+          CreateCanvas.path,
+          {
+            body
+          }
+        );
+        if (!data) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "POST"
+          });
+        }
+        return data;
+      },
+      update: async (body) => {
+        await this.waitForAuth();
+        const { data, error, response } = await this.internalApiClient.PUT(
+          UpdateCanvas.path,
+          {
+            params: {
+              path: {
+                canvas_id: String(body.id)
+              }
+            },
+            body
+          }
+        );
+        if (!data) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "PUT"
+          });
+        }
+        return data;
+      },
+      delete: async (canvasId) => {
+        await this.waitForAuth();
+        const { error, response } = await this.internalApiClient.DELETE(
+          DeleteCanvas.path,
+          {
+            params: { path: { canvas_id: canvasId } }
+          }
+        );
+        if (error) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "DELETE"
+          });
+        }
+      },
+      getForFlow: async (flowId) => {
+        await this.waitForAuth();
+        const { data, error, response } = await this.internalApiClient.GET(
+          GetCanvasForFlow.path,
+          {
+            params: {
+              path: {
+                flow_id: flowId
+              }
+            }
+          }
+        );
+        if (error) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "GET"
+          });
+        }
+        return FrontendCanvasSchema.parse(data);
       }
-      return data;
     },
     exportReportData: async (reportId, format = "blob") => {
       await this.waitForAuth();