@duque.edits/sdk 0.0.4 → 0.0.5

package/dist/rest/Routes.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Routes = exports.Route = void 0;
+const Route = (route) => route;
+exports.Route = Route;
+exports.Routes = {
+    //base: "http://localhost:3000/api/v1",
+    base: "https://duquedev.up.railway.app/api/v1",
+    field: (field) => `${field}`,
+    fields: (...fields) => `${fields.join("/")}`,
+    guilds: {
+        create: () => `/guilds`,
+        get: (guildId) => `/guilds/${guildId}`,
+        getAll: () => `/guilds`,
+        delete: (guildId) => `/guilds/${guildId}`,
+        deleteAll: () => `/guilds`,
+        resource: (guildId, resource) => `/guilds/${guildId}/${resource}`,
+        resources: (guildId, ...resourcess) => `/guilds/${guildId}/${resourcess.join("/")}`,
+        users: {
+            create: (guildId) => `/guilds/${guildId}/users`,
+            update: (guildId, userId) => `/guilds/${guildId}/users/${userId}`,
+            getAll: (guildId) => `/guilds/${guildId}/users`,
+            get: (guildId, userId) => `/guilds/${guildId}/users/${userId}`,
+            delete: (guildId, userId) => `/guilds/${guildId}/users/${userId}`,
+            deleteAll: (guildId) => `/guilds/${guildId}/users`,
+            resource: (guildId, userId, resource) => `/guilds/${guildId}/users/${userId}/${resource}`,
+        },
+        betUsers: {
+            getAll: (guildId) => `/guilds/${guildId}/betusers`,
+            get: (guildId, userId) => `/guilds/${guildId}/betusers/${userId}`,
+            create: (guildId) => `/guilds/${guildId}/betusers`,
+            update: (guildId, userId) => `/guilds/${guildId}/betusers/${userId}`,
+            delete: (guildId, userId) => `/guilds/${guildId}/betusers/${userId}`,
+            deleteAll: (guildId) => `/guilds/${guildId}/betusers`,
+            resource: (guildId, userId, resourceName) => `/guilds/${guildId}/betusers/${userId}/${resourceName}`,
+        },
+        matches: {
+            getAll: (guildId) => `/guilds/${guildId}/matches`,
+            get: (guildId, matchId) => `/guilds/${guildId}/matches/${matchId}`,
+            create: (guildId) => `/guilds/${guildId}/matches`,
+            update: (guildId, matchId) => `/guilds/${guildId}/matches/${matchId}`,
+            delete: (guildId, matchId) => `/guilds/${guildId}/matches/${matchId}`,
+            deleteAll: (guildId) => `/guilds/${guildId}/matches`,
+            resource: (guildId, matchId, ...resources) => `/guilds/${guildId}/matches/${matchId}/${resources.join("/")}`,
+        },
+        bets: {
+            getAll: (guildId) => `/guilds/${guildId}/bets`,
+            get: (guildId, betId) => `/guilds/${guildId}/bets/${betId}`,
+            create: (guildId) => `/guilds/${guildId}/bets`,
+            update: (guildId, betId) => `/guilds/${guildId}/bets/${betId}`,
+            delete: (guildId, betId) => `/guilds/${guildId}/bets/${betId}`,
+            deleteAll: (guildId) => `/guilds/${guildId}/bets`,
+            resource: (guildId, betId, ...resources) => `/guilds/${guildId}/bets/${betId}/${resources.join("/")}`,
+        },
+        tickets: {
+            getAll: (guildId) => `/guilds/${guildId}/tickets`,
+            get: (guildId, ticketId) => `/guilds/${guildId}/tickets/${ticketId}`,
+            create: (guildId) => `/guilds/${guildId}/tickets`,
+            update: (guildId, ticketId) => `/guilds/${guildId}/tickets/${ticketId}`,
+            delete: (guildId, ticketId) => `/guilds/${guildId}/tickets/${ticketId}`,
+            deleteAll: (guildId) => `/guilds/${guildId}/tickets`,
+            resource: (guildId, ticketId, ...resources) => `/guilds/${guildId}/tickets/${ticketId}/${resources.join("/")}`,
+        },
+        mediators: {
+            getAll: (guildId) => `/guilds/${guildId}/mediators`,
+            get: (guildId, mediatorId) => `/guilds/${guildId}/mediators/${mediatorId}`,
+            create: (guildId) => `/guilds/${guildId}/mediators`,
+            update: (guildId, mediatorId) => `/guilds/${guildId}/mediators/${mediatorId}`,
+            delete: (guildId, mediatorId) => `/guilds/${guildId}/mediators/${mediatorId}`,
+            deleteAll: (guildId) => `/guilds/${guildId}/mediators`,
+            resource: (guildId, mediatorId, ...resources) => `/guilds/${guildId}/mediators/${mediatorId}/${resources.join("/")}`,
+        },
+        shop: {
+            get: (guildId) => `/guilds/${guildId}/shop`,
+            update: (guildId) => `/guilds/${guildId}/shop`,
+            delete: (guildId) => `/guilds/${guildId}/shop/ `,
+            resource: (guildId, ...resources) => `/guilds/${guildId}/shop/${resources.join("/")}`,
+            products: {
+                getAll: (guildId) => `/guilds/${guildId}/shop/products`,
+                get: (guildId, productId) => `/guilds/${guildId}/shop/${productId}/products`,
+                create: (guildId) => `/guilds/${guildId}/shop/products`,
+                update: (guildId, productId) => `/guilds/${guildId}/shop/products/${productId}`,
+                delete: (guildId, productId) => `/guilds/${guildId}/shop/products/${productId}`,
+                deleteAll: (guildId) => `/guilds/${guildId}/products/shop`,
+                resource: (guildId, productId, ...resources) => `/guilds/${guildId}/shop/products/${productId}/${resources.join("/")}`,
+            },
+        },
+    },
+};

