seyfert 1.5.0 → 2.1.0

package/lib/cache/index.js

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = void 0;
+exports.Cache = exports.GuildBasedResource = exports.GuildRelatedResource = exports.BaseResource = void 0;
+const common_1 = require("../common");
 const guilds_1 = require("./resources/guilds");
 const users_1 = require("./resources/users");
 const channels_1 = require("./resources/channels");
@@ -27,9 +28,15 @@ const stickers_1 = require("./resources/stickers");
 const threads_1 = require("./resources/threads");
 const voice_states_1 = require("./resources/voice-states");
 const bans_1 = require("./resources/bans");
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");
 const overwrites_1 = require("./resources/overwrites");
 const messages_1 = require("./resources/messages");
+var base_1 = require("./resources/default/base");
+Object.defineProperty(exports, "BaseResource", { enumerable: true, get: function () { return base_1.BaseResource; } });
+var guild_related_1 = require("./resources/default/guild-related");
+Object.defineProperty(exports, "GuildRelatedResource", { enumerable: true, get: function () { return guild_related_1.GuildRelatedResource; } });
+var guild_based_1 = require("./resources/default/guild-based");
+Object.defineProperty(exports, "GuildBasedResource", { enumerable: true, get: function () { return guild_based_1.GuildBasedResource; } });
 __exportStar(require("./adapters/index"), exports);
 class Cache {
     intents;
@@ -52,55 +59,60 @@ class Cache {
     stageInstances;
     messages;
     bans;
-    constructor(intents, adapter, disabledCache = [], client) {
+    __logger__;
+    constructor(intents, adapter, disabledCache = {}, client) {
         this.intents = intents;
         this.adapter = adapter;
         this.disabledCache = disabledCache;
         // non-guild based
-        if (!this.disabledCache.includes('users')) {
+        if (!this.disabledCache.users) {
             this.users = new users_1.Users(this, client);
         }
-        if (!this.disabledCache.includes('guilds')) {
+        if (!this.disabledCache.guilds) {
             this.guilds = new guilds_1.Guilds(this, client);
         }
         // guild related
-        if (!this.disabledCache.includes('members')) {
+        if (!this.disabledCache.members) {
             this.members = new members_1.Members(this, client);
         }
-        if (!this.disabledCache.includes('voiceStates')) {
+        if (!this.disabledCache.voiceStates) {
             this.voiceStates = new voice_states_1.VoiceStates(this, client);
         }
         // guild based
-        if (!this.disabledCache.includes('roles')) {
+        if (!this.disabledCache.roles) {
             this.roles = new roles_1.Roles(this, client);
         }
-        if (!this.disabledCache.includes('overwrites')) {
+        if (!this.disabledCache.overwrites) {
             this.overwrites = new overwrites_1.Overwrites(this, client);
         }
-        if (!this.disabledCache.includes('channels')) {
+        if (!this.disabledCache.channels) {
             this.channels = new channels_1.Channels(this, client);
         }
-        if (!this.disabledCache.includes('emojis')) {
+        if (!this.disabledCache.emojis) {
             this.emojis = new emojis_1.Emojis(this, client);
         }
-        if (!this.disabledCache.includes('stickers')) {
+        if (!this.disabledCache.stickers) {
             this.stickers = new stickers_1.Stickers(this, client);
         }
-        if (!this.disabledCache.includes('presences')) {
+        if (!this.disabledCache.presences) {
             this.presences = new presence_1.Presences(this, client);
         }
-        if (!this.disabledCache.includes('threads')) {
+        if (!this.disabledCache.threads) {
             this.threads = new threads_1.Threads(this, client);
         }
-        if (!this.disabledCache.includes('stageInstances')) {
+        if (!this.disabledCache.stageInstances) {
             this.stageInstances = new stage_instances_1.StageInstances(this, client);
         }
-        if (!this.disabledCache.includes('messages')) {
+        if (!this.disabledCache.messages) {
             this.messages = new messages_1.Messages(this, client);
         }
-        if (!this.disabledCache.includes('bans')) {
+        if (!this.disabledCache.bans) {
             this.bans = new bans_1.Bans(this, client);
         }
+        if (this.disabledCache.onPacket) {
+            //@ts-expect-error
+            this.onPacket = () => { };
+        }
     }
     /** @internal */
     __setClient(client) {
@@ -124,7 +136,7 @@ class Cache {
     }
     // internal use ./structures
     hasIntent(intent) {
-        return (this.intents & v10_1.GatewayIntentBits[intent]) === v10_1.GatewayIntentBits[intent];
+        return (this.intents & types_1.GatewayIntentBits[intent]) === types_1.GatewayIntentBits[intent];
     }
     get hasGuildsIntent() {
         return this.hasIntent('Guilds');
@@ -274,7 +286,7 @@ class Cache {
             }
         }
         await this.adapter.bulkAddToRelationShip(relationshipsData);
-        await this.adapter.patch(false, allData);
+        await this.adapter.bulkPatch(false, allData);
     }
     async bulkSet(keys) {
         const allData = [];
@@ -289,7 +301,6 @@ class Cache {
                 case 'stageInstances':
                 case 'emojis':
                 case 'overwrites':
-                case 'bans':
                 case 'messages':
                     {
                         if (!this[type]?.filter(data, id, guildId))
@@ -308,6 +319,7 @@ class Cache {
                         allData.push([this[type].hashId(id), this[type].parse(data, id, guildId)]);
                     }
                     break;
+                case 'bans':
                 case 'voiceStates':
                 case 'members':
                     {
@@ -346,7 +358,7 @@ class Cache {
             }
         }
         await this.adapter.bulkAddToRelationShip(relationshipsData);
-        await this.adapter.set(allData);
+        await this.adapter.bulkSet(allData);
     }
     async onPacket(event) {
         switch (event.t) {
@@ -373,7 +385,7 @@ class Cache {
                         await this.overwrites?.set(event.d.id, event.d.guild_id, event.d.permission_overwrites);
                     break;
                 }
-                if (event.d.type === v10_1.ChannelType.DM) {
+                if (event.d.type === types_1.ChannelType.DM) {
                     await this.channels?.set(event.d.recipients[0]?.id, '@me', event.d);
                     break;
                 }
@@ -457,5 +469,299 @@ class Cache {
                 break;
         }
     }
+    async testAdapter() {
+        this.__logger__ ??= new common_1.Logger({
+            name: '[CACHE]',
+        });
+        await this.adapter.flush();
+        // this method will only check the cache for `users`, `members` y `channels`
+        // likewise these have the three types of resources (GuildRelatedResource, GuildBasedResource, BaseResource)
+        // will also check `overwrites`, since the latter stores an array not as an object but as data.
+        await this.testUsersAndMembers();
+        await this.testChannelsAndOverwrites();
+        this.__logger__.info('The adapter seems to work properly');
+        this.__logger__.debug('Flushing adapter');
+        delete this.__logger__;
+        await this.adapter.flush();
+    }
+    async testUsersAndMembers() {
+        if (!this.users)
+            throw new Error('Users cache disabled, you should enable it for this.');
+        if (!this.members)
+            throw new Error('Members cache disabled, you should enable it for this.');
+        function createUser(name) {
+            return {
+                avatar: 'xdxd',
+                discriminator: '0',
+                global_name: name,
+                id: `${Math.random()}`.slice(2),
+                username: `@seyfert/${name}`,
+            };
+        }
+        function createMember(name) {
+            return {
+                banner: null,
+                avatar: 'xdxd',
+                deaf: !false,
+                flags: types_1.GuildMemberFlags.StartedHomeActions,
+                joined_at: new Date().toISOString(),
+                mute: !true,
+                roles: ['111111111111'],
+                user: createUser(name),
+            };
+        }
+        const users = [
+            createUser('witherking_'),
+            createUser('vanecia'),
+            createUser('socram'),
+            createUser('free'),
+            createUser('justevil'),
+            createUser('nobody'),
+            createUser('aaron'),
+            createUser('simxnet'),
+            createUser('yuzu'),
+            createUser('vyrek'),
+            createUser('marcrock'),
+        ];
+        for (const user of users) {
+            await this.users.set(user.id, user);
+        }
+        let count = 0;
+        if ((await this.users.values()).length !== users.length)
+            throw new Error('users.values() is not of the expected size.');
+        if ((await this.users.count()) !== users.length)
+            throw new Error('users.count() is not of the expected amount');
+        for (const user of users) {
+            const cache = await this.users.raw(user.id);
+            if (!cache)
+                throw new Error(`users.raw(${user.id}) has returned undefined!!!!!!`);
+            if (cache.username !== user.username)
+                throw new Error(`users.raw(${user.id}).username is not of the expected value!!!!! (cache (${cache.username})) (expected value: (${user.username}))`);
+            if (cache.id !== user.id)
+                throw new Error(`users.raw(${user.id}).id is not of the expected value!!!!!! (cache (${cache.id})) (expected value: (${user.id}))`);
+            await this.users.remove(user.id);
+            if ((await this.users.count()) !== users.length - ++count)
+                throw new Error(`users.count() should be ${users.length - count}!! please check your remove method`);
+        }
+        this.__logger__.info('the user cache seems to be alright.');
+        this.__logger__.debug('Flushing adapter to clear users cache.');
+        await this.adapter.flush();
+        // unexpected error message
+        if ((await this.users.count()) !== 0)
+            throw new Error('users.count() should be 0!! please check your flush method');
+        const guildMembers = {
+            '852531635252494346': [
+                createMember("witherking_'s member"),
+                createMember("vanecia's member"),
+                createMember("nobody's member"),
+            ],
+            '1003825077969764412': [
+                createMember("free's member"),
+                createMember("socram's member"),
+                createMember("marcrock's member"),
+                createMember("justevil's member"),
+                createMember("vyrek's member"),
+            ],
+            '876711213126520882': [
+                createMember("aaron's member"),
+                createMember("simxnet's member"),
+                createMember("yuzu's member"),
+            ],
+        };
+        for (const guildId in guildMembers) {
+            const members = guildMembers[guildId];
+            for (const member of members) {
+                await this.members.set(member.user.id, guildId, member);
+            }
+            if ((await this.members.values(guildId)).length !== members.length)
+                throw new Error('members.values(guildId) is not of the expected size.');
+            if ((await this.members.count(guildId)) !== members.length)
+                throw new Error('members.count(guildId) is not of the expected amount');
+            for (const member of members) {
+                const cache = await this.members.raw(member.user.id, guildId);
+                if (!cache)
+                    throw new Error(`members.raw(${member.user.id}, ${guildId}) has returned undefined.`);
+                if (cache.roles[0] !== member.roles[0])
+                    throw new Error(`members.raw(${member.user.id}, ${guildId}).roles[0] is not the expected value: ${member.roles[0]} (cache: ${cache.roles[0]})`);
+                if (cache.user.username !== member.user.username)
+                    throw new Error(`members.raw(${member.user.id}, ${guildId}).user.username is not the expected value!!!!!! (cache (${cache.user.username})) (expected value: (${member.user.username}))`);
+                if (cache.user.id !== member.user.id)
+                    throw new Error(`members.raw(${member.user.id}, ${guildId}).user.id is not the expected value!!!!!! (cache (${cache.user.id})) (expected value: (${member.user.id}))`);
+            }
+        }
+        if ((await this.members.values('*')).length !== Object.values(guildMembers).flat().length)
+            throw new Error('members.values(*) is not of the expected size');
+        if ((await this.members.count('*')) !== Object.values(guildMembers).flat().length)
+            throw new Error('the global amount of members.count(*) is not the expected amount');
+        count = 0;
+        for (const guildId in guildMembers) {
+            const members = guildMembers[guildId];
+            for (const member of members) {
+                await this.members.remove(member.user.id, guildId);
+                if ((await this.members.count(guildId)) !== members.length - ++count)
+                    throw new Error(`members.count(${guildId}) should be ${members.length - count}!! please check your remove method`);
+            }
+            count = 0;
+        }
+        await this.adapter.flush();
+        // unexpected error message
+        if ((await this.users.count()) !== 0)
+            throw new Error('users.count() should be zero!! please check your flush method');
+        // unexpected error message
+        if ((await this.members.count('*')) !== 0)
+            throw new Error("members.count('*') should be zero!! please check your flush method");
+        this.__logger__.info('the member cache seems to be alright.');
+    }
+    async testChannelsAndOverwrites() {
+        if (!this.channels)
+            throw new Error('Channels cache disabled, you should enable it for this.');
+        if (!this.overwrites)
+            throw new Error('Overwrites cache disabled, you should enable it for this.');
+        function createChannel(name) {
+            return {
+                id: `${Math.random()}`.slice(2),
+                name,
+                type: types_1.ChannelType.GuildText,
+                position: Math.random() > 0.5 ? 1 : 0,
+            };
+        }
+        function createOverwrites(name) {
+            const channel_id = `${Math.random()}`.slice(2);
+            return [
+                {
+                    id: name,
+                    allow: '8',
+                    deny: '2',
+                    type: types_1.OverwriteType.Role,
+                    channel_id,
+                },
+                {
+                    id: `${name}-2`,
+                    allow: '8',
+                    deny: '2',
+                    type: types_1.OverwriteType.Role,
+                    channel_id,
+                },
+            ];
+        }
+        const guildChannels = {
+            '852531635252494346': [
+                createChannel("witherking_'s channel"),
+                createChannel("vanecia's channel"),
+                createChannel("nobody's channel"),
+            ],
+            '1003825077969764412': [
+                createChannel("free's channel"),
+                createChannel("socram's channel"),
+                createChannel("marcrock's channel"),
+                createChannel("justevil's channel"),
+                createChannel("vyrek's channel"),
+            ],
+            '876711213126520882': [
+                createChannel("aaron's channel"),
+                createChannel("simxnet's channel"),
+                createChannel("yuzu's channel"),
+            ],
+        };
+        for (const guildId in guildChannels) {
+            const channels = guildChannels[guildId];
+            for (const channel of channels) {
+                await this.channels.set(channel.id, guildId, channel);
+            }
+            if ((await this.channels.values(guildId)).length !== channels.length)
+                throw new Error('channels.values(guildId) is not of the expected size');
+            if ((await this.channels.count(guildId)) !== channels.length)
+                throw new Error('channels.count(guildId) is not of the expected amount');
+            for (const channel of channels) {
+                const cache = await this.channels.raw(channel.id);
+                if (!cache)
+                    throw new Error(`channels.raw(${channel.id}) has returned undefined!!!!!!`);
+                if (cache.type !== types_1.ChannelType.GuildText)
+                    throw new Error(`channels.raw(${channel.id}).type is not of the expected type: ${channel.type}!!!!!!!! (mismatched type: ${cache.type})`);
+                if (cache.name !== channel.name)
+                    throw new Error(`channels.raw(${channel.id}).name is not the expected value!!!!!! (cache (${cache.name})) (expected value: (${channel.name}))`);
+                if (cache.id !== channel.id)
+                    throw new Error(`channels.raw(${channel.id}).id is not the expected value!!!!!! (cache (${cache.id})) (expected value: (${channel.id}))`);
+            }
+        }
+        if ((await this.channels.values('*')).length !== Object.values(guildChannels).flat().length)
+            throw new Error('channels.values(*) is not of the expected size');
+        if ((await this.channels.count('*')) !== Object.values(guildChannels).flat().length)
+            throw new Error('channels.count(*) is not of the expected amount');
+        let count = 0;
+        for (const guildId in guildChannels) {
+            const channels = guildChannels[guildId];
+            for (const channel of channels) {
+                await this.channels.remove(channel.id, guildId);
+                if ((await this.channels.count(guildId)) !== channels.length - ++count)
+                    throw new Error(`channels.count(${guildId}) should be ${channels.length - count}!! please check your remove method`);
+            }
+            count = 0;
+        }
+        // unexpected error message
+        if ((await this.channels.count('*')) !== 0)
+            throw new Error(`channels.count('*') should be zero!! please check your remove method`);
+        this.__logger__.info('the channel cache seems to be alright');
+        const guildOverwrites = {
+            '852531635252494346': [
+                createOverwrites("witherking_'s channel"),
+                createOverwrites("vanecia's channel"),
+                createOverwrites("nobody's channel"),
+            ],
+            '1003825077969764412': [
+                createOverwrites("free's channel"),
+                createOverwrites("socram's channel"),
+                createOverwrites("marcrock's channel"),
+                createOverwrites("justevil's channel"),
+                createOverwrites("vyrek's channel"),
+            ],
+            '876711213126520882': [
+                createOverwrites("aaron's channel"),
+                createOverwrites("simxnet's channel"),
+                createOverwrites("yuzu's channel"),
+            ],
+        };
+        for (const guildId in guildOverwrites) {
+            const bulkOverwrites = guildOverwrites[guildId];
+            for (const overwrites of bulkOverwrites) {
+                await this.overwrites.set(overwrites[0].channel_id, guildId, overwrites);
+            }
+            if ((await this.overwrites.values(guildId)).length !== bulkOverwrites.length)
+                throw new Error('overwrites.values(channelId) is not of the expected size');
+            if ((await this.overwrites.count(guildId)) !== bulkOverwrites.length)
+                throw new Error('overwrites.count(channelId) is not of the expected amount');
+            for (const overwrites of bulkOverwrites) {
+                const cache = await this.overwrites.raw(overwrites[0].channel_id);
+                if (!cache)
+                    throw new Error(`overwrites.raw(${overwrites[0].channel_id}) has returned undefined!!!!!!`);
+                if (cache.length !== overwrites.length)
+                    throw new Error(`overwrites.raw(${overwrites[0].channel_id}).length is not of the expected length!!!!!! (cache (${cache.length})) (expected value: (${overwrites.length}))`);
+                for (const overwrite of overwrites) {
+                    if (!cache.some(x => {
+                        return (x.allow === overwrite.allow &&
+                            x.deny === overwrite.deny &&
+                            x.guild_id === guildId &&
+                            x.id === overwrite.id &&
+                            x.type === overwrite.type);
+                    }))
+                        throw new Error("cache wasn't found in the overwrites cache");
+                }
+            }
+        }
+        count = 0;
+        for (const guildId in guildOverwrites) {
+            const bulkOverwrites = guildOverwrites[guildId];
+            for (const overwrites of bulkOverwrites) {
+                await this.overwrites.remove(overwrites[0].channel_id, guildId);
+                if ((await this.overwrites.count(guildId)) !== bulkOverwrites.length - ++count)
+                    throw new Error(`overwrites.count(${guildId}) should be ${overwrites.length - count}!! please check your remove method`);
+            }
+            count = 0;
+        }
+        // unexpected error message
+        if ((await this.overwrites.count('*')) !== 0)
+            throw new Error(`overwrites.count('*') should be zero!! please check your remove method`);
+        this.__logger__.info('the overwrites cache seems to be alright.');
+    }
 }
 exports.Cache = Cache;

package/lib/cache/resources/bans.d.ts

@@ -1,12 +1,15 @@
-import type { APIBan } from 'discord-api-types/v10';
+import type { APIBan, GatewayGuildBanModifyDispatchData } from '../../types';
 import type { ReturnCache } from '../..';
 import { GuildBasedResource } from './default/guild-based';
-import { GuildBan } from '../../structures/GuildBan';
-export declare class Bans extends GuildBasedResource {
+import { type GuildBanStructure } from '../../client/transformers';
+export declare class Bans extends GuildBasedResource<any, GatewayGuildBanModifyDispatchData | APIBan> {
     namespace: string;
     filter(data: APIBan, id: string, guild_id: string): boolean;
     parse(data: any, key: string, guild_id: string): any;
-    get(id: string, guild: string): ReturnCache<GuildBan | undefined>;
-    bulk(ids: string[], guild: string): ReturnCache<GuildBan[]>;
-    values(guild: string): ReturnCache<GuildBan[]>;
+    get(id: string, guild: string): ReturnCache<GuildBanStructure | undefined>;
+    raw(id: string, guild: string): ReturnCache<Omit<GatewayGuildBanModifyDispatchData | APIBan, 'user'> | undefined>;
+    bulk(ids: string[], guild: string): ReturnCache<GuildBanStructure[]>;
+    bulkRaw(ids: string[], guild: string): ReturnCache<Omit<GatewayGuildBanModifyDispatchData | APIBan, 'user'>[]>;
+    values(guild: string): ReturnCache<GuildBanStructure[]>;
+    valuesRaw(guild: string): ReturnCache<Omit<GatewayGuildBanModifyDispatchData | APIBan, 'user'>[]>;
 }

package/lib/cache/resources/bans.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bans = void 0;
 const common_1 = require("../../common");
 const guild_based_1 = require("./default/guild-based");
-const GuildBan_1 = require("../../structures/GuildBan");
+const transformers_1 = require("../../client/transformers");
 class Bans extends guild_based_1.GuildBasedResource {
     namespace = 'ban';
     //@ts-expect-error
@@ -15,21 +15,30 @@ class Bans extends guild_based_1.GuildBasedResource {
         return rest;
     }
     get(id, guild) {
-        return (0, common_1.fakePromise)(super.get(id, guild)).then(rawBan => rawBan ? new GuildBan_1.GuildBan(this.client, rawBan, guild) : undefined);
+        return (0, common_1.fakePromise)(super.get(id, guild)).then(rawBan => rawBan ? transformers_1.Transformers.GuildBan(this.client, rawBan, guild) : undefined);
+    }
+    raw(id, guild) {
+        return super.get(id, guild);
     }
     bulk(ids, guild) {
         return (0, common_1.fakePromise)(super.bulk(ids, guild)).then(bans => bans
             .map(rawBan => {
-            return rawBan ? new GuildBan_1.GuildBan(this.client, rawBan, guild) : undefined;
+            return rawBan ? transformers_1.Transformers.GuildBan(this.client, rawBan, guild) : undefined;
         })
             .filter(Boolean));
     }
+    bulkRaw(ids, guild) {
+        return super.bulk(ids, guild);
+    }
     values(guild) {
         return (0, common_1.fakePromise)(super.values(guild)).then(bans => bans
             .map(rawBan => {
-            return rawBan ? new GuildBan_1.GuildBan(this.client, rawBan, guild) : undefined;
+            return rawBan ? transformers_1.Transformers.GuildBan(this.client, rawBan, guild) : undefined;
         })
             .filter(Boolean));
     }
+    valuesRaw(guild) {
+        return super.values(guild);
+    }
 }
 exports.Bans = Bans;

package/lib/cache/resources/channels.d.ts

@@ -1,12 +1,14 @@
-import type { APIChannel } from 'discord-api-types/v10';
-import type { AllChannels } from '../../structures';
-import channelFrom from '../../structures/channels';
+import type { APIChannel } from '../../types';
+import { channelFrom, type AllChannels } from '../../structures';
 import type { ReturnCache } from '../index';
 import { GuildRelatedResource } from './default/guild-related';
-export declare class Channels extends GuildRelatedResource {
+export declare class Channels extends GuildRelatedResource<any, APIChannel> {
     namespace: string;
     parse(data: APIChannel, id: string, guild_id: string): any;
     get(id: string): ReturnCache<AllChannels | undefined>;
+    raw(id: string): ReturnCache<Omit<APIChannel, 'permission_overwrites'> | undefined>;
     bulk(ids: string[]): ReturnCache<ReturnType<typeof channelFrom>[]>;
+    bulkRaw(ids: string[]): ReturnCache<Omit<APIChannel, 'permission_overwrites'>[]>;
     values(guild: string): ReturnCache<ReturnType<typeof channelFrom>[]>;
+    valuesRaw(guild: string): ReturnCache<Omit<APIChannel, 'permission_overwrites'>[]>;
 }

package/lib/cache/resources/channels.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channels = void 0;
 const common_1 = require("../../common");
-const channels_1 = __importDefault(require("../../structures/channels"));
+const structures_1 = require("../../structures");
 const guild_related_1 = require("./default/guild-related");
 class Channels extends guild_related_1.GuildRelatedResource {
     namespace = 'channel';
@@ -14,13 +11,22 @@ class Channels extends guild_related_1.GuildRelatedResource {
         return rest;
     }
     get(id) {
-        return (0, common_1.fakePromise)(super.get(id)).then(rawChannel => rawChannel ? (0, channels_1.default)(rawChannel, this.client) : undefined);
+        return (0, common_1.fakePromise)(super.get(id)).then(rawChannel => rawChannel ? (0, structures_1.channelFrom)(rawChannel, this.client) : undefined);
+    }
+    raw(id) {
+        return super.get(id);
     }
     bulk(ids) {
-        return (0, common_1.fakePromise)(super.bulk(ids)).then(channels => channels.map(rawChannel => (0, channels_1.default)(rawChannel, this.client)));
+        return (0, common_1.fakePromise)(super.bulk(ids)).then(channels => channels.map(rawChannel => (0, structures_1.channelFrom)(rawChannel, this.client)));
+    }
+    bulkRaw(ids) {
+        return super.bulk(ids);
     }
     values(guild) {
-        return (0, common_1.fakePromise)(super.values(guild)).then(channels => channels.map(rawChannel => (0, channels_1.default)(rawChannel, this.client)));
+        return (0, common_1.fakePromise)(super.values(guild)).then(channels => channels.map(rawChannel => (0, structures_1.channelFrom)(rawChannel, this.client)));
+    }
+    valuesRaw(guild) {
+        return super.values(guild);
     }
 }
 exports.Channels = Channels;

package/lib/cache/resources/default/base.d.ts

@@ -1,7 +1,7 @@
-import type { GatewayIntentBits } from 'discord-api-types/v10';
 import type { UsingClient } from '../../../commands';
+import type { GatewayIntentBits } from '../../../types';
 import type { Cache, ReturnCache } from '../../index';
-export declare class BaseResource<T = any> {
+export declare class BaseResource<T = any, S = any> {
     protected cache: Cache;
     client: UsingClient;
     namespace: string;
@@ -9,16 +9,16 @@ export declare class BaseResource<T = any> {
     filter(data: any, id: string): boolean;
     get adapter(): import("../../index").Adapter;
     removeIfNI(intent: keyof typeof GatewayIntentBits, id: string): import("../../../common").Awaitable<void>;
-    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, data: any): import("../../../common").Awaitable<void>;
+    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, data: S): import("../../../common").Awaitable<void>;
     get(id: string): ReturnCache<T | undefined>;
     bulk(ids: string[]): ReturnCache<T[]>;
-    set(id: string, data: any): import("../../../common").Awaitable<void>;
-    patch(id: string, data: any): import("../../../common").Awaitable<void>;
+    set(id: string, data: S): import("../../../common").Awaitable<void>;
+    patch(id: string, data: S): import("../../../common").Awaitable<void>;
     remove(id: string): import("../../../common").Awaitable<void>;
     keys(): ReturnCache<string[]>;
     values(): ReturnCache<T[]>;
-    count(): import("../../../common").Awaitable<number>;
-    contains(id: string): import("../../../common").Awaitable<boolean>;
+    count(): ReturnCache<number>;
+    contains(id: string): ReturnCache<boolean>;
     getToRelationship(): import("../../../common").Awaitable<string[]>;
     addToRelationship(id: string | string[]): import("../../../common").Awaitable<void>;
     removeToRelationship(id: string | string[]): import("../../../common").Awaitable<void>;

package/lib/cache/resources/default/base.js

@@ -38,7 +38,7 @@ class BaseResource {
         return this.adapter.get(this.hashId(id));
     }
     bulk(ids) {
-        return (0, common_1.fakePromise)(this.adapter.get(ids.map(id => this.hashId(id)))).then(x => x.filter(y => y));
+        return (0, common_1.fakePromise)(this.adapter.bulkGet(ids.map(id => this.hashId(id)))).then(x => x.filter(y => y));
     }
     set(id, data) {
         if (!this.filter(data, id))
@@ -75,7 +75,7 @@ class BaseResource {
         return this.adapter.removeToRelationship(this.namespace, id);
     }
     hashId(id) {
-        return `${this.namespace}.${id}`;
+        return id.startsWith(this.namespace) ? id : `${this.namespace}.${id}`;
     }
 }
 exports.BaseResource = BaseResource;

package/lib/cache/resources/default/guild-based.d.ts

@@ -1,7 +1,7 @@
-import type { GatewayIntentBits } from 'discord-api-types/v10';
 import type { UsingClient } from '../../../commands';
+import type { GatewayIntentBits } from '../../../types';
 import type { Cache, ReturnCache } from '../../index';
-export declare class GuildBasedResource<T = any> {
+export declare class GuildBasedResource<T = any, S = any> {
     protected cache: Cache;
     client: UsingClient;
     namespace: string;
@@ -10,16 +10,16 @@ export declare class GuildBasedResource<T = any> {
     parse(data: any, id: string, guild_id: string): any;
     get adapter(): import("../../index").Adapter;
     removeIfNI(intent: keyof typeof GatewayIntentBits, id: string | string[], guildId: string): import("../../../common").Awaitable<void>;
-    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, guildId: string, data: any): void;
+    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, guildId: string, data: S): void;
     get(id: string, guild: string): ReturnCache<(T & {
         guild_id: string;
     }) | undefined>;
     bulk(ids: string[], guild: string): ReturnCache<(T & {
         guild_id: string;
     })[]>;
-    set(__keys: string, guild: string, data: any): ReturnCache<void>;
-    set(__keys: [string, any][], guild: string): ReturnCache<void>;
-    patch(__keys: string, guild: string, data: any): ReturnCache<void>;
+    set(__keys: string, guild: string, data: S): ReturnCache<void>;
+    set(__keys: [string, S][], guild: string): ReturnCache<void>;
+    patch(__keys: string, guild: string, data: S): ReturnCache<void>;
     patch(__keys: [string, any][], guild: string): ReturnCache<void>;
     remove(id: string | string[], guild: string): import("../../../common").Awaitable<void>;
     keys(guild: string): ReturnCache<string[]>;