@duque.edits/sdk 0.0.4 → 0.0.5

package/v1/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;
-  }
-}

package/v1/rest/Routes.ts

@@ -1,143 +0,0 @@
-import { APIEndpoints } from "./APIEndpoints";
-export const Route = <K>(route: string) => route;
-
-export const Routes = {
-  //base: "http://localhost:3000/api/v1",
-  base: "https://duquedev.up.railway.app/api/v1",
-
-  field: (field: string) => `${field}`,
-  fields: (...fields: string[]) => `${fields.join("/")}`,
-
-  guilds: {
-    create: () => `/guilds`,
-
-    get: (guildId: string) => `/guilds/${guildId}`,
-    getAll: () => `/guilds`,
-    delete: (guildId: string) => `/guilds/${guildId}`,
-    deleteAll: () => `/guilds`,
-    resource: (guildId: string, resource: string) =>
-      `/guilds/${guildId}/${resource}`,
-    resources: (guildId: string, ...resourcess: string[]) =>
-      `/guilds/${guildId}/${resourcess.join("/")}`,
-
-    users: {
-      create: (guildId: string) => `/guilds/${guildId}/users`,
-      update: (guildId: string, userId: string) =>
-        `/guilds/${guildId}/users/${userId}`,
-
-      getAll: (guildId: string) => `/guilds/${guildId}/users`,
-      get: (guildId: string, userId: string) =>
-        `/guilds/${guildId}/users/${userId}`,
-
-      delete: (guildId: string, userId: string) =>
-        `/guilds/${guildId}/users/${userId}`,
-      deleteAll: (guildId: string) => `/guilds/${guildId}/users`,
-
-      resource: (guildId: string, userId: string, resource: string) =>
-        `/guilds/${guildId}/users/${userId}/${resource}`,
-    },
-
-    betUsers: {
-      getAll: (guildId: string) => `/guilds/${guildId}/betusers`,
-      get: (guildId: string, userId: string) =>
-        `/guilds/${guildId}/betusers/${userId}`,
-
-      create: (guildId: string) => `/guilds/${guildId}/betusers`,
-      update: (guildId: string, userId: string) =>
-        `/guilds/${guildId}/betusers/${userId}`,
-
-      delete: (guildId: string, userId: string) =>
-        `/guilds/${guildId}/betusers/${userId}`,
-
-      deleteAll: (guildId: string) => `/guilds/${guildId}/betusers`,
-      resource: (guildId: string, userId: string, resourceName: string) =>
-        `/guilds/${guildId}/betusers/${userId}/${resourceName}`,
-    },
-
-    matches: {
-      getAll: (guildId: string) => `/guilds/${guildId}/matches`,
-      get: (guildId: string, matchId: string) =>
-        `/guilds/${guildId}/matches/${matchId}`,
-
-      create: (guildId: string) => `/guilds/${guildId}/matches`,
-      update: (guildId: string, matchId: string) =>
-        `/guilds/${guildId}/matches/${matchId}`,
-
-      delete: (guildId: string, matchId: string) =>
-        `/guilds/${guildId}/matches/${matchId}`,
-      deleteAll: (guildId: string) => `/guilds/${guildId}/matches`,
-      resource: (guildId: string, matchId: string, ...resources: string[]) =>
-        `/guilds/${guildId}/matches/${matchId}/${resources.join("/")}`,
-    },
-
-    bets: {
-      getAll: (guildId: string) => `/guilds/${guildId}/bets`,
-      get: (guildId: string, betId: string) =>
-        `/guilds/${guildId}/bets/${betId}`,
-      create: (guildId: string) => `/guilds/${guildId}/bets`,
-      update: (guildId: string, betId: string) =>
-        `/guilds/${guildId}/bets/${betId}`,
-      delete: (guildId: string, betId: string) =>
-        `/guilds/${guildId}/bets/${betId}`,
-      deleteAll: (guildId: string) => `/guilds/${guildId}/bets`,
-      resource: (guildId: string, betId: string, ...resources: string[]) =>
-        `/guilds/${guildId}/bets/${betId}/${resources.join("/")}`,
-    },
-
-    tickets: {
-      getAll: (guildId: string) => `/guilds/${guildId}/tickets`,
-      get: (guildId: string, ticketId: string) =>
-        `/guilds/${guildId}/tickets/${ticketId}`,
-      create: (guildId: string) => `/guilds/${guildId}/tickets`,
-      update: (guildId: string, ticketId: string) =>
-        `/guilds/${guildId}/tickets/${ticketId}`,
-      delete: (guildId: string, ticketId: string) =>
-        `/guilds/${guildId}/tickets/${ticketId}`,
-      deleteAll: (guildId: string) => `/guilds/${guildId}/tickets`,
-      resource: (guildId: string, ticketId: string, ...resources: string[]) =>
-        `/guilds/${guildId}/tickets/${ticketId}/${resources.join("/")}`,
-    },
-    mediators: {
-      getAll: (guildId: string) => `/guilds/${guildId}/mediators`,
-      get: (guildId: string, mediatorId: string) =>
-        `/guilds/${guildId}/mediators/${mediatorId}`,
-      create: (guildId: string) => `/guilds/${guildId}/mediators`,
-      update: (guildId: string, mediatorId: string) =>
-        `/guilds/${guildId}/mediators/${mediatorId}`,
-      delete: (guildId: string, mediatorId: string) =>
-        `/guilds/${guildId}/mediators/${mediatorId}`,
-      deleteAll: (guildId: string) => `/guilds/${guildId}/mediators`,
-      resource: (guildId: string, mediatorId: string, ...resources: string[]) =>
-        `/guilds/${guildId}/mediators/${mediatorId}/${resources.join("/")}`,
-    },
-
-    shop: {
-      get: (guildId: string) => `/guilds/${guildId}/shop`,
-
-      update: (guildId: string) => `/guilds/${guildId}/shop`,
-      delete: (guildId: string) => `/guilds/${guildId}/shop/ `,
-      resource: (guildId: string, ...resources: string[]) =>
-        `/guilds/${guildId}/shop/${resources.join("/")}`,
-
-      products: {
-        getAll: (guildId: string) => `/guilds/${guildId}/shop/products`,
-        get: (guildId: string, productId: string) =>
-          `/guilds/${guildId}/shop/${productId}/products`,
-        create: (guildId: string) => `/guilds/${guildId}/shop/products`,
-        update: (guildId: string, productId: string) =>
-          `/guilds/${guildId}/shop/products/${productId}`,
-        delete: (guildId: string, productId: string) =>
-          `/guilds/${guildId}/shop/products/${productId}`,
-        deleteAll: (guildId: string) => `/guilds/${guildId}/products/shop`,
-        resource: (
-          guildId: string,
-          productId: string,
-          ...resources: string[]
-        ) =>
-          `/guilds/${guildId}/shop/products/${productId}/${resources.join(
-            "/"
-          )}`,
-      },
-    },
-  },
-};

