@duque.edits/sdk 0.0.1

package/src/managers/guild/GuildManager.ts

@@ -0,0 +1,84 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuild } from "../../types/api/APIGuild";
+import { Assertion } from "../../utils/Assertion";
+
+export class GuildManager {
+  /** A cache of guilds */
+  cache: Collection<string, Guild>;
+
+  /** The rest client */
+  rest: REST;
+
+  /**
+   * Manage guilds with the given client
+   * @param guilds An array of guilds
+   * @param rest The rest client
+   */
+  constructor(rest: REST) {
+    this.cache = new Collection<string, Guild>("guilds");
+    this.rest = rest;
+  }
+
+  /**
+   * Fetch a guild
+   * @param id Id of the guild to fetch
+   * @returns APIGuild
+   */
+  async fetch(id: string): Promise<Guild> {
+    const route = Routes.guilds.get(id);
+    const response = await this.rest.request<APIGuild, {}>({
+      method: "get",
+      url: route,
+    });
+    const guild = new Guild(response, this.rest);
+    this.cache.set(guild.id, guild);
+    return guild;
+  }
+
+  async fetchAll() {
+    const route = Routes.guilds.getAll();
+    const response = await this.rest.request<APIGuild[], {}>({
+      method: "get",
+      url: route,
+    });
+
+    for (let guildData of response) {
+      if (!guildData.id) continue;
+      const guild = new Guild(guildData, this.rest);
+
+      this.cache.set(guild.id, guild);
+      this.rest.guilds.cache.set(guild.id, guild);
+    }
+    return this.cache;
+  }
+
+  async delete(id: string) {
+    Assertion.assertString(id);
+
+    const route = Routes.guilds.delete(id);
+    const guild = this.cache.get(id);
+    this.rest.emit("guildDelete", guild);
+
+    await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+
+    this.cache.delete(id);
+    return this.cache;
+  }
+  async deleteAll() {
+    const route = Routes.guilds.deleteAll();
+    this.rest.emit("guildsDelete", this.cache);
+
+    const value = await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+    this.cache.clear();
+    return value;
+  }
+}

package/src/managers/match/GuildMatchManager.ts

@@ -0,0 +1,115 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { GuildMatch } from "../../structures/match/GuildMatch";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuildMatch } from "../../types/api/APIGuildMatch";
+import { Optional } from "../../types/api";
+import { Assertion } from "../../utils/Assertion";
+
+export class GuildMatchManager {
+  /** A cache of users */
+  cache: Collection<string, GuildMatch>;
+
+  /** The rest client */
+  rest: REST;
+
+  /** GuildMatch match 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.cache = new Collection<string, GuildMatch>("matches");
+    this.rest = rest;
+  }
+
+  /**
+   * Fetch a match
+   * @param id Id of the match to fetch
+   * @returns APIBetUser
+   */
+  async fetch(id: string) {
+    const route = Routes.guilds.matches.get(this.guild.id, id);
+    const response = await this.rest.request<APIGuildMatch, {}>({
+      method: "get",
+      url: route,
+    });
+    const match = new GuildMatch(response, this.guild, this, this.rest);
+    this.cache.set(match._id, match);
+    this.rest.matches.set(match._id, match);
+
+    return match;
+  }
+
+  async fetchAll() {
+    const route = Routes.guilds.matches.getAll(this.guild.id);
+    const response = await this.rest.request<APIGuildMatch[], {}>({
+      method: "get",
+      url: route,
+    });
+    if (Array.isArray(response) && response.length === 0) {
+      this.cache.clear();
+      return this.cache;
+    }
+    this.setAll(response);
+    return this.cache;
+  }
+  set(data: APIGuildMatch): GuildMatch {
+    if (!data?._id) return;
+    const match = new GuildMatch(data, this?.guild, this, this.rest);
+
+    this.cache.set(data?._id, match);
+    this.rest.matches.set(data?._id, match);
+    return match;
+  }
+  setAll(data: APIGuildMatch[]) {
+    if (!data) return this.cache;
+    for (let match of data || []) this.set(match);
+    return this.cache;
+  }
+
+  async create(payload: Optional<APIGuildMatch>): Promise<GuildMatch> {
+    Assertion.assertObject(payload);
+
+    const route = Routes.guilds.matches.create(this.guild.id);
+    const response = await this.rest.request<APIGuildMatch, typeof payload>({
+      method: "POST",
+      url: route,
+      payload,
+    });
+    const match = this.set(response);
+    return match;
+  }
+
+  async delete(id: string) {
+    Assertion.assertString(id);
+
+    const route = Routes.guilds.matches.delete(id, this.guild.id);
+    const match = this.cache.get(id);
+    this.rest.emit("matchDelete", match);
+
+    await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+
+    this.cache.delete(id);
+    return this.cache;
+  }
+  async deleteAll() {
+    const route = Routes.guilds.matches.deleteAll(this.guild.id);
+    this.rest.emit("matchesDelete", this.cache);
+
+    const value = await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+    this.cache.clear();
+    return value;
+  }
+}

