Bloxy Version 6

.gitignore

@@ -1,7 +1,11 @@
 node_modules
 coverage
 tests/index.js
-dist
+# dist # Should we really ignore the dist folder?
 docs
 site
 .idea
+.nyc_output
+
+# temporary
+tests_jest

.prettierrc

@@ -0,0 +1,4 @@
+{
+    "tabWidth": 2,
+    "trailingComma": "none"
+}

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "typescript.autoClosingTags": false,
+  "javascript.autoClosingTags": false
+}

dist/client/Client.d.ts

@@ -0,0 +1,37 @@
+import { ClientBase, ClientOptions } from "./ClientBase";
+import { APIs } from "./apis";
+import { ClientUser } from "../old_structures/ClientUser";
+import { RESTController } from "../controllers/rest";
+import { Group, PartialUser } from "../old_structures";
+import * as ClientSocket from "./lib/ClientSocket/ClientSocket";
+import { ChatManager } from "./lib/ChatManager/ChatManager";
+import { DataStoreManager } from "./lib/DataStoreManager/DataStoreManager";
+import { User } from "../structures/User";
+import { BaseUser } from "../structures/BaseUser";
+export declare class Client extends ClientBase {
+    user: ClientUser | null;
+    apis: APIs;
+    rest: RESTController;
+    socket: ClientSocket.Socket;
+    dataStoreManager: DataStoreManager;
+    chat: ChatManager;
+    constructor(options?: ClientOptions);
+    isLoggedIn(): boolean;
+    init(): void;
+    login(cookie?: string): Promise<ClientUser>;
+    getGroup(groupId: number): Promise<Group>;
+    /**
+     * Returns a base user object from a user id.
+     * @param userId The user's ID
+     */
+    getBaseUser(userId: number): BaseUser;
+    /**
+     * Returns a user object from a user id.
+     * @param userId The user's ID
+     */
+    getUser(userId: number): Promise<User>;
+    getUserIdFromUsername(username: string): Promise<PartialUser>;
+    getUsernameFromUserId(userId: number | string): Promise<PartialUser>;
+    getUsersByUserIds(userIds: number[] | string[], excludeBannedUsers?: boolean): Promise<PartialUser[]>;
+    getUsersByUsernames(usernames: string[], excludeBannedUsers?: boolean): Promise<PartialUser[]>;
+}

