comty.js 0.1.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "comty.js",
+  "version": "0.1.0",
+  "main": "./dist/index.js",
+  "author": "RageStudio <support@ragestudio.net>",
+  "scripts": {
+    "build": "corenode-cli build"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@foxify/events": "^2.1.0",
+    "axios": "^1.4.0",
+    "js-cookie": "^3.0.5",
+    "jsonwebtoken": "^9.0.0",
+    "jwt-decode": "^3.1.2",
+    "linebridge": "^0.15.12"
+  },
+  "devDependencies": {
+    "corenode": "^0.28.26"
+  }
+}

package/src/handlers/measurePing.js

@@ -0,0 +1,53 @@
+import request from "./request"
+
+export default async () => {
+    const timings = {}
+
+    const promises = [
+        new Promise(async (resolve) => {
+            const start = Date.now()
+
+            request({
+                method: "GET",
+                url: "/ping",
+            })
+                .then(() => {
+                    // set http timing in ms
+                    timings.http = Date.now() - start
+
+                    resolve()
+                })
+                .catch(() => {
+                    timings.http = "failed"
+                    resolve()
+                })
+
+            setTimeout(() => {
+                timings.http = "failed"
+
+                resolve()
+            }, 10000)
+        }),
+        new Promise((resolve) => {
+            const start = Date.now()
+
+            __comty_shared_state.wsInstances["default"].on("pong", () => {
+                timings.ws = Date.now() - start
+
+                resolve()
+            })
+
+            __comty_shared_state.wsInstances["default"].emit("ping")
+
+            setTimeout(() => {
+                timings.ws = "failed"
+
+                resolve()
+            }, 10000)
+        })
+    ]
+
+    await Promise.all(promises)
+
+    return timings
+}

package/src/handlers/request.js

@@ -0,0 +1,60 @@
+import handleBeforeRequest from "../helpers/handleBeforeRequest"
+import handleAfterRequest from "../helpers/handleAfterRequest"
+import SessionModel from "../models/session"
+
+export default async (
+    request = {
+        method: "GET",
+    },
+    ...args
+) => {
+    const instance = request.instance ?? __comty_shared_state.instances.default
+
+    if (!instance) {
+        throw new Error("No instance provided")
+    }
+
+    // handle before request
+    await handleBeforeRequest(request)
+
+    if (typeof request === "string") {
+        request = {
+            url: request,
+        }
+    }
+
+    if (typeof request.headers !== "object") {
+        request.headers = {}
+    }
+
+    let result = null
+
+    const makeRequest = async () => {
+        const sessionToken = await SessionModel.token
+
+        if (sessionToken) {
+            request.headers["Authorization"] = `${globalThis.isServerMode ? "Server" : "Bearer"} ${sessionToken}`
+        } else {
+            console.warn("Making a request with no session token")
+        }
+
+        const _result = await instance(request, ...args)
+            .catch((error) => {
+                return error
+            })
+
+        result = _result
+    }
+
+    await makeRequest()
+
+    // handle after request
+    await handleAfterRequest(result, makeRequest)
+
+    // if error, throw it
+    if (result instanceof Error) {
+        throw result
+    }
+
+    return result
+}

package/src/helpers/handleAfterRequest.js

@@ -0,0 +1,34 @@
+import handleRegenerationEvent from "./handleRegenerationEvent"
+
+export default async (data, callback) => {
+    // handle 401, 403 responses
+    if (data instanceof Error) {
+        if (data.code && (data.code === "ECONNABORTED" || data.code === "ERR_NETWORK")) {
+            console.error(`Request aborted or network error, ignoring`)
+            return false
+        }
+
+        if (data.response.status === 401) {
+            // check if the server issue a refresh token on data
+            if (data.response.data.refreshToken) {
+                console.log(`Session expired, but the server issued a refresh token, handling regeneration event`)
+
+                // handle regeneration event
+                await handleRegenerationEvent(data.response.data.refreshToken)
+
+                return await callback()
+            }
+
+            // check if route is from "session" namespace
+            if (data.config.url.includes("/session")) {
+                return __comty_shared_state.eventBus.emit("session.invalid", "Session expired, but the server did not issue a refresh token")
+            }
+        }
+
+        if (data.response.status === 403) {
+            if (data.config.url.includes("/session")) {
+                return __comty_shared_state.eventBus.emit("session.invalid", "Session not valid or not existent")
+            }
+        }
+    }
+}

