seyfert 1.5.0 → 2.0.0

package/lib/cache/adapters/limited.d.ts

@@ -5,41 +5,46 @@ export interface ResourceLimitedMemoryAdapter {
     expire?: number;
     limit?: number;
 }
-export interface LimitedMemoryAdapterOptions {
+export interface LimitedMemoryAdapterOptions<T> {
     default?: ResourceLimitedMemoryAdapter;
     guild?: ResourceLimitedMemoryAdapter;
     user?: ResourceLimitedMemoryAdapter;
+    ban?: ResourceLimitedMemoryAdapter;
     member?: ResourceLimitedMemoryAdapter;
     voice_state?: ResourceLimitedMemoryAdapter;
     channel?: ResourceLimitedMemoryAdapter;
     emoji?: ResourceLimitedMemoryAdapter;
-    overwrite?: ResourceLimitedMemoryAdapter;
     presence?: ResourceLimitedMemoryAdapter;
     role?: ResourceLimitedMemoryAdapter;
     stage_instance?: ResourceLimitedMemoryAdapter;
     sticker?: ResourceLimitedMemoryAdapter;
     thread?: ResourceLimitedMemoryAdapter;
+    overwrite?: ResourceLimitedMemoryAdapter;
+    message?: ResourceLimitedMemoryAdapter;
+    encode?(data: any): T;
+    decode?(data: T): unknown;
 }
-export declare class LimitedMemoryAdapter implements Adapter {
+export declare class LimitedMemoryAdapter<T> implements Adapter {
     isAsync: boolean;
-    readonly storage: Map<string, LimitedCollection<string, string>>;
+    readonly storage: Map<string, LimitedCollection<string, T>>;
     readonly relationships: Map<string, Map<string, string[]>>;
-    options: MakeRequired<LimitedMemoryAdapterOptions, 'default'>;
-    constructor(options: LimitedMemoryAdapterOptions);
+    options: MakeRequired<LimitedMemoryAdapterOptions<T>, 'default' | 'encode' | 'decode'>;
+    constructor(options?: LimitedMemoryAdapterOptions<T>);
+    start(): void;
     scan(query: string, keys?: false): any[];
     scan(query: string, keys: true): string[];
-    get(keys: string): any;
-    get(keys: string[]): any[];
+    bulkGet(keys: string[]): unknown[];
+    get(keys: string): unknown;
     private __set;
+    bulkSet(keys: [string, any][]): void;
     set(keys: string, data: any): void;
-    set(keys: [string, any][]): void;
+    bulkPatch(updateOnly: boolean, keys: [string, any][]): void;
     patch(updateOnly: boolean, keys: string, data: any): void;
-    patch(updateOnly: boolean, keys: [string, any][]): void;
     values(to: string): any[];
     keys(to: string): string[];
     count(to: string): number;
-    remove(keys: string): void;
-    remove(keys: string[]): void;
+    bulkRemove(keys: string[]): void;
+    remove(key: string): void;
     flush(): void;
     contains(to: string, keys: string): boolean;
     getToRelationship(to: string): string[];

package/lib/cache/adapters/limited.js

@@ -14,50 +14,60 @@ class LimitedMemoryAdapter {
                 expire: undefined,
                 limit: Number.POSITIVE_INFINITY,
             },
+            encode(data) {
+                return JSON.stringify(data);
+            },
+            decode(data) {
+                return JSON.parse(data);
+            },
         }, options);
     }
+    start() { }
     scan(query, keys = false) {
         const values = [];
         const sq = query.split('.');
         for (const iterator of [...this.storage.values()].flatMap(x => x.entries()))
             for (const [key, value] of iterator) {
                 if (key.split('.').every((value, i) => (sq[i] === '*' ? !!value : sq[i] === value))) {
-                    values.push(keys ? key : JSON.parse(value.value));
+                    values.push(keys ? key : this.options.decode(value.value));
                 }
             }
         return values;
     }
