@upsnap/strapi 1.0.7 → 1.0.9

package/dist/server/index.mjs

@@ -30,7 +30,7 @@ const service = ({ strapi }) => ({
     const settings2 = await this.settingsStore.get();
     return settings2?.token || null;
   },
-  async makeBackendRequest(endpoint, options, forValidation = false) {
+  async makeBackendRequest(endpoint, options, forValidation = false, sessionToken = "") {
     const token = await this.getToken();
     if (!token && !forValidation) {
       return { error: "No token found in settings" };
@@ -38,12 +38,27 @@ const service = ({ strapi }) => ({
     const response = await fetch(`${BACKEND_URL}${endpoint}`, {
       ...options,
       headers: {
-        Authorization: `Bearer ${token}`,
+        Authorization: `Bearer ${sessionToken || token}`,
         "Content-Type": "application/json",
         ...options.headers || {}
       }
     });
-    return response.json();
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    if (contentType.includes("text/csv")) {
+      return {
+        type: "csv",
+        data: await response.text(),
+        headers: response.headers
+      };
+    }
+    return {
+      type: "blob",
+      data: await response.arrayBuffer(),
+      headers: response.headers
+    };
   }
 });
 const settings = ({ strapi }) => ({
@@ -55,14 +70,16 @@ const settings = ({ strapi }) => ({
     };
   },
   async set(ctx) {
-    const { token } = ctx.request.body;
-    const isValidData = await service({ strapi }).makeBackendRequest("/tokens/validate", {
-      method: "POST",
-      body: JSON.stringify({ token })
-    }, true);
-    if (!isValidData?.data?.valid) {
-      ctx.body = { ok: false, error: "Invalid token" };
-      return;
+    const { token, logOut } = ctx.request.body;
+    if (!logOut) {
+      const isValidData = await service({ strapi }).makeBackendRequest("/tokens/validate", {
+        method: "POST",
+        body: JSON.stringify({ token })
+      }, true);
+      if (!isValidData?.data?.valid) {
+        ctx.body = { ok: false, error: "Invalid token" };
+        return;
+      }
     }
     const store = service({ strapi }).settingsStore;
     const current = await store.get() || {};
@@ -593,6 +610,81 @@ const monitor = ({ strapi }) => ({
       body: JSON.stringify({ ids: monitorIds, action: "delete" })
     });
     ctx.body = { monitorsData };
+  },
+  async getAllIncidents(ctx) {
+    const { ...params } = ctx.request.body;
+    const {
+      monitorId,
+      timeRange,
+      page,
+      pageSize,
+      checkType,
+      region,
+      search,
+      sortBy,
+      sortOrder
+    } = params;
+    if (!monitorId) {
+      ctx.status = 400;
+      ctx.body = { error: "monitorId is required" };
+      return;
+    }
+    const queryParams = new URLSearchParams();
+    queryParams.set("monitorId", monitorId);
+    if (timeRange) queryParams.set("time_range", timeRange);
+    if (page !== void 0) queryParams.set("page", page.toString());
+    if (pageSize !== void 0)
+      queryParams.set("page_size", pageSize.toString());
+    if (checkType) queryParams.set("check_type", checkType);
+    if (region) queryParams.set("region", region);
+    if (search) queryParams.set("search", search);
+    if (sortBy) queryParams.set("sort_by", sortBy);
+    if (sortOrder) queryParams.set("sort_order", sortOrder);
+    const incidentsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/incidents?${queryParams.toString()}`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { incidentsData };
+  },
+  async exportIncidents(ctx) {
+    try {
+      const { monitorId, region, type, start_time, end_time, search, file_type } = ctx.request.body;
+      if (!monitorId) {
+        ctx.status = 400;
+        ctx.body = { error: "monitorId is required" };
+        return;
+      }
+      const queryParams = new URLSearchParams();
+      if (type) queryParams.set("type", type);
+      if (start_time) queryParams.set("start_time", start_time);
+      if (end_time) queryParams.set("end_time", end_time);
+      if (search) queryParams.set("search", search);
+      if (file_type) queryParams.set("file_type", file_type);
+      if (region) queryParams.set("region", region);
+      const response = await service({ strapi }).makeBackendRequest(
+        `/user/monitors/${monitorId}/incidents/export?${queryParams.toString()}`,
+        { method: "GET" }
+      );
+      if (!response?.type) {
+        ctx.body = response;
+        return;
+      }
+      const contentType = response.headers.get("content-type") || "application/octet-stream";
+      const disposition = response.headers.get("content-disposition") || `attachment; filename=incidents.${file_type === "excel" ? "xlsx" : file_type || "csv"}`;
+      ctx.set("Content-Type", contentType);
+      ctx.set("Content-Disposition", disposition);
+      if (response.type === "csv") {
+        ctx.body = response.data;
+      } else {
+        ctx.body = Buffer.from(response.data);
+      }
+    } catch (error) {
+      console.error("Error exporting incidents: ", error);
+      ctx.status = 500;
+      ctx.body = { error: "Failed to export incidents" };
+    }
   }
 });
 const statusPage = ({ strapi }) => ({
@@ -660,12 +752,212 @@ const regions = ({ strapi }) => ({
     ctx.body = { regionsData };
   }
 });
+const userDetailsService = ({ strapi }) => ({
+  async createUserApiToken(sessionToken) {
+    const apiTokens = await service({ strapi }).makeBackendRequest(
+      `/tokens/generate`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          name: "For Strapi",
+          description: "Token for strapi plugin",
+          expires: 0
+        })
+      },
+      true,
+      sessionToken
+    );
+    if (apiTokens?.data?.token_hash) {
+      const token = apiTokens?.data?.token_hash;
+      return token;
+    }
+    return null;
+  },
+  async getUserApiToken(sessionToken) {
+    const apiTokens = await service({ strapi }).makeBackendRequest(
+      `/tokens`,
+      {
+        method: "GET"
+      },
+      true,
+      sessionToken
+    );
+    const tokens = apiTokens?.data?.tokens || [];
+    let apiToken = "";
+    if (apiTokens?.status === "success" && tokens.length === 0) {
+      apiToken = await this.createUserApiToken(sessionToken);
+    } else if (tokens.length > 0) {
+      apiToken = tokens?.[0]?.token_hash;
+    }
+    return apiToken;
+  },
+  async createInitialMonitor(site_url, apiToken) {
+    try {
+      const payload = {
+        name: "Default Monitor",
+        service_type: "website",
+        is_enabled: true,
+        channel_ids: [],
+        tag_ids: [],
+        regions: [
+          {
+            id: "default",
+            is_primary: true,
+            name: "Default (Server Region)"
+          }
+        ],
+        config: {
+          meta: {
+            follow_redirects: true,
+            timeout: 5,
+            url: site_url
+          },
+          services: {
+            broken_links: {
+              enabled: true,
+              monitor_interval: 86400
+            },
+            domain: {
+              enabled: true,
+              monitor_interval: 86400,
+              notify_days_before_expiry: 7
+            },
+            lighthouse: {
+              enabled: true,
+              strategy: "desktop",
+              monitor_interval: 604800
+            },
+            mixed_content: {
+              enabled: true,
+              monitor_interval: 86400
+            },
+            ssl: {
+              enabled: true,
+              monitor_interval: 86400,
+              notify_days_before_expiry: 7
+            },
+            uptime: {
+              enabled: true,
+              monitor_interval: 300
+            }
+          }
+        }
+      };
+      const monitorsData = await service({ strapi }).makeBackendRequest(`/user/monitors`, {
+        method: "POST",
+        body: JSON.stringify(payload)
+      }, true, apiToken);
+      if (monitorsData?.status === "success") {
+        const monitorId = monitorsData?.data?.monitor?.id;
+        return monitorId;
+      }
+      return null;
+    } catch (err) {
+      console.log("Error creating initial monitor ", err);
+      return null;
+    }
+  }
+});
 const userDetails = ({ strapi }) => ({
   async getUserDetails(ctx) {
     const userDetailsData = await service({ strapi }).makeBackendRequest(`/user/details`, {
       method: "GET"
     });
     ctx.body = { userDetailsData };
+  },
+  async signUp(ctx) {
+    try {
+      const { email, password, source, site_url, fullName } = ctx.request.body;
+      const registerData = await service({ strapi }).makeBackendRequest(
+        `/user/register`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            email,
+            password,
+            source,
+            full_name: fullName
+          })
+        },
+        true
+      );
+      if (registerData?.data?.token) {
+        const apiToken = await userDetailsService({ strapi }).getUserApiToken(registerData?.data?.token);
+        const monitorId = await userDetailsService({ strapi }).createInitialMonitor(site_url, apiToken);
+        if (!apiToken || !monitorId) {
+          ctx.body = { ok: false, message: "Error creating API token or Monitor" };
+          return;
+        }
+        const store = service({ strapi }).settingsStore;
+        const current = await store.get() || {};
+        await store.set({
+          value: {
+            ...current,
+            token: apiToken,
+            primaryMonitorId: monitorId
+          }
+        });
+        return ctx.body = { ok: true, message: registerData?.data?.message };
+      }
+      ctx.body = { ok: false };
+    } catch (err) {
+      console.log("Error signing up ", err);
+      ctx.body = { ok: false };
+    }
+  },
+  async signIn(ctx) {
+    try {
+      const { email, password } = ctx.request.body;
+      const loginData = await service({ strapi }).makeBackendRequest(
+        `/user/login`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            email,
+            password
+          })
+        },
+        true
+      );
+      if (loginData?.data?.token) {
+        const apiToken = await userDetailsService({ strapi }).getUserApiToken(loginData?.data?.token);
+        const store = service({ strapi }).settingsStore;
+        const current = await store.get() || {};
+        await store.set({
+          value: {
+            ...current,
+            token: apiToken
+          }
+        });
+        return ctx.body = { ok: true };
+      }
+      ctx.body = { ok: false, message: loginData?.message };
+    } catch (err) {
+      console.log("Error signing in ", err);
+      ctx.body = { ok: false };
+    }
+  },
+  async forgotPassword(ctx) {
+    try {
+      const { email } = ctx.request.body;
+      const forgotPasswordData = await service({ strapi }).makeBackendRequest(
+        `/user/forgot-password`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            email
+          })
+        },
+        true
+      );
+      if (forgotPasswordData?.status === "success") {
+        return ctx.body = { ok: true, message: forgotPasswordData?.data?.message };
+      }
+      ctx.body = { ok: false };
+    } catch (err) {
+      console.log("Error for forgot password ", err);
+      ctx.body = { ok: false };
+    }
   }
 });
 const notificationChannels = ({ strapi }) => ({
@@ -1066,12 +1358,58 @@ const routes = {
           policies: [],
           auth: false
         }
+      },
+      {
+        method: "POST",
+        path: "/signup",
+        handler: "userDetails.signUp",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/login",
+        handler: "userDetails.signIn",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/forgot-password",
+        handler: "userDetails.forgotPassword",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/all-incidents",
+        handler: "monitor.getAllIncidents",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/incidents/export",
+        handler: "monitor.exportIncidents",
+        config: {
+          policies: [],
+          auth: false
+        }
       }
     ]
   }
 };
 const services = {
-  service
+  service,
+  userDetailsService
 };
 const index = {
   register,

package/dist/server/src/index.d.ts

@@ -47,6 +47,8 @@ declare const _default: {
             updateMonitor(ctx: any): Promise<void>;
             deleteMonitor(ctx: any): Promise<void>;
             deleteMonitors(ctx: any): Promise<void>;
+            getAllIncidents(ctx: any): Promise<void>;
+            exportIncidents(ctx: any): Promise<void>;
         };
         statusPage: ({ strapi }: {
             strapi: import('@strapi/types/dist/core').Strapi;
@@ -67,6 +69,17 @@ declare const _default: {
             strapi: import('@strapi/types/dist/core').Strapi;
         }) => {
             getUserDetails(ctx: any): Promise<void>;
+            signUp(ctx: any): Promise<{
+                ok: boolean;
+                message: any;
+            }>;
+            signIn(ctx: any): Promise<{
+                ok: boolean;
+            }>;
+            forgotPassword(ctx: any): Promise<{
+                ok: boolean;
+                message: any;
+            }>;
         };
         notificationChannels: ({ strapi }: {
             strapi: import('@strapi/types/dist/core').Strapi;
@@ -123,7 +136,14 @@ declare const _default: {
                 }>): Promise<void>;
             };
             getToken(): Promise<string>;
-            makeBackendRequest(endpoint: string, options: RequestInit, forValidation?: boolean): Promise<unknown>;
+            makeBackendRequest(endpoint: string, options: RequestInit, forValidation?: boolean, sessionToken?: string): Promise<unknown>;
+        };
+        userDetailsService: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            createUserApiToken(sessionToken: string): Promise<any>;
+            getUserApiToken(sessionToken: string): Promise<string>;
+            createInitialMonitor(site_url: string, apiToken: string): Promise<any>;
         };
     };
     contentTypes: {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.7",
+  "version": "1.0.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/Appfoster/upsnap-strapi"