@duque.edits/sdk 0.0.4 → 0.0.5

package/dist/managers/product/GuildProductManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { GuildProduct } from "../../structures/product/GuildProduct";
+import { Optional } from "../../types/api";
+import { APIProduct } from "../../types/api/APIProduct";
+export declare class GuildProductManager {
+    /** A cache of users */
+    cache: Collection<string, GuildProduct>;
+    /** The rest client */
+    rest: REST;
+    /** GuildProduct product guild */
+    guild: Guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    create(payload: Optional<APIProduct>): Promise<GuildProduct>;
+    /**
+     * Fetch a product
+     * @param id Id of the product to fetch
+     * @returns APIBetUser
+     */
+    fetch(id: string): Promise<GuildProduct>;
+    fetchAll(): Promise<Collection<string, GuildProduct>>;
+    set(data: APIProduct): GuildProduct;
+    setAll(data: APIProduct[]): Collection<string, GuildProduct>;
+    delete(id: string, type: string): Promise<Collection<string, GuildProduct>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/product/GuildProductManager.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildProductManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Collection_1 = require("../../structures/Collection");
+const GuildProduct_1 = require("../../structures/product/GuildProduct");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildProductManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** GuildProduct product guild */
+    guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild, rest) {
+        this.guild = guild;
+        this.rest = rest;
+        this.cache = new Collection_1.Collection("products");
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = Routes_1.Routes.guilds.shop.products.create(this.guild.id);
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+        });
+        const product = this.set(response);
+        return product;
+    }
+    /**
+     * Fetch a product
+     * @param id Id of the product to fetch
+     * @returns APIBetUser
+     */
+    async fetch(id) {
+        const route = Routes_1.Routes.guilds.shop.products.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const product = new GuildProduct_1.GuildProduct(response, this, this.rest);
+        this.cache.set(product.id, product);
+        return product;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.shop.products.getAll(this.guild.id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        for (let betData of response) {
+            const product = new GuildProduct_1.GuildProduct(betData, this, this.rest);
+            this.cache.set(product.id, product);
+        }
+        return this.cache;
+    }
+    set(data) {
+        if (!data.id)
+            return;
+        const product = new GuildProduct_1.GuildProduct(data, this, this.rest);
+        this.cache.set(data.id, product);
+        return product;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let product of data)
+            this.set(product);
+        return this.cache;
+    }
+    async delete(id, type) {
+        Assertion_1.Assertion.assertString(id);
+        Assertion_1.Assertion.assertString(type);
+        const route = Routes_1.Routes.guilds.shop.products.delete(id, this.guild.id);
+        const payload = { type };
+        const product = this.cache.get(id);
+        this.rest.emit("productsDelete", product);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+            payload,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.shop.products.deleteAll(this.guild.id);
+        this.rest.emit("productsDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildProductManager = GuildProductManager;

package/dist/managers/ticket/GuildTicketManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { GuildTicket } from "../../structures/ticket/GuildTicket";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { Optional } from "../../types/api";
+import { APIGuildTicket } from "../../types/api/APIGuildTicket";
+export declare class GuildTicketManager {
+    /** A cache of users */
+    cache: Collection<string, GuildTicket>;
+    /** The rest client */
+    rest: REST;
+    /** GuildTicket ticket guild */
+    guild: Guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    create(payload: Optional<APIGuildTicket>): Promise<GuildTicket>;
+    /**
+     * Fetch a ticket
+     * @param id Id of the ticket to fetch
+     * @returns APIticketUser
+     */
+    fetch(id: string): Promise<GuildTicket>;
+    fetchAll(): Promise<Collection<string, GuildTicket>>;
+    set(data: APIGuildTicket): GuildTicket;
+    setAll(data: APIGuildTicket[]): Collection<string, GuildTicket>;
+    delete(id: string): Promise<Collection<string, GuildTicket>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/ticket/GuildTicketManager.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildTicketManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const GuildTicket_1 = require("../../structures/ticket/GuildTicket");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildTicketManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** GuildTicket ticket guild */
+    guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild, rest) {
+        this.guild = guild;
+        this.rest = rest;
+        this.cache = new Collection_1.Collection("tickets");
+    }
+    async create(payload) {
+        Assertion_1.Assertion.assertObject(payload);
+        const route = Routes_1.Routes.guilds.tickets.create(this.guild.id);
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+        });
+        const ticket = this.set(response);
+        return ticket;
+    }
+    /**
+     * Fetch a ticket
+     * @param id Id of the ticket to fetch
+     * @returns APIticketUser
+     */
+    async fetch(id) {
+        const route = Routes_1.Routes.guilds.tickets.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const ticket = new GuildTicket_1.GuildTicket(response, this.guild, this, this.rest);
+        this.cache.set(ticket.id, ticket);
+        return ticket;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.tickets.getAll(this.guild.id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        for (let ticketData of response) {
+            const ticket = new GuildTicket_1.GuildTicket(ticketData, this.guild, this, this.rest);
+            this.cache.set(ticket.id, ticket);
+        }
+        return this.cache;
+    }
+    set(data) {
+        if (!data.id)
+            return;
+        const ticket = new GuildTicket_1.GuildTicket(data, this.guild, this, this.rest);
+        this.cache.set(data.id.toString(), ticket);
+        return ticket;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let ticket of data)
+            this.set(ticket);
+        return this.cache;
+    }
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.tickets.delete(id, this.guild.id);
+        const ticket = this.cache.get(id);
+        this.rest.emit("ticketDelete", ticket);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.tickets.deleteAll(this.guild.id);
+        this.rest.emit("ticketsDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildTicketManager = GuildTicketManager;

package/dist/managers/user/GuildUserManager.d.ts

@@ -0,0 +1,32 @@
+import { REST } from "../../rest/REST";
+import { GuildUser } from "../../structures/user/GuildUser";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuildUser } from "../../types/api/APIGuildUser";
+import { Optional } from "../../types";
+export declare class GuildUserManager {
+    /** A cache of users */
+    cache: Collection<string, GuildUser>;
+    /** The rest client */
+    rest: REST;
+    /** Bet user guild */
+    guild: Guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    /**
+     * Fetch a user
+     * @param id Id of the user to fetch
+     * @returns GuildUser
+     */
+    fetch(id: string, name: string): Promise<GuildUser>;
+    fetchAll(): Promise<Collection<string, GuildUser>>;
+    updateUser(id: string, name: string, data: Optional<APIGuildUser>): Promise<GuildUser>;
+    set(data: APIGuildUser): GuildUser;
+    setAll(data: APIGuildUser[]): Collection<string, GuildUser>;
+    delete(id: string): Promise<Collection<string, GuildUser>>;
+    deleteAll(): Promise<boolean>;
+}