package/src/helpers/handleBeforeRequest.js

@@ -0,0 +1,13 @@
+export default async (request) => {
+    if (__comty_shared_state.onExpiredExceptionEvent) {
+        if (__comty_shared_state.excludedExpiredExceptionURL.includes(request.url)) return
+
+        await new Promise((resolve) => {
+            __comty_shared_state.eventBus.once("session.regenerated", () => {
+                console.log(`Session has been regenerated, retrying request`)
+
+                resolve()
+            })
+        })
+    }
+}

package/src/helpers/handleRegenerationEvent.js

@@ -0,0 +1,39 @@
+import SessionModel from "../models/session"
+import request from "../handlers/request"
+
+export default async (refreshToken) =>{
+    __comty_shared_state.eventBus.emit("session.expiredExceptionEvent", refreshToken)
+
+    __comty_shared_state.onExpiredExceptionEvent = true
+
+    const expiredToken = await SessionModel.token
+
+    // send request to regenerate token
+    const response = await request({
+        method: "POST",
+        url: "/session/regenerate",
+        data: {
+            expiredToken: expiredToken,
+            refreshToken,
+        }
+    }).catch((error) => {
+        console.error(`Failed to regenerate token: ${error.message}`)
+        return false
+    })
+
+    if (!response) {
+        return __comty_shared_state.eventBus.emit("session.invalid", "Failed to regenerate token")
+    }
+
+    if (!response.data?.token) {
+        return __comty_shared_state.eventBus.emit("session.invalid", "Failed to regenerate token, invalid server response.")
+    }
+
+    // set new token
+    SessionModel.token = response.data.token
+
+    __comty_shared_state.onExpiredExceptionEvent = false
+
+    // emit event
+    __comty_shared_state.eventBus.emit("session.regenerated")
+}

package/src/helpers/withSettings.js

@@ -0,0 +1,25 @@
+export default class Settings {
+    static get = (key) => {
+        if (typeof window === "undefined") {
+            return null
+        }
+
+        return window?.app?.cores?.settings.get(key)
+    }
+
+    static set = (key, value) => {
+        if (typeof window === "undefined") {
+            return null
+        }
+
+        return window?.app?.cores?.settings.set(key, value)
+    }
+
+    static is = (key) => {
+        if (typeof window === "undefined") {
+            return null
+        }
+
+        return window?.app?.cores?.settings.is(key)
+    }
+}

package/src/helpers/withStorage.js

@@ -0,0 +1,31 @@
+import jscookies from "js-cookie"
+
+class InternalStorage {
+    #storage = {}
+
+    get(key) {
+        // get value from storage
+        return this.#storage[key]
+    }
+
+    set(key, value) {
+        // storage securely in memory
+        return this.#storage[key] = value
+    }
+}
+
+export default class Storage {
+    static get engine() {
+        // check if is running in browser, if is import js-cookie
+        // else use in-memory safe storage
+        if (typeof window !== "undefined") {
+            return jscookies
+        }
+
+        if (!globalThis.__comty_shared_state["_internal_storage"]) {
+            globalThis.__comty_shared_state["_internal_storage"] = new InternalStorage()
+        }
+
+        return globalThis.__comty_shared_state["_internal_storage"]
+    }
+}

package/src/hooks/useRequest/index.js

