@devvistatech/devvista-kit 0.0.1

package/hooks/use-toast.ts

@@ -0,0 +1,188 @@
+'use client';
+
+import * as React from 'react';
+
+import type { ToastActionElement, ToastProps } from '@/components/other/toast';
+
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+
+type ToasterToast = ToastProps & {
+  id: string;
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  action?: ToastActionElement;
+};
+
+const actionTypes = {
+  ADD_TOAST: 'ADD_TOAST',
+  UPDATE_TOAST: 'UPDATE_TOAST',
+  DISMISS_TOAST: 'DISMISS_TOAST',
+  REMOVE_TOAST: 'REMOVE_TOAST',
+} as const;
+
+let count = 0;
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER;
+  return count.toString();
+}
+
+type ActionType = typeof actionTypes;
+
+type Action =
+  | {
+      type: ActionType['ADD_TOAST'];
+      toast: ToasterToast;
+    }
+  | {
+      type: ActionType['UPDATE_TOAST'];
+      toast: Partial<ToasterToast>;
+    }
+  | {
+      type: ActionType['DISMISS_TOAST'];
+      toastId?: ToasterToast['id'];
+    }
+  | {
+      type: ActionType['REMOVE_TOAST'];
+      toastId?: ToasterToast['id'];
+    };
+
+interface State {
+  toasts: ToasterToast[];
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>();
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    dispatch({
+      type: 'REMOVE_TOAST',
+      toastId: toastId,
+    });
+  }, TOAST_REMOVE_DELAY);
+
+  toastTimeouts.set(toastId, timeout);
+};
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'ADD_TOAST':
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      };
+
+    case 'UPDATE_TOAST':
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t
+        ),
+      };
+
+    case 'DISMISS_TOAST': {
+      const { toastId } = action;
+
+      if (toastId) {
+        addToRemoveQueue(toastId);
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id);
+        });
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t
+        ),
+      };
+    }
+    case 'REMOVE_TOAST':
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        };
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      };
+  }
+};
+
+const listeners: Array<(state: State) => void> = [];
+
+let memoryState: State = { toasts: [] };
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((listener) => {
+    listener(memoryState);
+  });
+}
+
+type Toast = Omit<ToasterToast, 'id'>;
+
+function toast({ ...props }: Toast) {
+  const id = genId();
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: 'UPDATE_TOAST',
+      toast: { ...props, id },
+    });
+  const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id });
+
+  dispatch({
+    type: 'ADD_TOAST',
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss();
+      },
+    },
+  });
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  };
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState);
+
+  React.useEffect(() => {
+    listeners.push(setState);
+    return () => {
+      const index = listeners.indexOf(setState);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }, [state]);
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  };
+}
+
+export { useToast, toast };

package/lib/auth-context.tsx