package/dist/structures/Collection.d.ts

@@ -0,0 +1,17 @@
+export declare class Collection<K, V> extends Map<K, V> {
+    key: string;
+    constructor(key?: string, data?: Iterable<V>);
+    at(index: number): V;
+    has(key: K): boolean;
+    get first(): V;
+    get last(): V;
+    get length(): number;
+    find(predicate: (value: V, key: K, Collection: this) => any): V;
+    filter(predicate: (value: V, key: K, Collection: this) => any): Collection<K, V>;
+    some(predicate: (value: V, key: K, Collection: this) => any): Collection<unknown, any>;
+    map(callback: (value: V, key: K, Collection: this) => any): any[];
+    toArray(): V[];
+    toJSON(): Record<string, unknown>;
+    sort(compareFunction: (a: V, b: V, Collection: this) => any): Collection<unknown, [K, V]>;
+    toString(): string;
+}

package/dist/structures/Collection.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+class Collection extends Map {
+    key;
+    constructor(key, data) {
+        super();
+        this.key = key;
+        if (data && Array.isArray(data) && key) {
+            if (data.length > 0)
+                return;
+            for (let v of data)
+                this.set(key, v);
+        }
+    }
+    at(index) {
+        if (index < 0 || index >= this.size) {
+            return undefined;
+        }
+        let i = 0;
+        for (let [key, value] of this) {
+            if (i === index) {
+                return value;
+            }
+            i++;
+        }
+    }
+    has(key) {
+        return this.get(key) !== undefined ? true : false;
+    }
+    get first() {
+        return this.values().next().value;
+    }
+    get last() {
+        return [...this.values()].at(-1);
+    }
+    get length() {
+        return this.toArray().length;
+    }
+    find(predicate) {
+        for (const [key, value] of this) {
+            if (predicate(value, key, this))
+                return value;
+        }
+        return undefined;
+    }
+    filter(predicate) {
+        const results = new Collection("", []);
+        for (const [key, value] of this) {
+            if (predicate(value, key, this))
+                results.set(key, value);
+        }
+        return results;
+    }
+    some(predicate) {
+        const results = new Collection("", []);
+        for (const [key, value] of this) {
+            if (predicate(value, key, this))
+                results.set(key, value);
+        }
+        return results;
+    }
+    map(callback) {
+        return [...this].map(([key, val]) => callback(val, key, this));
+    }
+    toArray() {
+        return [...this.values()];
+    }
+    toJSON() {
+        let obj = {};
+        for (let [k, v] of this.entries()) {
+            obj[`${k}`] = v;
+        }
+        return obj;
+    }
+    sort(compareFunction) {
+        const sortedEntries = [...this.entries()].sort((ab, ba) => {
+            return compareFunction(ab[1], ba[1], this);
+        });
+        return new Collection(this.key, sortedEntries);
+    }
+    toString() {
+        return `${this.size}`;
+    }
+}
+exports.Collection = Collection;
+module.exports = { Collection };