@@ -0,0 +1,32 @@
+import React from "react"
+
+export default (method, ...args) => {
+    if (typeof method !== "function") {
+        throw new Error("useRequest: method must be a function")
+    }
+
+    const [loading, setLoading] = React.useState(true)
+    const [result, setResult] = React.useState(null)
+    const [error, setError] = React.useState(null)
+
+    const makeRequest = (...newArgs) => {
+        method(...newArgs)
+            .then((data) => {
+                setResult(data)
+                setLoading(false)
+            })
+            .catch((err) => {
+                setError(err)
+                setLoading(false)
+            })
+    }
+
+    React.useEffect(() => {
+        makeRequest(...args)
+    }, [])
+
+    return [loading, result, error, (...newArgs) => {
+        setLoading(true)
+        makeRequest(...newArgs)
+    }]
+}

package/src/index.js

@@ -0,0 +1,103 @@
+import EventEmitter from "@foxify/events"
+
+import axios from "axios"
+import { io } from "socket.io-client"
+
+import remotes from "./remotes"
+
+import request from "./handlers/request"
+import Storage from "./helpers/withStorage"
+
+import SessionModel from "./models/session"
+import { createHandlers } from "./models"
+
+globalThis.isServerMode = typeof window === "undefined" && typeof global !== "undefined"
+
+if (globalThis.isServerMode) {
+    const { Buffer } = require("buffer")
+
+    globalThis.b64Decode = (data) => {
+        return Buffer.from(data, "base64").toString("utf-8")
+    }
+    globalThis.b64Encode = (data) => {
+        return Buffer.from(data, "utf-8").toString("base64")
+    }
+}
+
+export default function createClient({
+    wsEvents = Object(),
+    useWs = false,
+    accessKey = null,
+    privateKey = null,
+} = {}) {
+    const sharedState = globalThis.__comty_shared_state = {
+        onExpiredExceptionEvent: false,
+        excludedExpiredExceptionURL: ["/session/regenerate"],
+        eventBus: new EventEmitter(),
+        mainOrigin: remotes.default.origin,
+        instances: Object(),
+        wsInstances: Object(),
+        rest: null,
+    }
+
+    if (globalThis.isServerMode) {
+        sharedState.rest = createHandlers()
+    }
+
+    if (privateKey && accessKey && globalThis.isServerMode) {
+        Storage.engine.set("token", `${accessKey}:${privateKey}`)
+    }
+
+    // create instances for every remote
+    for (const [key, remote] of Object.entries(remotes)) {
+        sharedState.instances[key] = axios.create({
+            baseURL: remote.origin,
+        })
+
+        if (useWs && remote.hasWebsocket) {
+            sharedState.wsInstances[key] = io(remote.wsOrigin ?? remote.origin, {
+                transports: ["websocket"],
+                autoConnect: true,
+                ...remote.wsParams ?? {},
+            })
+        }
+    }
+
+    // register ws events
+    Object.keys(sharedState.wsInstances).forEach((key) => {
+        const ws = sharedState.wsInstances[key]
+
+        ws.on("connect", () => {
+            console.log(`[WS-API][${key}] Connected`)
+
+            if (remotes[key].needsAuth) {
+                // try to auth
+                ws.emit("authenticate", {
+                    token: SessionModel.token,
+                })
+            }
+        })
+
+        ws.on("disconnect", () => {
+            console.log(`[WS-API][${key}] Disconnected`)
+        })
+
+        ws.on("error", (error) => {
+            console.error(`[WS-API][${key}] Error`, error)
+        })
+
+        ws.onAny((event, ...args) => {
+            console.log(`[WS-API][${key}] Event recived`, event, ...args)
+        })
+
+        const customEvents = wsEvents[key]
+
+        if (customEvents) {
+            for (const [eventName, eventHandler] of Object.entries(customEvents)) {
+                ws.on(eventName, eventHandler)
+            }
+        }
+    })
+
+    return sharedState
+}

package/src/models/auth/index.js

