@duque.edits/sdk 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duque.edits/sdk",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
@@ -12,6 +12,10 @@
     "SDK",
     "DuqueEdits"
   ],
+  "files": [
+    "./dist",
+    "./package.json"
+  ],
   "scripts": {
     "test": "ts-node tests/index.ts"
   },
@@ -38,6 +42,16 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
   },
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./v1": {
+      "require": "./dist/v1",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },

package/.gitattributes

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

package/tests/index.ts

@@ -1,86 +0,0 @@
-import { after } from "node:test";
-import { REST } from "../src/rest/REST";
-const client = new REST("877598927149490186");
-const Reset = "\x1b[0m";
-const FgGreen = "\x1b[32m";
-const FgRed = "\x1b[31m";
-const FgBlue = "\x1b[34m";
-const FgCyan = "\x1b[36m";
-
-client.on("debug", console.log);
-
-client.init().then(async () => {
-  const guilds = client.guilds;
-  const guild = client.guilds.cache.get("1341399030282059776")!;
-
-  const users = guild?.users?.cache;
-
-  const me = users?.get("877598927149490186")!;
-  /* const matches = guild?.matches;
-  let match = await matches.create({
-    creatorId: "12",
-    type: "1v1",
-    maximumSize: 2,
-  });
-  await match.channels.createMany(
-    {
-      type: "dqwdqdwqdqwdqwd",
-      id: "1111111111111111111111111",
-    },
-    {
-      type: "duque",
-      id: "2333",
-    }
-  );
-  console.log({ chs: match?.channels?.cache });
-
-  await match.setMvp("2333");
-  console.log({ chs: match?.channels?.cache });
-
-  await match.setRoomCreatorId("2333");
-  console.log({ chs: match?.channels?.cache });
-
-  await match.setWinners({
-    id: "que",
-    name: "22e2e",
-  });
-  match = await match.fetch();
-
-  console.log({ chs: match?.channels?.cache }); */
-  /*
-  const channels = guild?.channels;
-  const categories = guild?.categories;
-
-  /* await me.update({
-    originalChannels: [
-      {
-        type: "dqwdqdwqdqwdqwd",
-        id: "1111111111111111111111111",
-      },
-      {
-        type: "dqwdqdwqdqwdqwd",
-        id: "2333",
-      },
-    ],
-    type: "add",
-  });
-
-  await me.update({
-    originalChannels: [
-      {
-        type: "3333",
-        id: "33333",
-      },
-      {
-        type: "313",
-        id: "074534535",
-      },
-    ],
-    type: "add",
-  }); 
-
-  console.log({ mecj: me.originalChannels }); */
-
-  await me.update({ wins: 10020, type: "add" });
-  console.log({ me })
-});

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipDefaultLibCheck": true,
-    "removeComments": false,
-    "strictNullChecks": false,
-  },
-  "include": ["v1"]
-}

package/v1/managers/bet/GuildBetManager.ts

@@ -1,117 +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 { 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/v1/managers/betuser/GuildBetUserManager.ts

@@ -1,103 +0,0 @@
-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/v1/managers/channel/ChannelManager.ts

@@ -1,168 +0,0 @@
-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/v1/managers/groupedchannel/GroupedChannelManager.ts

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