package/dist/structures/bet/GuildBet.d.ts

@@ -0,0 +1,86 @@
+import { REST } from "../../rest/REST";
+import { Guild } from "../guild/Guild";
+import { APIGuildBet } from "../../types/api/APIGuildBet";
+import { APIPlayer } from "../../types/api/APIPlayer";
+import { APIBetChannel } from "../../types/api/APIBetChannel";
+import { BaseMatchModes, BaseMatchStatus, Confirm, Logs, Optional } from "../../types/api";
+import { ChannelManager } from "../../managers/channel/ChannelManager";
+import { GuildBetManager } from "../../managers/bet/GuildBetManager";
+import { MessagesManager } from "../../managers/messages/MessagesManager";
+type ExtendedMatchStatus = BaseMatchStatus | "waiting";
+export declare class GuildBet {
+    /** The bet's type */
+    type: Omit<BaseMatchModes, "5x5" | "6x6" | "5v5" | "6v6">;
+    /** The bet's mode */
+    mode: "misto" | "emu" | "mob" | "MISTO" | "EMU" | "MOB";
+    /** The bet's status */
+    status: "off" | "created" | "on" | "shutted" | "waiting";
+    /** The bet's maximum size */
+    maximumSize: number;
+    /** The bet's price */
+    price: number;
+    /** Who has payed the bet */
+    payedBy: APIPlayer[];
+    /** The bet's players */
+    players: APIPlayer[];
+    /** An array of team a */
+    teamA: APIPlayer[];
+    /** An array of team b */
+    teamB: APIPlayer[];
+    /** The bet's channel */
+    channels: ChannelManager<GuildBet>;
+    /** THe bet's messages */
+    messages: MessagesManager;
+    /** The id of the winner */
+    winner: string;
+    /** The id of the loser */
+    loser: string;
+    /** The bet's creator id */
+    creatorId: string;
+    /** The bet's mediator */
+    mediatorId: string;
+    /** The bet's confirmers */
+    confirmed: Confirm[];
+    /** The bet's embed id */
+    embedMessageId: string;
+    /** The bet's logs */
+    logs: Logs;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** GuildBet's id */
+    _id: string;
+    /** The given guild */
+    readonly guild: Guild;
+    /** The rest client */
+    readonly rest: REST;
+    readonly key: string;
+    readonly manager: GuildBetManager;
+    /**
+     * GuildBet bet
+     * @param data  The bet's data
+     * @param guild The guild
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildBet, guild: Guild, manager: GuildBetManager, rest: REST);
+    toString(): string;
+    /**
+     * Fetches the bet
+     * @returns New Instance of the bet
+     */
+    fetch(): Promise<GuildBet>;
+    addConfirmed(type: string, id: string): Promise<Confirm>;
+    setConfirmed(set: Confirm[]): Promise<Confirm[]>;
+    setStatus(status: ExtendedMatchStatus): Promise<this>;
+    setWinner(userId: string): Promise<string>;
+    setLoser(userId: string): Promise<string>;
+    addChannel(id: string, type: string): Promise<import("../..").Channel<GuildBet>>;
+    addMessage(id: string, type: string, content?: string): Promise<import("../..").APIMessage>;
+    setChannels(channels: APIBetChannel[]): Promise<ChannelManager<GuildBet>>;
+    addPlayer(id: string, name: string): Promise<APIPlayer[]>;
+    removePlayer(id: string, name: string): Promise<APIPlayer[]>;
+    update(data: Optional<APIGuildBet>): Promise<this>;
+    toJSON(): Record<string, unknown>;
+}
+export {};

