@devvistatech/devvista-kit 0.0.10 → 0.0.13

package/app/api/analytics/[reportType]/route.ts

@@ -1,338 +1,275 @@
-import { NextRequest, NextResponse } from "next/server";
-import { BetaAnalyticsDataClient } from "@google-analytics/data";
-import { getAuth } from "@clerk/nextjs/server";
-
-interface StrapiUser {
-  id: number;
-  username: string;
-  email: string;
-  authId: string;
-  authProvider: string;
-  businessAdminId?: string;
-  userRole?: string;
-  firstName?: string;
-  lastName?: string;
-  businessId?: string[] | null;
-  dateJoined?: string;
-  businessOwner?: boolean;
-  userStatus?: string;
-  timezone?: string | null;
-  language?: string | null;
-  isVerified?: boolean;
-  businessTitle?: string | null;
-  userTitle?: string | null;
-  number?: string | null;
-  address?: {
-    zip: string;
-    city: string;
-    state: string;
-    street: string;
-    country: string;
-  } | null;
-  websiteUrl?: string | null;
-  primaryBusinessColor?: string | null;
-  secondaryBusinessColor?: string | null;
-  logoImage?: string | null;
-}
-
-interface AnalyticsData {
-  date: string;
-  country: string;
-  deviceCategory: string;
-  activeUsers: number;
-  totalUsers: number;
-  newUsers: number;
-  pageViews: number;
-  engagedSessions: number;
-  averageSessionDuration: number;
-  averageEngagementTimePerActiveUser: number;
-  bounceRate: number;
-}
-
-interface ChannelGroupData {
-  date: string;
-  channelGroup: string;
-  newUsers: number;
-  activeUsers: number;
-}
-
-interface RealtimeData {
-  activeUsersInLast30Minutes: number;
-}
-
-interface UserActivityData {
-  date: string;
-  country: string;
-  activeUsers: number;
-}
-
-const PROPERTY_ID = `properties/${process.env.GOOGLE_ANALYTICS_PROPERTY_ID}`;
-const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL || "";
-const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN || "";
-const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID || "";
-
-const analyticsDataClient = new BetaAnalyticsDataClient({
-  credentials: {
-    client_email: process.env.GOOGLE_ANALYTICS_CLIENT_EMAIL,
-    private_key: (process.env.GOOGLE_ANALYTICS_PRIVATE_KEY ?? "").replace(/\\n/g, "\n"),
-  },
-});
-
-async function verifyUser(request: NextRequest): Promise<StrapiUser | null> {
-  const { userId } = getAuth(request);
-  if (!userId) {
-    console.error("verifyUser: No userId found in request");
-    return null;
-  }
-
-  const maxRetries = 3;
-  let attempt = 0;
-
-  while (attempt < maxRetries) {
-    try {
-      if (!STRAPI_USER_LIST_API_URL || !STRAPI_API_TOKEN || !ADMIN_BUSINESS_ID) {
-        console.error("verifyUser: Missing environment variables", {
-          STRAPI_USER_LIST_API_URL,
-          STRAPI_API_TOKEN: !!STRAPI_API_TOKEN,
-          ADMIN_BUSINESS_ID,
-        });
-        return null;
-      }
-
-      const response = await fetch(
-        `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}&populate=*`,
-        {
-          headers: {
-            Authorization: `Bearer ${STRAPI_API_TOKEN}`,
-            "Content-Type": "application/json",
-          },
-          cache: "no-store",
-        }
-      );
-
-      if (!response.ok) {
-        if (response.status === 429) {
-          attempt++;
-          const delay = Math.pow(2, attempt) * 1000;
-          console.warn(`verifyUser: Rate limit hit, retrying after ${delay}ms`);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          continue;
-        }
-        const errorText = await response.text();
-        console.error("verifyUser failed:", { status: response.status, errorText });
-        return null;
-      }
-
-      const userData = await response.json();
-
-      if (!userData || !Array.isArray(userData.data) || userData.data.length === 0) {
-        console.error("verifyUser: No user found or invalid response for authId:", {
-          userId,
-          data: userData,
-        });
-        return null;
-      }
-
-      const strapiUser = userData.data.find((user: any) => user.authId === userId);
-
-      if (!strapiUser) {
-        console.error("verifyUser: No user found for authId", { userId });
-        return null;
-      }
-
-      return {
-        id: strapiUser.id,
-        username: strapiUser.username || "Unknown",
-        email: strapiUser.email || "",
-        authId: strapiUser.authId,
-        authProvider: strapiUser.authProvider,
-        businessAdminId: strapiUser.businessAdminId,
-        userRole: strapiUser.userRole,
-        firstName: strapiUser.firstName,
-        lastName: strapiUser.lastName,
-        businessId: strapiUser.businessId,
-        dateJoined: strapiUser.dateJoined,
-        businessOwner: strapiUser.businessOwner,
-        userStatus: strapiUser.userStatus,
-        timezone: strapiUser.timezone,
-        language: strapiUser.language,
-        isVerified: strapiUser.isVerified,
-        businessTitle: strapiUser.businessTitle,
-        userTitle: strapiUser.userTitle,
-        number: strapiUser.number,
-        address: strapiUser.address,
-        websiteUrl: strapiUser.websiteUrl,
-        primaryBusinessColor: strapiUser.primaryBusinessColor,
-        secondaryBusinessColor: strapiUser.secondaryBusinessColor,
-        logoImage: strapiUser.logoImage?.data?.attributes?.url || strapiUser.logoImage,
-      };
-    } catch (error) {
-      console.error(`verifyUser error (attempt ${attempt + 1}/${maxRetries}):`, error);
-      attempt++;
-      if (attempt < maxRetries) {
-        const delay = Math.pow(2, attempt) * 1000;
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      } else {
-        console.error("verifyUser: Max retries reached for Strapi API");
-        return null;
-      }
-    }
-  }
-
-  return null;
-}
-
-export async function GET(request: NextRequest, { params }: { params: Promise<{ reportType: string }> }) {
-  try {
-    const user = await verifyUser(request);
-    if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID || user.userRole !== "admin") {
-      console.error("Unauthorized access attempt", {
-        authId: user?.authId,
-        businessAdminId: user?.businessAdminId,
-        userRole: user?.userRole,
-      });
-      return NextResponse.json({ error: "Unauthorized: Only admins can access analytics" }, { status: 403 });
-    }
-
-    const today = new Date();
-    const currentYear = today.getFullYear();
-    const startDate = `${currentYear}-01-01`;
-    const yesterday = new Date(today);
-    yesterday.setDate(today.getDate() - 1);
-    const endDate = yesterday.toISOString().split("T")[0];
-    const { reportType } = await params;
-
-    switch (reportType) {
-      case "main":
-        const [mainResponse] = await analyticsDataClient.runReport({
-          property: PROPERTY_ID,
-          dateRanges: [{ startDate, endDate }],
-          dimensions: [{ name: "yearMonth" }],
-          metrics: [
-            { name: "activeUsers" },
-            { name: "totalUsers" },
-            { name: "newUsers" },
-            { name: "screenPageViews" },
-            { name: "engagedSessions" },
-            { name: "averageSessionDuration" },
-            { name: "userEngagementDuration" },
-            { name: "bounceRate" },
-          ],
-        });
-        const monthlyDataMap: { [key: string]: AnalyticsData } = {};
-        for (let month = 1; month <= 12; month++) {
-          const monthStr = month < 10 ? `0${month}` : `${month}`;
-          const key = `${currentYear}${monthStr}`;
-          monthlyDataMap[key] = {
-            date: key,
-            country: "All",
-            deviceCategory: "All",
-            activeUsers: 0,
-            totalUsers: 0,
-            newUsers: 0,
-            pageViews: 0,
-            engagedSessions: 0,
-            averageSessionDuration: 0,
-            averageEngagementTimePerActiveUser: 0,
-            bounceRate: 0,
-          };
-        }
-        (mainResponse.rows || []).forEach((row) => {
-          const dims = row.dimensionValues;
-          const mets = row.metricValues;
-          if (dims && mets) {
-            const month = dims[0]?.value || "Unknown";
-            if (monthlyDataMap[month]) {
-              const activeUsers = parseInt(mets[0]?.value || "0", 10);
-              monthlyDataMap[month].activeUsers = activeUsers;
-              monthlyDataMap[month].totalUsers = parseInt(mets[1]?.value || "0", 10);
-              monthlyDataMap[month].newUsers = parseInt(mets[2]?.value || "0", 10);
-              monthlyDataMap[month].pageViews = parseInt(mets[3]?.value || "0", 10);
-              monthlyDataMap[month].engagedSessions = parseInt(mets[4]?.value || "0", 10);
-              monthlyDataMap[month].averageSessionDuration = parseFloat(mets[5]?.value || "0") / 60;
-              monthlyDataMap[month].averageEngagementTimePerActiveUser = (parseFloat(mets[6]?.value || "0") / (activeUsers || 1)) / 60;
-              monthlyDataMap[month].bounceRate = parseFloat(mets[7]?.value || "0");
-            }
-          }
-        });
-        return NextResponse.json(Object.values(monthlyDataMap).sort((a, b) => a.date.localeCompare(b.date)));
-
-      case "channel-group":
-        const [channelResponse] = await analyticsDataClient.runReport({
-          property: PROPERTY_ID,
-          dateRanges: [{ startDate, endDate }],
-          dimensions: [{ name: "yearMonth" }, { name: "firstUserDefaultChannelGroup" }],
-          metrics: [{ name: "newUsers" }, { name: "activeUsers" }],
-        });
-        const channelData: ChannelGroupData[] = (channelResponse.rows || []).map((row) => {
-          const dims = row.dimensionValues;
-          const mets = row.metricValues;
-          if (!dims || !mets) {
-            return {
-              date: "Unknown",
-              channelGroup: "Unknown",
-              newUsers: 0,
-              activeUsers: 0,
-            };
-          }
-          return {
-            date: dims[0]?.value || "Unknown",
-            channelGroup: dims[1]?.value || "Unknown",
-            newUsers: parseInt(mets[0]?.value || "0", 10),
-            activeUsers: parseInt(mets[1]?.value || "0", 10),
-          };
-        });
-        return NextResponse.json(channelData.sort((a, b) => a.date.localeCompare(b.date)));
-
-      case "realtime":
-        const [realtimeResponse] = await analyticsDataClient.runRealtimeReport({
-          property: PROPERTY_ID,
-          metrics: [{ name: "activeUsers" }],
-        });
-        const totalActiveUsers = (realtimeResponse.rows || []).reduce((sum, row) => {
-          const mets = row.metricValues;
-          if (!mets) return sum;
-          return sum + parseInt(mets[0]?.value || "0", 10);
-        }, 0);
-        return NextResponse.json({ activeUsersInLast30Minutes: totalActiveUsers });
-
-      case "user-activity":
-        const [activityResponse] = await analyticsDataClient.runReport({
-          property: PROPERTY_ID,
-          dateRanges: [{ startDate, endDate }],
-          dimensions: [{ name: "yearMonth" }],
-          metrics: [{ name: "activeUsers" }],
-        });
-        const monthlyDataMapActivity: { [key: string]: UserActivityData } = {};
-        for (let month = 1; month <= 12; month++) {
-          const monthStr = month < 10 ? `0${month}` : `${month}`;
-          const key = `${currentYear}${monthStr}`;
-          monthlyDataMapActivity[key] = {
-            date: key,
-            country: "All",
-            activeUsers: 0,
-          };
-        }
-        (activityResponse.rows || []).forEach((row) => {
-          const dims = row.dimensionValues;
-          const mets = row.metricValues;
-          if (dims && mets) {
-            const month = dims[0]?.value || "Unknown";
-            if (monthlyDataMapActivity[month]) {
-              monthlyDataMapActivity[month].activeUsers = parseInt(mets[0]?.value || "0", 10);
-            }
-          }
-        });
-        return NextResponse.json(Object.values(monthlyDataMapActivity).sort((a, b) => a.date.localeCompare(b.date)));
-
-      default:
-        return NextResponse.json({ error: "Invalid report type" }, { status: 400 });
-    }
-  } catch (error) {
-    console.error(`Error in ${(await params).reportType}:`, error);
-    return NextResponse.json(
-      { error: `Failed to fetch ${(await params).reportType} data`, details: (error as Error).message },
-      { status: 500 }
-    );
-  }
+import { NextRequest, NextResponse } from "next/server";
+import { BetaAnalyticsDataClient } from "@google-analytics/data";
+import { getAuth } from "@clerk/nextjs/server";
+import { StrapiUser, AnalyticsData, ChannelGroupData, RealtimeData, UserActivityData } from "@/lib/types";
+
+const PROPERTY_ID = `properties/${process.env.GOOGLE_ANALYTICS_PROPERTY_ID}`;
+const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL || "";
+const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN || "";
+const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID || "";
+
+const analyticsDataClient = new BetaAnalyticsDataClient({
+  credentials: {
+    client_email: process.env.GOOGLE_ANALYTICS_CLIENT_EMAIL,
+    private_key: (process.env.GOOGLE_ANALYTICS_PRIVATE_KEY ?? "").replace(/\\n/g, "\n"),
+  },
+});
+
+async function verifyUser(request: NextRequest): Promise<StrapiUser | null> {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("verifyUser: No userId found in request");
+    return null;
+  }
+
+  const maxRetries = 3;
+  let attempt = 0;
+
+  while (attempt < maxRetries) {
+    try {
+      if (!STRAPI_USER_LIST_API_URL || !STRAPI_API_TOKEN || !ADMIN_BUSINESS_ID) {
+        console.error("verifyUser: Missing environment variables", {
+          STRAPI_USER_LIST_API_URL,
+          STRAPI_API_TOKEN: !!STRAPI_API_TOKEN,
+          ADMIN_BUSINESS_ID,
+        });
+        return null;
+      }
+
+      const response = await fetch(
+        `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}&populate=*`,
+        {
+          headers: {
+            Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+            "Content-Type": "application/json",
+          },
+          cache: "no-store",
+        }
+      );
+
+      if (!response.ok) {
+        if (response.status === 429) {
+          attempt++;
+          const delay = Math.pow(2, attempt) * 1000;
+          console.warn(`verifyUser: Rate limit hit, retrying after ${delay}ms`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        const errorText = await response.text();
+        console.error("verifyUser failed:", { status: response.status, errorText });
+        return null;
+      }
+
+      const userData = await response.json();
+
+      if (!userData || !Array.isArray(userData.data) || userData.data.length === 0) {
+        console.error("verifyUser: No user found or invalid response for authId:", {
+          userId,
+          data: userData,
+        });
+        return null;
+      }
+
+      const strapiUser = userData.data.find((user: any) => user.authId === userId);
+
+      if (!strapiUser) {
+        console.error("verifyUser: No user found for authId", { userId });
+        return null;
+      }
+
+      return {
+        id: strapiUser.id,
+        username: strapiUser.username || "Unknown",
+        email: strapiUser.email || "",
+        authId: strapiUser.authId,
+        authProvider: strapiUser.authProvider,
+        businessAdminId: strapiUser.businessAdminId,
+        userRole: strapiUser.userRole,
+        firstName: strapiUser.firstName,
+        lastName: strapiUser.lastName,
+        businessId: strapiUser.businessId,
+        dateJoined: strapiUser.dateJoined,
+        businessOwner: strapiUser.businessOwner,
+        userStatus: strapiUser.userStatus,
+        timezone: strapiUser.timezone,
+        language: strapiUser.language,
+        isVerified: strapiUser.isVerified,
+        businessTitle: strapiUser.businessTitle,
+        userTitle: strapiUser.userTitle,
+        number: strapiUser.number,
+        address: strapiUser.address,
+        websiteUrl: strapiUser.websiteUrl,
+        primaryBusinessColor: strapiUser.primaryBusinessColor,
+        secondaryBusinessColor: strapiUser.secondaryBusinessColor,
+        logoImage: strapiUser.logoImage?.data?.attributes?.url || strapiUser.logoImage,
+      };
+    } catch (error) {
+      console.error(`verifyUser error (attempt ${attempt + 1}/${maxRetries}):`, error);
+      attempt++;
+      if (attempt < maxRetries) {
+        const delay = Math.pow(2, attempt) * 1000;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } else {
+        console.error("verifyUser: Max retries reached for Strapi API");
+        return null;
+      }
+    }
+  }
+
+  return null;
+}
+
+export async function GET(request: NextRequest, { params }: { params: Promise<{ reportType: string }> }) {
+  try {
+    const user = await verifyUser(request);
+    if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID || user.userRole !== "admin") {
+      console.error("Unauthorized access attempt", {
+        authId: user?.authId,
+        businessAdminId: user?.businessAdminId,
+        userRole: user?.userRole,
+      });
+      return NextResponse.json({ error: "Unauthorized: Only admins can access analytics" }, { status: 403 });
+    }
+
+    const today = new Date();
+    const currentYear = today.getFullYear();
+    const startDate = `${currentYear}-01-01`;
+    const yesterday = new Date(today);
+    yesterday.setDate(today.getDate() - 1);
+    const endDate = yesterday.toISOString().split("T")[0];
+    const { reportType } = await params;
+
+    switch (reportType) {
+      case "main":
+        const [mainResponse] = await analyticsDataClient.runReport({
+          property: PROPERTY_ID,
+          dateRanges: [{ startDate, endDate }],
+          dimensions: [{ name: "yearMonth" }],
+          metrics: [
+            { name: "activeUsers" },
+            { name: "totalUsers" },
+            { name: "newUsers" },
+            { name: "screenPageViews" },
+            { name: "engagedSessions" },
+            { name: "averageSessionDuration" },
+            { name: "userEngagementDuration" },
+            { name: "bounceRate" },
+          ],
+        });
+        const monthlyDataMap: { [key: string]: AnalyticsData } = {};
+        for (let month = 1; month <= 12; month++) {
+          const monthStr = month < 10 ? `0${month}` : `${month}`;
+          const key = `${currentYear}${monthStr}`;
+          monthlyDataMap[key] = {
+            date: key,
+            country: "All",
+            deviceCategory: "All",
+            activeUsers: 0,
+            totalUsers: 0,
+            newUsers: 0,
+            pageViews: 0,
+            engagedSessions: 0,
+            averageSessionDuration: 0,
+            averageEngagementTimePerActiveUser: 0,
+            bounceRate: 0,
+          };
+        }
+        (mainResponse.rows || []).forEach((row) => {
+          const dims = row.dimensionValues;
+          const mets = row.metricValues;
+          if (dims && mets) {
+            const month = dims[0]?.value || "Unknown";
+            if (monthlyDataMap[month]) {
+              const activeUsers = parseInt(mets[0]?.value || "0", 10);
+              monthlyDataMap[month].activeUsers = activeUsers;
+              monthlyDataMap[month].totalUsers = parseInt(mets[1]?.value || "0", 10);
+              monthlyDataMap[month].newUsers = parseInt(mets[2]?.value || "0", 10);
+              monthlyDataMap[month].pageViews = parseInt(mets[3]?.value || "0", 10);
+              monthlyDataMap[month].engagedSessions = parseInt(mets[4]?.value || "0", 10);
+              monthlyDataMap[month].averageSessionDuration = parseFloat(mets[5]?.value || "0") / 60;
+              monthlyDataMap[month].averageEngagementTimePerActiveUser = (parseFloat(mets[6]?.value || "0") / (activeUsers || 1)) / 60;
+              monthlyDataMap[month].bounceRate = parseFloat(mets[7]?.value || "0");
+            }
+          }
+        });
+        return NextResponse.json(Object.values(monthlyDataMap).sort((a, b) => a.date.localeCompare(b.date)));
+
+      case "channel-group":
+        const [channelResponse] = await analyticsDataClient.runReport({
+          property: PROPERTY_ID,
+          dateRanges: [{ startDate, endDate }],
+          dimensions: [{ name: "yearMonth" }, { name: "firstUserDefaultChannelGroup" }],
+          metrics: [{ name: "newUsers" }, { name: "activeUsers" }],
+        });
+        const channelData: ChannelGroupData[] = (channelResponse.rows || []).map((row) => {
+          const dims = row.dimensionValues;
+          const mets = row.metricValues;
+          if (!dims || !mets) {
+            return {
+              date: "Unknown",
+              channelGroup: "Unknown",
+              newUsers: 0,
+              activeUsers: 0,
+            };
+          }
+          return {
+            date: dims[0]?.value || "Unknown",
+            channelGroup: dims[1]?.value || "Unknown",
+            newUsers: parseInt(mets[0]?.value || "0", 10),
+            activeUsers: parseInt(mets[1]?.value || "0", 10),
+          };
+        });
+        return NextResponse.json(channelData.sort((a, b) => a.date.localeCompare(b.date)));
+
+      case "realtime":
+        const [realtimeResponse] = await analyticsDataClient.runRealtimeReport({
+          property: PROPERTY_ID,
+          metrics: [{ name: "activeUsers" }],
+        });
+        const totalActiveUsers = (realtimeResponse.rows || []).reduce((sum, row) => {
+          const mets = row.metricValues;
+          if (!mets) return sum;
+          return sum + parseInt(mets[0]?.value || "0", 10);
+        }, 0);
+        return NextResponse.json({ activeUsersInLast30Minutes: totalActiveUsers });
+
+      case "user-activity":
+        const [activityResponse] = await analyticsDataClient.runReport({
+          property: PROPERTY_ID,
+          dateRanges: [{ startDate, endDate }],
+          dimensions: [{ name: "yearMonth" }],
+          metrics: [{ name: "activeUsers" }],
+        });
+        const monthlyDataMapActivity: { [key: string]: UserActivityData } = {};
+        for (let month = 1; month <= 12; month++) {
+          const monthStr = month < 10 ? `0${month}` : `${month}`;
+          const key = `${currentYear}${monthStr}`;
+          monthlyDataMapActivity[key] = {
+            date: key,
+            country: "All",
+            activeUsers: 0,
+          };
+        }
+        (activityResponse.rows || []).forEach((row) => {
+          const dims = row.dimensionValues;
+          const mets = row.metricValues;
+          if (dims && mets) {
+            const month = dims[0]?.value || "Unknown";
+            if (monthlyDataMapActivity[month]) {
+              monthlyDataMapActivity[month].activeUsers = parseInt(mets[0]?.value || "0", 10);
+            }
+          }
+        });
+        return NextResponse.json(Object.values(monthlyDataMapActivity).sort((a, b) => a.date.localeCompare(b.date)));
+
+      default:
+        return NextResponse.json({ error: "Invalid report type" }, { status: 400 });
+    }
+  } catch (error) {
+    console.error(`Error in ${(await params).reportType}:`, error);
+    return NextResponse.json(
+      { error: `Failed to fetch ${(await params).reportType} data`, details: (error as Error).message },
+      { status: 500 }
+    );
+  }
 }