seyfert 0.1.0

package/lib/cache/adapters/redis.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisAdapter = void 0;
+const ioredis_1 = require("ioredis");
+const common_1 = require("../../common");
+class RedisAdapter {
+    client;
+    namespace;
+    constructor(data) {
+        this.client = 'client' in data ? data.client : new ioredis_1.Redis(data.redisOptions);
+        this.namespace = data.namespace ?? 'seyfert';
+    }
+    scan(query, returnKeys = false) {
+        const match = this.buildKey(query);
+        return new Promise((r, j) => {
+            const stream = this.client.scanStream({
+                match,
+                // omit relationships
+                type: 'hash',
+            });
+            const keys = [];
+            stream
+                .on('data', resultKeys => keys.push(...resultKeys))
+                .on('end', () => (returnKeys ? r(keys.map(x => this.buildKey(x))) : r(this.get(keys))))
+                .on('error', err => j(err));
+        });
+    }
+    async get(keys) {
+        if (!Array.isArray(keys)) {
+            const value = await this.client.hgetall(this.buildKey(keys));
+            if (value) {
+                return toNormal(value);
+            }
+            return;
+        }
+        const pipeline = this.client.pipeline();
+        for (const key of keys) {
+            pipeline.hgetall(this.buildKey(key));
+        }
+        return (await pipeline.exec())?.filter(x => !!x[1]).map(x => toNormal(x[1])) ?? [];
+    }
+    async set(id, data) {
+        if (!Array.isArray(id)) {
+            await this.client.hset(this.buildKey(id), toDb(data));
+            return;
+        }
+        const pipeline = this.client.pipeline();
+        for (const [k, v] of id) {
+            pipeline.hset(this.buildKey(k), toDb(v));
+        }
+        await pipeline.exec();
+    }
+    async patch(updateOnly, id, data) {
+        if (!Array.isArray(id)) {
+            if (updateOnly) {
+                await this.client.eval(`if redis.call('exists',KEYS[1]) == 1 then redis.call('hset', KEYS[1], ${Array.from({ length: Object.keys(data).length * 2 }, (_, i) => `ARGV[${i + 1}]`)}) end`, 1, this.buildKey(id), ...(0, common_1.fastFlat)(Object.entries(toDb(data))));
+            }
+            else {
+                await this.client.hset(this.buildKey(id), toDb(data));
+            }
+            return;
+        }
+        const pipeline = this.client.pipeline();
+        for (const [k, v] of id) {
+            if (updateOnly) {
+                pipeline.eval(`if redis.call('exists',KEYS[1]) == 1 then redis.call('hset', KEYS[1], ${Array.from({ length: Object.keys(v).length * 2 }, (_, i) => `ARGV[${i + 1}]`)}) end`, 1, this.buildKey(k), ...(0, common_1.fastFlat)(Object.entries(toDb(v))));
+            }
+            else {
+                pipeline.hset(this.buildKey(k), toDb(v));
+            }
+        }
+        await pipeline.exec();
+    }
+    async values(to) {
+        const array = [];
+        const data = await this.keys(to);
+        if (data.length) {
+            const items = await this.get(data);
+            for (const item of items) {
+                if (item) {
+                    array.push(item);
+                }
+            }
+        }
+        return array;
+    }
+    async keys(to) {
+        const data = await this.getToRelationship(to);
+        return data.map(id => this.buildKey(`${to}.${id}`));
+    }
+    async count(to) {
+        return this.client.scard(`${this.buildKey(to)}:set`);
+    }
+    async remove(keys) {
+        if (!Array.isArray(keys)) {
+            await this.client.del(this.buildKey(keys));
+            return;
+        }
+        await this.client.del(...keys.map(x => this.buildKey(x)));
+    }
+    async contains(to, keys) {
+        return (await this.client.sismember(`${this.buildKey(to)}:set`, keys)) === 1;
+    }
+    async getToRelationship(to) {
+        return this.client.smembers(`${this.buildKey(to)}:set`);
+    }
+    async bulkAddToRelationShip(data) {
+        const pipeline = this.client.pipeline();
+        for (const [key, value] of Object.entries(data)) {
+            pipeline.sadd(`${this.buildKey(key)}:set`, ...value);
+        }
+        await pipeline.exec();
+    }
+    async addToRelationship(to, keys) {
+        await this.client.sadd(`${this.buildKey(to)}:set`, ...(Array.isArray(keys) ? keys : [keys]));
+    }
+    async removeToRelationship(to, keys) {
+        await this.client.srem(`${this.buildKey(to)}:set`, ...(Array.isArray(keys) ? keys : [keys]));
+    }
+    async removeRelationship(to) {
+        await this.client.del(...(Array.isArray(to) ? to.map(x => `${this.buildKey(x)}:set`) : [`${this.buildKey(to)}:set`]));
+    }
+    buildKey(key) {
+        return key.startsWith(this.namespace) ? key : `${this.namespace}:${key}`;
+    }
+}
+exports.RedisAdapter = RedisAdapter;
+const isObject = (o) => {
+    return !!o && typeof o === 'object' && !Array.isArray(o);
+};
+function toNormal(target) {
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        if (key.startsWith('O_')) {
+            result[key.slice(2)] = JSON.parse(value);
+        }
+        else if (key.startsWith('N_')) {
+            result[key.slice(2)] = Number(value);
+        }
+        else if (key.startsWith('B_')) {
+            result[key.slice(2)] = value === 'true';
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function toDb(target) {
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        switch (typeof value) {
+            case 'boolean':
+                result[`B_${key}`] = value;
+                break;
+            case 'number':
+                result[`N_${key}`] = `${value}`;
+                break;
+            case 'object':
+                if (Array.isArray(value)) {
+                    result[`O_${key}`] = JSON.stringify(value);
+                    break;
+                }
+                if (isObject(value)) {
+                    result[`O_${key}`] = JSON.stringify(value);
+                    break;
+                }
+                if (!Number.isNaN(value)) {
+                    result[`O_${key}`] = 'null';
+                    break;
+                }
+                result[`O_${key}`] = JSON.stringify(value);
+                break;
+            default:
+                result[key] = value;
+                break;
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,25 @@
+export interface Adapter {
+    scan(query: string, keys?: false): RPV<any[]>;
+    scan(query: string, keys: true): RPV<string[]>;
+    scan(query: string, keys?: boolean): RPV<(any | string)[]>;
+    get(keys: string[]): RPV<any[]>;
+    get(keys: string): RPV<any | null>;
+    get(keys: string | string[]): RPV<any | null>;
+    set(keyValue: [string, any][]): RPV<void>;
+    set(id: string, data: any): RPV<void>;
+    set(id: string | [string, any][], data?: any): RPV<void>;
+    patch(updateOnly: boolean, keyValue: [string, any][]): RPV<void>;
+    patch(updateOnly: boolean, id: string, data: any): RPV<void>;
+    patch(updateOnly: boolean, id: string | [string, any][], data?: any): RPV<void>;
+    values(to: string): RPV<any[]>;
+    keys(to: string): RPV<string[]>;
+    count(to: string): RPV<number>;
+    remove(keys: string | string[]): RPV<void>;
+    contains(to: string, keys: string): RPV<boolean>;
+    getToRelationship(to: string): RPV<string[]>;
+    bulkAddToRelationShip(data: Record<string, string[]>): RPV<void>;
+    addToRelationship(to: string, keys: string | string[]): RPV<void>;
+    removeToRelationship(to: string, keys: string | string[]): RPV<void>;
+    removeRelationship(to: string | string[]): RPV<void>;
+}
+export type RPV<V> = Promise<V> | V;

package/lib/cache/adapters/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { type MessagePort } from 'node:worker_threads';
+import type { WorkerSendCacheRequest } from '../../websocket/discord/worker';
+import type { Adapter } from './types';
+export declare class WorkerAdapter implements Adapter {
+    readonly parent: MessagePort;
+    promises: Map<string, (value: unknown) => void>;
+    constructor(parent: MessagePort);
+    protected send(method: WorkerSendCacheRequest['method'], ...args: any[]): Promise<any>;
+    scan(...rest: any[]): Promise<any>;
+    get(...rest: any[]): Promise<any>;
+    set(...rest: any[]): Promise<any>;
+    patch(...rest: any[]): Promise<any>;
+    values(...rest: any[]): Promise<any>;
+    keys(...rest: any[]): Promise<any>;
+    count(...rest: any[]): Promise<any>;
+    remove(...rest: any[]): Promise<any>;
+    contains(...rest: any[]): Promise<any>;
+    getToRelationship(...rest: any[]): Promise<any>;
+    bulkAddToRelationShip(...rest: any[]): Promise<any>;
+    addToRelationship(...rest: any[]): Promise<any>;
+    removeToRelationship(...rest: any[]): Promise<any>;
+    removeRelationship(...rest: any[]): Promise<any>;
+}

package/lib/cache/adapters/workeradapter.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerAdapter = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_worker_threads_1 = require("node:worker_threads");
+class WorkerAdapter {
+    parent;
+    promises = new Map();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    send(method, ...args) {
+        const nonce = (0, node_crypto_1.randomUUID)();
+        node_worker_threads_1.parentPort.postMessage({
+            type: 'CACHE_REQUEST',
+            args,
+            nonce,
+            method,
+            workerId: node_worker_threads_1.workerData.workerId,
+        });
+        let resolve = (_) => {
+            /**/
+        };
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            setTimeout(() => {
+                rej(new Error('Timeout cache request'));
+            }, 3e3);
+        });
+        this.promises.set(nonce, resolve);
+        return promise;
+    }
+    scan(...rest) {
+        return this.send('scan', ...rest);
+    }
+    get(...rest) {
+        return this.send('get', ...rest);
+    }
+    set(...rest) {
+        return this.send('set', ...rest);
+    }
+    patch(...rest) {
+        return this.send('patch', ...rest);
+    }
+    values(...rest) {
+        return this.send('values', ...rest);
+    }
+    keys(...rest) {
+        return this.send('keys', ...rest);
+    }
+    count(...rest) {
+        return this.send('count', ...rest);
+    }
+    remove(...rest) {
+        return this.send('remove', ...rest);
+    }
+    contains(...rest) {
+        return this.send('contains', ...rest);
+    }
+    getToRelationship(...rest) {
+        return this.send('getToRelationship', ...rest);
+    }
+    bulkAddToRelationShip(...rest) {
+        return this.send('bulkAddToRelationShip', ...rest);
+    }
+    addToRelationship(...rest) {
+        return this.send('addToRelationship', ...rest);
+    }
+    removeToRelationship(...rest) {
+        return this.send('removeToRelationship', ...rest);
+    }
+    removeRelationship(...rest) {
+        return this.send('removeRelationship', ...rest);
+    }
+}
+exports.WorkerAdapter = WorkerAdapter;

package/lib/cache/index.d.ts

@@ -0,0 +1,97 @@
+import type { GatewayDispatchPayload } from '../common';
+import type { Adapter } from './adapters';
+import { Guilds } from './resources/guilds';
+import { Users } from './resources/users';
+import { Channels } from './resources/channels';
+import { Emojis } from './resources/emojis';
+import { Members } from './resources/members';
+import { Presences } from './resources/presence';
+import { Roles } from './resources/roles';
+import { StageInstances } from './resources/stage-instances';
+import { Stickers } from './resources/stickers';
+import { Threads } from './resources/threads';
+import { VoiceStates } from './resources/voice-states';
+import type { BaseClient } from '../client/base';
+import { GatewayIntentBits } from '../common';
+export type GuildBased = 'members';
+export type GuildRelated = 'emojis' | 'roles' | 'threads' | 'channels' | 'stickers' | 'presences' | 'voiceStates' | 'stageInstances';
+export type NonGuildBased = 'users' | 'guilds';
+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_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 declare class Cache {
+    intents: number;
+    adapter: Adapter;
+    readonly disabledCache: (NonGuildBased | GuildBased | GuildRelated)[];
+    users?: Users;
+    guilds?: Guilds;
+    members?: Members;
+    roles?: Roles;
+    emojis?: Emojis;
+    threads?: Threads;
+    channels?: Channels;
+    stickers?: Stickers;
+    presences?: Presences;
+    voiceStates?: VoiceStates;
+    stageInstances?: StageInstances;
+    constructor(intents: number, adapter: Adapter, disabledCache?: (NonGuildBased | GuildBased | GuildRelated)[], client?: BaseClient);
+    hasIntent(intent: keyof typeof GatewayIntentBits): boolean;
+    get hasGuildsIntent(): boolean;
+    get hasRolesIntent(): boolean;
+    get hasChannelsIntent(): boolean;
+    get hasGuildMembersIntent(): boolean;
+    get hasEmojisAndStickersIntent(): boolean;
+    get hasVoiceStatesIntent(): boolean;
+    get hasPrenseceUpdates(): boolean;
+    get hasDirectMessages(): boolean;
+    bulkGet(keys: (readonly [
+        NonGuildBased | GuildRelated,
+        string
+    ] | readonly [
+        GuildBased,
+        string,
+        string
+    ])[]): Promise<Partial<{
+        guilds: import("..").Guild<"cached">[];
+        roles: import("..").GuildRole[];
+        emojis: import("..").GuildEmoji[];
+        stickers: import("..").Sticker[];
+        channels: NonNullable<import("..").AllChannels | undefined>[];
+        users: import("..").User[];
+        members: import("..").GuildMember[];
+        presences: (Omit<import("discord-api-types/payloads/v10/gateway").GatewayPresenceUpdate, "user"> & {
+            id: string;
+        } & {
+            guild_id: string;
+        })[];
+        threads: import("..").ThreadChannel[];
+        voiceStates: (Omit<import("discord-api-types/payloads/v10/voice").GatewayVoiceState, "member"> & {
+            guild_id: string;
+        } & {
+            guild_id: string;
+        })[];
+        stageInstances: (import("discord-api-types/payloads/v10/stageInstance").APIStageInstance & {
+            guild_id: string;
+        })[];
+    }>>;
+    bulkPatch(keys: (readonly [
+        NonGuildBased,
+        any,
+        string
+    ] | readonly [
+        GuildBased | GuildRelated,
+        any,
+        string,
+        string
+    ])[]): Promise<void>;
+    bulkSet(keys: (readonly [
+        NonGuildBased,
+        any,
+        string
+    ] | readonly [
+        GuildBased | GuildRelated,
+        any,
+        string,
+        string
+    ])[]): Promise<void>;
+    onPacket(event: GatewayDispatchPayload): Promise<void>;
+}