@duque.edits/sdk 0.2.0 → 0.2.2

package/dist/managers/logs/LogManager.js

@@ -18,7 +18,7 @@ class LogManager extends base_1.BaseManager {
             method: "GET",
             url: route,
         });
-        return response;
+        return this.set(response);
     }
     async create(data) {
         const route = this.base_url;
@@ -28,32 +28,40 @@ class LogManager extends base_1.BaseManager {
             url: route,
             payload,
         });
-        this.set(response);
-        return response;
-    }
-    async createMany(data) {
-        const route = this.base_url;
-        const payload = { ...data };
-        const response = await this.rest.request({
-            method: "POST",
-            url: route,
-            payload,
-        });
-        this.set(response);
-        return response;
+        const logEntry = this.set(response);
+        this.cache.set(data._id, logEntry);
+        this.rest.emit("logEntryCreate", logEntry, this.guild);
+        return logEntry;
     }
+    /* async createMany(data: Optional<APILogEntry>[]): Promise<APILogEntry[]> {
+      const route = Routes.fields(this.base_url, "bulk");
+      const payload = { ...data };
+      const response = await this.rest.request<APILogEntry[], typeof payload>({
+        method: "POST",
+        url: route,
+        payload,
+      });
+  
+      this.set(response);
+      return response;
+    } */
     set(data) {
         if (!data)
             return this.cache;
         if (Array.isArray(data)) {
+            this.cache.clear();
             for (let entry of data) {
-                this.cache.set(entry._id, entry);
+                if (!entry._id)
+                    continue;
+                const logEntry = new structures_1.LogEntry(entry, this);
+                this.cache.set(entry._id, logEntry);
             }
             return this.cache;
         }
         else {
-            this.cache.set(data._id, data);
-            return data;
+            const logEntry = new structures_1.LogEntry(data, this);
+            this.cache.set(data._id, logEntry);
+            return logEntry;
         }
     }
 }

package/dist/rest/REST.js

@@ -53,15 +53,6 @@ class REST extends events_1.default {
         await Promise.all([this.guilds.fetch(), this.minesGames.fetch()]);
         return this;
     }
-    /**
-     * Ping the api
-     */
-    async ping() {
-        return this.request({
-            url: "/status",
-            method: "get",
-        });
-    }
     /**
      * Request Data from a certain url
      * @param options

package/dist/rest/Routes.js

@@ -13,7 +13,7 @@ exports.Routes = {
         delete: (guildId) => `/guilds/${guildId}`,
         deleteAll: () => `/guilds`,
         resource: (guildId, resource) => `/guilds/${guildId}/manage/${resource}`,
-        resources: (guildId, ...resourcess) => `/guilds/${guildId}/manage/${resourcess.join("/")}`,
+        resources: (guildId, ...resources) => `/guilds/${guildId}/manage/${resources.join("/")}`,
         users: {
             create: (guildId) => `/guilds/${guildId}/users`,
             update: (guildId, userId) => `/guilds/${guildId}/users/${userId}`,

package/dist/structures/guild/Guild.js

@@ -164,6 +164,29 @@ class Guild {
         });
         return this._updateInternals(response);
     }
+    async setChannelIds(type, ...ids) {
+        const channel = this.channels.find((c) => c.type === type);
+        if (!ids || ids.length === 0)
+            return;
+        if (!channel) {
+            // create new channel if it doesn't exist
+            this.channels.push({ type, ids });
+        }
+        else {
+            // merge IDs, remove duplicates
+            const chIndex = this.channels.findIndex((ch) => ch.type === type);
+            const mergedIds = [...new Set([...ids])];
+            this.channels[chIndex] = { ...channel, ids: mergedIds };
+        }
+        const route = Routes_1.Routes.guilds.get(this.id);
+        const payload = { channels: this.channels };
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        return this._updateInternals(response);
+    }
     async removeIdInChannel(type, id) {
         const chIndex = this.channels.findIndex((c) => c.type === type);
         if (chIndex !== -1) {

package/dist/structures/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./guild/Guild"), exports);
+__exportStar(require("./logentry/LogEntry"), exports);
 __exportStar(require("./match/GuildMatch"), exports);
 __exportStar(require("./user/GuildUser"), exports);
 __exportStar(require("./vipmember/VipMember"), exports);

package/dist/structures/logentry/LogEntry.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogEntry = void 0;
+const rest_1 = require("../../rest");
+class LogEntry {
+    _id;
+    guild_id;
+    user_id;
+    admin_id;
+    object_id;
+    type;
+    description;
+    change;
+    before;
+    after;
+    logs_channel_id;
+    createdAt;
+    updatedAt;
+    manager;
+    /** The given guild */
+    guild;
+    /** The rest client */
+    rest;
+    constructor(data, manager) {
+        this.manager = manager;
+        this.guild = manager.guild;
+        this._id = data?._id;
+        this.guild_id = data?.guild_id;
+        this.user_id = data?.user_id;
+        this.admin_id = data?.admin_id;
+        this.object_id = data?.object_id;
+        this.type = data?.type;
+        this.description = data?.description;
+        this.change = data?.change;
+        this.before = data?.before;
+        this.after = data?.after;
+        this.logs_channel_id = data?.logs_channel_id;
+        this.createdAt = data?.createdAt ? new Date(data?.createdAt) : new Date();
+        this.updatedAt = data?.updatedAt ? new Date(data?.updatedAt) : new Date();
+    }
+    async fetch() {
+        const route = rest_1.Routes.guilds.resources(this.guild.id, "logs", this._id);
+        const response = await this.rest.request({ url: route, method: "GET" });
+        return this._updateInternals(response);
+    }
+    toJSON() {
+        const json = {};
+        for (const [key, value] of Object.entries(this)) {
+            if (typeof value !== "function") {
+                json[key] = value;
+            }
+        }
+        return json;
+    }
+    _updateInternals(data) {
+        for (let key in data) {
+            if (key === "id" || key === "createdAt")
+                continue;
+            if (key in this) {
+                this[key] = data[key];
+            }
+        }
+        this.updatedAt = new Date();
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+}
+exports.LogEntry = LogEntry;