package/v1/structures/Collection.ts

@@ -1,85 +0,0 @@
-type Predicate = (x: unknown) => boolean;
-type Optional<T> = { [K in keyof T]?: T[K] };
-
-export class Collection<K, V> extends Map<K, V> {
-  key: string;
-
-  constructor(key?: string, data?: Iterable<V>) {
-    super();
-    this.key = key;
-
-    if (data && Array.isArray(data) && key) {
-      if (data.length > 0) return;
-      for (let v of data) this.set(key as K, v);
-    }
-  }
-  at(index: number) {
-    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: K) {
-    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: (value: V, key: K, Collection: this) => any) {
-    for (const [key, value] of this) {
-      if (predicate(value, key, this)) return value;
-    }
-    return undefined;
-  }
-  filter(predicate: (value: V, key: K, Collection: this) => any) {
-    const results = new Collection<K, V>("", []);
-    for (const [key, value] of this) {
-      if (predicate(value, key, this)) results.set(key, value);
-    }
-    return results;
-  }
-  some(predicate: (value: V, key: K, Collection: this) => any) {
-    const results = new Collection("", []);
-    for (const [key, value] of this) {
-      if (predicate(value, key, this)) results.set(key, value);
-    }
-    return results;
-  }
-  map(callback: (value: V, key: K, Collection: this) => any) {
-    return [...this].map(([key, val]) => callback(val, key, this));
-  }
-  toArray() {
-    return [...this.values()];
-  }
-  toJSON() {
-    let obj: Record<string, unknown> = {};
-    for (let [k, v] of this.entries()) {
-      obj[`${k}`] = v;
-    }
-    return obj;
-  }
-  sort(compareFunction: (a: V, b: V, Collection: this) => any) {
-    const sortedEntries = [...this.entries()].sort((ab, ba) => {
-      return compareFunction(ab[1], ba[1], this);
-    });
-
-    return new Collection(this.key, sortedEntries);
-  }
-  toString() {
-    return `${this.size}`;
-  }
-}
-module.exports = { Collection };

