chapterjs 0.3.0 → 0.5.0

package/dist/cli/project.js

@@ -7,7 +7,10 @@ import { join } from 'node:path';
 import { setPublicDir } from '../assets/asset.js';
 import { listPublic, publicDeclarations } from '../assets/public.js';
 import { MissingForEvent } from '../events/registry.js';
-import { sourcesJoinVoice } from '../voice/usage.js';
+import { VOICE_USE } from '../voice/usage.js';
+import { MESSAGES_USE, REACTIONS_USE } from '../waiting/usage.js';
+import { MemoryWaiters } from '../waiting/waiters.js';
+import { scanUses, usesIntents } from '../loader/usage.js';
 import { writeGenerated } from '../loader/generated.js';
 import { commandDeclaration, scanCommands } from '../commands/declaration.js';
 import { CommandRouter } from '../commands/router.js';
@@ -16,9 +19,12 @@ import { componentDeclaration, findDuplicates, } from '../components/declaration
 import { ComponentRouter } from '../components/router.js';
 import { taskDeclaration } from '../tasks/declaration.js';
 import { storeDeclaration } from '../store/declaration.js';
-import { setStoreBackend } from '../store/backend.js';
+import { rankingDeclaration, } from '../ranking/declaration.js';
+import { nowhereToKeep, NowhereToKeepError, setStoreBackend, STORAGES, } from '../store/backend.js';
 import { DATA_FOLDER, FileStoreBackend } from '../store/file-backend.js';
-import { DEFAULT_PRESENCE, presenceDeclaration, } from '../presence/declaration.js';
+import { checkText, DEFAULT_PRESENCE, presenceDeclaration, readActivities, } from '../presence/declaration.js';
+import { PresenceRotation } from '../presence/rotation.js';
+import { GetCurrentApplication } from '../discord/endpoints.js';
 import { assembleMessages, commandsDeclarations, languageDeclaration, languageDefaultsDeclaration, messagesDeclarations, scanLanguages, } from '../messages/declaration.js';
 import { translation } from '../messages/translate.js';
 import { translateCommand, unknownCommands } from '../messages/commands.js';
@@ -29,7 +35,7 @@ import { GatewayIntent } from '../discord/intents.js';
 import { eventDeclaration } from '../events/declaration.js';
 import { EventRouter, intentsFor, intentsOf, limitsFor, } from '../events/router.js';
 import { GatewayFatalError, SessionLimitError } from '../gateway/errors.js';
-import { loadSources, readDeclarations, siteName, } from '../loader/loader.js';
+import { loadSources, bySite, readDeclarations, siteKey, siteName, } from '../loader/loader.js';
 import { locate, messageOf } from '../loader/locate.js';
 import { DiscordApiError, DiscordUnavailableError, InvalidTokenError, } from '../rest/errors.js';
 import { PreflightFailure } from './preflight.js';
@@ -68,9 +74,34 @@ export const DECLARATIONS = [
     componentDeclaration,
     taskDeclaration,
     storeDeclaration,
+    rankingDeclaration,
     presenceDeclaration,
     languageDeclaration,
 ];
