@wolfstar/plugin-cache 0.0.0

package/dist/esm/index.d.ts

@@ -0,0 +1,469 @@
+import { APIAuditLogEntry, APIAutoModerationRule, APIChannel, APIEmoji, APIEntitlement, APIGuild, APIGuildMember, APIGuildScheduledEvent, APIRole, APISoundboardSound, APIStageInstance, APISticker, APISubscription, APIThreadChannel, APIThreadMember, APIUser, APIVoiceState, GatewayApplicationCommandPermissionsUpdateDispatchData, GatewayDispatchPayload, GatewayGuildBanModifyDispatchData, GatewayGuildCreateDispatchData, GatewayIntegrationCreateDispatchData, GatewayIntegrationUpdateDispatchData, GatewayInviteCreateDispatchData, GatewayMessageCreateDispatchData, GatewayMessageUpdateDispatchData, GatewayPresenceUpdateDispatchData, Snowflake } from "discord-api-types/v10";
+//#region src/lib/keys.d.ts
+/**
+ * Creates a stable key for a guild-scoped entity.
+ */
+export declare function guildScopedKey(guildId: Snowflake, id: Snowflake): string;
+/**
+ * Creates a stable key for a channel message.
+ */
+export declare function messageKey(channelId: Snowflake, messageId: Snowflake): string;
+/**
+ * Creates a stable key for a guild member.
+ */
+export declare function memberKey(guildId: Snowflake, userId: Snowflake): string;
+/**
+ * Creates a stable key for a guild presence.
+ */
+export declare function presenceKey(guildId: Snowflake, userId: Snowflake): string;
+/**
+ * Creates a stable key for a guild voice state.
+ */
+export declare function voiceStateKey(guildId: Snowflake, userId: Snowflake): string;
+/**
+ * Creates a stable key for a guild role.
+ */
+export declare function roleKey(guildId: Snowflake, roleId: Snowflake): string;
+/**
+ * Creates a stable key for a guild emoji.
+ */
+export declare function emojiKey(guildId: Snowflake, emojiId: Snowflake): string;
+/**
+ * Creates a stable key for a guild sticker.
+ */
+export declare function stickerKey(guildId: Snowflake, stickerId: Snowflake): string;
+/**
+ * Creates a stable key for a guild scheduled event.
+ */
+export declare function scheduledEventKey(guildId: Snowflake, scheduledEventId: Snowflake): string;
+/**
+ * Creates a stable key for a stage instance.
+ */
+export declare function stageInstanceKey(guildId: Snowflake, channelId: Snowflake): string;
+/**
+ * Creates a stable key for a guild soundboard sound.
+ */
+export declare function soundboardSoundKey(guildId: Snowflake, soundId: Snowflake): string;
+/**
+ * Creates a stable key for a guild auto moderation rule.
+ */
+export declare function autoModerationRuleKey(guildId: Snowflake, ruleId: Snowflake): string;
+/**
+ * Creates a stable key for a guild ban.
+ */
+export declare function banKey(guildId: Snowflake, userId: Snowflake): string;
+/**
+ * Creates a stable key for a guild integration.
+ */
+export declare function integrationKey(guildId: Snowflake, integrationId: Snowflake): string;
+/**
+ * Creates a stable key for an invite, using `@global` for invites that do not belong to a guild.
+ */
+export declare function inviteKey(guildId: Snowflake | null | undefined, code: string): string;
+/**
+ * Creates a stable key for a thread member.
+ */
+export declare function threadMemberKey(threadId: Snowflake, userId: Snowflake): string;
+/**
+ * Creates a stable key for application command permissions.
+ */
+export declare function applicationCommandPermissionsKey(applicationId: Snowflake, guildId: Snowflake, commandId: Snowflake): string;
+//#endregion
+//#region src/lib/types.d.ts
+/**
+ * A value that may or may not be wrapped in a promise.
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * The raw, JSON-serializable shape stored for every entity kind.
+ *
+ * @remarks
+ * The cache never stores `Structure` instances, only the raw API payloads (merged in place for partial updates).
+ * Building structures on top of them is the job of the consumer, e.g. `@wolfstar/plugin-gateway`'s managers.
+ */
+interface CacheEntityTypes {
+  applicationCommandPermissions: GatewayApplicationCommandPermissionsUpdateDispatchData;
+  auditLogEntries: APIAuditLogEntry & {
+    guild_id: Snowflake;
+  };
+  autoModerationRules: APIAutoModerationRule;
+  bans: GatewayGuildBanModifyDispatchData;
+  channels: APIChannel & {
+    guild_id?: Snowflake;
+  };
+  emojis: APIEmoji & {
+    guild_id: Snowflake;
+  };
+  entitlements: APIEntitlement;
+  /**
+   * A guild without its collections (`roles`, `emojis`, `stickers`, `channels`, `members`, ...): they are stored in
+   * their own entity caches, which stay up to date as the guild changes.
+   */
+  guilds: Omit<APIGuild, "emojis" | "roles" | "stickers"> & Partial<Omit<GatewayGuildCreateDispatchData, keyof APIGuild>>;
+  integrations: GatewayIntegrationCreateDispatchData | GatewayIntegrationUpdateDispatchData;
+  invites: GatewayInviteCreateDispatchData;
+  members: APIGuildMember & {
+    guild_id: Snowflake;
+  };
+  messages: GatewayMessageCreateDispatchData | GatewayMessageUpdateDispatchData;
+  presences: GatewayPresenceUpdateDispatchData;
+  roles: APIRole & {
+    guild_id: Snowflake;
+  };
+  scheduledEvents: APIGuildScheduledEvent;
+  soundboardSounds: APISoundboardSound;
+  stageInstances: APIStageInstance;
+  stickers: APISticker & {
+    guild_id: Snowflake;
+  };
+  subscriptions: APISubscription;
+  threadMembers: APIThreadMember & {
+    guild_id?: Snowflake;
+  };
+  threads: APIThreadChannel;
+  users: APIUser;
+  voiceStates: APIVoiceState;
+}
+/**
+ * The name of any of the entity caches held by a {@link Cache}.
+ */
+type CacheEntityName = keyof CacheEntityTypes;
+/**
+ * A Map-like, per-entity key-value store.
+ *
+ * @remarks
+ * Every method returns an {@link Awaitable}, so synchronous (in-memory) and asynchronous (Redis) stores implement the
+ * exact same contract. `keys`, `values`, and `entries` return snapshots rather than live iterators, which keeps the
+ * semantics identical across backends.
+ */
+interface EntityCache<Raw> {
+  get(key: string): Awaitable<Raw | undefined>;
+  set(key: string, value: Raw): Awaitable<void>;
+  has(key: string): Awaitable<boolean>;
+  delete(key: string): Awaitable<boolean>;
+  clear(): Awaitable<void>;
+  getSize(): Awaitable<number>;
+  keys(): Awaitable<string[]>;
+  values(): Awaitable<Raw[]>;
+  entries(): Awaitable<[key: string, value: Raw][]>;
+}
+/**
+ * One {@link EntityCache} per entity kind.
+ */
+type CacheEntities = { readonly [Name in CacheEntityName]: EntityCache<CacheEntityTypes[Name]>; };
+/**
+ * A storage-agnostic Discord cache: one {@link EntityCache} per entity kind, and nothing else.
+ *
+ * @remarks
+ * The cache is intentionally dumb: it has no knowledge of the gateway nor of the relations between entities. Cascading
+ * a gateway dispatch into every relevant entity cache (e.g. dropping a guild's channels on `GUILD_DELETE`) is done by
+ * {@link applyGatewayDispatch}, which only relies on this interface, so any custom implementation gets it for free.
+ */
+interface Cache extends CacheEntities {}
+//#endregion
+//#region src/lib/operations.d.ts
+/**
+ * The name of every entity cache held by a {@link Cache}.
+ */
+export declare const CacheEntityNames: readonly CacheEntityName[];
+/**
+ * A single mutation a gateway dispatch produces on a {@link Cache}.
+ */
+type CacheOperation = {
+  type: "upsert";
+  store: CacheEntityName;
+  key: string;
+  raw: unknown;
+  /** Whether to shallow-merge `raw` onto the existing value, used for partial updates. */
+  merge?: boolean;
+} | {
+  type: "update";
+  store: CacheEntityName;
+  key: string;
+  /** Computes the new value from the cached one. Nothing is written when the key is not cached. */
+  update: (value: unknown) => unknown;
+} | {
+  type: "delete";
+  store: CacheEntityName;
+  key: string;
+} | {
+  type: "deletePrefix";
+  store: CacheEntityName;
+  prefix: string;
+} | {
+  type: "deleteWhere";
+  store: CacheEntityName;
+  predicate: (value: unknown) => boolean;
+};
+/**
+ * What {@link createCacheOperations} needs to know besides the dispatch.
+ */
+interface CacheOperationContext {
+  /**
+   * The bot's user ID. Reactions and poll votes only carry the voter's ID, so without it the cached `me` and
+   * `me_voted` flags are never set.
+   */
+  clientUserId?: string;
+}
+/**
+ * Translates a gateway dispatch into the list of {@link CacheOperation}s it implies, including the cascades (e.g.
+ * `CHANNEL_DELETE` also drops that channel's messages).
+ *
+ * @remarks
+ * This is a pure function, it does not touch any cache. Use {@link applyGatewayDispatch} to apply them.
+ * `INTERACTION_CREATE` is intentionally ignored: interactions are short-lived and never cached.
+ *
+ * @param payload The gateway dispatch payload.
+ * @param context The bot's user ID, for the `me` flags of reactions and poll votes.
+ */
+export declare function createCacheOperations(payload: GatewayDispatchPayload, context?: CacheOperationContext): CacheOperation[];
+/**
+ * Applies a list of {@link CacheOperation}s to a {@link Cache}, sequentially and in order.
+ *
+ * @param cache The cache to mutate.
+ * @param operations The operations to apply, usually created by {@link createCacheOperations}.
+ */
+export declare function applyCacheOperations(cache: Cache, operations: readonly CacheOperation[]): Promise<void>;
+/**
+ * Writes a gateway dispatch into every relevant entity cache of a {@link Cache}.
+ *
+ * @param cache The cache to mutate.
+ * @param payload The gateway dispatch payload.
+ * @param context The bot's user ID, for the `me` flags of reactions and poll votes.
+ */
+export declare function applyGatewayDispatch(cache: Cache, payload: GatewayDispatchPayload, context?: CacheOperationContext): Promise<void>;
+/**
+ * Shallow-merges `value` onto `existing` when both are plain objects, returning `value` otherwise.
+ */
+export declare function mergeValues<Value>(existing: Value | undefined, value: Value): Value;
+//#endregion
+//#region src/lib/gateway.d.ts
+/** A gateway that emits the dispatch event used by @discordjs/ws and @discordjs/core. */
+interface GatewayDispatchSource {
+  on(event: "dispatch", listener: (payload: GatewayDispatchPayload, shardId: number) => void): unknown;
+  off?(event: "dispatch", listener: (payload: GatewayDispatchPayload, shardId: number) => void): unknown;
+}
+interface CacheGatewayOptions extends CacheOperationContext {
+  /** Receives cache write failures from the asynchronous gateway listener. */
+  onError?: (error: unknown, payload: GatewayDispatchPayload, shardId: number) => void;
+}
+/**
+ * Writes gateway dispatches into a cache. Call the returned function to stop listening.
+ * Use this when a gateway has no GatewayClient managing its dispatch queue.
+ */
+export declare function attachCacheToGateway(gateway: GatewayDispatchSource, cache: Cache, options?: CacheGatewayOptions): () => void;
+//#endregion
+//#region src/lib/memory.d.ts
+/**
+ * An {@link EntityCache} backed by a `Map`, optionally bounded as a least-recently-used cache.
+ */
+export declare class MemoryEntityCache<Raw> implements EntityCache<Raw> {
+  #private;
+  /**
+   * The maximum amount of entries, `Infinity` for an unbounded cache.
+   */
+  readonly maxSize: number;
+  constructor(maxSize?: number);
+  get(key: string): Raw | undefined;
+  set(key: string, value: Raw): void;
+  has(key: string): boolean;
+  delete(key: string): boolean;
+  clear(): void;
+  getSize(): number;
+  keys(): string[];
+  values(): Raw[];
+  entries(): [key: string, value: Raw][];
+}
+/**
+ * A {@link Cache} whose entity caches are all {@link MemoryEntityCache}s.
+ */
+type InMemoryCache = { readonly [Name in CacheEntityName]: MemoryEntityCache<CacheEntityTypes[Name]>; };
+interface InMemoryCacheOptions {
+  /**
+   * The maximum amount of entries kept per entity cache before evicting the least recently used ones, either for
+   * every entity cache or per entity cache. Entity caches left out are unbounded.
+   *
+   * @default Infinity
+   */
+  maxSize?: number | Partial<Record<CacheEntityName, number>>;
+}
+/**
+ * Creates a {@link Cache} that keeps everything in the process' memory.
+ *
+ * @example
+ * ```typescript
+ * import { createInMemoryCache } from '@wolfstar/plugin-cache';
+ *
+ * // Keep at most 1000 messages around, everything else is unbounded.
+ * const cache = createInMemoryCache({ maxSize: { messages: 1_000 } });
+ * ```
+ *
+ * @param options The options for the cache.
+ */
+export declare function createInMemoryCache(options?: InMemoryCacheOptions): InMemoryCache & Cache;
+//#endregion
+//#region src/lib/redis.d.ts
+/**
+ * The subset of the [`ioredis`](https://github.com/redis/ioredis) client API the Redis cache relies on. An `ioredis`
+ * `Redis` or `Cluster` instance satisfies it, as can any other client exposing the same commands.
+ */
+interface RedisClientLike {
+  get(key: string): Promise<string | null>;
+  mget(...keys: string[]): Promise<(string | null)[]>;
+  set(key: string, value: string): Promise<unknown>;
+  set(key: string, value: string, mode: "PX", milliseconds: number): Promise<unknown>;
+  del(...keys: string[]): Promise<number>;
+  exists(...keys: string[]): Promise<number>;
+  zadd(key: string, ...scoreMembers: (string | number)[]): Promise<unknown>;
+  zrem(key: string, ...members: string[]): Promise<number>;
+  zrange(key: string, start: string, stop: string): Promise<string[]>;
+  zcard(key: string): Promise<number>;
+  zremrangebyscore(key: string, min: number | string, max: number | string): Promise<number>;
+  multi(): RedisTransactionLike;
+}
+/**
+ * The subset of an [`ioredis`](https://github.com/redis/ioredis) `MULTI` transaction the Redis cache relies on: every
+ * queued command returns the transaction, and `exec` runs them atomically.
+ */
+interface RedisTransactionLike {
+  set(key: string, value: string): RedisTransactionLike;
+  set(key: string, value: string, mode: "PX", milliseconds: number): RedisTransactionLike;
+  del(...keys: string[]): RedisTransactionLike;
+  zadd(key: string, ...scoreMembers: (string | number)[]): RedisTransactionLike;
+  zrem(key: string, ...members: string[]): RedisTransactionLike;
+  zremrangebyscore(key: string, min: number | string, max: number | string): RedisTransactionLike;
+  exec(): Promise<[error: Error | null, result: unknown][] | null>;
+}
+/**
+ * Thrown when a value stored in Redis cannot be read back: invalid JSON, or compressed bytes that fail to decompress.
+ *
+ * @remarks
+ * A missing value is not an error, `get` resolves to `undefined` for it. Redis connection errors are not wrapped
+ * either, they propagate as the client throws them.
+ */
+export declare class CacheValueError extends Error {
+  /**
+   * The Redis key holding the unreadable value.
+   */
+  readonly key: string;
+  constructor(key: string, cause: unknown);
+}
+/**
+ * The algorithm used to compress values before writing them to Redis.
+ */
+type RedisCacheCompression = "gzip" | "brotli" | "none";
+interface RedisEntityCacheOptions {
+  /**
+   * The prefix of every Redis key owned by this entity cache.
+   */
+  prefix: string;
+  /**
+   * The time-to-live of every entry, in seconds. Entries never expire when omitted.
+   */
+  ttl?: number;
+  /**
+   * The compression algorithm to use.
+   *
+   * @default "none"
+   */
+  compression?: RedisCacheCompression;
+  /**
+   * The minimum size, in bytes, a serialized value must reach to be compressed. Small payloads rarely benefit from it.
+   *
+   * @default 1024
+   */
+  compressionThreshold?: number;
+}
+/**
+ * An {@link EntityCache} backed by Redis.
+ *
+ * @remarks
+ * Every entry is stored as its own string key (`<prefix>:<key>`), and a sorted set (`<prefix>:@index`) tracks the
+ * stored keys with their expiration time as score, which is what `keys`, `entries`, `getSize`, and `clear` read from.
+ */
+export declare class RedisEntityCache<Raw> implements EntityCache<Raw> {
+  #private;
+  readonly prefix: string;
+  readonly ttl: number | undefined;
+  readonly compression: RedisCacheCompression;
+  readonly compressionThreshold: number;
+  constructor(redis: RedisClientLike, options: RedisEntityCacheOptions);
+  get(key: string): Promise<Raw | undefined>;
+  set(key: string, value: Raw): Promise<void>;
+  has(key: string): Promise<boolean>;
+  delete(key: string): Promise<boolean>;
+  clear(): Promise<void>;
+  getSize(): Promise<number>;
+  keys(): Promise<string[]>;
+  values(): Promise<Raw[]>;
+  entries(): Promise<[key: string, value: Raw][]>;
+  /**
+   * Gets the Redis key a value is stored at.
+   * @param key The entity cache key.
+   */
+  valueKey(key: string): string;
+  /**
+   * The Redis key of the sorted set indexing the stored keys.
+   */
+  get indexKey(): string;
+  private prune;
+  private serialize;
+  private deserialize;
+}
+/**
+ * A {@link Cache} whose entity caches are all {@link RedisEntityCache}s.
+ */
+type RedisCache = { readonly [Name in CacheEntityName]: RedisEntityCache<CacheEntityTypes[Name]>; };
+interface RedisCacheOptions {
+  /**
+   * The Redis client to use, e.g. an [`ioredis`](https://github.com/redis/ioredis) instance.
+   */
+  redis: RedisClientLike;
+  /**
+   * The prefix of every Redis key owned by the cache, which allows several caches to share a database.
+   *
+   * @default "wolfstar:cache"
+   */
+  prefix?: string;
+  /**
+   * The compression algorithm to use for values of at least {@link RedisCacheOptions.compressionThreshold} bytes.
+   *
+   * @default "none"
+   */
+  compression?: RedisCacheCompression;
+  /**
+   * The minimum size, in bytes, a serialized value must reach to be compressed.
+   *
+   * @default 1024
+   */
+  compressionThreshold?: number;
+  /**
+   * The time-to-live per entity cache, in seconds. Entity caches left out never expire.
+   */
+  ttl?: Partial<Record<CacheEntityName, number>>;
+}
+/**
+ * The default prefix of every Redis key owned by a cache created with {@link createRedisCache}.
+ */
+export declare const DefaultRedisCachePrefix = "wolfstar:cache";
+/**
+ * Creates a {@link Cache} stored in Redis, optionally compressing its values.
+ *
+ * @example
+ * ```typescript
+ * import { createRedisCache } from '@wolfstar/plugin-cache';
+ * import { Redis } from 'ioredis';
+ *
+ * const cache = createRedisCache({
+ *   redis: new Redis(process.env.REDIS_URL!),
+ *   compression: 'gzip',
+ *   ttl: { guilds: 60 * 60, users: 30 * 60 },
+ * });
+ * ```
+ *
+ * @param options The options for the cache.
+ */
+export declare function createRedisCache(options: RedisCacheOptions): RedisCache & Cache;
+//#endregion
+export type { Awaitable, Cache, CacheEntities, CacheEntityName, CacheEntityTypes, CacheGatewayOptions, CacheOperation, CacheOperationContext, EntityCache, GatewayDispatchSource, InMemoryCache, InMemoryCacheOptions, RedisCache, RedisCacheCompression, RedisCacheOptions, RedisClientLike, RedisEntityCacheOptions, RedisTransactionLike };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/lib/keys.ts","../../src/lib/types.ts","../../src/lib/operations.ts","../../src/lib/gateway.ts","../../src/lib/memory.ts","../../src/lib/redis.ts"],"mappings":"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"}