chapterjs 0.3.0 → 0.4.0

package/dist/store/redis-backend.d.ts

@@ -0,0 +1,38 @@
+import { RedisClient } from '../redis/client.js';
+import { RedisRankingBackend } from './redis-ranking.js';
+import { type StoreBackend, type StoreChange, type StoreEntry, type StoreKeyParts, type StoreListedEntry } from './backend.js';
+/** The prefix of every key written by `chapterjs dev`. */
+export declare const DEV_PREFIX = "dev:";
+export interface RedisStoreBackendOptions {
+    /** Put in front of every key: `dev:` under `chapterjs dev`, nothing in production. */
+    prefix?: string;
+    /** How many keys SCAN is asked for at a time. */
+    scanCount?: number;
+    /** How many connections updates may use at once, besides the main one. */
+    transactions?: number;
+    /** A new connection to the same Redis, for an update. */
+    connect?: () => RedisClient;
+    now?: () => number;
+}
+/** A part of a key, safe between two `:` and in a MATCH pattern. */
+export declare const escapePart: (part: string) => string;
+/** The parts back from a key, after the prefix and the name of the store. */
+export declare const unescapePart: (text: string) => string;
+/** The data of every store with `storage: 'redis'`, in one Redis. */
+export declare class RedisStoreBackend implements StoreBackend {
+    #private;
+    constructor(client: RedisClient, options?: RedisStoreBackendOptions);
+    /** Rankings as sorted sets: the key of a ranking is the key of its scope. */
+    rankings(): RedisRankingBackend;
+    /** The client, for the preflight check of the CLI. */
+    get client(): RedisClient;
+    /** The Redis key of a store and parts. */
+    key(store: string, parts: StoreKeyParts): string;
+    get(store: string, key: StoreKeyParts): Promise<StoreEntry | undefined>;
+    set(store: string, key: StoreKeyParts, entry: StoreEntry): Promise<void>;
+    update(store: string, key: StoreKeyParts, change: StoreChange): Promise<StoreEntry | undefined>;
+    clear(store: string, prefix: StoreKeyParts): Promise<number>;
+    delete(store: string, key: StoreKeyParts): Promise<boolean>;
+    entries(store: string, prefix: StoreKeyParts): Promise<StoreListedEntry[]>;
+    close(): Promise<void>;
+}

package/dist/store/redis-backend.js