-    get(keys) {
-        if (!Array.isArray(keys)) {
-            const data = [...this.storage.values()].find(x => x.has(keys))?.get(keys);
-            return data ? JSON.parse(data) : null;
-        }
+    bulkGet(keys) {
         const iterator = [...this.storage.values()];
         return keys
             .map(key => {
             const data = iterator.find(x => x.has(key))?.get(key);
-            return data ? JSON.parse(data) : null;
+            return data ? this.options.decode(data) : null;
         })
             .filter(x => x);
     }
+    get(keys) {
+        const data = [...this.storage.values()].find(x => x.has(keys))?.get(keys);
+        return data ? this.options.decode(data) : null;
+    }
     __set(key, data) {
         const __guildId = Array.isArray(data) ? data[0].guild_id : data.guild_id;
         const namespace = `${key.split('.')[0]}${__guildId ? `.${__guildId}` : ''}`;
         const self = this;
         if (!this.storage.has(namespace)) {
             this.storage.set(namespace, new __1.LimitedCollection({
-                expire: this.options[key.split('.')[0]]?.expire ?? this.options.default.expire,
-                limit: this.options[key.split('.')[0]]?.limit ?? this.options.default.limit,
+                expire: this.options[key.split('.')[0]]
+                    ?.expire ?? this.options.default.expire,
+                limit: this.options[key.split('.')[0]]
+                    ?.limit ?? this.options.default.limit,
                 resetOnDemand: true,
                 onDelete(k) {
                     const relationshipNamespace = key.split('.')[0];
-                    const relation = self.relationships.get(relationshipNamespace);
-                    if (relation) {
+                    const existsRelation = self.relationships.has(relationshipNamespace);
+                    if (existsRelation) {
                         switch (relationshipNamespace) {
                             case 'guild':
                             case 'user':
                                 self.removeToRelationship(namespace, k.split('.')[1]);
                                 break;
+                            case 'ban':
                             case 'member':
                             case 'voice_state':
                                 {
@@ -81,35 +91,31 @@ class LimitedMemoryAdapter {
                 },
             }));
         }
-        this.storage.get(namespace).set(key, JSON.stringify(data));
+        this.storage.get(namespace).set(key, this.options.encode(data));
+    }
+    bulkSet(keys) {
+        for (const [key, value] of keys) {
+            this.__set(key, value);
+        }
     }
     set(keys, data) {
-        if (Array.isArray(keys)) {
-            for (const [key, value] of keys) {
-                this.__set(key, value);
+        this.__set(keys, data);
+    }
+    bulkPatch(updateOnly, keys) {
+        for (const [key, value] of keys) {
+            const oldData = this.get(key);
+            if (updateOnly && !oldData) {
+                continue;
             }
-        }
-        else {
-            this.__set(keys, data);
+            this.__set(key, Array.isArray(value) ? value : { ...(oldData ?? {}), ...value });
         }
     }
     patch(updateOnly, keys, data) {
-        if (Array.isArray(keys)) {
-            for (const [key, value] of keys) {
-                const oldData = this.get(key);
-                if (updateOnly && !oldData) {
-                    continue;
-                }
-                this.__set(key, Array.isArray(value) ? value : { ...(oldData ?? {}), ...value });
-            }
-        }
-        else {
-            const oldData = this.get(keys);
-            if (updateOnly && !oldData) {
-                return;
-            }
-            this.__set(keys, Array.isArray(data) ? data : { ...(oldData ?? {}), ...data });
+        const oldData = this.get(keys);
+        if (updateOnly && !oldData) {
+            return;
         }
+        this.__set(keys, Array.isArray(data) ? data : { ...(oldData ?? {}), ...data });
     }
     values(to) {
         const array = [];
@@ -128,9 +134,47 @@ class LimitedMemoryAdapter {
     count(to) {
         return this.getToRelationship(to).length;
     }
-    remove(keys) {
-        for (const i of Array.isArray(keys) ? keys : [keys]) {
-            this.storage.get(i.split('.')[0])?.delete(i);
+    bulkRemove(keys) {
+        for (const i of keys) {
+            this.remove(i);
+        }
+    }
+    remove(key) {
+        const keySplit = key.split('.');
+        const parentNamespace = keySplit.at(0);
+        switch (parentNamespace) {
+            case 'ban':
+            case 'member':
+            case 'voice_state':
+                {
+                    this.storage
+                        .get(`${parentNamespace}.${keySplit.at(1)}`)
+                        ?.delete(`${parentNamespace}.${keySplit.at(1)}.${keySplit.at(2)}`);
+                }
+                break;
+            case 'user':
+            case 'guild':
+                this.storage.get(parentNamespace)?.delete(`${parentNamespace}.${keySplit.at(1)}`);
+                break;
+            case 'channel':
+            case 'emoji':
+            case 'presence':
+            case 'role':
+            case 'stage_instance':
+            case 'sticker':
+            case 'thread':
+            case 'overwrite':
+            case 'message':
+                for (const keyStorage of this.storage.keys()) {
+                    if (keyStorage.startsWith(parentNamespace)) {
+                        const storage = this.storage.get(keyStorage);
+                        if (storage.has(key)) {
+                            storage.delete(key);
+                            break;
+                        }
+                    }
+                }
+                break;
         }
     }
     flush() {

package/lib/cache/adapters/types.d.ts

@@ -1,22 +1,21 @@
 import type { Awaitable } from '../../common';
 export interface Adapter {
     isAsync: boolean;
+    start(): Awaitable<void>;
     scan(query: string, keys?: false): Awaitable<any[]>;
     scan(query: string, keys: true): Awaitable<string[]>;
     scan(query: string, keys?: boolean): Awaitable<(any | string)[]>;
-    get(keys: string[]): Awaitable<any[]>;
+    bulkGet(keys: string[]): Awaitable<any[]>;
     get(keys: string): Awaitable<any | null>;
-    get(keys: string | string[]): Awaitable<any | null>;
-    set(keyValue: [string, any][]): Awaitable<void>;
+    bulkSet(keyValue: [string, any][]): Awaitable<void>;
     set(id: string, data: any): Awaitable<void>;
-    set(id: string | [string, any][], data?: any): Awaitable<void>;
-    patch(updateOnly: boolean, keyValue: [string, any][]): Awaitable<void>;
+    bulkPatch(updateOnly: boolean, keyValue: [string, any][]): Awaitable<void>;
     patch(updateOnly: boolean, id: string, data: any): Awaitable<void>;
-    patch(updateOnly: boolean, id: string | [string, any][], data?: any): Awaitable<void>;
     values(to: string): Awaitable<any[]>;
     keys(to: string): Awaitable<string[]>;
     count(to: string): Awaitable<number>;
-    remove(keys: string | string[]): Awaitable<void>;
+    bulkRemove(keys: string[]): Awaitable<void>;
+    remove(keys: string): Awaitable<void>;
     flush(): Awaitable<void>;
     contains(to: string, keys: string): Awaitable<boolean>;
     getToRelationship(to: string): Awaitable<string[]>;

package/lib/cache/adapters/workeradapter.d.ts

@@ -1,8 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { WorkerData } from '../../websocket';
 import type { WorkerSendCacheRequest } from '../../websocket/discord/worker';
 import type { Adapter } from './types';
@@ -14,15 +9,20 @@ export declare class WorkerAdapter implements Adapter {
         timeout: NodeJS.Timeout;
     }>;
     constructor(workerData: WorkerData);
-    postMessage(body: any): boolean | void;
+    start(): void;
+    postMessage(body: any): unknown;
     protected send(method: WorkerSendCacheRequest['method'], ...args: any[]): Promise<any>;
     scan(...rest: any[]): Promise<any>;
+    bulkGet(...rest: any[]): Promise<any>;
     get(...rest: any[]): Promise<any>;
+    bulkSet(...rest: any[]): Promise<any>;
     set(...rest: any[]): Promise<any>;
+    bulkPatch(...rest: any[]): Promise<any>;
     patch(...rest: any[]): Promise<any>;
     values(...rest: any[]): Promise<any>;
     keys(...rest: any[]): Promise<any>;
     count(...rest: any[]): Promise<any>;
+    bulkRemove(...rest: any[]): Promise<any>;
     remove(...rest: any[]): Promise<any>;
     flush(): Promise<any>;
     contains(...rest: any[]): Promise<any>;

package/lib/cache/adapters/workeradapter.js

@@ -14,6 +14,7 @@ class WorkerAdapter {
         if (worker_threads?.parentPort)
             parentPort = worker_threads.parentPort;
     }
+    start() { }
     postMessage(body) {
         if (parentPort)
             return parentPort.postMessage(body);
@@ -41,12 +42,21 @@ class WorkerAdapter {
     scan(...rest) {
         return this.send('scan', ...rest);
     }
+    bulkGet(...rest) {
+        return this.send('bulkGet', ...rest);
+    }
     get(...rest) {
         return this.send('get', ...rest);
     }
+    bulkSet(...rest) {
+        return this.send('bulkSet', ...rest);
+    }
     set(...rest) {
         return this.send('set', ...rest);
     }
+    bulkPatch(...rest) {
+        return this.send('bulkPatch', ...rest);
+    }
     patch(...rest) {
         return this.send('patch', ...rest);
     }
@@ -59,6 +69,9 @@ class WorkerAdapter {
     count(...rest) {
         return this.send('count', ...rest);
     }
+    bulkRemove(...rest) {
+        return this.send('bulkRemove', ...rest);
+    }
     remove(...rest) {
         return this.send('remove', ...rest);
     }

package/lib/cache/index.d.ts

@@ -1,4 +1,4 @@
-import type { If } from '../common';
+import { Logger, type If } from '../common';
 import type { Adapter } from './adapters';
 import { Guilds } from './resources/guilds';
 import { Users } from './resources/users';
@@ -12,7 +12,7 @@ import { Stickers } from './resources/stickers';
 import { Threads } from './resources/threads';
 import { VoiceStates } from './resources/voice-states';
 import { Bans } from './resources/bans';
-import { GatewayIntentBits, type GatewayDispatchPayload } from 'discord-api-types/v10';
+import { GatewayIntentBits, type GatewayDispatchPayload } from '../types';
 import type { InternalOptions, UsingClient } from '../commands';
 import { Overwrites } from './resources/overwrites';
 import { Messages } from './resources/messages';
@@ -23,12 +23,16 @@ export type ReturnCache<T> = If<InferAsyncCache, Promise<T>, T>;
 export type GuildBased = 'members' | 'voiceStates';
 export type GuildRelated = 'emojis' | 'roles' | 'threads' | 'channels' | 'stickers' | 'presences' | 'stageInstances' | 'overwrites' | 'messages' | 'bans';
 export type NonGuildBased = 'users' | 'guilds';
+export type SeyfertBased = 'onPacket';
 export * from './adapters/index';
 export type CachedEvents = 'READY' | 'GUILD_CREATE' | 'GUILD_UPDATE' | 'GUILD_DELETE' | 'CHANNEL_CREATE' | 'CHANNEL_UPDATE' | 'CHANNEL_DELETE' | 'GUILD_ROLE_CREATE' | 'GUILD_ROLE_UPDATE' | 'GUILD_ROLE_DELETE' | 'GUILD_BAN_ADD' | 'GUILD_BAN_REMOVE' | 'GUILD_EMOJIS_UPDATE' | 'GUILD_STICKERS_UPDATE' | 'GUILD_MEMBER_ADD' | 'GUILD_MEMBER_UPDATE' | 'GUILD_MEMBER_REMOVE' | 'MESSAGE_CREATE' | 'PRESENCE_UPDATE' | 'THREAD_DELETE' | 'THREAD_CREATE' | 'THREAD_UPDATE' | 'USER_UPDATE' | 'VOICE_STATE_UPDATE' | 'STAGE_INSTANCE_CREATE' | 'STAGE_INSTANCE_UPDATE' | 'STAGE_INSTANCE_DELETE';
+export type DisabledCache = {
+    [P in NonGuildBased | GuildBased | GuildRelated | SeyfertBased]?: boolean;
+};
 export declare class Cache {
     intents: number;
     adapter: Adapter;
-    readonly disabledCache: (NonGuildBased | GuildBased | GuildRelated)[];
+    readonly disabledCache: DisabledCache;
     users?: Users;
     guilds?: Guilds;
     members?: Members;
@@ -43,7 +47,8 @@ export declare class Cache {
     stageInstances?: StageInstances;
     messages?: Messages;
     bans?: Bans;
-    constructor(intents: number, adapter: Adapter, disabledCache?: (NonGuildBased | GuildBased | GuildRelated)[], client?: UsingClient);
+    __logger__?: Logger;
+    constructor(intents: number, adapter: Adapter, disabledCache?: DisabledCache, client?: UsingClient);
     flush(): ReturnCache<void>;
     hasIntent(intent: keyof typeof GatewayIntentBits): boolean;
     get hasGuildsIntent(): boolean;
@@ -67,19 +72,20 @@ export declare class Cache {
         roles: import("..").GuildRole[];
         emojis: import("..").GuildEmoji[];
         stickers: import("..").Sticker[];
-        channels: NonNullable<ReturnCache<import("..").AllChannels | undefined>>[];
         members: import("..").GuildMember[];
         users: import("..").User[];
+        channels: NonNullable<ReturnCache<import("..").AllChannels | undefined>>[];
+        threads: import("..").ThreadChannel[];
         messages: import("..").Message[];
-        presences: (Omit<import("discord-api-types/v10").GatewayPresenceUpdate, "user"> & {
+        presences: (Omit<import("../types").GatewayPresenceUpdate, "user"> & {
             id: string;
+            user_id: string;
         } & {
             guild_id: string;
         })[];
-        threads: import("..").ThreadChannel[];
         bans: import("../structures/GuildBan").GuildBan[];
         voiceStates: import("..").VoiceState[];
-        stageInstances: (import("discord-api-types/v10").APIStageInstance & {
+        stageInstances: (import("../types").APIStageInstance & {
             guild_id: string;
         })[];
         overwrites: {
@@ -110,5 +116,8 @@ export declare class Cache {
         string,
         string
     ])[]): Promise<void>;
-    onPacket(event: GatewayDispatchPayload): Promise<void>;
+    onPacket?(event: GatewayDispatchPayload): Promise<void>;
+    testAdapter(): Promise<void>;
+    private testUsersAndMembers;
+    private testChannelsAndOverwrites;
 }