dist/client/Client.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const tslib_1 = require("tslib");
+const ClientBase_1 = require("./ClientBase");
+const apis_1 = require("./apis");
+const ClientUser_1 = require("../old_structures/ClientUser");
+const rest_1 = require("../controllers/rest");
+const old_structures_1 = require("../old_structures");
+const ClientSocket = (0, tslib_1.__importStar)(require("./lib/ClientSocket/ClientSocket"));
+const ChatManager_1 = require("./lib/ChatManager/ChatManager");
+const DataStoreManager_1 = require("./lib/DataStoreManager/DataStoreManager");
+const User_1 = require("../structures/User");
+const BaseUser_1 = require("../structures/BaseUser");
+class Client extends ClientBase_1.ClientBase {
+    constructor(options) {
+        super(options);
+        this.user = null;
+        this.apis = (0, apis_1.initAPIs)(this);
+        this.rest = new rest_1.RESTController(this, this.options.rest);
+        this.socket = new ClientSocket.Socket(this);
+        this.dataStoreManager = new DataStoreManager_1.DataStoreManager(this);
+        this.chat = new ChatManager_1.ChatManager(this);
+        this.init();
+    }
+    isLoggedIn() {
+        return this.user !== null;
+    }
+    init() {
+        if (this.options.rest) {
+            this.rest.setOptions(this.options.rest);
+        }
+    }
+    login(cookie) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            this.log("info", {
+                name: "Client.login",
+                description: `Started login process..`
+            });
+            cookie = cookie || (this.options.credentials || {}).cookie || undefined;
+            if (!cookie) {
+                throw new Error("Attempted to log in without a cookie!");
+            }
+            this.options.credentials = Object.assign(Object.assign({}, this.options.credentials), { cookie });
+            const createdCookie = this.rest.createCookie({
+                key: ".ROBLOSECURITY",
+                value: cookie,
+                domain: "roblox.com",
+                hostOnly: false,
+                httpOnly: false
+            });
+            this.rest.addCookie(createdCookie);
+            this.log("info", {
+                name: "Client.login",
+                description: `Added cookie to cookie jar, proceeding to fetching authenticated user information..`
+            });
+            const getAuthenticationData = yield this.apis.usersAPI.getAuthenticatedUserInformation();
+            this.user = new ClientUser_1.ClientUser({
+                id: getAuthenticationData.id,
+                name: getAuthenticationData.name
+            }, this);
+            this.emit("loggedIn");
+            this.log("info", {
+                name: "Client.login",
+                description: `Successfully logged in as ${getAuthenticationData.name}`
+            });
+            return this.user;
+        });
+    }
+    getGroup(groupId) {
+        return this.apis.groupsAPI
+            .getGroup({
+            groupId
+        })
+            .then((data) => {
+            if (!data) {
+                throw new Error(`Group not found: ${groupId}`);
+            }
+            else {
+                return new old_structures_1.Group(data, this);
+            }
+        });
+    }
+    /**
+     * Returns a base user object from a user id.
+     * @param userId The user's ID
+     */
+    getBaseUser(userId) {
+        return new BaseUser_1.BaseUser(this, userId);
+    }
+    /**
+     * Returns a user object from a user id.
+     * @param userId The user's ID
+     */
+    getUser(userId) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            const data = yield this.apis.usersAPI.getUserById({ userId });
+            return new User_1.User(this, data);
+        });
+    }
+    getUserIdFromUsername(username) {
+        return this.apis.usersAPI
+            .getUsersByUsernames({
+            usernames: [username],
+            excludeBannedUsers: false
+        })
+            .then((response) => {
+            if (response.data && response.data[0]) {
+                return new old_structures_1.PartialUser(response.data[0], this);
+            }
+            else {
+                throw new Error("Got invalid response from getUserIdFromUsername");
+            }
+        });
+    }
+    getUsernameFromUserId(userId) {
+        if (typeof userId === "string") {
+            userId = parseInt(userId);
+        }
+        return this.apis.generalApi
+            .getUserById({
+            userId
+        })
+            .then((data) => new old_structures_1.PartialUser(data, this));
+    }
+    getUsersByUserIds(userIds, excludeBannedUsers = false) {
+        if (typeof userIds[0] === "string") {
+            userIds = userIds.map((userId) => parseInt(userId));
+        }
+        return this.apis.usersAPI
+            .getUsersByIds({
+            excludeBannedUsers,
+            userIds: userIds
+        })
+            .then((response) => response.data.map((userData) => new old_structures_1.PartialUser(userData, this)));
+    }
+    getUsersByUsernames(usernames, excludeBannedUsers = false) {
+        return this.apis.usersAPI
+            .getUsersByUsernames({
+            excludeBannedUsers,
+            usernames
+        })
+            .then((response) => response.data.map((userData) => new old_structures_1.PartialUser(userData, this)));
+    }
+}
+exports.Client = Client;

dist/client/ClientBase.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { RESTControllerOptions } from "../interfaces/RESTInterfaces";
+import { Debugger } from "debug";
+export interface ClientCredentialsOptions {
+    cookie?: string;
+}
+export interface ClientCallbacks {
+    getFunCaptchaToken?: (publicKey: string, targetUrl: string) => Promise<string>;
+}
+export interface ClientSetup {
+    websocket?: {
+        maxRetries: number;
+    };
+    debug: boolean;
+}
+export interface ClientOptions {
+    credentials?: ClientCredentialsOptions;
+    rest?: RESTControllerOptions;
+    callbacks?: ClientCallbacks;
+    setup?: ClientSetup;
+}
+interface DebugData {
+    name: string;
+    description: string;
+}
+export declare class ClientBase extends EventEmitter {
+    options: ClientOptions;
+    debugger: {
+        info: Debugger;
+        warn: Debugger;
+        error: Debugger;
+    };
+    constructor(options?: ClientOptions);
+    updateOptions(options?: ClientOptions): ClientOptions;
+    log(level: "info" | "warn" | "error", data: DebugData): void;
+}
+export {};

