seyfert 1.4.0 → 2.0.0

package/lib/cache/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = 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");
@@ -26,7 +27,8 @@ const stage_instances_1 = require("./resources/stage-instances");
 const stickers_1 = require("./resources/stickers");
 const threads_1 = require("./resources/threads");
 const voice_states_1 = require("./resources/voice-states");
-const v10_1 = require("discord-api-types/v10");
+const bans_1 = require("./resources/bans");
+const types_1 = require("../types");
 const overwrites_1 = require("./resources/overwrites");
 const messages_1 = require("./resources/messages");
 __exportStar(require("./adapters/index"), exports);
@@ -50,52 +52,59 @@ class Cache {
     presences;
     stageInstances;
     messages;
-    constructor(intents, adapter, disabledCache = [], client) {
+    bans;
+    __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.bans) {
+            this.bans = new bans_1.Bans(this, client);
+        }
+        if (this.disabledCache.onPacket)
+            delete this.onPacket;
     }
     /** @internal */
     __setClient(client) {
@@ -112,13 +121,14 @@ class Cache {
         this.threads?.__setClient(client);
         this.stageInstances?.__setClient(client);
         this.messages?.__setClient(client);
+        this.bans?.__setClient(client);
     }
     flush() {
         return this.adapter.flush();
     }
     // 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');
@@ -144,6 +154,9 @@ class Cache {
     get hasDirectMessages() {
         return this.hasIntent('DirectMessages');
     }
+    get hasBansIntent() {
+        return this.hasIntent('GuildBans');
+    }
     async bulkGet(keys) {
         const allData = {};
         for (const [type, id, guildId] of keys) {
@@ -167,6 +180,7 @@ class Cache {
                 case 'users':
                 case 'guilds':
                 case 'overwrites':
+                case 'bans':
                 case 'messages':
                     {
                         if (!allData[type]) {
@@ -207,6 +221,7 @@ class Cache {
                 case 'stageInstances':
                 case 'emojis':
                 case 'overwrites':
+                case 'bans':
                 case 'messages':
                     {
                         if (!this[type]?.filter(data, id, guildId))
@@ -263,7 +278,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 = [];
@@ -296,6 +311,7 @@ class Cache {
                         allData.push([this[type].hashId(id), this[type].parse(data, id, guildId)]);
                     }
                     break;
+                case 'bans':
                 case 'voiceStates':
                 case 'members':
                     {
@@ -334,7 +350,7 @@ class Cache {
             }
         }
         await this.adapter.bulkAddToRelationShip(relationshipsData);
-        await this.adapter.set(allData);
+        await this.adapter.bulkSet(allData);
     }
     async onPacket(event) {
         switch (event.t) {
@@ -361,7 +377,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;
                 }
@@ -376,6 +392,12 @@ class Cache {
             case 'GUILD_ROLE_DELETE':
                 await this.roles?.remove(event.d.role_id, event.d.guild_id);
                 break;
+            case 'GUILD_BAN_ADD':
+                await this.bans?.set(event.d.user.id, event.d.guild_id, event.d);
+                break;
+            case 'GUILD_BAN_REMOVE':
+                await this.bans?.remove(event.d.user.id, event.d.guild_id);
+                break;
             case 'GUILD_EMOJIS_UPDATE':
                 await this.emojis?.remove(await this.emojis?.keys(event.d.guild_id), event.d.guild_id);
                 await this.emojis?.set(event.d.emojis.map(x => [x.id, x]), event.d.guild_id);
@@ -439,5 +461,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

@@ -0,0 +1,15 @@
+import type { APIBan, GatewayGuildBanModifyDispatchData } from '../../types';
+import type { ReturnCache } from '../..';
+import { GuildBasedResource } from './default/guild-based';
+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<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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bans = void 0;
+const common_1 = require("../../common");
+const guild_based_1 = require("./default/guild-based");
+const transformers_1 = require("../../client/transformers");
+class Bans extends guild_based_1.GuildBasedResource {
+    namespace = 'ban';
+    //@ts-expect-error
+    filter(data, id, guild_id) {
+        return true;
+    }
+    parse(data, key, guild_id) {
+        const { user, ...rest } = super.parse(data, data.user?.id ?? key, guild_id);
+        return rest;
+    }
+    get(id, guild) {
+        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 ? 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 ? 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;