@kash-88/alerts 1.0.0

package/src/func/getPrivateToken.ts

@@ -0,0 +1,53 @@
+import axios from "axios";
+import { GetPrivateToken } from "@type";
+import { validateDataObject } from "@utils";
+
+/**
+ * Gets a private token for subscribing to a DonationAlerts channel via Centrifuge.
+ *
+ * @example
+ * import { connectPrivateToken } from "@kash-88/alerts";
+ *
+ * // The "channel" can be obtained using the "getUserChannel" function,
+ * // and the "uuidv4_client_id" is provided during authentication in WebSocket (ws).
+ * 
+ * try {
+ *   const token = await connectPrivateToken({
+ *     channel: "USER_CHANNEL",
+ *     uuidv4_client_id: "USER_uuid_ID",
+ *     access_token: "USER_ACCESS_TOKEN"
+ *   });
+ * 
+ *   console.log(token);
+ * } catch (error) {
+ *   console.error("Error getting Oauth token:", error.response.data);
+ * }
+ *
+ * @param {Object} params - Parameters for getting the token.
+ * @param {string} params.channel - Channel name to subscribe.
+ * @param {string} params.uuidv4_client_id - UUID v4 client ID.
+ * @param {string} params.access_token - OAuth access token of the user.
+ * @returns {Promise<string>} - Token for channel subscription.
+ */
+
+export async function getPrivateToken(data: GetPrivateToken): Promise<string> {
+  try {
+    validateDataObject(data, ["channel", "uuidv4_client_id", "access_token"]);
+
+    const response = await axios.post(
+      "https://www.donationalerts.com/api/v1/centrifuge/subscribe",
+      {
+        channels: [data.channel],
+        client: data.uuidv4_client_id
+      },
+      {
+        headers: {
+          "Authorization": `Bearer ${data.access_token}`
+        }
+      }
+    );
+    return response.data.channels[0].token;
+  } catch (error: any) {
+    throw new Error(error?.response?.data?.error_description || error?.message || error);
+  }
+} 

package/src/func/getUser.ts

@@ -0,0 +1,42 @@
+import axios from "axios";
+import { User } from "@type";
+
+/**
+ * Fetches the profile information for the authenticated user.
+ * 
+ * @example
+ * import { getUser } from "@kash.88/alerts";
+ * 
+ * // Get an access_token using getOauthToken or updateAccessToken
+ * 
+ * try {
+ *   const accessToken = "USER_ACCESS_TOKEN";
+ *   const user = await getUser(accessToken);
+ * 
+ *   console.log(user);
+ * } catch (error) {
+ *   console.error("Error fetching user:", error.response.data);
+ * }
+ * 
+ * @param {string} access_token - The access token for authentication.
+ * @returns {Promise<User>} A promise that resolves to the user profile data.
+ * @see {@link https://www.donationalerts.com/apidoc#api_v1__users__user_profile_information}
+ */
+
+export default async function getUser(access_token: string): Promise<User> {
+    try {
+        if (!access_token) {
+            throw new Error("You must provide \"access_token\" as a non-empty string.");
+        }
+
+        const response = await axios.get<{ data: User }>("https://www.donationalerts.com/api/v1/user/oauth", {
+            headers: {
+                Authorization: `Bearer ${access_token}`
+            }
+        });
+
+        return response.data.data;
+    } catch (error: any) {
+        throw new Error(error?.response?.data?.error_description || error?.message || error);
+    }
+} 

package/src/func/getUserChannel.ts

@@ -0,0 +1,34 @@
+/**
+ * Fetches the profile information for the authenticated user.
+ * 
+ * @example
+ * import { getUserChannel } from "@kash.88/alerts";
+ * 
+ * // The "id" can be obtained using the "getUser" function,
+ * 
+ * try {
+ *   const userId = "USER_ID";
+ *   const channelId = getUserChannel(userId);
+ * } catch (error) {
+ *   console.error("Error generating channel ID:", error.message);
+ * }
+ * 
+ * @param {string|number} id - The user ID for which to generate the channel identifier.
+ * @returns {string} The donation alert channel identifier in the format "$alerts:donation_{id}".
+ */
+
+export default function getUserChannel(id: string | number): string {
+    try {
+        if (typeof id !== "string" && typeof id !== "number") {
+            throw new Error("You must provide \"id\" as a string or number.");
+        }
+
+        if (id === null || id === undefined || id === "") {
+            throw new Error("You must provide a non-empty \"id\".");
+        }
+
+        return `$alerts:donation_${id}`;
+    } catch (error: any) {
+        throw new Error(error?.response?.data?.error_description || error?.message || error);
+    }
+} 