dist/client/ClientBase.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientBase = void 0;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
+const utilFunctions_1 = require("../util/utilFunctions");
+class ClientBase extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.options = this.updateOptions(options);
+        this.debugger = {
+            info: (0, debug_1.default)("bloxy:info"),
+            warn: (0, debug_1.default)("bloxy:warn"),
+            error: (0, debug_1.default)("bloxy:error")
+        };
+    }
+    updateOptions(options) {
+        this.options = (0, utilFunctions_1.utilMergeDeep)({
+            credentials: {},
+            rest: {},
+            setup: {},
+            callbacks: {}
+        }, options || {});
+        return this.options;
+    }
+    log(level, data) {
+        const loggerToUse = level === "info"
+            ? this.debugger.info
+            : level === "error"
+                ? this.debugger.error
+                : this.debugger.warn;
+        loggerToUse(`[${new Date().toISOString()}] ${data.name}: ${data.description}`);
+    }
+}
+exports.ClientBase = ClientBase;

dist/client/apis/AccountInformationAPI.d.ts

@@ -0,0 +1,73 @@
+import { BaseAPI } from "./BaseAPI";
+import { Client } from "../Client";
+import { UserIdOption, Privacy } from "../..";
+export declare type AccountInformationBirthdate = {
+    birthDay: number;
+    birthMonth: number;
+    birthYear: number;
+};
+export declare type AccountInformationDescription = {
+    description: string;
+};
+export declare type AccountInformationGender = {
+    gender: number;
+};
+export declare type AccountInformationXboxConsecutiveLoginDays = {
+    count: number;
+};
+export declare type AccountInformationMetaData = {
+    isAllowedNotificationsEndpointDisabled: boolean;
+    isAccountSettingsPolicyEnabled: boolean;
+    isPhoneNumberEnabled: boolean;
+    MaxUserDescriptionLength: number;
+    isUserDescriptionEnabled: boolean;
+    isUserBlockEndpointsUpdated: boolean;
+    isIDVerificationEnabled: boolean;
+    isPasswordRequiredForAgingDown: boolean;
+    homePageUpsellCardVariation: string;
+};
+export declare type AccountInformationOwnPromotionChannels = {
+    promotionChannelsVisibilityPrivacy: Privacy;
+    facebook: string;
+    twitter: string;
+    youtube: string;
+    twitch: string;
+    guilded: string;
+};
+export declare type AccountInformationPromotionChannels = Omit<AccountInformationOwnPromotionChannels, "promotionChannelsVisibilityPrivacy">;
+export declare type AccountInformationStarCodeAffiliate = {
+    userId: number;
+    name: string;
+    code: string;
+};
+export declare type AccountInformationSetStarCodeAffiliate = {
+    code: string;
+};
+export declare type AccountInformationAddStarCodeAffiliateOption = {
+    code: string;
+};
+export declare type AccountInformationRobloxBadge = {
+    id: number;
+    name: string;
+    description: string;
+    imageUrl: string;
+};
+export declare type AccountInformationRobloxBadges = AccountInformationRobloxBadge[];
+export declare class AccountInformationAPI extends BaseAPI {
+    constructor(client: Client);
+    getUserBirthdate(): Promise<AccountInformationBirthdate>;
+    updateUserBirthdate(options: AccountInformationBirthdate): Promise<boolean>;
+    getUserDescription(): Promise<AccountInformationDescription>;
+    updateUserDescription(options: AccountInformationDescription): Promise<boolean>;
+    getUserGender(): Promise<AccountInformationGender>;
+    updateUserGender(options: AccountInformationGender): Promise<boolean>;
+    getConsecutiveXboxLoginDays(): Promise<AccountInformationXboxConsecutiveLoginDays>;
+    getMetaData(): Promise<AccountInformationMetaData>;
+    getSelfPromotionChannels(): Promise<AccountInformationOwnPromotionChannels>;
+    getUserPromotionChannels(options: UserIdOption): Promise<AccountInformationPromotionChannels>;
+    updateUserPromotionChannels(options: AccountInformationOwnPromotionChannels): Promise<boolean>;
+    removeStarCodeAffiliate(): Promise<boolean>;
+    getStarCodeAffiliate(): Promise<AccountInformationStarCodeAffiliate>;
+    addStarCodeAffiliate(options: AccountInformationAddStarCodeAffiliateOption): Promise<AccountInformationStarCodeAffiliate>;
+    getRobloxBadges(options: UserIdOption): Promise<AccountInformationRobloxBadges>;
+}