package/dist/managers/user/GuildUserManager.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildUserManager = void 0;
+const Routes_1 = require("../../rest/Routes");
+const GuildUser_1 = require("../../structures/user/GuildUser");
+const Collection_1 = require("../../structures/Collection");
+const Assertion_1 = require("../../utils/Assertion");
+class GuildUserManager {
+    /** A cache of users */
+    cache;
+    /** The rest client */
+    rest;
+    /** Bet user guild */
+    guild;
+    /**
+     * Manage users with the given client
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild, rest) {
+        this.guild = guild;
+        this.rest = rest;
+        this.cache = new Collection_1.Collection("users");
+    }
+    /**
+     * Fetch a user
+     * @param id Id of the user to fetch
+     * @returns GuildUser
+     */
+    async fetch(id, name) {
+        const route = Routes_1.Routes.guilds.users.get(this.guild.id, id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+            payload: { name },
+        });
+        if (!response)
+            return this.cache.get(id);
+        const user = new GuildUser_1.GuildUser(response, this, this.rest);
+        this.cache.set(user?.id, user);
+        this.rest.users.set(user?.id, user);
+        return user;
+    }
+    async fetchAll() {
+        const route = Routes_1.Routes.guilds.users.getAll(this.guild.id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        if (Array.isArray(response) && response.length === 0) {
+            this.cache.clear();
+            return this.cache;
+        }
+        this.setAll(response);
+        return this.cache;
+    }
+    async updateUser(id, name, data) {
+        const route = Routes_1.Routes.guilds.users.update(this.guild.id, id);
+        const payload = { ...data, name };
+        const response = await this.rest.request({
+            method: "Patch",
+            url: route,
+            payload,
+        });
+        const user = this.set(response);
+        return user;
+    }
+    set(data) {
+        if (!data.id)
+            return;
+        const user = new GuildUser_1.GuildUser(data, this, this.rest);
+        this.cache.set(user?.id, user);
+        this.rest.users.set(user?.id, user);
+        return user;
+    }
+    setAll(data) {
+        if (!data)
+            return this.cache;
+        for (let user of data)
+            this.set(user);
+        return this.cache;
+    }
+    async delete(id) {
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.users.delete(id, this.guild.id);
+        const user = this.cache.get(id);
+        this.rest.emit("userDelete", user);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.delete(id);
+        return this.cache;
+    }
+    async deleteAll() {
+        const route = Routes_1.Routes.guilds.users.deleteAll(this.guild.id);
+        this.rest.emit("usersDelete", this.cache);
+        const value = await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return value;
+    }
+}
+exports.GuildUserManager = GuildUserManager;