package/dist/structures/bet/GuildBet.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildBet = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Assertion_1 = require("../../utils/Assertion");
+const ChannelManager_1 = require("../../managers/channel/ChannelManager");
+const MessagesManager_1 = require("../../managers/messages/MessagesManager");
+class GuildBet {
+    /** The bet's type */
+    type;
+    /** The bet's mode */
+    mode;
+    /** The bet's status */
+    status;
+    /** The bet's maximum size */
+    maximumSize;
+    /** The bet's price */
+    price;
+    /** Who has payed the bet */
+    payedBy;
+    /** The bet's players */
+    players;
+    /** An array of team a */
+    teamA;
+    /** An array of team b */
+    teamB;
+    /** The bet's channel */
+    channels;
+    /** THe bet's messages */
+    messages;
+    /** The id of the winner */
+    winner;
+    /** The id of the loser */
+    loser;
+    /** The bet's creator id */
+    creatorId;
+    /** The bet's mediator */
+    mediatorId;
+    /** The bet's confirmers */
+    confirmed;
+    /** The bet's embed id */
+    embedMessageId;
+    /** The bet's logs */
+    logs;
+    /** Creation Date */
+    createdAt;
+    /** Updated Date */
+    updatedAt;
+    /** GuildBet's id */
+    _id;
+    /** The given guild */
+    guild;
+    /** The rest client */
+    rest;
+    key;
+    manager;
+    /**
+     * GuildBet bet
+     * @param data  The bet's data
+     * @param guild The guild
+     * @param rest The rest client
+     */
+    constructor(data, guild, manager, rest) {
+        this.type = data.type;
+        this.mode = data.mode;
+        this.status = data.status;
+        this.maximumSize = data.maximumSize;
+        this.price = data.price;
+        this.payedBy = data.payedBy;
+        this.players = data.players;
+        this.teamA = data.teamA;
+        this.teamB = data.teamB;
+        this.winner = data.winner;
+        this.loser = data.loser;
+        this.creatorId = data.creatorId;
+        this.mediatorId = data.mediatorId;
+        this.confirmed = data.confirmed;
+        this.embedMessageId = data.embedMessageId;
+        this.winner = data?.winner;
+        this.loser = data?.loser;
+        this._id = data?._id;
+        this.logs = data.logs;
+        this.manager = manager;
+        this.key = "bets";
+        this.channels = new ChannelManager_1.ChannelManager(guild, this, rest);
+        this.messages = new MessagesManager_1.MessagesManager(this?.guild, this?._id, rest);
+        this.createdAt = data?.createdAt ? new Date(data?.createdAt) : new Date();
+        this.updatedAt = data?.updatedAt ? new Date(data?.updatedAt) : new Date();
+        this.guild = guild;
+        this.rest = rest;
+        this.channels.setAll(data?.channels);
+        this.messages.setAll(data?.messages);
+    }
+    toString() {
+        return this._id || "1";
+    }
+    /**
+     * Fetches the bet
+     * @returns New Instance of the bet
+     */
+    async fetch() {
+        const route = Routes_1.Routes.guilds.bets.get(this.guild.id, this._id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const bt = new GuildBet(response, this.guild, this.manager, this.rest);
+        this.manager.cache.set(bt._id, bt);
+        return bt;
+    }
+    async addConfirmed(type, id) {
+        Assertion_1.Assertion.assertString(type);
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "confirmed");
+        const payload = { entry: { type, id } };
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        this.confirmed = response.confirmed;
+        this.manager.cache.set(this._id, this);
+        return response.confirmed.find((cn) => cn.type == type);
+    }
+    async setConfirmed(set) {
+        Assertion_1.Assertion.assertObject(set);
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "confirmed");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload: set,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        this.confirmed = response.confirmed;
+        this.manager.cache.set(this._id, this);
+        return this.confirmed;
+    }
+    async setStatus(status) {
+        Assertion_1.Assertion.assertString(status);
+        const payload = { set: status.toLowerCase() };
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "status");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        this.status = response.status;
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setWinner(userId) {
+        Assertion_1.Assertion.assertString(userId);
+        const payload = { set: userId };
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "winner");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        this.winner = response.winner;
+        this.manager.cache.set(this._id, this);
+        return response.winner;
+    }
+    async setLoser(userId) {
+        Assertion_1.Assertion.assertString(userId);
+        const payload = { set: userId };
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "loser");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        this.loser = response.loser;
+        this.manager.cache.set(this._id, this);
+        return response.loser;
+    }
+    async addChannel(id, type) {
+        const ch = await this.channels.create(id, type);
+        this.manager.cache.set(this._id, this);
+        return ch;
+    }
+    async addMessage(id, type, content) {
+        const response = await this.messages.create({
+            userId: id,
+            type: type,
+            content,
+        });
+        this.manager.cache.set(this._id, this);
+        this.rest.bets.set(this._id, this);
+        return response;
+    }
+    async setChannels(channels) {
+        Assertion_1.Assertion.assertObject(channels);
+        const payload = { set: channels };
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "channels");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        this.channels.setAll(response.channels);
+        this.manager.cache.set(this._id, this);
+        return this.channels;
+    }
+    async addPlayer(id, name) {
+        Assertion_1.Assertion.assertString(id);
+        Assertion_1.Assertion.assertString(name);
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "players");
+        const payload = { id, name };
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        this.players = response;
+        this.manager.cache.set(this._id, this);
+        return this.players;
+    }
+    async removePlayer(id, name) {
+        Assertion_1.Assertion.assertString(id);
+        Assertion_1.Assertion.assertString(name);
+        const route = Routes_1.Routes.guilds.bets.resource(this.guild.id, this._id, "players", id);
+        const payload = { id, name };
+        const response = await this.rest.request({
+            method: "DELETE",
+            url: route,
+            payload,
+        });
+        this.players = response;
+        this.manager.cache.set(this._id, this);
+        return this.players;
+    }
+    async update(data) {
+        const route = Routes_1.Routes.guilds.bets.get(this.guild.id, this._id);
+        const payload = data;
+        const response = await this.rest.request({
+            method: "patch",
+            url: route,
+            payload,
+        });
+        this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+        for (const k in response) {
+            if (k === "id")
+                continue;
+            if (Object.hasOwn(this, k)) {
+                if (k === "channels") {
+                    this.channels.setAll(response["channels"]);
+                    continue;
+                }
+                if (k === "messages") {
+                    this.messages.setAll(response["messages"]);
+                    continue;
+                }
+                this[k] = response[k];
+            }
+        }
+        this.rest.bets.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    toJSON() {
+        const json = {};
+        for (const [key, value] of Object.entries(this)) {
+            if (typeof value !== "function") {
+                json[key] = value;
+            }
+        }
+        return json;
+    }
+}
+exports.GuildBet = GuildBet;

