@b3dotfun/sdk 0.0.44-alpha.1 → 0.0.45

package/dist/esm/notifications/services/api.js

@@ -0,0 +1,173 @@
+import { getAuthToken } from "../../shared/utils/auth-token.js";
+const DEFAULT_API_URL = "https://notifications.b3.fun";
+let apiUrl = DEFAULT_API_URL;
+export function setApiUrl(url) {
+    apiUrl = url;
+}
+export function getApiUrl() {
+    return apiUrl;
+}
+function getHeaders(includeAuth = false) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (includeAuth) {
+        const token = getAuthToken();
+        if (token) {
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+    }
+    return headers;
+}
+export const notificationsAPI = {
+    // ===== USER MANAGEMENT =====
+    /**
+     * Register the current user (userId extracted from JWT)
+     */
+    async registerUser() {
+        const res = await fetch(`${apiUrl}/users`, {
+            method: "POST",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Get current user's profile and preferences
+     */
+    async getUser() {
+        const res = await fetch(`${apiUrl}/users/me`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Get current user's notification history
+     */
+    async getHistory(appId, limit = 100) {
+        const params = new URLSearchParams();
+        if (appId)
+            params.append("appId", appId);
+        params.append("limit", limit.toString());
+        const res = await fetch(`${apiUrl}/users/me/history?${params}`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== CHANNELS =====
+    /**
+     * Add a notification channel for current user
+     */
+    async addChannel(channelType, channelIdentifier, metadata) {
+        const res = await fetch(`${apiUrl}/users/me/channels`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify({
+                channelType,
+                channelIdentifier,
+                enabled: true,
+                metadata,
+            }),
+        });
+        return res.json();
+    },
+    /**
+     * Connect email for current user
+     */
+    async connectEmail(email) {
+        return this.addChannel("email", email);
+    },
+    /**
+     * Update a notification channel
+     */
+    async updateChannel(channelId, updates) {
+        const res = await fetch(`${apiUrl}/users/me/channels/${channelId}`, {
+            method: "PUT",
+            headers: getHeaders(true),
+            body: JSON.stringify(updates),
+        });
+        return res.json();
+    },
+    /**
+     * Delete a notification channel
+     */
+    async deleteChannel(channelId) {
+        const res = await fetch(`${apiUrl}/users/me/channels/${channelId}`, {
+            method: "DELETE",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== TELEGRAM =====
+    /**
+     * Get Telegram deep link for current user
+     */
+    async getTelegramLink() {
+        const res = await fetch(`${apiUrl}/telegram/request-link`, {
+            method: "POST",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Check current user's Telegram connection status
+     */
+    async checkTelegramStatus() {
+        const res = await fetch(`${apiUrl}/telegram/status/me`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== APP PREFERENCES =====
+    /**
+     * Save notification preferences for an app
+     */
+    async savePreferences(appId, settings) {
+        const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify({ ...settings, enabled: true }),
+        });
+        return res.json();
+    },
+    /**
+     * Get notification settings for an app
+     */
+    async getAppSettings(appId) {
+        const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== IN-APP NOTIFICATIONS =====
+    /**
+     * Get current user's in-app notifications
+     */
+    async getInAppNotifications() {
+        const res = await fetch(`${apiUrl}/users/me/notifications`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Mark a notification as read
+     */
+    async markNotificationAsRead(notificationId) {
+        const res = await fetch(`${apiUrl}/users/me/notifications/${notificationId}/read`, {
+            method: "PUT",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== SENDING NOTIFICATIONS =====
+    /**
+     * Send a notification (requires auth)
+     */
+    async sendNotification(data) {
+        const res = await fetch(`${apiUrl}/send`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify(data),
+        });
+        return res.json();
+    },
+};

package/dist/esm/notifications/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./api";

package/dist/esm/notifications/services/index.js

@@ -0,0 +1 @@
+export * from "./api.js";

package/dist/esm/notifications/types/index.d.ts

@@ -0,0 +1,50 @@
+export type ChannelType = "email" | "telegram" | "discord" | "sms" | "whatsapp" | "in_app";
+export interface NotificationChannel {
+    id: number;
+    channel_type: ChannelType;
+    enabled: number;
+    channel_identifier: string;
+}
+export interface UserData {
+    user: {
+        id: number;
+        user_id: string;
+    };
+    channels: NotificationChannel[];
+    appSettings: Array<{
+        app_id: string;
+        notification_type: string;
+        enabled: number;
+        channels: string;
+    }>;
+}
+export interface NotificationHistory {
+    id: string;
+    app_id: string;
+    notification_type: string;
+    title: string;
+    message: string;
+    created_at: string;
+    read: boolean;
+}
+export interface TelegramLinkResponse {
+    deepLink: string;
+    verificationCode: string;
+    botUsername: string;
+}
+export interface TelegramStatusResponse {
+    connected: boolean;
+    chatId?: string;
+}
+export interface NotificationPreferences {
+    notificationType: string;
+    channels: string[];
+}
+export interface SendNotificationRequest {
+    userId: string;
+    appId: string;
+    notificationType: string;
+    message: string;
+    title?: string;
+    data?: Record<string, any>;
+}

package/dist/esm/shared/utils/auth-token.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the authentication token from the B3 auth cookie
+ * This token is managed by the B3 Global Account authentication system
+ *
+ * @returns The JWT token string or null if not found
+ */
+export declare function getAuthToken(): string | null;

package/dist/esm/shared/utils/auth-token.js

@@ -0,0 +1,11 @@
+import Cookies from "js-cookie";
+const B3_AUTH_COOKIE_NAME = "b3-auth";
+/**
+ * Get the authentication token from the B3 auth cookie
+ * This token is managed by the B3 Global Account authentication system
+ *
+ * @returns The JWT token string or null if not found
+ */
+export function getAuthToken() {
+    return Cookies.get(B3_AUTH_COOKIE_NAME) || null;
+}

package/dist/esm/shared/utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./auth-token";
 export * from "./cn";
 export * from "./formatNumber";
 export * from "./formatUsername";

package/dist/esm/shared/utils/index.js

@@ -1,4 +1,5 @@
 // Export utility functions
+export * from "./auth-token.js";
 export * from "./cn.js";
 export * from "./formatNumber.js";
 export * from "./formatUsername.js";

package/dist/types/notifications/index.d.ts

@@ -0,0 +1,4 @@
+export declare const VERSION = "1.0.0";
+export * from "./types";
+export * from "./services";
+export { getAuthToken } from "../shared/utils/auth-token";

package/dist/types/notifications/react/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from "./useNotifications";

package/dist/types/notifications/react/hooks/useNotifications.d.ts

@@ -0,0 +1,42 @@
+import type { UserData } from "../../types";
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '@b3dotfun/sdk/notifications/react';
+ *
+ * function NotificationSettings() {
+ *   const { user, loading, connectEmail, connectTelegram, isEmailConnected } = useNotifications();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {!isEmailConnected && (
+ *         <button onClick={() => connectEmail('user@example.com')}>
+ *           Connect Email
+ *         </button>
+ *       )}
+ *       <button onClick={connectTelegram}>Connect Telegram</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useNotifications(): {
+    user: UserData | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    connectEmail: (email: string) => Promise<void>;
+    connectTelegram: () => Promise<void>;
+    updateChannel: (channelId: string, updates: {
+        enabled?: boolean;
+    }) => Promise<void>;
+    deleteChannel: (channelId: string) => Promise<void>;
+    isEmailConnected: boolean;
+    isTelegramConnected: boolean;
+    isDiscordConnected: boolean;
+};

package/dist/types/notifications/react/index.d.ts

@@ -0,0 +1 @@
+export * from "./hooks";

package/dist/types/notifications/services/api.d.ts

@@ -0,0 +1,65 @@
+import type { NotificationHistory, NotificationPreferences, SendNotificationRequest, TelegramLinkResponse, TelegramStatusResponse, UserData } from "../types";
+export declare function setApiUrl(url: string): void;
+export declare function getApiUrl(): string;
+export declare const notificationsAPI: {
+    /**
+     * Register the current user (userId extracted from JWT)
+     */
+    registerUser(): Promise<any>;
+    /**
+     * Get current user's profile and preferences
+     */
+    getUser(): Promise<UserData>;
+    /**
+     * Get current user's notification history
+     */
+    getHistory(appId?: string, limit?: number): Promise<NotificationHistory[]>;
+    /**
+     * Add a notification channel for current user
+     */
+    addChannel(channelType: string, channelIdentifier: string, metadata?: Record<string, any>): Promise<any>;
+    /**
+     * Connect email for current user
+     */
+    connectEmail(email: string): Promise<any>;
+    /**
+     * Update a notification channel
+     */
+    updateChannel(channelId: string, updates: {
+        enabled?: boolean;
+        channelIdentifier?: string;
+        metadata?: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Delete a notification channel
+     */
+    deleteChannel(channelId: string): Promise<any>;
+    /**
+     * Get Telegram deep link for current user
+     */
+    getTelegramLink(): Promise<TelegramLinkResponse>;
+    /**
+     * Check current user's Telegram connection status
+     */
+    checkTelegramStatus(): Promise<TelegramStatusResponse>;
+    /**
+     * Save notification preferences for an app
+     */
+    savePreferences(appId: string, settings: NotificationPreferences): Promise<any>;
+    /**
+     * Get notification settings for an app
+     */
+    getAppSettings(appId: string): Promise<any>;
+    /**
+     * Get current user's in-app notifications
+     */
+    getInAppNotifications(): Promise<any>;
+    /**
+     * Mark a notification as read
+     */
+    markNotificationAsRead(notificationId: string): Promise<any>;
+    /**
+     * Send a notification (requires auth)
+     */
+    sendNotification(data: SendNotificationRequest): Promise<any>;
+};

package/dist/types/notifications/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./api";

package/dist/types/notifications/types/index.d.ts

@@ -0,0 +1,50 @@
+export type ChannelType = "email" | "telegram" | "discord" | "sms" | "whatsapp" | "in_app";
+export interface NotificationChannel {
+    id: number;
+    channel_type: ChannelType;
+    enabled: number;
+    channel_identifier: string;
+}
+export interface UserData {
+    user: {
+        id: number;
+        user_id: string;
+    };
+    channels: NotificationChannel[];
+    appSettings: Array<{
+        app_id: string;
+        notification_type: string;
+        enabled: number;
+        channels: string;
+    }>;
+}
+export interface NotificationHistory {
+    id: string;
+    app_id: string;
+    notification_type: string;
+    title: string;
+    message: string;
+    created_at: string;
+    read: boolean;
+}
+export interface TelegramLinkResponse {
+    deepLink: string;
+    verificationCode: string;
+    botUsername: string;
+}
+export interface TelegramStatusResponse {
+    connected: boolean;
+    chatId?: string;
+}
+export interface NotificationPreferences {
+    notificationType: string;
+    channels: string[];
+}
+export interface SendNotificationRequest {
+    userId: string;
+    appId: string;
+    notificationType: string;
+    message: string;
+    title?: string;
+    data?: Record<string, any>;
+}

package/dist/types/shared/utils/auth-token.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the authentication token from the B3 auth cookie
+ * This token is managed by the B3 Global Account authentication system
+ *
+ * @returns The JWT token string or null if not found
+ */
+export declare function getAuthToken(): string | null;

package/dist/types/shared/utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./auth-token";
 export * from "./cn";
 export * from "./formatNumber";
 export * from "./formatUsername";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.0.44-alpha.1",
+  "version": "0.0.45",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",
@@ -170,6 +170,26 @@
       "import": "./dist/esm/global-account/server.js",
       "require": "./dist/cjs/global-account/server.js"
     },
+    "./notifications": {
+      "types": "./dist/types/notifications/index.d.ts",
+      "import": "./dist/esm/notifications/index.js",
+      "require": "./dist/cjs/notifications/index.js"
+    },
+    "./notifications/react": {
+      "types": "./dist/types/notifications/react/index.d.ts",
+      "import": "./dist/esm/notifications/react/index.js",
+      "require": "./dist/cjs/notifications/react/index.js"
+    },
+    "./notifications/services": {
+      "types": "./dist/types/notifications/services/index.d.ts",
+      "import": "./dist/esm/notifications/services/index.js",
+      "require": "./dist/cjs/notifications/services/index.js"
+    },
+    "./notifications/types": {
+      "types": "./dist/types/notifications/types/index.d.ts",
+      "import": "./dist/esm/notifications/types/index.js",
+      "require": "./dist/cjs/notifications/types/index.js"
+    },
     "./shared/utils": {
       "types": "./dist/types/shared/utils/index.d.ts",
       "import": "./dist/esm/shared/utils/index.js",

package/src/notifications/index.ts

@@ -0,0 +1,11 @@
+export const VERSION = "1.0.0";
+
+// Export types
+export * from "./types";
+
+// Export services
+export * from "./services";
+
+// Re-export auth token getter from shared for convenience
+// Note: Auth token is managed by B3 Global Account authentication
+export { getAuthToken } from "../shared/utils/auth-token";

package/src/notifications/react/hooks/index.ts

@@ -0,0 +1 @@
+export * from "./useNotifications";

package/src/notifications/react/hooks/useNotifications.ts

@@ -0,0 +1,153 @@
+import { useEffect, useRef, useState } from "react";
+import { notificationsAPI } from "../../services/api";
+import type { UserData } from "../../types";
+
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '@b3dotfun/sdk/notifications/react';
+ *
+ * function NotificationSettings() {
+ *   const { user, loading, connectEmail, connectTelegram, isEmailConnected } = useNotifications();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {!isEmailConnected && (
+ *         <button onClick={() => connectEmail('user@example.com')}>
+ *           Connect Email
+ *         </button>
+ *       )}
+ *       <button onClick={connectTelegram}>Connect Telegram</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useNotifications() {
+  const [user, setUser] = useState<UserData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Refs to track polling timers for cleanup
+  const telegramPollIntervalRef = useRef<NodeJS.Timeout | null>(null);
+  const telegramPollTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Cleanup function for Telegram polling
+  const cleanupTelegramPolling = () => {
+    if (telegramPollIntervalRef.current) {
+      clearInterval(telegramPollIntervalRef.current);
+      telegramPollIntervalRef.current = null;
+    }
+    if (telegramPollTimeoutRef.current) {
+      clearTimeout(telegramPollTimeoutRef.current);
+      telegramPollTimeoutRef.current = null;
+    }
+  };
+
+  // Load user data on mount
+  useEffect(() => {
+    loadUser();
+  }, []);
+
+  // Cleanup polling on unmount
+  useEffect(() => {
+    return () => {
+      cleanupTelegramPolling();
+    };
+  }, []);
+
+  const loadUser = async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const userData = await notificationsAPI.getUser();
+      setUser(userData);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to load user"));
+      console.error("Failed to load user:", err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const connectEmail = async (email: string) => {
+    try {
+      await notificationsAPI.connectEmail(email);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to connect email:", err);
+      throw err;
+    }
+  };
+
+  const connectTelegram = async () => {
+    try {
+      // Clear any existing polling before starting new one
+      cleanupTelegramPolling();
+
+      const { deepLink } = await notificationsAPI.getTelegramLink();
+      window.open(deepLink, "_blank");
+
+      // Poll for connection status
+      telegramPollIntervalRef.current = setInterval(async () => {
+        try {
+          const { connected } = await notificationsAPI.checkTelegramStatus();
+          if (connected) {
+            cleanupTelegramPolling();
+            await loadUser(); // Refresh user data
+          }
+        } catch (err) {
+          console.error("Failed to check Telegram status:", err);
+        }
+      }, 2000);
+
+      // Stop polling after 2 minutes
+      telegramPollTimeoutRef.current = setTimeout(() => {
+        cleanupTelegramPolling();
+      }, 120000);
+    } catch (err) {
+      console.error("Failed to connect Telegram:", err);
+      throw err;
+    }
+  };
+
+  const updateChannel = async (channelId: string, updates: { enabled?: boolean }) => {
+    try {
+      await notificationsAPI.updateChannel(channelId, updates);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to update channel:", err);
+      throw err;
+    }
+  };
+
+  const deleteChannel = async (channelId: string) => {
+    try {
+      await notificationsAPI.deleteChannel(channelId);
+      await loadUser(); // Refresh user data
+    } catch (err) {
+      console.error("Failed to delete channel:", err);
+      throw err;
+    }
+  };
+
+  return {
+    user,
+    loading,
+    error,
+    refresh: loadUser,
+    connectEmail,
+    connectTelegram,
+    updateChannel,
+    deleteChannel,
+    // Convenience helpers
+    isEmailConnected: user?.channels?.find(c => c.channel_type === "email")?.enabled === 1,
+    isTelegramConnected: user?.channels?.find(c => c.channel_type === "telegram")?.enabled === 1,
+    isDiscordConnected: user?.channels?.find(c => c.channel_type === "discord")?.enabled === 1,
+  };
+}

package/src/notifications/react/index.ts

@@ -0,0 +1 @@
+export * from "./hooks";