package/dist/rest/APIEndpoints.d.ts

@@ -0,0 +1,11 @@
+declare class Guild {
+    id: string;
+    tickets: [];
+}
+export declare const APIEndpoints: {
+    "guilds/get": {
+        response: typeof Guild;
+    };
+};
+export type APIEndpoint = keyof string;
+export {};

package/dist/rest/APIEndpoints.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIEndpoints = void 0;
+class Guild {
+    id;
+    tickets;
+}
+exports.APIEndpoints = {
+    "guilds/get": {
+        response: Guild,
+    },
+};

package/dist/rest/REST.d.ts

@@ -0,0 +1,51 @@
+import EventEmitter from "events";
+import { GuildManager } from "../managers/guild/GuildManager";
+import { GuildBet } from "../structures/bet/GuildBet";
+import { Collection } from "../structures/Collection";
+import { GuildBetUser } from "../structures/betuser/GuildBetUser";
+import { GuildMatch } from "../structures/match/GuildMatch";
+import { GuildMediator } from "../structures/mediator/GuildMediator";
+import { GuildUser } from "../structures/user/GuildUser";
+interface RequestOptions<Payload> {
+    /** The request's method */
+    method: string;
+    /** The request's url */
+    url: string;
+    /** The request payload */
+    payload?: Payload;
+}
+/**
+ * The main class of this package
+ */
+export declare class REST extends EventEmitter {
+    /**
+     * The unique key for client
+     */
+    key: string;
+    /** The guild manager */
+    guilds: GuildManager;
+    bets: Collection<string, GuildBet>;
+    matches: Collection<string, GuildMatch>;
+    betUsers: Collection<string, GuildBetUser>;
+    users: Collection<string, GuildUser>;
+    mediators: Collection<string, GuildMediator>;
+    /**
+     *
+     * @param key The unique key for he client
+     */
+    constructor(key?: string);
+    /**
+     * Set the api key
+     * @param key The unique key of the client
+     */
+    setKey(key: string): void;
+    /** Initialize the caching sistem */
+    init(): Promise<this>;
+    /**
+     * Request Data from a certain url
+     * @param options
+     * @returns
+     */
+    request<Expecting, Payload>(options: RequestOptions<Payload>): Promise<Expecting>;
+}
+export {};

package/dist/rest/REST.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REST = void 0;
+const events_1 = __importDefault(require("events"));
+const Assertion_1 = require("../utils/Assertion");
+const undici_1 = require("undici");
+const Routes_1 = require("./Routes");
+const dotenv_1 = __importDefault(require("dotenv"));
+const GuildManager_1 = require("../managers/guild/GuildManager");
+const Collection_1 = require("../structures/Collection");
+dotenv_1.default.config();
+const Reset = "\x1b[0m";
+const FgGreen = "\x1b[32m";
+const FgRed = "\x1b[31m";
+const FgBlue = "\x1b[34m";
+const FgCyan = "\x1b[36m";
+/**
+ * The main class of this package
+ */
+class REST extends events_1.default {
+    /**
+     * The unique key for client
+     */
+    key;
+    /** The guild manager */
+    guilds;
+    bets;
+    matches;
+    betUsers;
+    users;
+    mediators;
+    /**
+     *
+     * @param key The unique key for he client
+     */
+    constructor(key) {
+        super({ captureRejections: true });
+        if (key) {
+            Assertion_1.Assertion.assertString(key);
+            this.key = key;
+        }
+        this.guilds = new GuildManager_1.GuildManager(this);
+        this.bets = new Collection_1.Collection("bets");
+        this.matches = new Collection_1.Collection("matches");
+        this.betUsers = new Collection_1.Collection("betUsers");
+        this.users = new Collection_1.Collection("users");
+        this.mediators = new Collection_1.Collection("mediators");
+    }
+    /**
+     * Set the api key
+     * @param key The unique key of the client
+     */
+    setKey(key) {
+        this.key = key;
+    }
+    /** Initialize the caching sistem */
+    async init() {
+        await this.guilds.fetchAll();
+        return this;
+    }
+    /**
+     * Request Data from a certain url
+     * @param options
+     * @returns
+     */
+    async request(options) {
+        let { method, url, payload } = options;
+        Assertion_1.Assertion.assertString(method);
+        Assertion_1.Assertion.assertString(this.key);
+        Assertion_1.Assertion.assertString(url);
+        method = method.toUpperCase();
+        url = Routes_1.Routes.base + url;
+        const headers = new undici_1.Headers();
+        headers.append("duque-auth", process.env.AUTH);
+        headers.append("Content-Type", "application/json");
+        headers.append("duque-client-key", this.key);
+        const before = Date.now();
+        this.emit("debug", [`[Request] ${FgBlue}${method} ${FgCyan}${url}`, Reset].join("\n"));
+        const res = await (0, undici_1.request)(url, {
+            method,
+            headers,
+            body: payload !== undefined ? JSON.stringify(payload) : undefined,
+        });
+        const body = await res.body.json();
+        const { data, message } = body;
+        const now = new Date().getTime();
+        if (message)
+            this.emit("debug", `${FgRed}${message}${Reset}`);
+        this.emit("debug", `[Request]${FgGreen} ${(now - before) / 1000}s done.${Reset}`);
+        return data;
+    }
+}
+exports.REST = REST;