package/dist/structures/betuser/GuildBetUser.d.ts

@@ -0,0 +1,82 @@
+import { REST } from "../../rest/REST";
+import { Daily, Items, Optional, ProfileCard } from "../../types/api";
+import { APIGuildBetUser } from "../../types/api/APIGuildBetUser";
+import { GuildBetUserManager } from "../../managers/betuser/GuildBetUserManager";
+export declare class GuildBetUser implements APIGuildBetUser {
+    /** User daily */
+    daily: Omit<Daily, "points">;
+    /** User's name */
+    name: string;
+    /** User's name */
+    id: string;
+    /** User's credit */
+    credit: number;
+    /** User's wins */
+    wins: number;
+    /** User's mvps */
+    mvps: number;
+    /** User's losses */
+    losses: number;
+    /** User's bets played */
+    betsPlayed: string[];
+    /** User's blacklist */
+    blacklist: boolean;
+    /** User's coins */
+    coins: number;
+    /** User's items */
+    items: Items;
+    /** User's profile card */
+    profileCard: ProfileCard;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** The given manager */
+    readonly manager: GuildBetUserManager;
+    /** The rest client */
+    readonly rest: REST;
+    /**
+     * Bet user
+     * @param data  The user's data
+     * @param manager The manager
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildBetUser, manager: GuildBetUserManager, rest: REST);
+    /** String representation of this user */
+    toString(): string;
+    /**
+     * Fetches the user
+     * @returns New Instance of the user
+     */
+    fetch(): Promise<GuildBetUser>;
+    /**
+     * Add a propery
+     * @param key The desired key
+     * @param value The desired value
+     * @returns GuildBetUser
+     */
+    add<K extends keyof BetUserAddOptions, V extends BetUserAddOptions[K]>(key: K, value: V): Promise<this>;
+    /**
+     * Set the user blacklist
+     * @param value Value to set to
+     * @returns GuildBetUser
+     */
+    setBlacklist(value: boolean): Promise<this>;
+    /**
+     * Update certain property
+     * @param data The new data to update with
+     * @returns
+     */
+    update(data: Omit<Optional<APIGuildBetUser>, "daily"> & {
+        type?: "add" | "remove";
+    }): Promise<this>;
+    delete(): Promise<boolean>;
+    toJSON(): Record<string, unknown>;
+}
+export type BetUserAddOptions = {
+    coins: number;
+    credit: number;
+    wins: number;
+    losses: number;
+    mvps: number;
+};