@devvistatech/devvista-kit 0.0.1

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

@@ -0,0 +1,338 @@
+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: { 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 } = 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 ${params.reportType}:`, error);
+    return NextResponse.json(
+      { error: `Failed to fetch ${params.reportType} data`, details: (error as Error).message },
+      { status: 500 }
+    );
+  }
+}

package/app/api/bio/route.ts

@@ -0,0 +1,314 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAuth } from "@clerk/nextjs/server";
+
+export const revalidate = 0; // Disable Next.js ISR
+
+interface StrapiUser {
+  id: number;
+  username: string;
+  email: string;
+  businessAdminId?: string;
+}
+
+interface BioContent {
+  id: number;
+  documentId: string;
+  title: string;
+  description: string;
+  bio: boolean;
+  image?: { url: string; id: number };
+  createdAt: string;
+}
+
+const CONTENT_API_URL = process.env.STRAPI_CONTENT_API_URL || "";
+const UPLOAD_API_URL = process.env.STRAPI_API_URL + "/api/upload" || "";
+const BASE_URL = process.env.STRAPI_API_URL || "";
+const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL || "";
+const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID || "";
+const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN || "";
+
+export async function GET() {
+  try {
+    if (!CONTENT_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CONTENT_API_URL && "STRAPI_CONTENT_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const response = await fetch(
+      `${CONTENT_API_URL}?filters[bio][$eq]=true&publicationState=live&populate=*&fields[0]=title&fields[1]=description&fields[2]=bio&fields[3]=createdAt&pagination[pageSize]=100&t=${Date.now()}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("Fetch bio data failed:", response.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to fetch bio data: ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const result = await response.json();
+
+    if (!result.data || result.data.length === 0) {
+      console.warn("No bio data found with bio=true in Strapi response");
+      return NextResponse.json({ error: "No bio data found with bio=true" }, { status: 404 });
+    }
+
+    const bioData: BioContent[] = result.data.map((item: any) => {
+      const image = item.image;
+      const rawUrl = image?.url || "";
+      const imageUrl = rawUrl ? (rawUrl.startsWith("http") ? rawUrl : `${BASE_URL}${rawUrl}`) : null;
+      return {
+        id: item.id,
+        documentId: item.documentId,
+        title: item.title || "",
+        description: item.description || "",
+        bio: item.bio,
+        image: imageUrl ? { url: imageUrl, id: image?.id || 0 } : undefined,
+        createdAt: item.createdAt,
+      };
+    });
+
+    return NextResponse.json({
+      data: bioData[0],
+      meta: result.meta,
+    });
+  } catch (error) {
+    console.error("Fetch Bio Error:", error);
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "An error occurred while fetching bio data",
+      },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  try {
+    if (!CONTENT_API_URL || !STRAPI_API_TOKEN || !STRAPI_USER_LIST_API_URL || !ADMIN_BUSINESS_ID) {
+      console.error(
+        "Missing environment variables:",
+        !CONTENT_API_URL && "STRAPI_CONTENT_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN",
+        !STRAPI_USER_LIST_API_URL && "STRAPI_USER_LIST_API_URL",
+        !ADMIN_BUSINESS_ID && "ADMIN_BUSINESS_ID"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const userResponse = await fetch(
+      `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    if (!userResponse.ok) {
+      const errorText = await userResponse.text();
+      console.error("Strapi user fetch error:", errorText);
+      return NextResponse.json(
+        { error: `User verification failed: ${userResponse.status}` },
+        { status: userResponse.status }
+      );
+    }
+
+    const userData = await userResponse.json();
+    const strapiUser = userData.data?.find((user: any) => user.authId === userId);
+
+    if (!strapiUser || strapiUser.businessAdminId !== ADMIN_BUSINESS_ID) {
+      console.error("User not authorized:", { strapiUser, businessAdminId: strapiUser?.businessAdminId });
+      return NextResponse.json(
+        { error: "Unauthorized: Only admin can update bio data" },
+        { status: 403 }
+      );
+    }
+
+    const fetchResponse = await fetch(
+      `${CONTENT_API_URL}?filters[bio][$eq]=true&fields[0]=documentId`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+      }
+    );
+
+    if (!fetchResponse.ok) {
+      const errorText = await fetchResponse.text();
+      console.error("Fetch bio data failed:", fetchResponse.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to fetch bio data: ${fetchResponse.status} - ${errorText}` },
+        { status: fetchResponse.status }
+      );
+    }
+
+    const fetchResult = await fetchResponse.json();
+    if (!fetchResult.data || fetchResult.data.length === 0) {
+      console.warn("No bio data found with bio=true");
+      return NextResponse.json({ error: "No bio data found with bio=true" }, { status: 404 });
+    }
+
+    const documentId = fetchResult.data[0].documentId;
+
+    const formData = await request.formData();
+    const description = formData.get("description") as string | null;
+    const title = formData.get("title") as string | null;
+    const image = formData.get("image") as File | null;
+
+    let uploadedFileId: number | null = null;
+    if (image) {
+      if (!["image/jpeg", "image/png", "image/gif"].includes(image.type)) {
+        return NextResponse.json(
+          { error: "Only JPEG, PNG, or GIF images are allowed" },
+          { status: 400 }
+        );
+      }
+
+      const uploadFormData = new FormData();
+      uploadFormData.append("files", image);
+
+      const uploadResponse = await fetch(UPLOAD_API_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        body: uploadFormData,
+      });
+
+      if (!uploadResponse.ok) {
+        const errorText = await uploadResponse.text();
+        console.error("Image upload failed:", uploadResponse.status, errorText);
+        return NextResponse.json(
+          { error: `Failed to upload image: ${uploadResponse.status} - ${errorText}` },
+          { status: uploadResponse.status }
+        );
+      }
+
+      const uploadResult = await uploadResponse.json();
+      uploadedFileId = uploadResult[0]?.id;
+      if (!uploadedFileId) {
+        console.error("Invalid upload response: Missing file ID");
+        return NextResponse.json(
+          { error: "Invalid upload response: Missing file ID" },
+          { status: 400 }
+        );
+      }
+    }
+
+    const payload: { data: { title?: string; description?: string; bio: boolean; image?: number } } = {
+      data: { bio: true },
+    };
+    if (title) payload.data.title = title;
+    if (description) payload.data.description = description;
+    if (uploadedFileId) payload.data.image = uploadedFileId;
+
+    if (Object.keys(payload.data).length === 1) {
+      return NextResponse.json({ data: null });
+    }
+
+    const updateResponse = await fetch(`${CONTENT_API_URL}/${documentId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!updateResponse.ok) {
+      const errorText = await updateResponse.text();
+      console.error("Update bio failed:", updateResponse.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to update bio data: ${updateResponse.status} - ${errorText}` },
+        { status: updateResponse.status }
+      );
+    }
+
+    const response = await fetch(
+      `${CONTENT_API_URL}?filters[bio][$eq]=true&publicationState=live&populate=image&fields[0]=title&fields[1]=description&fields[2]=bio&fields[3]=createdAt&pagination[pageSize]=100&t=${Date.now()}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("Refetch bio data failed:", response.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to refetch bio data: ${response.status} - ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const result = await response.json();
+    if (!result.data || result.data.length === 0) {
+      console.warn("Bio data not found after update");
+      return NextResponse.json({ error: "Bio data not found after update" }, { status: 404 });
+    }
+
+    const bioData: BioContent[] = result.data
+      .map((item: any) => {
+        const image = item.image;
+        if (!image || !image.url) {
+          console.warn(`Image missing for item ${item.id}:`, JSON.stringify(item, null, 2));
+          return null;
+        }
+        const rawUrl = image.url || "";
+        const imageUrl = rawUrl.startsWith("http") ? rawUrl : `${BASE_URL}${rawUrl}`;
+        return {
+          id: item.id,
+          documentId: item.documentId,
+          title: item.title || "",
+          description: item.description || "",
+          bio: item.bio,
+          image: { url: imageUrl, id: image.id },
+          createdAt: item.createdAt,
+        };
+      })
+      .filter((item: BioContent | null): item is BioContent => item !== null);
+
+    return NextResponse.json({
+      data: bioData[0],
+      meta: result.meta,
+    });
+  } catch (error) {
+    console.error("Update Bio Error:", error);
+    return NextResponse.json(
+      {
+        error:
+          error instanceof Error ? error.message : "An error occurred while updating bio data",
+      },
+      { status: 500 }
+    );
+  }
+}