@duque.edits/sdk 0.0.3 → 0.0.5

package/src/managers/messages/MessagesManager.ts

@@ -1,95 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Routes } from "../../rest/Routes";
-import { GuildBet } from "../../structures/bet/GuildBet";
-import { Collection } from "../../structures/Collection";
-import { Guild } from "../../structures/guild/Guild";
-import { GuildMatch } from "../../structures/match/GuildMatch";
-import { GuildTicket } from "../../structures/ticket/GuildTicket";
-import { Optional } from "../../types/api";
-import { APIMessage } from "../../types/api/APIMessage";
-import { Assertion } from "../../utils/Assertion";
-
-export class MessagesManager {
-  /** A cache of messages */
-  cache: Collection<string, APIMessage>;
-
-  /** Key */
-  key: string;
-
-  baseUrl: string;
-
-  /** The rest client */
-  rest: REST;
-
-  /** APIMessage message guild */
-  guild: Guild;
-  /**
-   * Manage messages with the given client
-   * @param messages An array of messages
-   * @param rest The rest client
-   */
-  constructor(guild: Guild, key: string, rest: REST) {
-    this.guild = guild;
-
-    this.key = key;
-    this.baseUrl = Routes.fields(Routes.guilds.get(guild?.id), key, "messages");
-
-    this.cache = new Collection<string, APIMessage>(`${key}-messages`);
-
-    this.rest = rest;
-  }
-  async create(payload: Optional<APIMessage>): Promise<APIMessage> {
-    Assertion.assertObject(payload);
-
-    const route = this.baseUrl;
-    const response = await this.rest.request<APIMessage, typeof payload>({
-      method: "POST",
-      url: route,
-      payload,
-    });
-    const message = this.set(response);
-    return message;
-  }
-
-  /**
-   * Fetch a message
-   * @param id Id of the message to fetch
-   * @returns APIgroupedChannelUser
-   */
-  async fetch(type: string) {
-    const route = Routes.fields(this.baseUrl, type);
-    const response = await this.rest.request<APIMessage, {}>({
-      method: "get",
-      url: route,
-    });
-    const channel = this.set(response);
-    this.cache.set(channel.type, channel);
-
-    return channel;
-  }
-
-  async fetchAll() {
-    const route = this.baseUrl;
-    const response = await this.rest.request<APIMessage[], {}>({
-      method: "get",
-      url: route,
-    });
-
-    for (let data of response) {
-      if (!data.type) continue;
-      this.cache.set(data?.type, data);
-    }
-    return this.cache;
-  }
-
-  set(data: APIMessage): APIMessage {
-    if (!data?.type) return;
-    this.cache.set(data?.type, data);
-    return data;
-  }
-  setAll(data: APIMessage[]) {
-    if (!data) return this.cache;
-    for (let message of data) this.set(message);
-    return this.cache;
-  }
-}

package/src/managers/permission/GuildPermissionManager.ts

@@ -1,88 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Routes } from "../../rest/Routes";
-import { Collection } from "../../structures/Collection";
-import { Guild } from "../../structures/guild/Guild";
-import { Optional } from "../../types/api";
-import { APIGuild } from "../../types/api/APIGuild";
-import { APIGuildPermissions } from "../../types/api/APIGuildPermissions";
-import { Assertion } from "../../utils/Assertion";
-
-export class GuildPermissionManager {
-  /** The rest client */
-  rest: REST;
-
-  /** GuildBet bet guild */
-  guild: Guild;
-
-  permissions: APIGuildPermissions;
-  /**
-   * Manage users with the given client
-   * @param users An array of users
-   * @param rest The rest client
-   */
-  constructor(guild: Guild, rest: REST) {
-    this.guild = guild;
-    this.rest = rest;
-  }
-
-  /**
-   * Fetch a bet
-   * @param id Id of the bet to fetch
-   * @returns APIBetUser
-   */
-  async fetch() {
-    const route = Routes.guilds.resource(this.guild.id, "permissions");
-    const response = await this.rest.request<APIGuildPermissions, {}>({
-      method: "get",
-      url: route,
-    });
-    this.setAll(response);
-  }
-  async addId(permissionId: keyof APIGuildPermissions, roleId: string) {
-    const route = Routes.guilds.resources(
-      this.guild.id,
-      "permissions",
-      permissionId,
-      "ids"
-    );
-    const payload = { id: roleId };
-    const response = await this.rest.request<string[], typeof payload>({
-      method: "post",
-      url: route,
-      payload,
-    });
-    this.permissions[permissionId] = response;
-    return response;
-  }
-  async removeId(permissionId: keyof APIGuildPermissions, roleId: string) {
-    const route = Routes.guilds.resources(
-      this.guild.id,
-      "permissions",
-      permissionId,
-      "ids",
-      roleId
-    );
-    const payload = { id: roleId };
-    const response = await this.rest.request<string[], typeof payload>({
-      method: "delete",
-      url: route,
-      payload,
-    });
-
-    this.permissions[permissionId] = response;
-    return response;
-  }
-  setAll(data: APIGuildPermissions) {
-    if (!data) return this.permissions;
-    this.permissions = data;
-  }
-  toJSON() {
-    const json: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(this)) {
-      if (typeof value !== "function") {
-        json[key] = value;
-      }
-    }
-    return json;
-  }
-}