package/src/managers/mediator/GuildMediatorManager.ts

@@ -0,0 +1,111 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { GuildMediator } from "../../structures/mediator/GuildMediator";
+import { Optional } from "../../types/api";
+import { APIGuildMediator } from "../../types/api/APIGuildMediator";
+import { Assertion } from "../../utils/Assertion";
+
+export class GuildMediatorManager {
+  /** A cache of users */
+  cache: Collection<string, GuildMediator>;
+
+  /** The rest client */
+  rest: REST;
+
+  /** GuildMediator mediator 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, GuildMediator>("mediators");
+  }
+
+  async create(payload: Optional<APIGuildMediator>): Promise<GuildMediator> {
+    Assertion.assertObject(payload);
+
+    const route = Routes.guilds.mediators.create(this.guild.id);
+    const response = await this.rest.request<APIGuildMediator, typeof payload>({
+      method: "POST",
+      url: route,
+    });
+    const mediator = this.set(response);
+    return mediator;
+  }
+
+  /**
+   * Fetch a mediator
+   * @param id Id of the mediator to fetch
+   * @returns APImediatorUser
+   */
+  async fetch(id: string) {
+    const route = Routes.guilds.mediators.get(this.guild.id, id);
+    const response = await this.rest.request<APIGuildMediator, {}>({
+      method: "get",
+      url: route,
+    });
+
+    const mediator = new GuildMediator(response, this.guild, this, this.rest);
+    this.cache.set(mediator.id, mediator);
+
+    return mediator;
+  }
+
+  async fetchAll() {
+    const route = Routes.guilds.mediators.getAll(this.guild.id);
+    const response = await this.rest.request<APIGuildMediator[], {}>({
+      method: "get",
+      url: route,
+    });
+
+    this.setAll(response);
+    return this.cache;
+  }
+
+  set(data: APIGuildMediator): GuildMediator {
+    if (!data.id) return;
+    const mediator = new GuildMediator(data, this.guild, this, this.rest);
+    this.cache.set(data.id, mediator);
+    this.rest.mediators.set(mediator.id, mediator);
+    return mediator;
+  }
+  setAll(data: APIGuildMediator[]) {
+    if (!data) return this.cache;
+    for (let mediator of data) this.set(mediator);
+    return this.cache;
+  }
+
+  async delete(id: string) {
+    Assertion.assertString(id);
+
+    const route = Routes.guilds.mediators.delete(id, this.guild.id);
+    const mediator = this.cache.get(id);
+    this.rest.emit("mediatorDelete", mediator);
+
+    await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+
+    this.cache.delete(id);
+    return this.cache;
+  }
+  async deleteAll() {
+    const route = Routes.guilds.mediators.deleteAll(this.guild.id);
+    this.rest.emit("mediatorsDelete", this.cache);
+
+    const value = await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+    this.cache.clear();
+    return value;
+  }
+}

package/src/managers/messages/MessagesManager.ts

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,115 @@
+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;
+  }
+}