@duque.edits/sdk 0.0.1

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 duque das edits
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# A SDK for my API
+
+> You can use this package as base for your own sdk
+
+> __Version__: [2.5.3](https://www.npmjs.com/package/@duque.edits/rest)
+
+## Features
+- Rest Client
+- Guild Manager
+  
+## To-Do
+- Bet User Manager
+- User Manager
+- Bet Manager
+- Match Manager
+- Ticket Manager

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@duque.edits/sdk",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "commonjs",
+  "description": "An SDK that facilitates interaction with my API.",
+  "keywords": [
+    "REST",
+    "API",
+    "SDK",
+    "DuqueEdits"
+  ],
+  "scripts": {
+    "test": "ts-node tests/index.ts"
+  },
+  "author": "Duque Edits jedits077@gmail.com",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/duque7x/sdk-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/duque7x/sdk-api/issues"
+  },
+  "homepage": "https://github.com/duque7x/sdk-api#readme",
+  "dependencies": {
+    "undici": "^7.10.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@types/node": "^24.0.14",
+    "chalk": "^4.1.2",
+    "dotenv": "^16.6.1",
+    "eslint": "^9.29.0",
+    "globals": "^16.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export * from "./managers/bet/GuildBetManager";
+export * from "./managers/betuser/GuildBetUserManager";
+export * from "./managers/channel/ChannelManager";
+export * from "./managers/groupedchannel/GroupedChannelManager";
+export * from "./managers/guild/GuildManager";
+export * from "./managers/match/GuildMatchManager";
+export * from "./managers/mediator/GuildMediatorManager";
+export * from "./managers/messages/MessagesManager";
+export * from "./managers/permission/GuildPermissionManager";
+export * from "./managers/product/GuildProductManager";
+export * from "./managers/ticket/GuildTicketManager";
+export * from "./managers/user/GuildUserManager";
+
+export * from "./structures/bet/GuildBet";
+export * from "./structures/betuser/GuildBetUser";
+export * from "./structures/channel/Channel";
+export * from "./structures/groupedchannel/GroupedChannel";
+export * from "./structures/guild/Guild";
+export * from "./structures/match/GuildMatch";
+export * from "./structures/mediator/GuildMediator";
+export * from "./structures/product/GuildProduct";
+export * from "./structures/shop/GuildShop";
+export * from "./structures/ticket/GuildTicket";
+export * from "./structures/user/GuildUser";
+export * from "./structures/Collection";
+
+export * from "./rest/REST";
+export * from "./rest/Routes";
+
+export * from "./types/index";

package/src/managers/bet/GuildBetManager.ts

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

package/src/managers/betuser/GuildBetUserManager.ts

@@ -0,0 +1,103 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { GuildBetUser } from "../../structures/betuser/GuildBetUser";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuildBetUser } from "../../types/api/APIGuildBetUser";
+import { Assertion } from "../../utils/Assertion";
+
+export class GuildBetUserManager {
+  /** A cache of users */
+  cache: Collection<string, GuildBetUser>;
+
+  /** 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, GuildBetUser>("betUsers");
+  }
+  set(data: APIGuildBetUser): Collection<string, GuildBetUser> {
+    if (!data.id) return;
+    const user = new GuildBetUser(data, this, this.rest);
+    this.rest.betUsers.set(user.id, user);
+    return this.cache.set(user.id, user);
+  }
+  setAll(data: APIGuildBetUser[]): Collection<string, GuildBetUser> {
+    if (!data) return this.cache;
+    for (let user of data) this.set(user);
+    return this.cache;
+  }
+  /**
+   * Fetch a user
+   * @param id Id of the user to fetch
+   * @returns GuildBetUser
+   */
+  async fetch(id: string, name: string): Promise<GuildBetUser> {
+    const route = Routes.guilds.betUsers.get(this.guild.id, id);
+    const response = await this.rest.request<APIGuildBetUser, { name: string }>(
+      {
+        method: "get",
+        url: route,
+        payload: { name },
+      }
+    );
+    if (!response) return this.cache.get(id);
+
+    const user = new GuildBetUser(response, this, this.rest);
+    this.cache.set(user?.id, user);
+    this.rest.betUsers.set(user?.id, user);
+
+    return user;
+  }
+
+  async fetchAll(): Promise<Collection<string, GuildBetUser>> {
+    const route = Routes.guilds.betUsers.getAll(this.guild.id);
+    const response = await this.rest.request<APIGuildBetUser[], {}>({
+      method: "get",
+      url: route,
+    });
+    if (Array.isArray(response) && response.length === 0) {
+      this.cache.clear();
+      return this.cache;
+    }
+    this.setAll(response);
+    return this.cache;
+  }
+
+  async delete(id: string) {
+    Assertion.assertString(id);
+
+    const route = Routes.guilds.betUsers.delete(id, this.guild.id);
+    const betUser = this.cache.get(id);
+    this.rest.emit("betDelete", betUser);
+
+    await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+
+    this.cache.delete(id);
+    return this.cache;
+  }
+  async deleteAll() {
+    const route = Routes.guilds.betUsers.deleteAll(this.guild.id);
+    this.rest.emit("betsDelete", this.cache);
+
+    const value = await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+    this.cache.clear();
+    return value;
+  }
+}