package/dist/rest/Routes.d.ts

@@ -0,0 +1,84 @@
+export declare const Route: <K>(route: string) => string;
+export declare const Routes: {
+    base: string;
+    field: (field: string) => string;
+    fields: (...fields: string[]) => string;
+    guilds: {
+        create: () => string;
+        get: (guildId: string) => string;
+        getAll: () => string;
+        delete: (guildId: string) => string;
+        deleteAll: () => string;
+        resource: (guildId: string, resource: string) => string;
+        resources: (guildId: string, ...resourcess: string[]) => string;
+        users: {
+            create: (guildId: string) => string;
+            update: (guildId: string, userId: string) => string;
+            getAll: (guildId: string) => string;
+            get: (guildId: string, userId: string) => string;
+            delete: (guildId: string, userId: string) => string;
+            deleteAll: (guildId: string) => string;
+            resource: (guildId: string, userId: string, resource: string) => string;
+        };
+        betUsers: {
+            getAll: (guildId: string) => string;
+            get: (guildId: string, userId: string) => string;
+            create: (guildId: string) => string;
+            update: (guildId: string, userId: string) => string;
+            delete: (guildId: string, userId: string) => string;
+            deleteAll: (guildId: string) => string;
+            resource: (guildId: string, userId: string, resourceName: string) => string;
+        };
+        matches: {
+            getAll: (guildId: string) => string;
+            get: (guildId: string, matchId: string) => string;
+            create: (guildId: string) => string;
+            update: (guildId: string, matchId: string) => string;
+            delete: (guildId: string, matchId: string) => string;
+            deleteAll: (guildId: string) => string;
+            resource: (guildId: string, matchId: string, ...resources: string[]) => string;
+        };
+        bets: {
+            getAll: (guildId: string) => string;
+            get: (guildId: string, betId: string) => string;
+            create: (guildId: string) => string;
+            update: (guildId: string, betId: string) => string;
+            delete: (guildId: string, betId: string) => string;
+            deleteAll: (guildId: string) => string;
+            resource: (guildId: string, betId: string, ...resources: string[]) => string;
+        };
+        tickets: {
+            getAll: (guildId: string) => string;
+            get: (guildId: string, ticketId: string) => string;
+            create: (guildId: string) => string;
+            update: (guildId: string, ticketId: string) => string;
+            delete: (guildId: string, ticketId: string) => string;
+            deleteAll: (guildId: string) => string;
+            resource: (guildId: string, ticketId: string, ...resources: string[]) => string;
+        };
+        mediators: {
+            getAll: (guildId: string) => string;
+            get: (guildId: string, mediatorId: string) => string;
+            create: (guildId: string) => string;
+            update: (guildId: string, mediatorId: string) => string;
+            delete: (guildId: string, mediatorId: string) => string;
+            deleteAll: (guildId: string) => string;
+            resource: (guildId: string, mediatorId: string, ...resources: string[]) => string;
+        };
+        shop: {
+            get: (guildId: string) => string;
+            update: (guildId: string) => string;
+            delete: (guildId: string) => string;
+            resource: (guildId: string, ...resources: string[]) => string;
+            products: {
+                getAll: (guildId: string) => string;
+                get: (guildId: string, productId: string) => string;
+                create: (guildId: string) => string;
+                update: (guildId: string, productId: string) => string;
+                delete: (guildId: string, productId: string) => string;
+                deleteAll: (guildId: string) => string;
+                resource: (guildId: string, productId: string, ...resources: string[]) => string;
+            };
+        };
+    };
+};