@@ -0,0 +1,245 @@
+// The backend of the stores declared with `storage: 'redis'`: each value
+// is one Redis key, `<store>:<part>:<part>` (`dev:` in front of it under
+// `chapterjs dev`, so a Redis shared with production is never mixed up),
+// its JSON as the value and its expiration given to Redis itself, which
+// forgets the key alone. Nothing is written that a store did not ask for.
+// An update is a transaction: WATCH the key, read it, then MULTI, write,
+// EXEC, which Redis refuses when anyone wrote the key in between; it is
+// then tried again on what is there now. A transaction needs a connection
+// of its own (WATCH and MULTI belong to the connection, and the main one
+// carries every other command), so a few are opened when updates need
+// them, and lent one update at a time.
+// https://redis.io/docs/latest/commands/set/ (PX), /commands/pttl/,
+// /commands/scan/ (MATCH, COUNT), /commands/mget/, /commands/del/,
+// https://redis.io/docs/latest/develop/interact/transactions/ (WATCH)
+import { RedisClient } from '../redis/client.js';
+import { RedisRankingBackend } from './redis-ranking.js';
+import { tooBusy, UPDATE_ATTEMPTS } from './ipc-backend.js';
+import { KeyQueue, startsWith, } from './backend.js';
+/** The prefix of every key written by `chapterjs dev`. */
+export const DEV_PREFIX = 'dev:';
+/**
+ * What a part of a key may not contain as is: `:` separates the parts,
+ * `*`, `?`, `[`, `]` and `\` mean something to SCAN, `%` is the escape.
+ */
+const ESCAPED = /[%:*?[\]\\]/g;
+/** A part of a key, safe between two `:` and in a MATCH pattern. */
+export const escapePart = (part) => part.replace(ESCAPED, char => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`);
+/** The parts back from a key, after the prefix and the name of the store. */
+export const unescapePart = (text) => text.replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+/** The data of every store with `storage: 'redis'`, in one Redis. */
+export class RedisStoreBackend {
+    #client;
+    #prefix;
+    #scanCount;
+    #now;
+    #connect;
+    #maxLent;
+    /** Connections for updates that wait for one. */
+    #idle = [];
+    /** Every connection opened for updates, to close them. */
+    #opened = [];
+    /** Updates waiting for a connection, when every one is lent. */
+    #queue = [];
+    #updates = new KeyQueue();
+    #rankings = null;
+    constructor(client, options = {}) {
+        this.#client = client;
+        this.#prefix = options.prefix ?? '';
+        this.#scanCount = options.scanCount ?? 500;
+        this.#now = options.now ?? Date.now;
+        this.#maxLent = options.transactions ?? 4;
+        this.#connect = options.connect ?? (() => new RedisClient(client.address));
+    }
+    /** A connection of its own for one update, given back by `release`. */
+    async #lend() {
+        const idle = this.#idle.pop();
+        if (idle)
+            return idle;
+        if (this.#opened.length < this.#maxLent) {
+            const opened = this.#connect();
+            this.#opened.push(opened);
+            return opened;
+        }
+        return new Promise(resolve => this.#queue.push(resolve));
+    }
+    #release(client) {
+        const next = this.#queue.shift();
+        if (next)
+            next(client);
+        else
+            this.#idle.push(client);
+    }
+    /** Rankings as sorted sets: the key of a ranking is the key of its scope. */
+    rankings() {
+        this.#rankings ??= new RedisRankingBackend(this.#client, (name, scope) => this.key(name, scope));
+        return this.#rankings;
+    }
+    /** The client, for the preflight check of the CLI. */
+    get client() {
+        return this.#client;
+    }
+    /** The Redis key of a store and parts. */
+    key(store, parts) {
+        return [this.#prefix + store, ...parts.map(escapePart)].join(':');
+    }
+    /** The parts of a Redis key of `store`, or `null` for another key. */
+    #parts(store, key) {
+        const head = `${this.#prefix}${store}:`;
+        if (!key.startsWith(head))
+            return null;
+        return key.slice(head.length).split(':').map(unescapePart);
+    }
+    #entry(value, pttl) {
+        if (typeof value !== 'string')
+            return undefined;
+        // -2: the key is gone since; -1: no expiration.
+        if (pttl === -2)
+            return undefined;
+        return {
+            value: JSON.parse(value),
+            expiresAt: typeof pttl === 'number' && pttl >= 0 ? this.#now() + pttl : null,
+        };
+    }
+    async get(store, key) {
+        const name = this.key(store, key);
+        const [value, pttl] = await Promise.all([
+            this.#client.send('GET', name),
+            this.#client.send('PTTL', name),
+        ]);
+        return this.#entry(value, pttl);
+    }
+    async set(store, key, entry) {
+        const name = this.key(store, key);
+        const json = JSON.stringify(entry.value);
+        if (entry.expiresAt === null) {
+            await this.#client.send('SET', name, json);
+            return;
+        }
+        const ms = entry.expiresAt - this.#now();
+        // Already expired: there is nothing to keep, and nothing to leave.
+        if (ms <= 0) {
+            await this.#client.send('DEL', name);
+            return;
+        }
+        await this.#client.send('SET', name, json, 'PX', ms);
+    }
+    update(store, key, change) {
+        const name = this.key(store, key);
+        return this.#updates.run(name, () => this.#update(store, name, change));
+    }
+    async #update(store, name, change) {
+        const client = await this.#lend();
+        try {
+            for (let attempt = 0; attempt < UPDATE_ATTEMPTS; attempt++) {
+                await client.send('WATCH', name);
+                const [value, pttl] = await Promise.all([
+                    client.send('GET', name),
+                    client.send('PTTL', name),
+                ]);
+                const current = this.#entry(value, pttl);
+                let next;
+                try {
+                    next = change(current);
+                }
+                catch (error) {
+                    await client.send('UNWATCH');
+                    throw error;
+                }
+                if (next === undefined) {
+                    await client.send('UNWATCH');
+                    return current;
+                }
+                const ms = next.expiresAt === null ? null : next.expiresAt - this.#now();
+                const write = ms === null
+                    ? ['SET', name, JSON.stringify(next.value)]
+                    : ms <= 0
+                        ? ['DEL', name]
+                        : ['SET', name, JSON.stringify(next.value), 'PX', ms];
+                const [, , done] = await Promise.all([
+                    client.send('MULTI'),
+                    client.send(...write),
+                    client.send('EXEC'),
+                ]);
+                // `null`: someone wrote the key since WATCH, nothing was written.
+                if (done !== null)
+                    return next;
+            }
+            throw new Error(tooBusy(store));
+        }
+        finally {
+            this.#release(client);
+        }
+    }
+    async clear(store, prefix) {
+        let count = 0;
+        for (const keys of await this.#scan(store, prefix)) {
+            if (keys.length === 0)
+                continue;
+            const removed = await this.#client.send('DEL', ...keys.map(item => item.key));
+            if (typeof removed === 'number')
+                count += removed;
+        }
+        return count;
+    }
+    async delete(store, key) {
+        return (await this.#client.send('DEL', this.key(store, key))) === 1;
+    }
+    async entries(store, prefix) {
+        const listed = [];
+        for (const batch of await this.#scan(store, prefix)) {
+            if (batch.length === 0)
+                continue;
+            const [values, ...ttls] = await Promise.all([
+                this.#client.send('MGET', ...batch.map(item => item.key)),
+                ...batch.map(item => this.#client.send('PTTL', item.key)),
+            ]);
+            if (!Array.isArray(values))
+                continue;
+            batch.forEach((item, index) => {
+                const entry = this.#entry(values[index] ?? null, ttls[index] ?? -2);
+                if (entry)
+                    listed.push({ key: item.parts, ...entry });
+            });
+        }
+        return listed;
+    }
+    /**
+     * The keys of `store` that start with `prefix`, part by part, in batches
+     * of `scanCount`.
+     */
+    async #scan(store, prefix) {
+        // Every key of the store, or the ones whose text starts like the
+        // prefix: `a:b*` also matches `a:bc`, so the parts are checked after.
+        const pattern = `${this.key(store, prefix)}${prefix.length === 0 ? ':' : ''}*`;
+        const keys = [];
+        let cursor = '0';
+        do {
+            const reply = await this.#client.send('SCAN', cursor, 'MATCH', pattern, 'COUNT', this.#scanCount);
+            if (!Array.isArray(reply) || reply.length !== 2) {
+                throw new Error(`Redis answered SCAN with something unexpected.`);
+            }
+            cursor = String(reply[0]);
+            for (const key of reply[1]) {
+                if (typeof key === 'string')
+                    keys.push(key);
+            }
+        } while (cursor !== '0');
+        const batches = [];
+        // A key SCAN gave twice (it may, while keys are written) counts once.
+        const unique = [...new Set(keys)];
+        for (let at = 0; at < unique.length; at += this.#scanCount) {
+            batches.push(unique
+                .slice(at, at + this.#scanCount)
+                .map(key => ({ key, parts: this.#parts(store, key) }))
+                .filter((item) => item.parts !== null && startsWith(item.parts, prefix)));
+        }
+        return batches;
+    }
+    async close() {
+        await Promise.all([
+            this.#client.close(),
+            ...this.#opened.map(client => client.close()),
+        ]);
+    }
+}

package/dist/store/redis-ranking.d.ts

@@ -0,0 +1,15 @@
+import type { RedisClient } from '../redis/client.js';
+import type { StoreKeyParts } from './backend.js';
+import type { RankedScore, RankingBackend, RankingOrder } from './ranking-backend.js';
+export declare class RedisRankingBackend implements RankingBackend {
+    #private;
+    constructor(client: RedisClient, key: (name: string, scope: StoreKeyParts) => string);
+    add(name: string, scope: StoreKeyParts, id: string, by: number): Promise<number>;
+    set(name: string, scope: StoreKeyParts, id: string, score: number): Promise<void>;
+    score(name: string, scope: StoreKeyParts, id: string): Promise<number | undefined>;
+    rank(name: string, scope: StoreKeyParts, id: string, order: RankingOrder): Promise<number | undefined>;
+    range(name: string, scope: StoreKeyParts, order: RankingOrder, start: number, count: number): Promise<RankedScore[]>;
+    remove(name: string, scope: StoreKeyParts, id: string): Promise<boolean>;
+    size(name: string, scope: StoreKeyParts): Promise<number>;
+    clear(name: string, scope: StoreKeyParts): Promise<number>;
+}

package/dist/store/redis-ranking.js

@@ -0,0 +1,69 @@
+// The rankings kept in Redis, as sorted sets: one key per ranking and per
+// server (`xp:<server id>`, `xp` for a global one, `dev:` in front under
+// `chapterjs dev`), the ids as members and the scores as scores, so Redis
+// itself keeps them in order and adds to a score in one go.
+// https://redis.io/docs/latest/commands/zincrby/, /commands/zadd/,
+// /commands/zscore/, /commands/zrevrank/, /commands/zrevrange/,
+// /commands/zrange/, /commands/zrem/, /commands/zcard/
+/** A score as Redis writes it: `"10"`, `"1.5"`, `"inf"`. */
+const scoreOf = (reply) => {
+    const text = String(reply);
+    if (text === 'inf' || text === '+inf')
+        return Infinity;
+    if (text === '-inf')
+        return -Infinity;
+    return Number(text);
+};
+export class RedisRankingBackend {
+    #client;
+    #key;
+    constructor(client, key) {
+        this.#client = client;
+        this.#key = key;
+    }
+    async add(name, scope, id, by) {
+        return scoreOf(await this.#client.send('ZINCRBY', this.#key(name, scope), by, id));
+    }
+    async set(name, scope, id, score) {
+        await this.#client.send('ZADD', this.#key(name, scope), score, id);
+    }
+    async score(name, scope, id) {
+        const reply = await this.#client.send('ZSCORE', this.#key(name, scope), id);
+        return reply === null ? undefined : scoreOf(reply);
+    }
+    async rank(name, scope, id, order) {
+        const reply = await this.#client.send(order === 'highest' ? 'ZREVRANK' : 'ZRANK', this.#key(name, scope), id);
+        return typeof reply === 'number' ? reply : undefined;
+    }
+    async range(name, scope, order, start, count) {
+        if (count === 0)
+            return [];
+        const reply = await this.#client.send(order === 'highest' ? 'ZREVRANGE' : 'ZRANGE', this.#key(name, scope), start, start + count - 1, 'WITHSCORES');
+        if (!Array.isArray(reply))
+            return [];
+        const ranked = [];
+        for (let index = 0; index + 1 < reply.length; index += 2) {
+            ranked.push({
+                id: String(reply[index]),
+                score: scoreOf(reply[index + 1] ?? null),
+            });
+        }
+        return ranked;
+    }
+    async remove(name, scope, id) {
+        return (await this.#client.send('ZREM', this.#key(name, scope), id)) === 1;
+    }
+    async size(name, scope) {
+        const reply = await this.#client.send('ZCARD', this.#key(name, scope));
+        return typeof reply === 'number' ? reply : 0;
+    }
+    async clear(name, scope) {
+        const key = this.#key(name, scope);
+        // Sent one after the other on one connection: counted, then removed.
+        const [count] = await Promise.all([
+            this.#client.send('ZCARD', key),
+            this.#client.send('DEL', key),
+        ]);
+        return typeof count === 'number' ? count : 0;
+    }
+}

package/dist/store/scope.d.ts

@@ -6,3 +6,14 @@ export declare function withGuild<T>(guildId: string | null, fn: () => T): T;
  * the framework runs.
  */
 export declare function currentGuildId(): string | null | undefined;
+/**
+ * The scope part of a key, for data per server or for the whole bot: the
+ * id of the server the code runs for (`guildOf`), or nothing for a global
+ * one. `what` names the kind of declaration in the message, when no server
+ * is known.
+ */
+export declare function scopeParts(what: string, name: string, scope: 'guild' | 'global', guildOf: () => string | null): string[];
+/** The id of what `in()` was given: a server, or its id. */
+export declare function guildIdOf(guild: {
+    id: string;
+} | string): string;

package/dist/store/scope.js

@@ -18,3 +18,26 @@ export function withGuild(guildId, fn) {
 export function currentGuildId() {
     return scope.getStore();
 }
+/**
+ * The scope part of a key, for data per server or for the whole bot: the
+ * id of the server the code runs for (`guildOf`), or nothing for a global
+ * one. `what` names the kind of declaration in the message, when no server
+ * is known.
+ */
+export function scopeParts(what, name, scope, guildOf) {
+    if (scope === 'global')
+        return [];
+    const guildId = guildOf();
+    if (!guildId) {
+        throw new Error(`${name} is a ${what} per server, and this code does not run in one: use ${name}.in(guild) to say which server, or declare the ${what} with scope: 'global'.`);
+    }
+    return [guildId];
+}
+/** The id of what `in()` was given: a server, or its id. */
+export function guildIdOf(guild) {
+    const id = typeof guild === 'string' ? guild : guild?.id;
+    if (typeof id !== 'string' || id === '') {
+        throw new TypeError('in() takes a server (a Guild) or its id, like warnings.in(guild) or warnings.in(guild.id).');
+    }
+    return id;
+}

package/dist/store/store.d.ts

@@ -1,9 +1,17 @@
 import type { Duration } from '../commands/command.js';
 import type { Guild } from '../structures/guild.js';
+import { type StoreStorage } from './backend.js';
 /** Where the data of a store is kept apart: per server, or one for the whole bot. */
 export type StoreScope = 'guild' | 'global';
+export type { StoreStorage };
 /** What a file gives to `store()`. */
 export interface StoreConfig {
+    /**
+     * Where the data is kept: `'file'` (the default), a file in the `data/`
+     * folder of the project, or `'redis'`, the Redis of `REDIS_URL` in
+     * `.env`. Only stores that say `'redis'` write anything there.
+     */
+    storage?: StoreStorage;
     /**
      * `'guild'` (the default): the data is kept per server, and a function
      * that runs in a server reads and writes the data of that server, with
@@ -46,13 +54,37 @@ export interface ScopedStore<T> {
     /** Keeps `value` at `key`. The value must be JSON: no `Date`, `Map` or class instance. */
     set(key: StoreKey, value: T, options?: StoreSetOptions): Promise<void>;
     /**
-     * Reads the value at `key` and keeps what `change` returns, in one go.
-     * `change` receives `undefined` when there is no value yet. The
+     * Reads the value at `key` and keeps what `change` returns, in one go:
+     * nothing written meanwhile is lost, even by another process. `change`
+     * receives `undefined` when there is no value yet, and may run again
+     * when the value changed in between: keep it a plain computation. The
      * expiration stays what it was, unless `options` say otherwise.
      */
     update(key: StoreKey, change: (current: T | undefined) => T, options?: StoreSetOptions): Promise<T>;
+    /**
+     * Adds `by` (1 by default, negative to take away) to the number at
+     * `key`, starting from 0, in one go like `update()`, and resolves with
+     * the new number. Only for a store of numbers.
+     */
+    increment(this: ScopedStore<number>, key: StoreKey, by?: number, options?: StoreSetOptions): Promise<number>;
     /** Forgets the value at `key`. `true` when there was one. */
     delete(key: StoreKey): Promise<boolean>;
+    /**
+     * The values at several keys at once, in their order: `undefined` for a
+     * key that has none.
+     */
+    getMany(keys: readonly StoreKey[]): Promise<(T | undefined)[]>;
+    /**
+     * Keeps several values at once, each with the same `options`. Every
+     * value is checked before anything is written.
+     */
+    setMany(values: readonly (readonly [key: StoreKey, value: T])[], options?: StoreSetOptions): Promise<void>;
+    /**
+     * Forgets every value whose key starts with `prefix`, or every value of
+     * the store (of the server, for a store per server) without one.
+     * Resolves with how many there were.
+     */
+    deleteAll(prefix?: StoreKey): Promise<number>;
     /**
      * Every entry, or the ones whose key starts with `prefix`, in no
      * particular order. Expired ones are left out.
@@ -79,6 +111,7 @@ export interface StoreState {
     name?: string;
     /** What `read` found in the config. */
     scope: StoreScope;
+    storage: StoreStorage;
     /** The default expiration, in ms, or `null` for never. */
     expires: number | null;
 }
@@ -89,6 +122,7 @@ export declare const isStoreDeclaration: (value: unknown) => boolean;
 export declare function bindStore(declared: unknown, bound: {
     name: string;
     scope: StoreScope;
+    storage: StoreStorage;
     expires: number | null;
 }): void;
 /**
@@ -99,9 +133,9 @@ export declare function checkJson(value: unknown, path?: string): void;
 /**
  * Declares a store: data the bot keeps from one restart to the next,
  * typed by what it holds. Export the result from any file of `src/`: the
- * name of the export is the name of the store, and its file in `data/`.
- * Per server unless `scope: 'global'` is given, with an expiration if
- * `expires` is.
+ * name of the export is the name of the store, and its file in `data/`
+ * (or its keys in Redis, with `storage: 'redis'`). Per server unless
+ * `scope: 'global'` is given, with an expiration if `expires` is.
  *
  * ```ts
  * import { store } from 'chapterjs';

package/dist/store/store.js

@@ -6,7 +6,7 @@
 // the bot runs; the data itself lives in a backend (`backend.ts`).
 import { parseDuration } from '../util/duration.js';
 import { storeBackend, } from './backend.js';
-import { currentGuildId } from './scope.js';
+import { currentGuildId, guildIdOf, scopeParts } from './scope.js';
 const STATE = Symbol.for('chapterjs.store');
 /** The state of a declared store, if the value is one. */
 export function storeStateOf(value) {
@@ -22,6 +22,7 @@ export function bindStore(declared, bound) {
         throw new TypeError('Not a store.');
     state.name = bound.name;
     state.scope = bound.scope;
+    state.storage = bound.storage;
     state.expires = bound.expires;
 }
 const parts = (key) => {
@@ -105,47 +106,95 @@ function scoped(state, guildOf) {
         if (!state.name) {
             throw new Error('This store was not loaded by ChapterJS: a store is exported from a file of src/ (export const name = store()), and used once the bot started.');
         }
-        const backend = storeBackend();
-        if (state.scope === 'global') {
-            return { backend, name: state.name, prefix: [] };
-        }
-        const guildId = guildOf();
-        if (!guildId) {
-            throw new Error(`${state.name} is a store per server, and this code does not run in one: use ${state.name}.in(guild) to say which server, or declare the store with scope: 'global'.`);
-        }
-        return { backend, name: state.name, prefix: [guildId] };
+        const backend = storeBackend(state.storage, state.name);
+        return {
+            backend,
+            name: state.name,
+            prefix: scopeParts('store', state.name, state.scope, guildOf),
+        };
     };
     const full = (prefix, key) => [
         ...prefix,
         ...parts(key),
     ];
-    const set = async (key, value, options, keep) => {
+    const set = async (key, value, options) => {
         const { backend, name, prefix } = ready();
         checkJson(value);
-        const now = Date.now();
-        const at = keep !== undefined && (!options || options.expires === undefined)
-            ? keep
-            : expiresAt(options, state.expires, now);
+        const at = expiresAt(options, state.expires, Date.now());
         await backend.set(name, full(prefix, key), { value, expiresAt: at });
     };
+    const update = async (key, change, options) => {
+        const { backend, name, prefix } = ready();
+        let kept;
+        // Read and kept by the backend with nothing written in between; run
+        // again when the value changed meanwhile.
+        await backend.update(name, full(prefix, key), current => {
+            const value = change(current?.value);
+            checkJson(value);
+            kept = value;
+            return {
+                value,
+                expiresAt: current && (!options || options.expires === undefined)
+                    ? current.expiresAt
+                    : expiresAt(options, state.expires, Date.now()),
+            };
+        });
+        return kept;
+    };
     return {
         async get(key) {
             const { backend, name, prefix } = ready();
             const entry = await backend.get(name, full(prefix, key));
             return entry?.value;
         },
-        set: (key, value, options) => set(key, value, options, undefined),
-        async update(key, change, options) {
-            const { backend, name, prefix } = ready();
-            const entry = await backend.get(name, full(prefix, key));
-            const next = change(entry?.value);
-            await set(key, next, options, entry ? entry.expiresAt : undefined);
-            return next;
+        set: (key, value, options) => set(key, value, options),
+        update: (key, change, options) => update(key, change, options),
+        increment(key, by = 1, options) {
+            if (typeof by !== 'number' || !Number.isFinite(by)) {
+                return Promise.reject(new TypeError(`increment() adds a number, got ${JSON.stringify(by) ?? typeof by}.`));
+            }
+            return update(key, current => {
+                if (current !== undefined && typeof current !== 'number') {
+                    throw new TypeError(`increment() adds to a number, and the value at ${JSON.stringify(parts(key))} is ${Array.isArray(current) ? 'a list' : current === null ? 'null' : `a ${typeof current}`}: use update() to change it.`);
+                }
+                return ((current ?? 0) + by);
+            }, options);
         },
         async delete(key) {
             const { backend, name, prefix } = ready();
             return backend.delete(name, full(prefix, key));
         },
+        async getMany(keys) {
+            const { backend, name, prefix } = ready();
+            if (!Array.isArray(keys)) {
+                throw new TypeError('getMany() takes a list of keys, like warnings.getMany([a.id, b.id]).');
+            }
+            // Every key checked before anything is asked.
+            const all = keys.map(key => full(prefix, key));
+            const entries = await Promise.all(all.map(key => backend.get(name, key)));
+            return entries.map(entry => entry?.value);
+        },
+        async setMany(values, options) {
+            const { backend, name, prefix } = ready();
+            if (!Array.isArray(values)) {
+                throw new TypeError("setMany() takes a list of [key, value] pairs, like scores.setMany([['a', 1], ['b', 2]]).");
+            }
+            const now = Date.now();
+            const at = expiresAt(options, state.expires, now);
+            const checked = values.map((pair, index) => {
+                if (!Array.isArray(pair) || pair.length !== 2) {
+                    throw new TypeError(`setMany() takes a list of [key, value] pairs, and item ${index} is not one.`);
+                }
+                const [key, value] = pair;
+                checkJson(value, `the value of item ${index}`);
+                return { key: full(prefix, key), value };
+            });
+            await Promise.all(checked.map(({ key, value }) => backend.set(name, key, { value, expiresAt: at })));
+        },
+        async deleteAll(prefixKey) {
+            const { backend, name, prefix } = ready();
+            return backend.clear(name, prefixKey === undefined ? prefix : full(prefix, prefixKey));
+        },
         async entries(prefixKey) {
             const { backend, name, prefix } = ready();
             const listed = await backend.entries(name, prefixKey === undefined ? prefix : full(prefix, prefixKey));
@@ -169,9 +218,9 @@ function scoped(state, guildOf) {
 /**
  * Declares a store: data the bot keeps from one restart to the next,
  * typed by what it holds. Export the result from any file of `src/`: the
- * name of the export is the name of the store, and its file in `data/`.
- * Per server unless `scope: 'global'` is given, with an expiration if
- * `expires` is.
+ * name of the export is the name of the store, and its file in `data/`
+ * (or its keys in Redis, with `storage: 'redis'`). Per server unless
+ * `scope: 'global'` is given, with an expiration if `expires` is.
  *
  * ```ts
  * import { store } from 'chapterjs';
@@ -183,13 +232,11 @@ function scoped(state, guildOf) {
  * ```
  */
 export function store(config = {}) {
-    const state = { config, scope: 'guild', expires: null };
-    const guildIdOf = (guild) => {
-        const id = typeof guild === 'string' ? guild : guild?.id;
-        if (typeof id !== 'string' || id === '') {
-            throw new TypeError('in() takes a server (a Guild) or its id, like warnings.in(guild) or warnings.in(guild.id).');
-        }
-        return id;
+    const state = {
+        config,
+        scope: 'guild',
+        storage: 'file',
+        expires: null,
     };
     const declared = {
         ...scoped(state, () => currentGuildId() ?? null),