package/src/managers/channel/ChannelManager.ts

@@ -0,0 +1,168 @@
+import { REST } from "../../rest/REST";
+import { Route, Routes } from "../../rest/Routes";
+import { GuildBet } from "../../structures/bet/GuildBet";
+import { Channel } from "../../structures/channel/Channel";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { GuildMatch } from "../../structures/match/GuildMatch";
+import { Optional } from "../../types/api";
+import { APIBaseChannel } from "../../types/api/APIBaseChannel";
+
+import { Assertion } from "../../utils/Assertion";
+type Channels = Optional<APIBaseChannel>;
+
+export class ChannelManager<Structure extends GuildBet | GuildMatch> {
+  /** A cache of bet channels */
+  cache: Collection<string, Channel<Structure>>;
+
+  /** The rest client */
+  rest: REST;
+
+  /** GuildBet user guild */
+  guild: Guild;
+
+  /** The bet */
+  structure: Structure;
+
+  /** Base Url  */
+  baseUrl: string;
+
+  /**
+   * Manage channels of a bet
+   * @param guild The guild at hand
+   * @param bet The bet at hand
+   * @param rest The rest client
+   */
+  constructor(guild: Guild, structure: Structure, rest: REST) {
+    this.structure = structure;
+    this.rest = rest;
+    this.guild = guild;
+    this.cache = new Collection<string, Channel<Structure>>("channels");
+    this.baseUrl = Routes.guilds[structure.key as "bets"].resource(guild.id, structure._id, "channels");
+  }
+  async create(id: string, type: string): Promise<Channel<Structure>> {
+    Assertion.assertString(id);
+    Assertion.assertString(type);
+
+    const route = this.baseUrl;
+    const payload = { id, type };
+    const response = await this.rest.request<APIBaseChannel, typeof payload>({
+      method: "POST",
+      url: route,
+      payload,
+    });
+    const channel = this.set(response);
+
+    this.rest.emit("channelCreate", channel);
+    return channel;
+  }
+  async createMany(...channels: Channels[]) {
+    Assertion.assertArray(channels);
+    const route = Routes.fields(this.baseUrl, "bulk");
+    const payload = { channels };
+    const response = await this.rest.request<APIBaseChannel[], typeof payload>({
+      method: "POST",
+      url: route,
+      payload,
+    });
+
+    this.rest.emit("channelBulkCreate", response);
+    return this.setAll(response);
+  }
+  async deleteMany(...channels: Optional<APIBaseChannel>[]) {
+    Assertion.assertArray(channels);
+
+    const route = Routes.fields(this.baseUrl, "bulk");
+    const payload = { channels };
+    const response = await this.rest.request<APIBaseChannel[], typeof payload>({
+      method: "DELETE",
+      url: route,
+      payload,
+    });
+    const channel = this.setAll(response);
+
+    this.rest.emit("channelBulkDelete", channel);
+    return channel;
+  }
+  setAll(data: APIBaseChannel[]): Collection<string, Channel<Structure>> {
+    if (!data) return this.cache;
+    for (let channelData of data) this.set(channelData);
+    return this.cache;
+  }
+  set(data: APIBaseChannel): Channel<Structure> {
+    if (!data.type) return;
+    const channel = new Channel(
+      {
+        baseUrl: Routes.guilds[this.structure.key as "bets"].resource(this.guild.id, this.structure._id, "channels"),
+        data: data,
+        guild: this.guild,
+        manager: this,
+      },
+      this.rest
+    );
+    this.cache.set(data.type, channel);
+    return channel;
+  }
+  async update(type: string, payload: Optional<APIBaseChannel>): Promise<Channel<Structure>> {
+    Assertion.assertString(type);
+    Assertion.assertObject(payload);
+
+    const route = Routes.fields(this.baseUrl, type);
+    const response = await this.rest.request<APIBaseChannel, {}>({
+      method: "PATCH",
+      url: route,
+      payload,
+    });
+    const channel = this.set(response);
+    this.rest.emit("betUpdate", this.structure, this.structure);
+    return channel;
+  }
+  async fetch(type: string): Promise<Channel<Structure>> {
+    Assertion.assertString(type);
+
+    const route = Routes.fields(this.baseUrl, type);
+    const response = await this.rest.request<APIBaseChannel, {}>({
+      method: "GET",
+      url: route,
+    });
+
+    const channel = this.set(response);
+    this.cache.set(channel.type, channel);
+
+    return channel;
+  }
+  async fetchAll() {
+    const response = await this.rest.request<APIBaseChannel[], {}>({
+      method: "GET",
+      url: this.baseUrl,
+    });
+    if (Array.isArray(response) && response.length === 0) {
+      this.cache.clear();
+      return this.cache;
+    }
+    for (let channelData of response) this.set(channelData);
+    return this.cache;
+  }
+
+  async delete(type: string): Promise<Collection<string, Channel<Structure>>> {
+    Assertion.assertString(type);
+
+    const route = this.baseUrl;
+    const response = await this.rest.request<APIBaseChannel[], {}>({
+      method: "DELETE",
+      url: Routes.fields(route, type),
+    });
+    this.cache.delete(type);
+    return this.cache;
+  }
+
+  async deleteAll(): Promise<boolean> {
+    const route = this.baseUrl;
+    const value = await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+    this.cache.clear();
+    return value;
+  }
+}