package/src/func/updateAccessToken.ts

@@ -0,0 +1,43 @@
+import axios from "axios";
+import { validateDataObject } from "@utils";
+import { UpdateTokenData, OauthToken } from "@type";
+
+/**
+ * Refreshes an access token using a refresh token.
+ * 
+ * @example
+ * import { updateAccessToken } from "@kash.88/alerts";
+ * 
+ * try {
+ *   const tokenData = await updateAccessToken({
+ *     client_id: "YOUR_CLIENT_ID",
+ *     client_secret: "YOUR_CLIENT_SECRET",
+ *     refresh_token: "USER_REFRESH_TOKEN"
+ *   });
+ * 
+ *   console.log(tokenData.access_token);
+ * } catch (error) {
+ *   console.error("Error updating access token:", error.response.data);
+ * }
+ * 
+ * @param {UpdateTokenData} data - The data for the token refresh request.
+ * @returns {Promise<OauthToken>} A promise that resolves to the new token data from the API.
+ * @see {@link https://www.donationalerts.com/apidoc#authorization__authorization_code__getting_access_token}
+ */
+
+export default async function updateAccessToken(data: UpdateTokenData): Promise<OauthToken> {
+    try {
+        validateDataObject(data, ["client_id", "client_secret", "refresh_token"]);
+
+        const response = await axios.post<OauthToken>("https://www.donationalerts.com/oauth/token", {
+            grant_type: "refresh_token",
+            client_id: data.client_id,
+            client_secret: data.client_secret,
+            refresh_token: data.refresh_token
+        });
+
+        return response.data;
+    } catch (error: any) {
+        throw new Error(error?.response?.data?.error_description || error?.message || error);
+    }
+} 

package/src/index.ts

@@ -0,0 +1,19 @@
+import getAuthorizeLink from "@function/getAuthorizeLink";
+import getOauthToken from "@function/getOauthToken";
+import getUser from "@function/getUser";
+import updateAccessToken from "@function/updateAccessToken";
+import getUserChannel from "@function/getUserChannel";
+import { getPrivateToken } from "@function/getPrivateToken";
+import CentrifugeClient from "@ws/CentrifugeClient";
+
+export * from "@type";
+
+export {
+    getAuthorizeLink,
+    getOauthToken,
+    getUser,
+    updateAccessToken,
+    getUserChannel,
+    getPrivateToken,
+    CentrifugeClient
+}; 

package/src/types.ts

@@ -0,0 +1,38 @@
+export interface OauthToken {
+    token_type: string;
+    expires_in: number;
+    access_token: string;
+    refresh_token: string;
+}
+
+export interface GetPrivateToken {
+    channel: string;
+    uuidv4_client_id: string;
+    access_token: string;
+}
+
+export interface User {
+    id: number;
+    code: string;
+    name: string;
+    avatar: string;
+    email: string;
+    socket_connection_token: string;
+}
+
+export interface GetAuthorizeLinkData {
+    client_id: string | number;
+    scope: string[];
+}
+
+export interface GetOauthData {
+    client_id: string | number;
+    client_secret: string;
+    code: string;
+}
+
+export interface UpdateTokenData {
+    client_id: string | number;
+    client_secret: string;
+    refresh_token: string;
+} 

package/src/utils.ts