@@ -0,0 +1,131 @@
+"use client";
+
+import { createContext, useContext, useState, useEffect } from "react";
+import { useAuth as useClerkAuth, useUser } from "@clerk/nextjs";
+
+interface StrapiUser {
+  id: number;
+  username: string;
+  email: string;
+  businessAdminId?: string;
+  isAdmin?: boolean;
+  firstName?: string;
+  lastName?: string;
+  businessId?: string[];
+  dateJoined?: string;
+  businessOwner?: boolean;
+  userStatus?: string;
+  timezone?: string;
+  language?: string;
+  isVerified?: boolean;
+  authProvider?: string;
+  authId?: string;
+  businessTitle?: string;
+  userTitle?: string;
+  number?: string;
+  address?: {
+    zip: string;
+    city: string;
+    state: string;
+    street: string;
+    country: string;
+  };
+  websiteUrl?: string;
+  userRole?: string;
+  primaryBusinessColor?: string;
+  secondaryBusinessColor?: string;
+  logoImage?: string;
+}
+
+interface AuthContextType {
+  user: StrapiUser | null;
+  authLoading: boolean;
+  error: string | null;
+  checkSession: () => Promise<void>;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+const userCache = new Map<string, StrapiUser>();
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+  const [user, setUser] = useState<StrapiUser | null>(null);
+  const [authLoading, setAuthLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null); // Added error state
+  const { isSignedIn, userId } = useClerkAuth();
+  const { user: clerkUser } = useUser();
+
+  const syncUserToStrapi = async (clerkUserData: any) => {
+    if (!clerkUserData || !userId) {
+      console.error("Missing clerkUserData or userId:", { clerkUserData, userId });
+      setError("Missing user data for sync");
+      return;
+    }
+
+    if (userCache.has(userId)) {
+      setUser(userCache.get(userId)!);
+      setError(null);
+      return;
+    }
+
+    try {
+      const response = await fetch("/api/sync-user", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(clerkUserData),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`Failed to sync user: ${response.status}`, errorText);
+        setError(`Failed to sync user: ${response.status}`);
+        return;
+      }
+
+      const strapiUser = await response.json();
+      userCache.set(userId, strapiUser);
+      setUser(strapiUser);
+      setError(null);
+    } catch (error) {
+      console.error("Error syncing user to Strapi:", error);
+      setError(error instanceof Error ? error.message : "Failed to sync user");
+    }
+  };
+
+  const checkSession = async () => {
+    setAuthLoading(true);
+    if (!isSignedIn || !userId || !clerkUser) {
+      setUser(null);
+      setError("User not signed in");
+      setAuthLoading(false);
+      return;
+    }
+    try {
+      await syncUserToStrapi(clerkUser);
+    } catch (err) {
+      console.error("checkSession error:", err);
+      setError(err instanceof Error ? err.message : "Session check failed");
+      setUser(null);
+    } finally {
+      setAuthLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    checkSession();
+  }, [isSignedIn, userId, clerkUser]);
+
+  return (
+    <AuthContext.Provider value={{ user, authLoading, error, checkSession }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useStrapiAuth() {
+  const context = useContext(AuthContext);
+  if (!context) throw new Error("useStrapiAuth must be used within an AuthProvider");
+  return context;
+}

package/lib/google-analytics.tsx

@@ -0,0 +1,98 @@
+export interface AnalyticsData {
+  date: string;
+  country: string;
+  deviceCategory: string;
+  activeUsers: number;
+  totalUsers: number;
+  newUsers: number;
+  pageViews: number;
+  engagedSessions: number;
+  averageSessionDuration: number;
+  averageEngagementTimePerActiveUser: number;
+  bounceRate: number;
+}
+
+export interface ChannelGroupData {
+  date: string;
+  channelGroup: string;
+  newUsers: number;
+  activeUsers: number;
+}
+
+export interface RealtimeData {
+  activeUsersInLast30Minutes: number;
+}
+
+export interface UserActivityData {
+  date: string;
+  country: string;
+  activeUsers: number;
+}
+
+export async function getAnalyticsData(mainAnalyticsYear: number, token: string): Promise<AnalyticsData[]> {
+  const response = await fetch(`/api/analytics/main?year=${mainAnalyticsYear}&t=${Date.now()}`, {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    cache: "no-store",
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch analytics data: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  return data;
+}
+
+export async function getChannelGroupData(channelGroupYear: number, token: string): Promise<ChannelGroupData[]> {
+  const response = await fetch(`/api/analytics/channel-group?year=${channelGroupYear}&t=${Date.now()}`, {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    cache: "no-store",
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch channel group data: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  return data;
+}
+
+export async function getRealtimeData(token: string): Promise<RealtimeData> {
+  const response = await fetch(`/api/analytics/realtime?t=${Date.now()}`, {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    cache: "no-store",
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch realtime data: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  return data;
+}
+
+export async function getUserActivityData(userActivityYear: number, token: string): Promise<UserActivityData[]> {
+  const response = await fetch(`/api/analytics/user-activity?year=${userActivityYear}&t=${Date.now()}`, {
+    method: 'GET',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    cache: "no-store",
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch user activity data: ${response.status} ${errorText}`);
+  }
+  const data = await response.json();
+  return data;
+}

package/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/lib/verify-user.ts

@@ -0,0 +1,118 @@
+import { getAuth } from "@clerk/nextjs/server";
+import { NextRequest } from "next/server";
+
+interface StrapiUser {
+  id: number;
+  username: string;
+  email: string;
+  businessAdminId?: string;
+  isAdmin?: boolean;
+  firstName?: string;
+  lastName?: string;
+  businessId?: string[];
+  dateJoined?: string;
+  businessOwner?: boolean;
+  userStatus?: string;
+  timezone?: string;
+  language?: string;
+  isVerified?: boolean;
+  authProvider?: string;
+  authId?: string;
+  businessTitle?: string;
+  userTitle?: string;
+  number?: string;
+  address?: {
+    zip: string;
+    city: string;
+    state: string;
+    street: string;
+    country: string;
+  };
+  websiteUrl?: string;
+  userRole?: string;
+  primaryBusinessColor?: string;
+  secondaryBusinessColor?: string;
+  logoImage?: string;
+}
+
+export async function verifyUser(request: NextRequest): Promise<StrapiUser | null> {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    return null;
+  }
+
+  const maxRetries = 3;
+  let attempt = 0;
+
+  while (attempt < maxRetries) {
+    try {
+      const response = await fetch(
+        `${process.env.STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}&populate=*`,
+        {
+          headers: {
+            Authorization: `Bearer ${process.env.STRAPI_API_TOKEN}`,
+            "Content-Type": "application/json",
+          },
+        }
+      );
+
+      if (!response.ok) {
+        if (response.status === 429) {
+          attempt++;
+          const delay = Math.pow(2, attempt) * 1000;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        console.error("User verification failed:", response.status);
+        return null;
+      }
+
+      const users = await response.json();
+      if (!users.data || users.data.length === 0) {
+        console.error("No user found in user-list for authId:", userId);
+        return null;
+      }
+
+      const userData = users.data[0].attributes;
+      return {
+        id: users.data[0].id,
+        authId: userData.authId,
+        authProvider: userData.authProvider,
+        email: userData.email,
+        username: userData.username,
+        businessAdminId: userData.businessAdminId,
+        isAdmin: userData.userRole === "admin" && userData.businessAdminId === process.env.ADMIN_BUSINESS_ID,
+        firstName: userData.firstName,
+        lastName: userData.lastName,
+        dateJoined: userData.dateJoined,
+        businessOwner: userData.businessOwner,
+        userStatus: userData.userStatus,
+        timezone: userData.timezone,
+        language: userData.language,
+        isVerified: userData.isVerified,
+        businessTitle: userData.businessTitle,
+        userTitle: userData.userTitle,
+        number: userData.number,
+        address: userData.address,
+        websiteUrl: userData.websiteUrl,
+        userRole: userData.userRole,
+        primaryBusinessColor: userData.primaryBusinessColor,
+        secondaryBusinessColor: userData.secondaryBusinessColor,
+        logoImage: userData.logoImage?.data?.attributes?.url,
+        businessId: userData.businessId,
+      };
+    } catch (error) {
+      console.error(`Error verifying user (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("Max retries reached for Strapi API");
+        return null;
+      }
+    }
+  }
+
+  return null;
+}

package/middleware.ts

@@ -0,0 +1,35 @@
+import { clerkMiddleware, createRouteMatcher } from "@clerk/nextjs/server";
+
+const isPublicRoute = createRouteMatcher([
+  '/',
+  '/about',
+  '/contact',
+  '/gallery',
+  '/schedule',
+  '/faq',
+  '/api/about',
+  '/api/bio',
+  '/api/schedule',
+  '/api/files',
+  '/api/gallery-data',
+  '/api/trial-request', 
+  '/api/contact',
+  '/api/blog',
+  '/blog/:path*',
+  '/.well-known/(.*)',
+]);
+
+export default clerkMiddleware((auth, req) => {
+  if (isPublicRoute(req) && req.method === 'GET') {
+    return;
+  }
+  auth.protect();
+});
+
+export const config = {
+  matcher: [
+    '/((?!.*\\..*|_next|/.well-known/.*).*)', 
+    '/',
+    '/(api|trpc)(.*)',
+  ],
+};

package/next.config.js

@@ -0,0 +1,10 @@
+const nextConfig = {
+  images: { unoptimized: true },
+    experimental: {
+    serverActions: {
+      allowedOrigins: ['localhost:3000'], 
+    },
+  },
+};
+
+module.exports = nextConfig;

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@devvistatech/devvista-kit",
+  "version": "0.0.1",
+  "private": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "devvista-kit": "bin/init.js"
+  },
+  "files": [
+    "bin/**/*",
+    "app/**/*",
+    "components/**/*",
+    "lib/**/*",
+    "public/**/*",
+    "src/**/*",
+    "middleware.ts",
+    "hooks/**/*",
+    "utils/**/*",
+    "dist/**/*",
+    "next.config.js",
+    "tsconfig.json",
+    "tailwind.config.ts",
+    "postcss.config.js",
+    "globals.css",
+    "layout.tsx",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "next dev",
+    "build:dev": "cross-env NODE_ENV=development next build",
+    "start:dev": "cross-env NODE_ENV=development next start",
+    "build:prod": "cross-env NODE_ENV=production next build",
+    "start:prod": "cross-env NODE_ENV=production next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^1.3.23",
+    "@clerk/nextjs": "^6.28.0",
+    "@google-analytics/data": "^5.1.0",
+    "@hookform/resolvers": "^3.9.0",
+    "@radix-ui/react-accordion": "^1.2.0",
+    "@radix-ui/react-alert-dialog": "^1.1.1",
+    "@radix-ui/react-aspect-ratio": "^1.1.0",
+    "@radix-ui/react-avatar": "^1.1.0",
+    "@radix-ui/react-checkbox": "^1.1.1",
+    "@radix-ui/react-collapsible": "^1.1.0",
+    "@radix-ui/react-context-menu": "^2.2.1",
+    "@radix-ui/react-dialog": "^1.1.1",
+    "@radix-ui/react-dropdown-menu": "^2.1.1",
+    "@radix-ui/react-hover-card": "^1.1.1",
+    "@radix-ui/react-label": "^2.1.0",
+    "@radix-ui/react-menubar": "^1.1.1",
+    "@radix-ui/react-navigation-menu": "^1.2.0",
+    "@radix-ui/react-popover": "^1.1.1",
+    "@radix-ui/react-progress": "^1.1.0",
+    "@radix-ui/react-radio-group": "^1.2.0",
+    "@radix-ui/react-scroll-area": "^1.1.0",
+    "@radix-ui/react-select": "^2.1.1",
+    "@radix-ui/react-separator": "^1.1.0",
+    "@radix-ui/react-slider": "^1.2.0",
+    "@radix-ui/react-slot": "^1.1.0",
+    "@radix-ui/react-switch": "^1.1.0",
+    "@radix-ui/react-tabs": "^1.1.0",
+    "@radix-ui/react-toast": "^1.2.1",
+    "@radix-ui/react-toggle": "^1.1.0",
+    "@radix-ui/react-toggle-group": "^1.1.0",
+    "@radix-ui/react-tooltip": "^1.1.2",
+    "@types/react": "^18.3.11",
+    "@types/react-dom": "^18.3.0",
+    "ai": "^4.3.17",
+    "autoprefixer": "^10.4.20",
+    "chart.js": "^4.5.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.0.0",
+    "date-fns": "^3.6.0",
+    "deepmerge": "^4.3.1",
+    "embla-carousel-react": "^8.3.0",
+    "eslint": "^9.13.0",
+    "eslint-config-next": "^15.0.0",
+    "framer-motion": "^11.11.9",
+    "input-otp": "^1.2.4",
+    "lucide-react": "^0.446.0",
+    "next": "^15.0.0",
+    "next-themes": "^0.3.0",
+    "nodemailer": "^7.0.5",
+    "postcss": "^8.4.47",
+    "react": "^18.3.1",
+    "react-chartjs-2": "^5.3.0",
+    "react-day-picker": "^8.10.1",
+    "react-dom": "^18.3.1",
+    "react-hook-form": "^7.53.0",
+    "react-hot-toast": "^2.5.2",
+    "react-quill": "^2.0.0",
+    "react-resizable-panels": "^2.1.3",
+    "recharts": "^2.12.7",
+    "sonner": "^1.5.0",
+    "striptags": "^3.2.0",
+    "svix": "^1.69.0",
+    "tailwind-merge": "^2.5.2",
+    "tailwindcss": "^3.4.13",
+    "tailwindcss-animate": "^1.0.7",
+    "typescript": "^5.6.3",
+    "vaul": "^0.9.9",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^22.7.5",
+    "@types/nodemailer": "^6.4.17",
+    "cross-env": "^10.0.0"
+  }
+}