package/src/managers/groupedchannel/GroupedChannelManager.ts

@@ -0,0 +1,117 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { GroupedChannel } from "../../structures/groupedchannel/GroupedChannel";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { Optional } from "../../types/api";
+import { APIGuildGroupedChannel } from "../../types/api/APIGuildGroupedChannel";
+import { Assertion } from "../../utils/Assertion";
+
+export class GroupedChannelManager {
+  /** A cache of channels */
+  cache: Collection<string, GroupedChannel>;
+
+  /** Key */
+  key: string;
+
+  baseUrl: string;
+
+  /** The rest client */
+  rest: REST;
+
+  /** GroupedChannel groupedChannel guild */
+  guild: Guild;
+  /**
+   * Manage channels with the given client
+   * @param channels An array of channels
+   * @param rest The rest client
+   */
+  constructor(guild: Guild, key: string, rest: REST) {
+    this.key = key;
+    this.baseUrl = Routes.fields(Routes.guilds.get(guild?.id), key);
+
+    this.cache = new Collection<string, GroupedChannel>("groupedChannels");
+
+    this.guild = guild;
+    this.rest = rest;
+  }
+  async delete(type: string) {
+    const route = Routes.fields(this.baseUrl, type);
+    const response = await this.rest.request<boolean, {}>({
+      method: "delete",
+      url: route,
+    });
+    this.cache.delete(type);
+    return response;
+  }
+  async create(
+    payload: Optional<APIGuildGroupedChannel>
+  ): Promise<GroupedChannel> {
+    Assertion.assertObject(payload);
+
+    const route = this.baseUrl;
+    const response = await this.rest.request<
+      APIGuildGroupedChannel,
+      typeof payload
+    >({
+      method: "POST",
+      url: route,
+      payload,
+    });
+    const groupedChannel = this.set(response);
+    return groupedChannel;
+  }
+
+  /**
+   * Fetch a groupedChannel
+   * @param id Id of the groupedChannel to fetch
+   * @returns APIgroupedChannelUser
+   */
+  async fetch(type: string) {
+    const route = Routes.fields(this.baseUrl, type);
+    const response = await this.rest.request<APIGuildGroupedChannel, {}>({
+      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<APIGuildGroupedChannel[], {}>({
+      method: "get",
+      url: route,
+    });
+
+    for (let groupedChannelData of response) {
+      const groupedChannel = new GroupedChannel(
+        groupedChannelData,
+        this.guild,
+        this,
+        this.rest
+      );
+      this.cache.set(groupedChannel.type, groupedChannel);
+    }
+    return this.cache;
+  }
+  setAll(data: APIGuildGroupedChannel[]) {
+    if (!data) return this.cache;
+    for (let groupedChannel of data) this.set(groupedChannel);
+    return this.cache;
+  }
+
+  set(data: APIGuildGroupedChannel): GroupedChannel {
+    if (!data?.type) return;
+    const groupedChannel = new GroupedChannel(
+      data,
+      this.guild,
+      this,
+      this.rest
+    );
+    this.cache.set(data.type, groupedChannel);
+    return groupedChannel;
+  }
+}