package/src/managers/product/GuildProductManager.ts

@@ -1,115 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Routes } from "../../rest/Routes";
-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";
-import { Assertion } from "../../utils/Assertion";
-
-export 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) {
-    this.guild = guild;
-    this.rest = rest;
-
-    this.cache = new Collection<string, GuildProduct>("products");
-  }
-
-  async create(payload: Optional<APIProduct>): Promise<GuildProduct> {
-    Assertion.assertObject(payload);
-
-    const route = Routes.guilds.shop.products.create(this.guild.id);
-    const response = await this.rest.request<APIProduct, typeof payload>({
-      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: string) {
-    const route = Routes.guilds.shop.products.get(this.guild.id, id);
-    const response = await this.rest.request<APIProduct, {}>({
-      method: "get",
-      url: route,
-    });
-    const product = new GuildProduct(response, this, this.rest);
-    this.cache.set(product.id, product);
-
-    return product;
-  }
-
-  async fetchAll() {
-    const route = Routes.guilds.shop.products.getAll(this.guild.id);
-    const response = await this.rest.request<APIProduct[], {}>({
-      method: "get",
-      url: route,
-    });
-
-    for (let betData of response) {
-      const product = new GuildProduct(betData, this, this.rest);
-      this.cache.set(product.id, product);
-    }
-    return this.cache;
-  }
-
-  set(data: APIProduct): GuildProduct {
-    if (!data.id) return;
-    const product = new GuildProduct(data, this, this.rest);
-    this.cache.set(data.id, product);
-    return product;
-  }
-  setAll(data: APIProduct[]) {
-    if (!data) return this.cache;
-    for (let product of data) this.set(product);
-    return this.cache;
-  }
-
-  async delete(id: string, type: string) {
-    Assertion.assertString(id);
-    Assertion.assertString(type);
-
-    const route = 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.guilds.shop.products.deleteAll(this.guild.id);
-    this.rest.emit("productsDelete", this.cache);
-
-    const value = await this.rest.request<boolean, {}>({
-      method: "DELETE",
-      url: route,
-    });
-    this.cache.clear();
-    return value;
-  }
-}

package/src/managers/ticket/GuildTicketManager.ts

@@ -1,112 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Routes } from "../../rest/Routes";
-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";
-import { Assertion } from "../../utils/Assertion";
-
-export 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) {
-    this.guild = guild;
-    this.rest = rest;
-
-    this.cache = new Collection<string, GuildTicket>("tickets");
-  }
-
-  async create(payload: Optional<APIGuildTicket>): Promise<GuildTicket> {
-    Assertion.assertObject(payload);
-
-    const route = Routes.guilds.tickets.create(this.guild.id);
-    const response = await this.rest.request<APIGuildTicket, typeof payload>({
-      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: string) {
-    const route = Routes.guilds.tickets.get(this.guild.id, id);
-    const response = await this.rest.request<APIGuildTicket, {}>({
-      method: "get",
-      url: route,
-    });
-
-    const ticket = new GuildTicket(response, this.guild, this, this.rest);
-    this.cache.set(ticket.id, ticket);
-
-    return ticket;
-  }
-
-  async fetchAll() {
-    const route = Routes.guilds.tickets.getAll(this.guild.id);
-    const response = await this.rest.request<APIGuildTicket[], {}>({
-      method: "get",
-      url: route,
-    });
-
-    for (let ticketData of response) {
-      const ticket = new GuildTicket(ticketData, this.guild, this, this.rest);
-      this.cache.set(ticket.id, ticket);
-    }
-    return this.cache;
-  }
-  set(data: APIGuildTicket): GuildTicket {
-    if (!data.id) return;
-    const ticket = new GuildTicket(data, this.guild, this, this.rest);
-    this.cache.set(data.id.toString(), ticket);
-    return ticket;
-  }
-  setAll(data: APIGuildTicket[]) {
-    if (!data) return this.cache;
-    for (let ticket of data) this.set(ticket);
-    return this.cache;
-  }
-
-  async delete(id: string) {
-    Assertion.assertString(id);
-
-    const route = Routes.guilds.tickets.delete(id, this.guild.id);
-    const ticket = this.cache.get(id);
-    this.rest.emit("ticketDelete", ticket);
-
-    await this.rest.request<boolean, {}>({
-      method: "DELETE",
-      url: route,
-    });
-
-    this.cache.delete(id);
-    return this.cache;
-  }
-  async deleteAll() {
-    const route = Routes.guilds.tickets.deleteAll(this.guild.id);
-    this.rest.emit("ticketsDelete", this.cache);
-
-    const value = await this.rest.request<boolean, {}>({
-      method: "DELETE",
-      url: route,
-    });
-    this.cache.clear();
-    return value;
-  }
-}

package/src/managers/user/GuildUserManager.ts

@@ -1,116 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Routes } from "../../rest/Routes";
-import { GuildUser } from "../../structures/user/GuildUser";
-import { Collection } from "../../structures/Collection";
-import { Guild } from "../../structures/guild/Guild";
-import { APIGuildUser } from "../../types/api/APIGuildUser";
-import { Assertion } from "../../utils/Assertion";
-import { Optional } from "../../types";
-
-export 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) {
-    this.guild = guild;
-    this.rest = rest;
-
-    this.cache = new Collection<string, GuildUser>("users");
-  }
-
-  /**
-   * Fetch a user
-   * @param id Id of the user to fetch
-   * @returns GuildUser
-   */
-  async fetch(id: string, name: string): Promise<GuildUser> {
-    const route = Routes.guilds.users.get(this.guild.id, id);
-    const response = await this.rest.request<APIGuildUser, { name: string }>({
-      method: "get",
-      url: route,
-      payload: { name },
-    });
-    if (!response) return this.cache.get(id);
-
-    const user = new GuildUser(response, this, this.rest);
-    this.cache.set(user?.id, user);
-    this.rest.users.set(user?.id, user);
-
-    return user;
-  }
-
-  async fetchAll(): Promise<Collection<string, GuildUser>> {
-    const route = Routes.guilds.users.getAll(this.guild.id);
-    const response = await this.rest.request<APIGuildUser[], {}>({
-      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: string, name: string, data: Optional<APIGuildUser>) {
-    const route = Routes.guilds.users.update(this.guild.id, id);
-    const payload = { ...data, name };
-    const response = await this.rest.request<APIGuildUser, typeof payload>({
-      method: "Patch",
-      url: route,
-      payload,
-    });
-    const user = this.set(response);
-    return user;
-  }
-  set(data: APIGuildUser): GuildUser {
-    if (!data.id) return;
-    const user = new GuildUser(data, this, this.rest);
-    this.cache.set(user?.id, user);
-    this.rest.users.set(user?.id, user);
-
-    return user;
-  }
-  setAll(data: APIGuildUser[]): Collection<string, GuildUser> {
-    if (!data) return this.cache;
-    for (let user of data) this.set(user);
-    return this.cache;
-  }
-
-  async delete(id: string) {
-    Assertion.assertString(id);
-
-    const route = Routes.guilds.users.delete(id, this.guild.id);
-    const user = this.cache.get(id);
-    this.rest.emit("userDelete", user);
-
-    await this.rest.request<boolean, {}>({
-      method: "DELETE",
-      url: route,
-    });
-
-    this.cache.delete(id);
-    return this.cache;
-  }
-  async deleteAll() {
-    const route = Routes.guilds.users.deleteAll(this.guild.id);
-    this.rest.emit("usersDelete", this.cache);
-
-    const value = await this.rest.request<boolean, {}>({
-      method: "DELETE",
-      url: route,
-    });
-    this.cache.clear();
-    return value;
-  }
-}

package/src/rest/APIEndpoints.ts

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

package/src/rest/REST.ts

@@ -1,126 +0,0 @@
-import EventEmitter from "events";
-import { Assertion } from "../utils/Assertion";
-import { request, Headers } from "undici";
-import { Routes } from "./Routes";
-import env from "dotenv";
-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";
-env.config();
-
-const Reset = "\x1b[0m";
-const FgGreen = "\x1b[32m";
-const FgRed = "\x1b[31m";
-const FgBlue = "\x1b[34m";
-const FgCyan = "\x1b[36m";
-
-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 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) {
-    super({ captureRejections: true });
-
-    if (key) {
-      Assertion.assertString(key);
-      this.key = key;
-    }
-
-    this.guilds = new GuildManager(this);
-    this.bets = new Collection<string, GuildBet>("bets");
-    this.matches = new Collection<string, GuildMatch>("matches");
-    this.betUsers = new Collection<string, GuildBetUser>("betUsers");
-    this.users = new Collection<string, GuildUser>("users");
-    this.mediators = new Collection<string, GuildMediator>("mediators");
-  }
-  /**
-   * Set the api key
-   * @param key The unique key of the client
-   */
-  setKey(key: string) {
-    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<Expecting, Payload>(options: RequestOptions<Payload>) {
-    let { method, url, payload } = options;
-    Assertion.assertString(method);
-    Assertion.assertString(this.key);
-    Assertion.assertString(url);
-
-    method = method.toUpperCase();
-    url = Routes.base + url;
-
-    const headers = new 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 request(url, {
-      method,
-      headers,
-      body: payload !== undefined ? JSON.stringify(payload) : undefined,
-    });
-
-    const body = await res.body.json();
-    const { data, message } = body as Record<string, unknown>;
-    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 as Expecting;
-  }
-}