@@ -0,0 +1,53 @@
+import request from "../../handlers/request"
+import SessionModel from "../session"
+
+export default class AuthModel {
+    static login = async (payload) => {
+        const response = await request({
+            method: "post",
+            url: "/auth/login",
+            data: {
+                username: payload.username, //window.btoa(payload.username),
+                password: payload.password, //window.btoa(payload.password),
+            },
+        })
+
+        SessionModel.token = response.data.token
+
+        __comty_shared_state.eventBus.emit("auth:login_success")
+
+        return response.data
+    }
+
+    static logout = async () => {
+        await SessionModel.destroyCurrentSession()
+
+        SessionModel.removeToken()
+
+        __comty_shared_state.eventBus.emit("auth:logout_success")
+    }
+
+    static register = async (payload) => {
+        const { username, password, email } = payload
+
+        const response = await request({
+            method: "post",
+            url: "/auth/register",
+            data: {
+                username,
+                password,
+                email,
+            }
+        }).catch((error) => {
+            console.error(error)
+
+            return false
+        })
+
+        if (!response) {
+            throw new Error("Unable to register user")
+        }
+
+        return response
+    }
+}

package/src/models/feed/index.js

@@ -0,0 +1,82 @@
+import request from "../../handlers/request"
+import Settings from "../../helpers/withSettings"
+
+export default class FeedModel {
+    static getMusicFeed = async ({ trim, limit } = {}) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/feed/music`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static getGlobalMusicFeed = async ({ trim, limit } = {}) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/feed/music/global`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static getTimelineFeed = async ({ trim, limit } = {}) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/feed/timeline`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static getPostsFeed = async ({ trim, limit } = {}) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/feed/posts`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static getPlaylistsFeed = async ({ trim, limit } = {}) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/feed/playlists`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static search = async (keywords, params = {}) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/search`,
+            params: {
+                keywords: keywords,
+                params: params
+            }
+        })
+
+        return data
+    }
+}

package/src/models/follows/index.js

@@ -0,0 +1,48 @@
+import { SessionModel } from "../../models"
+import request from "../../handlers/request"
+
+export default class FollowsModel {
+    static imFollowing = async (user_id) => {
+        if (!user_id) {
+            throw new Error("user_id is required")
+        }
+
+        const response = await request({
+            method: "GET",
+            url: `/follow/user/${user_id}`,
+        })
+
+        return response.data
+    }
+
+    static getFollowers = async (user_id) => {
+        if (!user_id) {
+            // set current user_id
+            user_id = SessionModel.user_id
+        }
+
+        const response = await request({
+            method: "GET",
+            url: `/follow/user/${user_id}/followers`,
+        })
+
+        return response.data
+    }
+
+    static toogleFollow = async ({ user_id, username }) => {
+        if (!user_id && !username) {
+            throw new Error("user_id or username is required")
+        }
+
+        const response = await request({
+            method: "POST",
+            url: "/follow/user/toogle",
+            data: {
+                user_id: user_id,
+                username: username
+            },
+        })
+
+        return response.data
+    }
+}

package/src/models/index.js

@@ -0,0 +1,44 @@
+import AuthModel from "./auth"
+import FeedModel from "./feed"
+import FollowsModel from "./follows"
+import LivestreamModel from "./livestream"
+import PlaylistsModel from "./playlists"
+import PostModel from "./post"
+import SessionModel from "./session"
+import SyncModel from "./sync"
+import UserModel from "./user"
+
+function getEndpointsFromModel(model) {
+    return Object.entries(model).reduce((acc, [key, value]) => {
+        acc[key] = value
+
+        return acc
+    }, {})
+}
+
+function createHandlers() {
+    return {
+        auth: getEndpointsFromModel(AuthModel),
+        feed: getEndpointsFromModel(FeedModel),
+        follows: getEndpointsFromModel(FollowsModel),
+        livestream: getEndpointsFromModel(LivestreamModel),
+        playlists: getEndpointsFromModel(PlaylistsModel),
+        post: getEndpointsFromModel(PostModel),
+        session: getEndpointsFromModel(SessionModel),
+        sync: getEndpointsFromModel(SyncModel),
+        user: getEndpointsFromModel(UserModel),
+    }
+}
+
+export {
+    AuthModel,
+    FeedModel,
+    FollowsModel,
+    LivestreamModel,
+    PlaylistsModel,
+    PostModel,
+    SessionModel,
+    SyncModel,
+    UserModel,
+    createHandlers,
+}