package/dist/structures/user/GuildUser.js

@@ -220,15 +220,15 @@ class GuildUser {
         const route = Routes_1.Routes.guilds.users.get(this.manager.guild.id, this.id);
         let payload = {};
         const numericFields = ["wins", "points", "losses", "mvps", "games", "creations"];
-        const arrayFields = ["items", "original_channels"];
+        const arrayFields = ["items", "original_channels", "adverts"];
         if (data?.type === "add" || data?.type === "remove") {
             for (const key in data) {
                 if (key === "type")
                     continue;
                 const value = data[key];
                 if (numericFields.includes(key)) {
-                    const current = this[key];
-                    const num = value;
+                    const current = (this[key] || 0);
+                    const num = (value || 0);
                     payload[key] = Math.max(0, data?.type === "add" ? current + num : current - num);
                 }
                 else if (key === "blacklist") {

package/dist/types/api/APILogEntry.js

@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogEntryTypes = void 0;
+var LogEntryTypes;
+(function (LogEntryTypes) {
+    LogEntryTypes["QueueCreated"] = "queue_created";
+    LogEntryTypes["QueueShut"] = "queue_shut";
+    LogEntryTypes["MatchStarted"] = "match_started";
+    LogEntryTypes["MatchUpdated"] = "match_updated";
+    LogEntryTypes["MatchClosed"] = "match_closed";
+    LogEntryTypes["UserUpdated"] = "user_updated";
+    LogEntryTypes["UserManaged"] = "user_managed";
+})(LogEntryTypes || (exports.LogEntryTypes = LogEntryTypes = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duque.edits/sdk",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "main": "dist/index",
   "types": "./types/index.d.ts",
   "typings": "./types/index.d.ts",

package/types/managers/logs/LogManager.d.ts

@@ -1,11 +1,10 @@
-import { Collection, Guild } from "../../structures";
+import { Collection, Guild, LogEntry } from "../../structures";
 import { Optional } from "../../types";
 import { APILogEntry } from "../../types/api/APILogEntry";
 import { BaseManager } from "../base";
-export declare class LogManager extends BaseManager<APILogEntry> {
+export declare class LogManager extends BaseManager<LogEntry> {
     constructor(guild: Guild);
-    fetch(): Promise<APILogEntry[]>;
-    create(data: Optional<APILogEntry>): Promise<APILogEntry>;
-    createMany(data: Optional<APILogEntry>[]): Promise<APILogEntry[]>;
-    set(data: APILogEntry | APILogEntry[]): APILogEntry | Collection<string, APILogEntry>;
+    fetch(): Promise<Collection<string, LogEntry>>;
+    create(data: Optional<APILogEntry>): Promise<LogEntry>;
+    set(data: APILogEntry | APILogEntry[]): LogEntry | Collection<string, LogEntry>;
 }

package/types/rest/REST.d.ts

@@ -31,10 +31,6 @@ export declare class REST extends EventEmitter {
     constructor(options: ClientOptions);
     /** Initialize the caching sistem */
     init(): Promise<this>;
-    /**
-     * Ping the api
-     */
-    ping(): Promise<unknown>;
     /**
      * Request Data from a certain url
      * @param options

package/types/rest/Routes.d.ts

@@ -10,7 +10,7 @@ export declare const Routes: {
         delete: (guildId: string) => string;
         deleteAll: () => string;
         resource: (guildId: string, resource: string) => string;
-        resources: (guildId: string, ...resourcess: string[]) => string;
+        resources: (guildId: string, ...resources: string[]) => string;
         users: {
             create: (guildId: string) => string;
             update: (guildId: string, userId: string) => string;

package/types/structures/guild/Guild.d.ts

@@ -55,6 +55,7 @@ export declare class Guild {
     createCode(data: Optional<APICode>): Promise<this>;
     removeCode(codeId: string): Promise<this>;
     addIdToChannel(type: GuildChannelsType, id: string | string[]): Promise<this>;
+    setChannelIds(type: GuildChannelsType, ...ids: string[]): Promise<this>;
     removeIdInChannel(type: GuildChannelsType, id: string): Promise<this>;
     _start(): Promise<this>;
     _updateInternals(data: Optional<APIGuild>): this;

package/types/structures/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./guild/Guild";
+export * from "./logentry/LogEntry";
 export * from "./match/GuildMatch";
 export * from "./user/GuildUser";
 export * from "./vipmember/VipMember";

package/types/structures/logentry/LogEntry.d.ts

@@ -0,0 +1,28 @@
+import { LogManager } from "../../managers";
+import { REST } from "../../rest";
+import { APILogEntry, LogEntryTypes, Optional } from "../../types";
+import { Guild } from "../guild/Guild";
+export declare class LogEntry {
+    _id: string;
+    guild_id: string;
+    user_id: string;
+    admin_id: string;
+    object_id: string;
+    type: LogEntryTypes;
+    description: string;
+    change: string;
+    before: any;
+    after: any;
+    logs_channel_id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    manager: LogManager;
+    /** The given guild */
+    readonly guild: Guild;
+    /** The rest client */
+    readonly rest: REST;
+    constructor(data: APILogEntry, manager: LogManager);
+    fetch(): Promise<LogEntry>;
+    toJSON(): Record<string, unknown>;
+    _updateInternals(data: Optional<APILogEntry>): this;
+}

package/types/types/RestTypes.d.ts

@@ -1,3 +1,4 @@
+import { LogEntry } from "../structures";
 import { Collection } from "../structures/Collection";
 import { Guild } from "../structures/guild/Guild";
 import { GuildMatch } from "../structures/match/GuildMatch";
@@ -31,4 +32,5 @@ export interface RestEvents {
     userDelete: [GuildUser];
     userUpdate: [GuildUser];
     usersDelete: [Collection<string, GuildUser>];
+    logEntryCreate: [LogEntry, Guild];
 }

package/types/types/api/APIGuild.d.ts

@@ -21,6 +21,7 @@ export interface GuildStatus {
     logs_queues: "on" | "off";
     logs_users: "on" | "off";
     logs_managing: "on" | "off";
+    name_hidden: "on" | "off";
 }
 export interface GuildModes {
     on: string[];

package/types/types/api/APILogEntry.d.ts

@@ -1,9 +1,24 @@
+export declare enum LogEntryTypes {
+    QueueCreated = "queue_created",
+    QueueShut = "queue_shut",
+    MatchStarted = "match_started",
+    MatchUpdated = "match_updated",
+    MatchClosed = "match_closed",
+    UserUpdated = "user_updated",
+    UserManaged = "user_managed"
+}
 export interface APILogEntry {
     _id: string;
     guild_id: string;
-    type: string;
     user_id: string;
+    admin_id: string;
+    object_id: string;
+    type: LogEntryTypes;
     description: string;
+    change: string;
+    logs_channel_id: string;
+    before: any;
+    after: any;
     createdAt: Date;
     updatedAt: Date;
 }