@@ -0,0 +1,56 @@
+/**
+ * Checks if a value is a plain object.
+ * @param {unknown} value The value to check.
+ * @returns {boolean} True if the value is a plain object, false otherwise.
+ * @private
+ */
+
+function isObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Validates that the provided data is an object and contains the required keys.
+ * For each required key, it also validates that the value is a string or a number.
+ * @param {unknown} data - The data object to validate.
+ * @param {string[]} requiredKeys - An array of keys that must be present in the data object.
+ * @throws {Error} If validation fails.
+ * @private
+ */
+
+export function validateDataObject(data: unknown, requiredKeys: string[]): asserts data is Record<string, string | number | string[]> {
+    if (!isObject(data)) {
+        throw new Error("You must provide data as an object.");
+    }
+
+    for (const key of requiredKeys) {
+        if (!(key in data) || data[key] === undefined || data[key] === null) {
+            throw new Error(`You must provide "${key}" in the data object.`);
+        }
+
+        const value = data[key];
+
+        if (key === "scope") {
+            if(!Array.isArray(value)) {
+                throw new Error(`"${key}" must be an array of strings.`);
+            }
+            continue;
+        }
+
+        if (typeof value !== "string" && typeof value !== "number") {
+            throw new Error(`"${key}" must be a string or a number.`);
+        }
+    }
+}
+
+/**
+ * Checks if required environment variables are present.
+ * Throws an error with a clear message if any variable is missing.
+ * @param {string[]} keys - List of required environment variable names.
+ */
+export function checkEnv(keys: string[]): void {
+    const missing = keys.filter((key) => !process.env[key]);
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables: ${missing.join(", ")}`);
+    }
+} 

package/src/ws/CentrifugeClient.ts

@@ -0,0 +1,108 @@
+import { getPrivateToken } from "@kash-88/alerts";
+import { WebSocket } from "ws";
+import { EventEmitter } from "events";
+import TypedEmitter from "typed-emitter";
+
+// --- Interfaces ---
+interface CentrifugeConfiguration {
+    ws: {
+        url: string;
+    };
+}
+
+interface WSClientOptions {
+    channel: string;
+    socket_connection_token: string;
+    access_token: string;
+}
+
+interface CentrifugeMessage {
+    params: Record<string, unknown>;
+    id: number;
+    method?: number;
+}
+
+// --- Configuration ---
+const configuration: CentrifugeConfiguration = {
+    ws: {
+        url: "wss://centrifugo.donationalerts.com/connection/websocket"
+    }
+};
+
+type MessageEvents = {
+    open: () => void;
+    message: (data: CentrifugeMessage) => void;
+    close: () => void;
+    error: (error: Error) => void;
+    reconnecting: (attempt: number) => void;
+    reconnect_failed: () => void;
+}
+
+// --- Class ---
+export default class CentrifugeClient extends (EventEmitter as new () => TypedEmitter<MessageEvents>) {
+    private options: WSClientOptions;
+    private ws: WebSocket | null = null;
+
+    constructor(options: WSClientOptions) {
+        super();
+        this.options = options; this.ws;
+    }
+
+    public createConnection(): WebSocket {
+        if (this.ws) {
+            return this.ws;
+        }
+
+        try {
+            this.ws = new WebSocket(configuration.ws.url);
+            
+            return this.ws;
+        } catch (error) {
+            console.error("[WS] Failed to create connection:", error);
+            throw error;
+        }
+    }
+
+    public confirmConnection(socket_connection_token: string = this.options.socket_connection_token): void {
+        const message: CentrifugeMessage = {
+            params: {
+                token: socket_connection_token
+            },
+            id: 1
+        };
+        this.sendMessage(JSON.stringify(message));
+    }
+
+    public async connectPrivateToken(channel: string, uuidv4_client_id: string, access_token: string = this.options.access_token): Promise<void> {
+        try {
+            const token = await getPrivateToken({
+                channel,
+                uuidv4_client_id,
+                access_token
+            });
+
+            const subscribeMessage: CentrifugeMessage = {
+                params: {
+                    channel: channel,
+                    token
+                },
+                method: 1,
+                id: 2
+            };
+
+            this.sendMessage(JSON.stringify(subscribeMessage));
+        } catch (error: any) {
+            throw new Error(error);
+        }
+    }
+
+    public sendMessage(message: string): void {
+        if(!this.ws) return;
+
+        try {
+            this.ws.send(message);
+        } catch (error: any) {
+            throw new Error(error);
+        }
+    }
+}