@upsnap/strapi 1.0.0 → 1.0.2

package/dist/server/index.js

@@ -0,0 +1,1090 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi }) => ({
+  index(ctx) {
+    ctx.body = strapi.plugin("upsnap").service("service").getWelcomeMessage();
+  }
+});
+const BACKEND_URL = "https://api.upsnap.ai/v1";
+const LIGHTHOUSE_CHECKS = ["performance", "accessibility", "bestPractices", "seo", "pwa"];
+const service = ({ strapi }) => ({
+  getWelcomeMessage() {
+    return "Welcome to Strapi 🚀";
+  },
+  settingsStore: strapi.store({
+    type: "plugin",
+    name: "upsnap",
+    key: "settings"
+  }),
+  async getToken() {
+    const settings2 = await this.settingsStore.get();
+    return settings2?.token || null;
+  },
+  async makeBackendRequest(endpoint, options) {
+    const token = await this.getToken();
+    if (!token) {
+      return { error: "No token found in settings" };
+    }
+    const response = await fetch(`${BACKEND_URL}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        ...options.headers || {}
+      }
+    });
+    return response.json();
+  }
+});
+const settings = ({ strapi }) => ({
+  async get(ctx) {
+    const settings2 = await service({ strapi }).settingsStore.get();
+    ctx.body = {
+      token: settings2?.token ?? null,
+      primaryMonitorId: settings2?.primaryMonitorId ?? null
+    };
+  },
+  async set(ctx) {
+    const { token } = ctx.request.body;
+    const isValidData = await service({ strapi }).makeBackendRequest("/tokens/validate", {
+      method: "POST",
+      body: JSON.stringify({ token })
+    });
+    if (!isValidData?.data?.valid) {
+      ctx.body = { ok: false, error: "Invalid token" };
+      return;
+    }
+    const store = service({ strapi }).settingsStore;
+    const current = await store.get() || {};
+    await store.set({
+      value: {
+        ...current,
+        token
+      }
+    });
+    ctx.body = { ok: true };
+  },
+  async setPrimaryMonitorId(ctx) {
+    const { monitorId } = ctx.request.body;
+    const store = service({ strapi }).settingsStore;
+    const current = await store.get() || {};
+    await store.set({
+      value: {
+        ...current,
+        primaryMonitorId: monitorId
+      }
+    });
+    ctx.body = { ok: true };
+  },
+  async getPrimaryMonitorId(ctx) {
+    const settings2 = await service({ strapi }).settingsStore.get();
+    ctx.body = { primaryMonitorId: settings2?.primaryMonitorId };
+  }
+});
+function getMixedContentMessage(meta) {
+  if (!meta) return "Mixed content check completed";
+  const mixedCount = meta.mixedCount ?? 0;
+  if (mixedCount === 0) return "No mixed content found.";
+  if (mixedCount === 1) return "1 mixed content item detected.";
+  return `${mixedCount} mixed content items detected!`;
+}
+function buildSuccessResponse(raw) {
+  const meta = raw?.result?.details?.mixed_content?.meta || {};
+  raw?.result?.durationMs ?? null;
+  const mixedCount = meta?.mixedCount ?? 0;
+  let status = "success";
+  if (mixedCount > 0) status = "warning";
+  return {
+    status,
+    message: getMixedContentMessage(meta),
+    data: raw
+  };
+}
+const formatMessage = (message) => {
+  return message.charAt(0).toUpperCase() + message.slice(1);
+};
+function getStatusMessage(statusCode) {
+  if (statusCode === void 0 || statusCode === null) return "Status check completed";
+  if (statusCode >= 200 && statusCode < 300) return "All good";
+  if (statusCode >= 300 && statusCode < 400) return "Redirection detected, but reachable";
+  if (statusCode >= 400 && statusCode < 500) return "Client error detected";
+  if (statusCode >= 500) return "Server error detected";
+  return "Status check completed";
+}
+function buildReachabilitySuccessResponse(raw) {
+  const meta = raw?.result?.details?.uptime?.meta || null;
+  raw?.result?.durationMs ?? null;
+  return {
+    status: "success",
+    message: getStatusMessage(meta?.statusCode),
+    data: raw
+  };
+}
+function buildReachabilityErrorResponse(raw) {
+  const uptime = raw?.result?.details?.uptime || {};
+  const summary = raw?.result?.summary || {};
+  const errorMsg = uptime?.error ?? summary?.message ?? "Unknown error from healthcheck service";
+  return {
+    status: "error",
+    message: "Failed to get the reachability reports",
+    error: formatMessage(errorMsg),
+    data: raw
+  };
+}
+function getSecurityCertMessage(meta) {
+  if (!meta?.chain || !Array.isArray(meta.chain)) {
+    return "Security certificates check completed";
+  }
+  const leafCert = meta.chain.find((c) => c.depth === 0)?.info;
+  if (!leafCert) return "Unable to verify SSL certificate chain";
+  const { daysUntilExpiry, isExpired } = leafCert;
+  if (isExpired) {
+    return "Certificate has expired!";
+  }
+  if (daysUntilExpiry <= 0) {
+    return "Expires today.";
+  }
+  if (daysUntilExpiry <= 7) {
+    return `Expiring soon (in ${daysUntilExpiry} day${daysUntilExpiry > 1 ? "s" : ""})!`;
+  }
+  if (daysUntilExpiry <= 15) {
+    return `Expires in ${daysUntilExpiry} days. Consider renewing soon.`;
+  }
+  return `Valid for ${daysUntilExpiry} more day${daysUntilExpiry > 1 ? "s" : ""}.`;
+}
+function buildSslSuccessResponse(raw) {
+  const meta = raw?.result?.details?.ssl?.meta || {};
+  raw?.result?.durationMs ?? null;
+  const leafCert = meta?.chain?.find((c) => c.depth === 0)?.info;
+  const daysUntilExpiry = leafCert?.daysUntilExpiry ?? null;
+  const isExpired = leafCert?.isExpired ?? false;
+  let status = "success";
+  if (isExpired) {
+    status = "error";
+  } else if (daysUntilExpiry !== null && daysUntilExpiry <= 15) {
+    status = "warning";
+  }
+  return {
+    status,
+    message: getSecurityCertMessage(meta),
+    data: raw
+  };
+}
+function buildSslErrorResponse(raw) {
+  const sslDetails = raw?.result?.details?.ssl || {};
+  const summary = raw?.result?.summary || {};
+  const errorMsg = sslDetails?.error ?? summary?.message ?? "Unknown error from SSL check service";
+  return {
+    status: "error",
+    message: "Failed to get SSL certificate report",
+    error: errorMsg,
+    data: raw
+  };
+}
+function getDomainCheckMessage(meta) {
+  if (!meta) return "Domain check completed";
+  if (meta?.message) return meta.message;
+  const { domainExpired, domainExpiring, domainDays } = meta;
+  if (domainExpired) {
+    return "Domain has expired! Immediate renewal is required.";
+  }
+  if (domainExpiring) {
+    return "Domain is expiring soon! Please renew your registration.";
+  }
+  if (domainDays <= 7) {
+    return `Expiring in ${domainDays} day${domainDays > 1 ? "s" : ""}! Renew immediately.`;
+  }
+  if (domainDays <= 15) {
+    return `Expires in ${domainDays} days. Consider renewing soon.`;
+  }
+  if (domainDays <= 30) {
+    return `Valid for ${domainDays} more days. Renewal window approaching.`;
+  }
+  if (domainDays > 365) {
+    return "Renewed for more than a year.";
+  }
+  return "Domain is active and healthy.";
+}
+function buildDomainSuccessResponse(raw) {
+  const meta = raw?.result?.details?.domain?.meta || {};
+  raw?.result?.durationMs ?? null;
+  const domainExpired = meta?.domainExpired ?? false;
+  const domainExpiring = meta?.domainExpiring ?? false;
+  const domainDays = meta?.domainDays ?? null;
+  let status = "success";
+  if (domainExpired) {
+    status = "error";
+  } else if (domainExpiring || meta?.message || domainDays !== null && domainDays <= 30) {
+    status = "warning";
+  }
+  return {
+    status,
+    message: getDomainCheckMessage(meta),
+    data: raw
+  };
+}
+function buildDomainErrorResponse(raw) {
+  const domainDetails = raw?.result?.details?.domain || {};
+  const summary = raw?.result?.summary || {};
+  const errorMsg = domainDetails?.error ?? summary?.message ?? "Unknown error from domain check service";
+  return {
+    status: "error",
+    message: "Failed to get domain report",
+    error: formatMessage(errorMsg),
+    data: raw
+  };
+}
+function getLighthouseMessage(meta) {
+  if (!meta) return "Lighthouse audit completed";
+  const categories = ["performance", "accessibility", "bestPractices", "seo", "pwa"];
+  const lowScores = categories.filter(
+    (cat) => meta[cat]?.score !== void 0 && meta[cat]?.score < 50
+  );
+  const mediumScores = categories.filter((cat) => meta[cat]?.score >= 50 && meta[cat]?.score < 90);
+  if (lowScores.length > 0) return `Poor scores.`;
+  if (mediumScores.length > 0) return `Some scores could be improved.`;
+  return "Excellent.";
+}
+function buildLighthouseSuccessResponse(raw) {
+  const meta = raw?.result?.details?.lighthouse?.meta || {};
+  raw?.result?.durationMs ?? null;
+  const categories = LIGHTHOUSE_CHECKS;
+  const allScores = categories.map((cat) => meta[cat]?.score ?? null);
+  const minScore = Math.min(...allScores.filter((v) => v !== null));
+  let status = "success";
+  if (minScore < 50) status = "warning";
+  else if (minScore < 90) status = "warning";
+  return {
+    status,
+    message: getLighthouseMessage(meta),
+    data: raw
+  };
+}
+function buildLighthouseErrorResponse(raw) {
+  const lighthouseDetails = raw?.result?.details?.lighthouse || {};
+  const summary = raw?.result?.summary || {};
+  const errorMsg = lighthouseDetails?.error ?? summary?.message ?? "Unknown error from Lighthouse audit service";
+  return {
+    status: "error",
+    message: "Failed to get Lighthouse report",
+    error: formatMessage(errorMsg),
+    data: raw
+  };
+}
+function getBrokenLinksMessage(meta) {
+  if (!meta) return "Broken link check completed";
+  const { broken = 0, redirected = 0 } = meta;
+  if (broken === 0 && redirected === 0) return "No broken links!";
+  if (broken > 0) return `${broken} broken ${broken > 1 ? "links" : "link"} found.`;
+  if (redirected > 0)
+    return `${redirected} redirected ${redirected > 1 ? "links" : "link"} detected.`;
+  return "Scan completed with mixed results.";
+}
+function buildBrokenLinksSuccessResponse(raw) {
+  const meta = raw?.result?.details?.broken_links?.meta || null;
+  raw?.result?.durationMs ?? null;
+  const { broken = 0, redirected = 0 } = meta || {};
+  let status = "success";
+  if (broken > 0 || redirected > 0) {
+    status = "warning";
+  }
+  return {
+    status,
+    message: getBrokenLinksMessage(meta),
+    data: raw
+  };
+}
+function buildBrokenLinksErrorResponse(raw) {
+  const brokenLinks = raw?.result?.details?.broken_links || {};
+  const summary = raw?.result?.summary || {};
+  const errorMsg = brokenLinks?.error ?? summary?.message ?? "Unknown error from broken links check service";
+  return {
+    status: "error",
+    message: "Failed to get broken links report",
+    error: formatMessage(errorMsg),
+    data: raw
+  };
+}
+const monitor = ({ strapi }) => ({
+  async getById(ctx) {
+    const monitorId = ctx.params.id;
+    const token = await service({ strapi }).getToken();
+    const monitorResponse = await fetch(`${BACKEND_URL}/user/monitors/${monitorId}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    const monitor2 = await monitorResponse.json();
+    ctx.body = { monitor: monitor2 };
+  },
+  async get(ctx) {
+    const monitorsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { monitorsData };
+  },
+  async getMonitorUptimeStats(ctx) {
+    const monitorId = ctx.params.id;
+    const { region } = ctx.query;
+    const uptimeStatsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/${monitorId}/uptime-stats?uptime_stats_time_frames=day,week,month&region=${region}`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { uptimeStatsData };
+  },
+  async getMonitorHistogram(ctx) {
+    const monitorId = ctx.params.id;
+    const { region } = ctx.query;
+    const histogramData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/${monitorId}/histogram?region=${region}`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { histogramData };
+  },
+  async getHealthChecks(ctx) {
+    const { monitorUrl } = ctx.request.body;
+    const healthCheckData = await service({ strapi }).makeBackendRequest(`/healthcheck`, {
+      method: "POST",
+      headers: {
+        "X-Requested-From": "craft"
+      },
+      body: JSON.stringify({
+        url: monitorUrl,
+        checks: ["uptime", "ssl", "lighthouse", "domain", "broken_links", "mixed_content"],
+        strategy: "desktop",
+        force_fetch: false
+      })
+    });
+    ctx.body = { healthCheckData };
+  },
+  async getUptimeHealthCheck(ctx) {
+    const { monitorUrl } = ctx.request.body;
+    const uptimeHealthCheckData = await service({ strapi }).makeBackendRequest(
+      `/healthcheck`,
+      {
+        method: "POST",
+        headers: {
+          "X-Requested-From": "craft"
+        },
+        body: JSON.stringify({
+          url: monitorUrl,
+          checks: ["uptime"],
+          force_fetch: false
+        })
+      }
+    );
+    const summaryOk = uptimeHealthCheckData?.result?.summary?.ok;
+    const uptimeOk = uptimeHealthCheckData?.result?.details?.uptime?.ok;
+    if (summaryOk === false || uptimeOk === false) {
+      const errorResponse = buildReachabilityErrorResponse(uptimeHealthCheckData);
+      ctx.body = { uptimeHealthCheckData: errorResponse };
+      return;
+    }
+    ctx.body = { uptimeHealthCheckData: buildReachabilitySuccessResponse(uptimeHealthCheckData) };
+  },
+  async getSslHealthCheck(ctx) {
+    const { monitorUrl } = ctx.request.body;
+    const sslHealthCheckData = await service({ strapi }).makeBackendRequest(`/healthcheck`, {
+      method: "POST",
+      headers: {
+        "X-Requested-From": "craft"
+      },
+      body: JSON.stringify({
+        url: monitorUrl,
+        checks: ["ssl"],
+        force_fetch: false
+      })
+    });
+    const summaryOk = sslHealthCheckData?.result?.summary?.ok;
+    const sslOk = sslHealthCheckData?.result?.details?.ssl?.ok;
+    const sslError = sslHealthCheckData?.result?.details?.ssl?.error;
+    if ((summaryOk === false || sslOk === false) && sslError) {
+      ctx.body = { sslHealthCheckData: buildSslErrorResponse(sslHealthCheckData) };
+      return;
+    }
+    ctx.body = { sslHealthCheckData: buildSslSuccessResponse(sslHealthCheckData) };
+  },
+  async getDomainHealthCheck(ctx) {
+    const { monitorUrl } = ctx.request.body;
+    const domainHealthCheckData = await service({ strapi }).makeBackendRequest(
+      `/healthcheck`,
+      {
+        method: "POST",
+        headers: {
+          "X-Requested-From": "craft"
+        },
+        body: JSON.stringify({
+          url: monitorUrl,
+          checks: ["domain"],
+          force_fetch: false
+        })
+      }
+    );
+    const summaryOk = domainHealthCheckData?.result?.summary?.ok;
+    const domainOk = domainHealthCheckData?.result?.details?.domain?.ok;
+    const domainError = domainHealthCheckData?.result?.details?.domain?.error;
+    if ((summaryOk === false || domainOk === false) && domainError) {
+      ctx.body = { domainHealthCheckData: buildDomainErrorResponse(domainHealthCheckData) };
+      return;
+    }
+    ctx.body = { domainHealthCheckData: buildDomainSuccessResponse(domainHealthCheckData) };
+  },
+  async getLighthouseHealthCheck(ctx) {
+    const { monitorUrl, strategy } = ctx.request.body;
+    const lighthouseHealthCheckData = await service({ strapi }).makeBackendRequest(
+      `/healthcheck`,
+      {
+        method: "POST",
+        headers: {
+          "X-Requested-From": "craft"
+        },
+        body: JSON.stringify({
+          url: monitorUrl,
+          checks: ["lighthouse"],
+          strategy: strategy || "desktop",
+          force_fetch: false
+        })
+      }
+    );
+    const summaryOk = lighthouseHealthCheckData?.result?.summary?.ok;
+    const lighthouseOk = lighthouseHealthCheckData?.result?.details?.lighthouse?.ok;
+    const lighthouseError = lighthouseHealthCheckData?.result?.details?.lighthouse?.error;
+    if ((summaryOk === false || lighthouseOk === false) && lighthouseError) {
+      ctx.body = {
+        lighthouseHealthCheckData: buildLighthouseErrorResponse(lighthouseHealthCheckData)
+      };
+      return;
+    }
+    ctx.body = {
+      lighthouseHealthCheckData: buildLighthouseSuccessResponse(lighthouseHealthCheckData)
+    };
+  },
+  async getBrokenLinksHealthCheck(ctx) {
+    const { monitorUrl } = ctx.request.body;
+    const brokenLinksHealthCheckData = await service({ strapi }).makeBackendRequest(
+      `/healthcheck`,
+      {
+        method: "POST",
+        headers: {
+          "X-Requested-From": "craft"
+        },
+        body: JSON.stringify({
+          url: monitorUrl,
+          checks: ["broken_links"],
+          force_fetch: false
+        })
+      }
+    );
+    const summaryOk = brokenLinksHealthCheckData?.result?.summary?.ok;
+    const checkOk = brokenLinksHealthCheckData?.result?.details?.broken_links?.ok;
+    const isError = brokenLinksHealthCheckData?.result?.details?.broken_links?.error;
+    if ((summaryOk === false || checkOk === false) && isError) {
+      ctx.body = {
+        brokenLinksHealthCheckData: buildBrokenLinksErrorResponse(brokenLinksHealthCheckData)
+      };
+      return;
+    }
+    ctx.body = {
+      brokenLinksHealthCheckData: buildBrokenLinksSuccessResponse(brokenLinksHealthCheckData)
+    };
+  },
+  async getMixedContentHealthCheck(ctx) {
+    const { monitorUrl } = ctx.request.body;
+    const mixedContentHealthCheckData = await service({ strapi }).makeBackendRequest(
+      `/healthcheck`,
+      {
+        method: "POST",
+        headers: {
+          "X-Requested-From": "craft"
+        },
+        body: JSON.stringify({
+          url: monitorUrl,
+          checks: ["mixed_content"],
+          force_fetch: false
+        })
+      }
+    );
+    ctx.body = { mixedContentHealthCheckData: buildSuccessResponse(mixedContentHealthCheckData) };
+  },
+  async getMonitorResponseTime(ctx) {
+    const monitorId = ctx.params.id;
+    const { start, end, region } = ctx.query;
+    const responseTimeData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/${monitorId}/response-time?start=${start}&end=${end}&region=${region || "default"}`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { responseTimeData };
+  },
+  async getMonitorIncidents(ctx) {
+    const monitorId = ctx.params.id;
+    const incidentsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/incidents?monitorId=${monitorId}&page=1&page_size=20&time_range=7D`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { incidentsData };
+  },
+  async getMonitorSettings(ctx) {
+    const monitorId = ctx.params.id;
+    const monitorSettingsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/settings?id=${monitorId}`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { monitorSettingsData };
+  },
+  async createMonitor(ctx) {
+    const { ...data } = ctx.request.body;
+    const monitorsData = await service({ strapi }).makeBackendRequest(`/user/monitors`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    ctx.body = { monitorsData };
+  },
+  async updateMonitor(ctx) {
+    const monitorId = ctx.params.id;
+    const { ...data } = ctx.request.body;
+    const monitorsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/${monitorId}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(data)
+      }
+    );
+    ctx.body = { monitorsData };
+  },
+  async deleteMonitor(ctx) {
+    const monitorId = ctx.params.id;
+    const monitorsData = await service({ strapi }).makeBackendRequest(
+      `/user/monitors/${monitorId}`,
+      {
+        method: "DELETE"
+      }
+    );
+    ctx.body = { monitorsData };
+  },
+  async deleteMonitors(ctx) {
+    const { monitorIds } = ctx.request.body;
+    const monitorsData = await service({ strapi }).makeBackendRequest(`/user/monitors`, {
+      method: "PATCH",
+      body: JSON.stringify({ ids: monitorIds, action: "delete" })
+    });
+    ctx.body = { monitorsData };
+  }
+});
+const statusPage = ({ strapi }) => ({
+  async getStatusPages(ctx) {
+    const statusPagesData = await service({ strapi }).makeBackendRequest(`/user/status-pages`, {
+      method: "GET"
+    });
+    ctx.body = { statusPagesData };
+  },
+  async getStatusPagesByID(ctx) {
+    const id = ctx.params.id;
+    const statusPagesData = await service({ strapi }).makeBackendRequest(
+      `/user/status-pages/${id}`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { statusPagesData };
+  },
+  async saveStatusPages(ctx) {
+    const { name, monitor_ids, is_published } = ctx.request.body;
+    const statusPagesData = await service({ strapi }).makeBackendRequest(`/user/status-pages`, {
+      method: "POST",
+      body: JSON.stringify({ name, monitor_ids, is_published })
+    });
+    ctx.body = { statusPagesData };
+  },
+  async updateStatusPages(ctx) {
+    const { id, ...data } = ctx.request.body;
+    const statusPagesData = await service({ strapi }).makeBackendRequest(
+      `/user/status-pages/${id}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(data)
+      }
+    );
+    ctx.body = { statusPagesData };
+  },
+  async resetLink(ctx) {
+    const { id } = ctx.request.body;
+    const statusPagesData = await service({ strapi }).makeBackendRequest(
+      `/user/status-pages/${id}/reset`,
+      {
+        method: "POST"
+      }
+    );
+    ctx.body = { statusPagesData };
+  },
+  async deleteStatusPages(ctx) {
+    const id = ctx.params.id;
+    const statusPagesData = await service({ strapi }).makeBackendRequest(
+      `/user/status-pages/${id}`,
+      {
+        method: "DELETE"
+      }
+    );
+    ctx.body = { statusPagesData };
+  }
+});
+const regions = ({ strapi }) => ({
+  async getRegions(ctx) {
+    const regionsData = await service({ strapi }).makeBackendRequest(`/regions`, {
+      method: "GET"
+    });
+    ctx.body = { regionsData };
+  }
+});
+const userDetails = ({ strapi }) => ({
+  async getUserDetails(ctx) {
+    const userDetailsData = await service({ strapi }).makeBackendRequest(`/user/details`, {
+      method: "GET"
+    });
+    ctx.body = { userDetailsData };
+  }
+});
+const notificationChannels = ({ strapi }) => ({
+  async getNotificationChannels(ctx) {
+    const notificationChannelsData = await service({ strapi }).makeBackendRequest(
+      `/user/integrations`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { notificationChannelsData };
+  },
+  async createNotificationChannel(ctx) {
+    const { ...data } = ctx.request.body;
+    const notificationChannelsData = await service({ strapi }).makeBackendRequest(
+      `/user/integrations`,
+      {
+        method: "POST",
+        body: JSON.stringify(data)
+      }
+    );
+    ctx.body = { notificationChannelsData };
+  },
+  async getSupportedIntegrations(ctx) {
+    const supportedIntegrationsData = await service({ strapi }).makeBackendRequest(
+      `/integrations/supported`,
+      {
+        method: "GET"
+      }
+    );
+    ctx.body = { supportedIntegrationsData };
+  },
+  async testNotificationChannel(ctx) {
+    const { id } = ctx.params;
+    const testResult = await service({ strapi }).makeBackendRequest(
+      `/user/integrations/${id}/test`,
+      {
+        method: "POST"
+      }
+    );
+    ctx.body = { testResult };
+  },
+  async updateNotificationChannel(ctx) {
+    const { id } = ctx.params;
+    const { ...data } = ctx.request.body;
+    const updatedChannel = await service({ strapi }).makeBackendRequest(
+      `/user/integrations/${id}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(data)
+      }
+    );
+    ctx.body = { updatedChannel };
+  },
+  async deleteNotificationChannel(ctx) {
+    const { id } = ctx.params;
+    const deleteResult = await service({ strapi }).makeBackendRequest(`/user/integrations/${id}`, {
+      method: "DELETE"
+    });
+    ctx.body = { deleteResult };
+  }
+});
+const controllers = {
+  controller,
+  settings,
+  monitor,
+  statusPage,
+  regions,
+  userDetails,
+  notificationChannels
+};
+const middlewares = {};
+const policies = {};
+const routes = {
+  admin: {
+    type: "admin",
+    routes: [
+      {
+        method: "GET",
+        path: "/settings",
+        handler: "settings.get",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/settings",
+        handler: "settings.set",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitor/:id",
+        handler: "monitor.getById",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitors",
+        handler: "monitor.get",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitor/:id/uptime-stats",
+        handler: "monitor.getMonitorUptimeStats",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitor/:id/histogram",
+        handler: "monitor.getMonitorHistogram",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check",
+        handler: "monitor.getHealthChecks",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check/uptime",
+        handler: "monitor.getUptimeHealthCheck",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check/ssl",
+        handler: "monitor.getSslHealthCheck",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check/domain",
+        handler: "monitor.getDomainHealthCheck",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check/lighthouse",
+        handler: "monitor.getLighthouseHealthCheck",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check/broken-links",
+        handler: "monitor.getBrokenLinksHealthCheck",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitor/health-check/mixed-content",
+        handler: "monitor.getMixedContentHealthCheck",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitor/:id/response-time",
+        handler: "monitor.getMonitorResponseTime",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitor/:id/incidents",
+        handler: "monitor.getMonitorIncidents",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/status-pages",
+        handler: "statusPage.getStatusPages",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/status-pages/:id",
+        handler: "statusPage.getStatusPagesByID",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/status-pages",
+        handler: "statusPage.saveStatusPages",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "PUT",
+        path: "/status-pages",
+        handler: "statusPage.updateStatusPages",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/status-pages/reset",
+        handler: "statusPage.resetLink",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "DELETE",
+        path: "/status-pages/:id",
+        handler: "statusPage.deleteStatusPages",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/regions",
+        handler: "regions.getRegions",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/monitor/settings/:id",
+        handler: "monitor.getMonitorSettings",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/user/details",
+        handler: "userDetails.getUserDetails",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/notification-channels",
+        handler: "notificationChannels.getNotificationChannels",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/notification-channels",
+        handler: "notificationChannels.createNotificationChannel",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitors",
+        handler: "monitor.createMonitor",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "PUT",
+        path: "/monitors/:id",
+        handler: "monitor.updateMonitor",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "DELETE",
+        path: "/monitors/:id",
+        handler: "monitor.deleteMonitor",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/monitors/bulk-delete",
+        handler: "monitor.deleteMonitors",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/settings/get-primary-monitor-id",
+        handler: "settings.getPrimaryMonitorId",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/settings/set-primary-monitor-id",
+        handler: "settings.setPrimaryMonitorId",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "GET",
+        path: "/integrations/supported",
+        handler: "notificationChannels.getSupportedIntegrations",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "PUT",
+        path: "/notification-channels/:id",
+        handler: "notificationChannels.updateNotificationChannel",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "POST",
+        path: "/notification-channels/:id/test",
+        handler: "notificationChannels.testNotificationChannel",
+        config: {
+          policies: [],
+          auth: false
+        }
+      },
+      {
+        method: "DELETE",
+        path: "/notification-channels/:id",
+        handler: "notificationChannels.deleteNotificationChannel",
+        config: {
+          policies: [],
+          auth: false
+        }
+      }
+    ]
+  }
+};
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+exports.default = index;