@mundogamernetwork/shared-ui 1.0.2 → 1.1.0

package/services/testimoniesService.ts

@@ -0,0 +1,40 @@
+import httpService from "./httpService";
+
+export interface TestimonyParams {
+	page?: number;
+	per_page?: number;
+	[key: string]: any;
+}
+
+const buildQuery = (params: TestimonyParams): string => {
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) {
+		if (value !== undefined && value !== null && value !== "") {
+			search.append(key, String(value));
+		}
+	}
+	const qs = search.toString();
+	return qs ? `?${qs}` : "";
+};
+
+export const getUserTestimonials = (params: TestimonyParams = {}) => {
+	return httpService({
+		url: `/public/user-testimonials${buildQuery(params)}`,
+		baseURL: import.meta.env.VITE_API_BASE_URL,
+	});
+};
+
+export const submitUserTestimonial = (data: {
+	body: string;
+	name: string;
+	role?: string;
+	company?: string;
+	[key: string]: any;
+}) => {
+	return httpService({
+		method: "POST",
+		url: "/public/user-testimonials",
+		data,
+		baseURL: import.meta.env.VITE_API_BASE_URL,
+	});
+};

package/stores/chat.ts

@@ -125,6 +125,26 @@ export const useChatStore = defineStore("chat-store", () => {
 		handleChatMessages(chatId);
 	};
 
+	// WS channels: receiver = user.{platform}.chats.{uuid}
+	//              sender  = user.{platform}.chats.sendMessage.{uuid}
+	const subscribeToChatChannel = (userUuid: string, platformSlug: string, asSender = false) => {
+		if (typeof window === "undefined" || !window.Echo) return;
+		const channelName = asSender
+			? `user.${platformSlug}.chats.sendMessage.${userUuid}`
+			: `user.${platformSlug}.chats.${userUuid}`;
+		window.Echo.private(channelName).listen(".NewChatMessage", (data: any) => {
+			callNewMessage(data);
+		});
+	};
+
+	const unsubscribeFromChatChannel = (userUuid: string, platformSlug: string, asSender = false) => {
+		if (typeof window === "undefined" || !window.Echo) return;
+		const channelName = asSender
+			? `user.${platformSlug}.chats.sendMessage.${userUuid}`
+			: `user.${platformSlug}.chats.${userUuid}`;
+		window.Echo.leaveChannel(`private-${channelName}`);
+	};
+
 	return {
 		hasNewMessage,
 		currentMessageData,
@@ -142,6 +162,8 @@ export const useChatStore = defineStore("chat-store", () => {
 		substituteUserChat,
 		startPollingForMessages,
 		stopAllPolling,
+		subscribeToChatChannel,
+		unsubscribeFromChatChannel,
 	};
 });
 

package/stores/notifications.ts

@@ -10,7 +10,9 @@ import type { MgNotification } from "../types";
 
 export const useNotificationsStore = defineStore("notifications-store", () => {
 	const notifications = ref<MgNotification[]>([]);
-	const notificationCount = ref(0);
+	const unreadCount = ref(0);
+	// Alias kept for backward compat
+	const notificationCount = unreadCount;
 	const totalNotifications = ref(0);
 	const currentPage = ref(1);
 	const loading = ref(false);
@@ -108,12 +110,46 @@ export const useNotificationsStore = defineStore("notifications-store", () => {
 	};
 
 	const addNotification = (notification: MgNotification) => {
+		const key = (notification as any).notification_id ?? notification.id;
+		const exists = key && notifications.value.some((n: any) => ((n.notification_id ?? n.id) === key));
+		if (exists) return;
 		notifications.value.unshift(notification);
 		notificationCount.value++;
 	};
 
+	const mapIncomingNotification = (data: any): MgNotification => ({
+		type: data.mg_network_system_id ?? data.type ?? null,
+		object: data.object ?? data.data?.object ?? null,
+		id: data.notification_id ?? data.id ?? null,
+		slug: data.slug ?? data.data?.slug ?? null,
+		url: data.url ?? data.data?.url ?? null,
+		title: data.title ?? data.data?.title ?? "",
+		message: data.message ?? data.data?.message ?? "",
+		image: data.image ?? data.data?.image ?? "",
+		read_at: null,
+		created_at: data.created_at_diff ?? data.created_at ?? "",
+	});
+
+	const subscribeToUserChannel = (userId: number | string) => {
+		if (typeof window === "undefined" || !window.Echo) return;
+		window.Echo.private(`App.Models.User.${userId}`).notification((data: any) => {
+			addNotification(mapIncomingNotification(data));
+			if (typeof window !== "undefined" && window.Audio) {
+				try {
+					new Audio("/sounds/notification.mp3").play().catch(() => {});
+				} catch {}
+			}
+		});
+	};
+
+	const unsubscribeFromUserChannel = (userId: number | string) => {
+		if (typeof window === "undefined" || !window.Echo) return;
+		window.Echo.leaveChannel(`private-App.Models.User.${userId}`);
+	};
+
 	return {
 		notifications,
+		unreadCount,
 		notificationCount,
 		totalNotifications,
 		currentPage,
@@ -125,6 +161,8 @@ export const useNotificationsStore = defineStore("notifications-store", () => {
 		markAllAsRead,
 		removeNotification,
 		addNotification,
+		subscribeToUserChannel,
+		unsubscribeFromUserChannel,
 	};
 });
 

package/stores/testimonies.ts

@@ -0,0 +1,40 @@
+import { defineStore } from "pinia";
+import { ref } from "vue";
+import { getUserTestimonials } from "../services/testimoniesService";
+
+export const useTestimoniesStore = defineStore("testimonies-store", () => {
+	const testimonies = ref<any[]>([]);
+	const loading = ref(false);
+	const error = ref<string | null>(null);
+	const total = ref(0);
+	const currentPage = ref(1);
+
+	const fetchTestimonies = async (params: Record<string, any> = {}) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			const response = await getUserTestimonials(params);
+			const data = response.data;
+			testimonies.value = data.data ?? [];
+			total.value = data.meta?.pagination?.total ?? data.meta?.total ?? testimonies.value.length;
+			currentPage.value = data.meta?.pagination?.current_page ?? 1;
+		} catch {
+			error.value = "Failed to fetch testimonials";
+		} finally {
+			loading.value = false;
+		}
+	};
+
+	return {
+		testimonies,
+		loading,
+		error,
+		total,
+		currentPage,
+		fetchTestimonies,
+	};
+});
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useTestimoniesStore, import.meta.hot));
+}

