@upsnap/strapi 1.0.6 → 1.0.8

package/dist/admin/index.mjs

@@ -36,7 +36,7 @@ const index = {
         defaultMessage: PLUGIN_ID.slice(0, 1).toUpperCase() + PLUGIN_ID.slice(1)
       },
       Component: async () => {
-        const { App } = await import("./App-DQN0F1ZK.mjs");
+        const { App } = await import("./App-DJivreSE.mjs");
         return App;
       }
     });

package/dist/server/index.js

@@ -32,7 +32,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" };
@@ -40,7 +40,7 @@ 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 || {}
       }
@@ -57,14 +57,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() || {};
@@ -662,12 +664,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 }) => ({
@@ -1068,12 +1270,40 @@ 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
+        }
       }
     ]
   }
 };
 const services = {
-  service
+  service,
+  userDetailsService
 };
 const index = {
   register,

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,7 +38,7 @@ 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 || {}
       }
@@ -55,14 +55,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() || {};
@@ -660,12 +662,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 +1268,40 @@ 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
+        }
       }
     ]
   }
 };
 const services = {
-  service
+  service,
+  userDetailsService
 };
 const index = {
   register,

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

@@ -67,6 +67,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 +134,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.6",
+  "version": "1.0.8",
   "repository": {
     "type": "git",
     "url": "https://github.com/Appfoster/upsnap-strapi"