package/v1/structures/bet/GuildBet.ts

@@ -1,332 +0,0 @@
-import { REST } from "../../rest/REST";
-import { Routes } from "../../rest/Routes";
-import { Guild } from "../guild/Guild";
-import { APIGuildBet } from "../../types/api/APIGuildBet";
-import { APIPlayer } from "../../types/api/APIPlayer";
-import { APIBetChannel } from "../../types/api/APIBetChannel";
-import { APIBetMessage } from "../../types/api/APIBetMessage";
-import { BaseMatchModes, BaseMatchStatus, Confirm, Logs, Optional } from "../../types/api";
-import { Assertion } from "../../utils/Assertion";
-import { ChannelManager } from "../../managers/channel/ChannelManager";
-import { GuildBetManager } from "../../managers/bet/GuildBetManager";
-import { MessagesManager } from "../../managers/messages/MessagesManager";
-
-type ExtendedMatchStatus = BaseMatchStatus | "waiting";
-
-export 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) {
-    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<GuildBet>(guild, this, rest);
-    this.messages = new 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.guilds.bets.get(this.guild.id, this._id);
-    const response = await this.rest.request<APIGuildBet, {}>({
-      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: string, id: string) {
-    Assertion.assertString(type);
-    Assertion.assertString(id);
-
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "confirmed");
-    const payload = { entry: { type, id } };
-
-    const response = await this.rest.request<APIGuildBet, typeof payload>({
-      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: Confirm[]) {
-    Assertion.assertObject(set);
-
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "confirmed");
-
-    const response = await this.rest.request<APIGuildBet, typeof set>({
-      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: ExtendedMatchStatus) {
-    Assertion.assertString(status);
-
-    const payload = { set: status.toLowerCase() };
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "status");
-    const response = await this.rest.request<APIGuildBet, typeof payload>({
-      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: string) {
-    Assertion.assertString(userId);
-
-    const payload = { set: userId };
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "winner");
-    const response = await this.rest.request<APIGuildBet, {}>({
-      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: string) {
-    Assertion.assertString(userId);
-
-    const payload = { set: userId };
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "loser");
-    const response = await this.rest.request<APIGuildBet, {}>({
-      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: string, type: string) {
-    const ch = await this.channels.create(id, type);
-    this.manager.cache.set(this._id, this);
-    return ch;
-  }
-  async addMessage(id: string, type: string, content?: string) {
-    const response = await this.messages.create({
-      userId: id,
-      type: type as "img",
-      content,
-    });
-
-    this.manager.cache.set(this._id, this);
-    this.rest.bets.set(this._id, this);
-    return response;
-  }
-  async setChannels(channels: APIBetChannel[]) {
-    Assertion.assertObject(channels);
-
-    const payload = { set: channels };
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "channels");
-    const response = await this.rest.request<APIGuildBet, {}>({
-      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: string, name: string) {
-    Assertion.assertString(id);
-    Assertion.assertString(name);
-
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "players");
-    const payload = { id, name };
-    const response = await this.rest.request<APIPlayer[], typeof payload>({
-      method: "POST",
-      url: route,
-      payload,
-    });
-
-    this.players = response;
-    this.manager.cache.set(this._id, this);
-    return this.players;
-  }
-  async removePlayer(id: string, name: string) {
-    Assertion.assertString(id);
-    Assertion.assertString(name);
-
-    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "players", id);
-    const payload = { id, name };
-    const response = await this.rest.request<APIPlayer[], typeof payload>({
-      method: "DELETE",
-      url: route,
-      payload,
-    });
-    this.players = response;
-    this.manager.cache.set(this._id, this);
-    return this.players;
-  }
-
-  async update(data: Optional<APIGuildBet>) {
-    const route = Routes.guilds.bets.get(this.guild.id, this._id);
-    const payload = data;
-
-    const response = await this.rest.request<APIGuildBet, typeof payload>({
-      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 as any)[k] = response[k as keyof APIGuildBet];
-      }
-    }
-    this.rest.bets.set(this._id, this);
-    this.manager.cache.set(this._id, this);
-    return this;
-  }
-  toJSON() {
-    const json: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(this)) {
-      if (typeof value !== "function") {
-        json[key] = value;
-      }
-    }
-    return json;
-  }
-}