package/utils/authRedirect.ts

@@ -0,0 +1,18 @@
+export function buildLoginUrl(baseUrl: string, currentPath?: string): string {
+	const redirectTo = currentPath ?? (typeof window !== "undefined" ? window.location.href : "");
+	const params = new URLSearchParams({ redirect_to: redirectTo });
+	return `${baseUrl}/login?${params}`;
+}
+
+export function buildRegisterUrl(accountsUrl: string, currentPath?: string, systemId?: string): string {
+	const redirectTo = currentPath ?? (typeof window !== "undefined" ? window.location.href : "");
+	const params = new URLSearchParams({ redirect_to: redirectTo });
+	if (systemId) params.set("system_id", systemId);
+	return `${accountsUrl}/register?${params}`;
+}
+
+export function buildLogoutUrl(apiBaseUrl: string, redirectAfter?: string): string {
+	if (!redirectAfter) return `${apiBaseUrl}/logout`;
+	const params = new URLSearchParams({ redirect_to: redirectAfter });
+	return `${apiBaseUrl}/logout?${params}`;
+}

package/utils/clearSession.ts

@@ -0,0 +1,103 @@
+/**
+ * Centralized session-recovery utilities.
+ *
+ * The core problem these solve: a stale/invalid `oauth_token` cookie that the
+ * browser keeps sending makes every request fail (OAuth rejects it), and the
+ * server's Set-Cookie to clear it may not reach the browser (cross-domain /
+ * CDN stripping). The user gets stuck — unable to load the site OR log in.
+ *
+ * The fix: clear the auth credentials CLIENT-SIDE so the next request is a clean
+ * guest request and the user can log in again.
+ */
+
+// Auth-related cookies set across the MGN ecosystem.
+const AUTH_COOKIES = [
+	"oauth_token",
+	"oauth_state",
+	"browser_id",
+	"oauth_version",
+	"mundo_gamer_network_session",
+	"XSRF-TOKEN",
+];
+
+/**
+ * Compute every plausible (domain, path) combination a cookie might have been
+ * set with, so we can reliably expire it regardless of how the backend scoped it.
+ *
+ * e.g. host = api.mundogamer.community →
+ *   domains: ["", "api.mundogamer.community", ".api.mundogamer.community",
+ *             "mundogamer.community", ".mundogamer.community"]
+ */
+function candidateDomains(): string[] {
+	if (typeof location === "undefined") return [""];
+	const host = location.hostname;
+	const domains = new Set<string>([""]); // "" = default (current host, no domain attr)
+	domains.add(host);
+	domains.add(`.${host}`);
+
+	const parts = host.split(".");
+	// Walk up to the registrable domain: a.b.c.com → b.c.com → c.com
+	for (let i = 1; i < parts.length - 1; i++) {
+		const parent = parts.slice(i).join(".");
+		domains.add(parent);
+		domains.add(`.${parent}`);
+	}
+	return Array.from(domains);
+}
+
+/** Expire a single cookie across every plausible domain/path scope. */
+function expireCookie(name: string) {
+	if (typeof document === "undefined") return;
+	const expires = "expires=Thu, 01 Jan 1970 00:00:00 GMT";
+	const paths = ["/", location?.pathname || "/"];
+	for (const domain of candidateDomains()) {
+		for (const path of paths) {
+			const domainAttr = domain ? `;domain=${domain}` : "";
+			document.cookie = `${name}=;${expires};path=${path}${domainAttr};SameSite=Lax`;
+			// Secure variant for cross-site contexts
+			document.cookie = `${name}=;${expires};path=${path}${domainAttr};SameSite=None;Secure`;
+		}
+	}
+}
+
+/**
+ * Clear ONLY the auth credentials (cookies + auth store), leaving the user's
+ * other client state (cart, preferences, theme) intact. Use this on detected
+ * session loss so the user recovers without losing unrelated data.
+ */
+export function clearAuthCredentials() {
+	if (typeof window === "undefined") return;
+	AUTH_COOKIES.forEach(expireCookie);
+	try {
+		const authStore = useAuthStore();
+		authStore.clearUser?.();
+	} catch (_) {
+		// store not available in this context
+	}
+}
+
+/**
+ * Full client reset — auth cookies + localStorage + sessionStorage + auth store.
+ * Use on explicit logout or as the "Reset & Reload" recovery action so a stuck
+ * browser is fully cleaned and the user can start fresh.
+ */
+export function clearClientSession() {
+	if (typeof window === "undefined") return;
+	AUTH_COOKIES.forEach(expireCookie);
+
+	// Also expire ANY cookie currently visible to JS (defensive — catches
+	// renamed/legacy auth cookies we don't know about).
+	try {
+		document.cookie.split(";").forEach((c) => {
+			const name = c.split("=")[0].trim();
+			if (name) expireCookie(name);
+		});
+	} catch (_) {}
+
+	try { localStorage.clear(); } catch (_) {}
+	try { sessionStorage.clear(); } catch (_) {}
+	try {
+		const authStore = useAuthStore();
+		authStore.clearUser?.();
+	} catch (_) {}
+}