+/**
+ * What the files may do that only their code shows, each with the intents
+ * it needs: read in `src/` (dev, at every load) or kept by the build.
+ */
+export const CODE_USES = [VOICE_USE, MESSAGES_USE, REACTIONS_USE];
+/**
+ * A promise of the files that nobody waited for (`store.set()` without
+ * `await`, in a `run` that is not `async`) rejects with nobody to tell:
+ * Node would stop the bot. Reported instead, with the file and the line,
+ * and what to write. A rejection from outside the files stays what it is:
+ * a bug of the framework, loud. Returns what stops watching.
+ */
+export function reportLooseRejections(cwd, log) {
+    const listener = (reason) => {
+        const where = locate(reason, cwd);
+        if (!where)
+            throw reason;
+        log.error(`${where.file}:${where.line} ${messageOf(reason)}\nThis call was not awaited: write await in front of it (and async before run), so that your function waits for it.`);
+    };
+    process.on('unhandledRejection', listener);
+    return () => {
+        process.off('unhandledRejection', listener);
+    };
+}
 /** Whether the folder is a project: it has a `src` folder. */
 export async function hasSources(cwd, log) {
     if ((await stat(join(cwd, 'src')).catch(() => null))?.isDirectory()) {
@@ -86,32 +117,25 @@ const PRIVATE_INTENTS = GatewayIntent.DirectMessages |
     GatewayIntent.DirectMessagePolls;
 const megabytes = (bytes) => `${Math.round(bytes / 1024 / 1024)} MB`;
 /** What tells one declaration from another: its file and its export. */
-const keyOf = (site) => `${site.file}#${site.export}`;
+const keyOf = siteKey;
 /**
  * Two declarations with the same name, where the name is the export's
  * (a task): the later one is left out, with a message saying so.
  */
-function sameNames(entries, nameOf, what) {
+function sameNames(entries, nameOf, what, running) {
     const seen = new Map();
     const conflicts = [];
-    const valid = [...entries]
-        .sort((a, b) => a.file === b.file
-        ? a.export < b.export
-            ? -1
-            : 1
-        : a.file < b.file
-            ? -1
-            : 1)
-        .filter(entry => {
+    const valid = bySite(entries, running).filter(entry => {
         const first = seen.get(nameOf(entry));
         if (!first) {
             seen.set(nameOf(entry), entry);
             return true;
         }
+        const kind = (one) => typeof what === 'string' ? what : what(one);
         conflicts.push({
             file: entry.file,
             export: entry.export,
-            message: `There is already a ${what} named ${nameOf(entry)}, in ${first.file}: the name of the export is the name of the ${what}, so rename one of them.`,
+            message: `There is already a ${kind(first)} named ${nameOf(entry)}, in ${first.file}: the name of the export is the name of the ${kind(entry)}, so rename one of them.`,
         });
         return false;
     });
@@ -121,9 +145,18 @@ export function createProject(options) {
     const { cwd, log } = options;
     // Where `asset()` reads the files of the project from.
     setPublicDir(cwd);
-    // Where the stores keep their data, for every store of the process.
-    const storeBackend = options.stores ?? new FileStoreBackend(join(cwd, DATA_FOLDER));
-    setStoreBackend(storeBackend);
+    // Where the stores keep their data, for every store of the process: a
+    // backend per storage the project has one for.
+    const storeBackends = new Map();
+    for (const storage of STORAGES) {
+        const backend = options.stores?.[storage] ??
+            (storage === 'file'
+                ? new FileStoreBackend(join(cwd, DATA_FOLDER))
+                : null);
+        setStoreBackend(storage, backend);
+        if (backend)
+            storeBackends.set(storage, backend);
+    }
     const report = (failure) => {
         const where = locate(failure.error, cwd);
         log.error(`${where ? `${where.file}:${where.line}` : siteName(failure)} ${messageOf(failure.error)}`);
@@ -150,20 +183,80 @@ export function createProject(options) {
     let components = new Map();
     let tasks = new Map();
     let stores = new Map();
+    let rankings = new Map();
     let presence = null;
+    /** Where the presence is declared, for what its functions do wrong. */
+    let presenceSite = { file: 'the presence', export: 'default' };
     /** The files the presence was declared in, to keep it when they break. */
     let presenceFiles = new Set();
-    // Joining voice needs the bot's own voice state, sent with an intent.
-    let voice = options.joinsVoice ?? false;
-    const neededIntents = () => intentsFor(events.values()) | (voice ? GatewayIntent.GuildVoiceStates : 0);
+    // Joining voice, waiting for messages or reactions: intents the code
+    // needs without any declaration saying it.
+    let uses = options.uses ?? {};
+    const neededIntents = () => intentsFor(events.values()) | usesIntents(CODE_USES, uses);
     let messages = null;
     /** The last version of each language that loaded. */
     let languages = new Map();
     let languageDefaults = [];
+    /** Whether the files were loaded before: what a reload compares with. */
+    let loadedOnce = false;
     /** The bot running the files now, to give it what a reload changes. */
     let running = null;
     /** The presence each bot was given last, to send only what changed. */
     const given = new WeakMap();
+    /** What each bot shows now, to send only what changed. */
+    const shown = new WeakMap();
+    /** Whether the running bot is only part of the bot (a cluster). */
+    let partial = false;
+    /** How many servers the whole bot is in, as Discord counted it last. */
+    let counted = null;
+    let counting = false;
+    /**
+     * How many servers the bot is in: what this process knows when it runs
+     * every shard; else what Discord counts for the application, asked at
+     * most every 10 minutes.
+     * @see https://docs.discord.com/developers/resources/application#application-object-application-structure
+     */
+    const guildCount = (bot) => {
+        const local = bot.ctx.cache.guilds.size;
+        if (!partial)
+            return local;
+        if (!counting && (!counted || Date.now() - counted.at > 600_000)) {
+            counting = true;
+            bot.ctx.rest
+                .request(GetCurrentApplication, [])
+                .then(application => {
+                const guilds = application.approximate_guild_count;
+                if (guilds !== undefined)
+                    counted = { guilds, at: Date.now() };
+            })
+                .catch(() => { })
+                .finally(() => (counting = false));
+        }
+        return counted?.guilds ?? local;
+    };
+    let presenceBot = () => null;
+    const rotation = new PresenceRotation({
+        apply(raw) {
+            const bot = presenceBot();
+            if (!bot)
+                return;
+            const text = JSON.stringify(raw);
+            if (shown.get(bot) === text)
+                return;
+            shown.set(bot, text);
+            bot.setPresence(raw);
+        },
+        context() {
+            const bot = presenceBot();
+            if (!bot?.ctx.self)
+                return null;
+            return {
+                guilds: guildCount(bot),
+                ...translation(bot.ctx, null),
+            };
+        },
+        onError: error => report({ ...presenceSite, error }),
+    });
     let lost = false;
     const count = (size, one, many) => `${size} ${size === 1 ? one : many}`;
     return {
@@ -182,7 +275,20 @@ export function createProject(options) {
         get stores() {
             return stores;
         },
-        storeBackend,
+        storeBackends,
+        get rankings() {
+            return rankings;
+        },
+        redisStores: () => ({
+            stores: [...stores.values()]
+                .filter(entry => entry.store.storage === 'redis')
+                .map(entry => entry.store.name)
+                .sort(),
+            rankings: [...rankings.values()]
+                .filter(entry => entry.ranking.storage === 'redis')
+                .map(entry => entry.ranking.name)
+                .sort(),
+        }),
         get presence() {
             return presence;
         },
@@ -198,7 +304,10 @@ export function createProject(options) {
             })),
             ...(messages ? { defaultLocale: messages.default } : {}),
             languageDefaults,
-            commands: [...commands.values()].map(({ command }) => ({
+            // Only slash commands have texts in the language files.
+            commands: [...commands.values()]
+                .filter(({ command }) => command.type === 'slash')
+                .map(({ command }) => ({
                 name: command.path.join(' '),
                 described: command.described,
             })),
@@ -206,19 +315,20 @@ export function createProject(options) {
         report,
         async load() {
             const { built } = options;
-            if (options.joinsVoice === undefined) {
-                voice = await sourcesJoinVoice(cwd);
+            if (options.uses === undefined) {
+                uses = await scanUses(cwd, CODE_USES);
             }
             // Every file of src/ runs (or ran, in a build); what each exports is
             // then read, kind by kind.
             const sources = built ? { modules: built, failed: [] } : await loadSources(cwd);
             const read = (declaration) => readDeclarations(sources.modules, declaration);
-            const [eventItems, commandItems, componentItems, taskItems, storeItems, presenceItems, languageItems,] = [
+            const [eventItems, commandItems, componentItems, taskItems, storeItems, rankingItems, presenceItems, languageItems,] = [
                 read(eventDeclaration),
                 read(commandDeclaration),
                 read(componentDeclaration),
                 read(taskDeclaration),
                 read(storeDeclaration),
+                read(rankingDeclaration),
                 read(presenceDeclaration),
                 read(languageDeclaration),
             ];
@@ -246,13 +356,14 @@ export function createProject(options) {
                 event: item.value,
             }));
             router.set(events.values());
+            // A name two declarations share stays with the one that ran before.
             const { valid, conflicts } = findConflicts([
                 ...next(commands, commandItems, item => ({
                     file: item.file,
                     export: item.export,
                     command: item.value,
                 })).values(),
-            ]);
+            ], new Set(commands.keys()));
             commands = new Map(valid.map(entry => [keyOf(entry), entry]));
             const unique = findDuplicates([
                 ...next(components, componentItems, item => ({
@@ -260,7 +371,7 @@ export function createProject(options) {
                     export: item.export,
                     component: item.value,
                 })).values(),
-            ]);
+            ], new Set(components.keys()));
             components = new Map(unique.valid.map(entry => [keyOf(entry), entry]));
             componentRouter.set(components.values());
             const sameTask = sameNames([
@@ -269,22 +380,43 @@ export function createProject(options) {
                     export: item.export,
                     task: item.value,
                 })).values(),
-            ], entry => entry.task.name, 'task');
+            ], entry => entry.task.name, 'task', new Set(tasks.keys()));
             tasks = new Map(sameTask.valid.map(entry => [keyOf(entry), entry]));
             scheduler.set(tasks.values());
-            // Two stores with one name would share one file: the later is left out.
+            const keptOf = (entry) => 'store' in entry ? entry.store : entry.ranking;
             const sameStore = sameNames([
                 ...next(stores, storeItems, item => ({
                     file: item.file,
                     export: item.export,
                     store: item.value,
                 })).values(),
-            ], entry => entry.store.name, 'store');
-            stores = new Map(sameStore.valid.map(entry => [keyOf(entry), entry]));
+                ...next(rankings, rankingItems, item => ({
+                    file: item.file,
+                    export: item.export,
+                    ranking: item.value,
+                })).values(),
+            ], entry => keptOf(entry).name, entry => ('store' in entry ? 'store' : 'ranking'), new Set([...stores.keys(), ...rankings.keys()]));
+            // What is kept where nothing keeps it (Redis without REDIS_URL) is
+            // reported and left out: it says so itself when used.
+            const unkept = sameStore.valid.filter(entry => !storeBackends.has(keptOf(entry).storage));
+            const kept = sameStore.valid.filter(entry => !unkept.includes(entry));
+            stores = new Map(kept
+                .filter((entry) => 'store' in entry)
+                .map(entry => [keyOf(entry), entry]));
+            rankings = new Map(kept
+                .filter((entry) => 'ranking' in entry)
+                .map(entry => [keyOf(entry), entry]));
+            const nowhere = unkept.map(entry => ({
+                file: entry.file,
+                export: entry.export,
+                error: new NowhereToKeepError(nowhereToKeep(keptOf(entry).storage, keptOf(entry).name, 'store' in entry ? 'store' : 'ranking')),
+            }));
             // One presence. A second one is left out.
             const [first, ...extra] = presenceItems.loaded;
-            if (first)
+            if (first) {
                 presence = first.value;
+                presenceSite = { file: first.file, export: first.export };
+            }
             else if (presenceItems.failed.length === 0 &&
                 ![...broken].some(file => presenceFiles.has(file))) {
                 presence = null;
@@ -311,14 +443,20 @@ export function createProject(options) {
             languages = nextLanguages;
             let assembled = assembleMessages([...languages.values()]);
             // A language that no longer matches the others keeps its last version
-            // that did, like a declaration that no longer loads.
+            // that did, like a declaration that no longer loads; one that was not
+            // there before is left out. What already ran is never what breaks
+            // the languages: a second default: true saved in a new file must not
+            // take the texts of every command away.
             const restored = assembled.failed.filter(failure => {
                 const key = keyOf({
                     file: failure.file,
                     export: failure.export ?? 'default',
                 });
+                const current = languages.get(key);
+                if (current === undefined)
+                    return false;
                 const previous = previousLanguages.get(key);
-                return previous !== undefined && previous !== languages.get(key);
+                return previous === undefined ? loadedOnce : previous !== current;
             });
             if (restored.length > 0) {
                 for (const failure of restored) {
@@ -326,7 +464,11 @@ export function createProject(options) {
                         file: failure.file,
                         export: failure.export ?? 'default',
                     });
-                    languages.set(key, previousLanguages.get(key));
+                    const previous = previousLanguages.get(key);
+                    if (previous)
+                        languages.set(key, previous);
+                    else
+                        languages.delete(key);
                 }
                 const again = assembleMessages([...languages.values()]);
                 assembled = {
@@ -338,6 +480,7 @@ export function createProject(options) {
                 };
             }
             messages = assembled.messages;
+            loadedOnce = true;
             if (running)
                 running.ctx.messages = messages;
             // A command has its texts in its file, or in the language files: the
@@ -345,7 +488,9 @@ export function createProject(options) {
             // be described is left out.
             const badTexts = [...assembled.failed];
             if (messages) {
-                const names = new Set([...commands.values()].map(entry => entry.command.path.join(' ')));
+                const names = new Set([...commands.values()]
+                    .filter(entry => entry.command.type === 'slash')
+                    .map(entry => entry.command.path.join(' ')));
                 for (const { file, path } of unknownCommands(messages, names)) {
                     badTexts.push({
                         file,
@@ -369,10 +514,12 @@ export function createProject(options) {
                 ...componentItems.failed,
                 ...taskItems.failed,
                 ...storeItems.failed,
+                ...rankingItems.failed,
                 ...presenceItems.failed,
                 ...languageItems.failed,
                 ...badTexts,
                 ...twice,
+                ...nowhere,
                 ...[
                     ...conflicts,
                     ...unique.conflicts,
@@ -404,6 +551,9 @@ export function createProject(options) {
                     : []),
                 ...(tasks.size > 0 ? [count(tasks.size, 'task', 'tasks')] : []),
                 ...(stores.size > 0 ? [count(stores.size, 'store', 'stores')] : []),
+                ...(rankings.size > 0
+                    ? [count(rankings.size, 'ranking', 'rankings')]
+                    : []),
                 ...(presence ? ['a presence'] : []),
                 ...(messages
                     ? [
@@ -417,13 +567,17 @@ export function createProject(options) {
             components.size === 0 &&
             tasks.size === 0 &&
             stores.size === 0 &&
+            rankings.size === 0 &&
             presence === null &&
             messages === null,
         // A file declaring several events that need the intent is named once.
         filesNeeding: intent => [
-            ...new Set([...events.values()]
-                .filter(({ event }) => (intentsOf(event) & GatewayIntent[intent]) !== 0)
-                .map(({ file }) => file)),
+            ...new Set([
+                ...[...events.values()]
+                    .filter(({ event }) => (intentsOf(event) & GatewayIntent[intent]) !== 0)
+                    .map(({ file }) => file),
+                ...CODE_USES.filter(use => (use.intents & GatewayIntent[intent]) !== 0).flatMap(use => uses[use.name] ?? []),
+            ]),
         ],
         intents: (privateEvents = true) => neededIntents() & (privateEvents ? ~0 : ~PRIVATE_INTENTS),
         async connect(connection) {
@@ -435,6 +589,7 @@ export function createProject(options) {
                 guildFilter: connection.guildFilter,
                 privateEvents: connection.privateEvents,
                 presence: presence?.raw,
+                waiters: new MemoryWaiters(options.observe?.waits ? { watch: options.observe.waits } : {}),
                 shards: connection.shards,
                 identifyGate: connection.identifyGate,
                 ...(connection.identifyInterval === undefined
@@ -443,7 +598,12 @@ export function createProject(options) {
                 // Only what the files of the project use is remembered.
                 cache: { limits: limitsFor(events.values()) },
                 // A local fake of Discord (tests) serves voice without TLS too.
-                voice: { secure: !connection.apiUrl?.startsWith('http://') },
+                voice: {
+                    secure: !connection.apiUrl?.startsWith('http://'),
+                    ...(connection.voiceUnavailable === undefined
+                        ? {}
+                        : { unavailable: connection.voiceUnavailable }),
+                },
                 rest: {
                     ...(connection.apiUrl ? { baseUrl: connection.apiUrl } : {}),
                     ...(connection.globalLimit === undefined
@@ -487,19 +647,62 @@ export function createProject(options) {
                 },
             });
             given.set(created, presence?.key ?? '');
+            shown.set(created, JSON.stringify(presence?.raw ?? DEFAULT_PRESENCE));
+            partial =
+                connection.shards !== undefined &&
+                    connection.shards.ids.length < connection.shards.count;
             created.ctx.messages = messages;
             running = created;
             await created.connect();
             return created;
         },
         applyPresence(bot) {
+            // Always the functions of the files as they are now: a file they
+            // import may have changed. What is shown is only sent when it differs.
+            rotation.set(presence);
             const key = presence?.key ?? '';
             if (given.get(bot) === key)
                 return false;
             given.set(bot, key);
-            bot.setPresence(presence?.raw ?? DEFAULT_PRESENCE);
             return true;
         },
+        startPresence(current) {
+            presenceBot = current;
+            rotation.set(presence);
+            rotation.start();
+        },
+        stopPresence: () => rotation.stop(),
+        get presenceFile() {
+            return presence ? presenceSite.file : null;
+        },
+        async runPresence(bot) {
+            if (!presence)
+                return;
+            const context = {
+                guilds: guildCount(bot),
+                ...translation(bot.ctx, null),
+            };
+            const failed = (error) => report({ ...presenceSite, error });
+            let activities = presence.activities;
+            if (typeof activities === 'function') {
+                try {
+                    activities = readActivities(await activities(context));
+                }
+                catch (error) {
+                    return failed(error);
+                }
+            }
+            for (const { name } of activities) {
+                if (typeof name !== 'function')
+                    continue;
+                try {
+                    checkText(await name(context));
+                }
+                catch (error) {
+                    failed(error);
+                }
+            }
+        },
         ready(bot) {
             const user = bot.ctx.cache.users.get(bot.ctx.self.userId);
             router.emit('ready', {
@@ -530,7 +733,10 @@ export function createProject(options) {
         },
         // The bot looks after its own memory: it remembers less before memory
         // is full, and only speaks up when it can't give up anything more.
-        closeStores: () => storeBackend.close(),
+        closeStores: async () => {
+            for (const backend of storeBackends.values())
+                await backend.close();
+        },
         watchMemory: current => watchMemory({
             cache: () => current()?.ctx.cache,
             onTightened: ({ members, forgotten }, { used, limit }) => log.info(`Memory was getting full (${megabytes(used)} of ${megabytes(limit)}): the bot now remembers ${members} members per server at most, and forgot ${forgotten} members and users it had not seen for the longest. Nothing changes for your code.`),

package/dist/cli/redis.d.ts

@@ -0,0 +1,23 @@
+import type { RedisAddress } from '../redis/url.js';
+import { RedisStoreBackend } from '../store/redis-backend.js';
+import type { Log } from './log.js';
+import type { Project } from './project.js';
+/**
+ * The backend of the stores kept in Redis. Nothing is connected until a
+ * store is used, or `checkRedis()` asks; an outage is said once with `⚠`
+ * and its end with `↻`.
+ */
+export declare function redisStores(address: RedisAddress, log: Log, options?: {
+    prefix?: string;
+}): RedisStoreBackend;
+/**
+ * The `ℹ` line naming the stores and rankings kept in Redis, or `null`
+ * without any: "The store sessions and the ranking xp are kept in Redis…".
+ */
+export declare function describeRedisStores(project: Project, backend: RedisStoreBackend | null): string | null;
+/**
+ * Makes sure Redis answers before the bot goes online, when a store is
+ * kept there: a Redis that can't be reached is an error now, not when
+ * someone uses the bot.
+ */
+export declare function checkRedis(project: Project, backend: RedisStoreBackend | null, log: Log): Promise<boolean>;

package/dist/cli/redis.js

@@ -0,0 +1,69 @@
+// What `dev` and `start` share about Redis: the backend made of
+// `REDIS_URL`, checked before Discord is reached when a store needs it,
+// and the line that says which stores are kept there.
+import { RedisClient } from '../redis/client.js';
+import { RedisStoreBackend } from '../store/redis-backend.js';
+/**
+ * The backend of the stores kept in Redis. Nothing is connected until a
+ * store is used, or `checkRedis()` asks; an outage is said once with `⚠`
+ * and its end with `↻`.
+ */
+export function redisStores(address, log, options = {}) {
+    const client = new RedisClient(address, {
+        // While checkRedis() asks, a failure is what stops the bot, said once
+        // by it: "trying again" would not be true.
+        onError: message => {
+            if (!checking.has(backend))
+                log.warn(message);
+        },
+        onReconnect: () => log.reload(`Redis at ${client.where} is back`),
+    });
+    const backend = new RedisStoreBackend(client, options);
+    return backend;
+}
+/** The backends `checkRedis()` is asking right now. */
+const checking = new WeakSet();
+/** `a`, `a and b`, `a, b and c`. */
+const and = (items) => items.length <= 1
+    ? (items[0] ?? '')
+    : `${items.slice(0, -1).join(', ')} and ${items.at(-1)}`;
+/**
+ * The `ℹ` line naming the stores and rankings kept in Redis, or `null`
+ * without any: "The store sessions and the ranking xp are kept in Redis…".
+ */
+export function describeRedisStores(project, backend) {
+    const { stores, rankings } = project.redisStores();
+    const total = stores.length + rankings.length;
+    if (!backend || total === 0)
+        return null;
+    const group = (one, many, names) => names.length === 0
+        ? []
+        : [`the ${names.length === 1 ? one : many} ${and(names)}`];
+    const list = and([
+        ...group('store', 'stores', stores),
+        ...group('ranking', 'rankings', rankings),
+    ]);
+    return `${list[0].toUpperCase()}${list.slice(1)} ${total === 1 ? 'is' : 'are'} kept in Redis at ${backend.client.where}`;
+}
+/**
+ * Makes sure Redis answers before the bot goes online, when a store is
+ * kept there: a Redis that can't be reached is an error now, not when
+ * someone uses the bot.
+ */
+export async function checkRedis(project, backend, log) {
+    const { stores, rankings } = project.redisStores();
+    if (!backend || stores.length + rankings.length === 0)
+        return true;
+    checking.add(backend);
+    try {
+        await backend.client.ping();
+        return true;
+    }
+    catch (error) {
+        log.error(`${error instanceof Error ? error.message.replace(/ Trying again in \d+ s\.$/, '') : String(error)}`);
+        return false;
+    }
+    finally {
+        checking.delete(backend);
+    }
+}