chapterjs 0.3.0 → 0.4.0

package/README.md

@@ -30,7 +30,7 @@ export default command({
 });
 ```
 
-The framework loads every file of `src/`, wherever it is and whatever it is called, and runs what the files export: `command()`, `event()`, `button()`, `select()`, `modal()`, `embed()`, `task()`, `store()`, `presence()`, `language()`. The folders are yours to organise with.
+The framework loads every file of `src/`, wherever it is and whatever it is called, and runs what the files export: `command()`, `event()`, `button()`, `select()`, `modal()`, `embed()`, `task()`, `store()`, `ranking()`, `presence()`, `language()`. The folders are yours to organise with.
 
 ## What it does
 
@@ -38,7 +38,7 @@ The framework loads every file of `src/`, wherever it is and whatever it is call
 - **Events**: the intents follow from the files you write, privileged ones included, with a direct link when one must be enabled.
 - **Components**: buttons, select menus, forms and embeds, with typed `data` carried in the message and no id to write.
 - **Tasks**: every so often or with a cron, in the timezone you choose.
-- **Storage**: `store<Warning[]>({ expires: '30d' })` keeps data from one restart to the next, per server, typed, in a JSON file written for you.
+- **Storage**: `store<Warning[]>({ expires: '30d' })` keeps data from one restart to the next, per server, typed, in a JSON file written for you, or in Redis with `storage: 'redis'` and a `REDIS_URL`; `ranking()` keeps a score per member in order, for leaderboards.
 - **Translated messages**: `t('welcome', { name })` speaks the language of who will read it.
 - **Voice**: join a channel and play a file, an attachment or a link, end-to-end encrypted (DAVE).
 - **Tests**: `chapterjs test` runs the bot against a Discord in memory, no token needed: every file is used once by itself, then your scenarios (`scenario('ping answers Pong', async bot => { … })`) say what the bot should answer.

package/dist/cli/build.js

@@ -15,6 +15,7 @@ import { pathToFileURL } from 'node:url';
 import { enableProjectLoader } from '../loader/hot.js';
 import { listSources } from '../loader/loader.js';
 import { sourcesJoinVoice } from '../voice/usage.js';
+import { MemoryStoreBackend } from '../store/memory-backend.js';
 import { createProject, hasSources, writeTypes } from './project.js';
 /** Where the build of a project is, from its folder. */
 export const buildDir = (cwd) => join(cwd, '.chapterjs', 'build');
@@ -105,7 +106,18 @@ export async function build(options) {
     };
     // 1. Every file must run, one by one: each says what is wrong with it.
     enableProjectLoader(src, { reload: false });
-    const sources = createProject({ cwd, version: options.version, log });
+    // The files run once and keep nothing: a store, wherever it says it
+    // keeps its data, has nowhere to go (so a build needs no Redis).
+    const nothing = {
+        file: new MemoryStoreBackend(),
+        redis: new MemoryStoreBackend(),
+    };
+    const sources = createProject({
+        cwd,
+        version: options.version,
+        log,
+        stores: nothing,
+    });
     const failures = await sources.load();
     // 2. Types: what the editor underlines, for the whole project. Written
     // once the files ran, so a language only offers the commands they do
@@ -181,6 +193,7 @@ export async function build(options) {
         version: options.version,
         log,
         built: await loadBundle(cwd),
+        stores: nothing,
     });
     const broken = await built.load();
     if (broken.length > 0) {

package/dist/cli/dev.js

@@ -16,7 +16,9 @@ import { snapshotFolder, watchFolder } from '../loader/watch.js';
 import { RestClient } from '../rest/rest.js';
 import { readDevEnv } from './env.js';
 import { describeIntents, ensureInDevGuild, ensurePrivilegedIntents, fetchApplication, } from './preflight.js';
-import { createProject, explain, hasSources, writeTypes } from './project.js';
+import { createProject, explain, hasSources, reportLooseRejections, writeTypes, } from './project.js';
+import { checkRedis, describeRedisStores, redisStores } from './redis.js';
+import { DEV_PREFIX } from '../store/redis-backend.js';
 import { checkForUpdate, describeUpdate } from './update-check.js';
 /** Runs until stopped. Resolves with the exit code of the process. */
 export async function dev(options) {
@@ -30,8 +32,16 @@ export async function dev(options) {
     }
     const { token, devGuildId } = read.env;
     const src = join(cwd, 'src');
+    // Every key written from here starts with `dev:`: a Redis shared with
+    // production, which the docs advise against, is never mixed up.
+    const redis = read.env.redis
+        ? redisStores(read.env.redis, log, { prefix: DEV_PREFIX })
+        : null;
     if (!(await hasSources(cwd, log)))
         return 1;
+    // A promise of the files left alone is an error of the file, not the end
+    // of the bot.
+    const loose = reportLooseRejections(cwd, log);
     // Asked now, said once the bot is online: the registry answers while the
     // files load and Discord is checked, so nobody waits for it.
     const update = checkForUpdate({
@@ -44,6 +54,7 @@ export async function dev(options) {
         cwd,
         version: options.version,
         log,
+        ...(redis ? { stores: { redis } } : {}),
         ...(options.deferAfter === undefined
             ? {}
             : { deferAfter: options.deferAfter }),
@@ -57,6 +68,12 @@ export async function dev(options) {
     // Now that the files ran, a language only offers the commands they do
     // not describe, and `t` is typed from the default language.
     await writeTypes(cwd, project.typesInfo());
+    // A store kept in Redis needs it now, not when someone uses the bot.
+    if (!(await checkRedis(project, redis, log))) {
+        await project.closeStores();
+        return 1;
+    }
+    let redisLine = describeRedisStores(project, redis);
     // 3. What Discord must agree with before connecting.
     const apiUrl = options.env.CHAPTERJS_API_URL;
     const rest = new RestClient({
@@ -154,6 +171,8 @@ export async function dev(options) {
         log.success(`Connected to ${guild.name} as ${self.username}`);
         log.info(`Intents computed from your files: ${describeIntents(connectedIntents)}`);
         (project.isEmpty() ? log.info : log.success)(project.summary());
+        if (redisLine)
+            log.info(redisLine);
         project.ready(bot);
         // Tasks follow the bot through reconnections: they read the current one.
         project.startTasks(() => bot);
@@ -215,6 +234,13 @@ export async function dev(options) {
                 // offer it, or not.
                 if ((await writeTypes(cwd, project.typesInfo())) > 0)
                     log.reload('Types updated');
+                // A store moved to Redis, or out of it, is said once.
+                const kept = describeRedisStores(project, redis);
+                if (kept !== redisLine) {
+                    redisLine = kept;
+                    if (kept)
+                        log.info(kept);
+                }
                 const intents = project.intents(false);
                 if ((intents & ~connectedIntents) !== 0 && bot) {
                     // Intents are given when connecting: new ones need a new session.
@@ -256,6 +282,7 @@ export async function dev(options) {
         memory.stop();
         await bot?.close();
         await project.closeStores();
+        loose();
         if (code === 0)
             log.success('Disconnected');
         return code;
@@ -267,6 +294,7 @@ export async function dev(options) {
         memory.stop();
         await bot?.close();
         await project.closeStores();
+        loose();
         if (signal.aborted)
             return 0;
         explain(error, log);

package/dist/cli/env.d.ts

@@ -1,12 +1,17 @@
+import { type RedisAddress } from '../redis/url.js';
 export interface DevEnv {
     token: string;
     devGuildId: string;
+    /** Where the stores with `storage: 'redis'` go, when `REDIS_URL` is set. */
+    redis: RedisAddress | null;
 }
 /** What `chapterjs start` runs with. */
 export interface StartEnv {
     token: string;
     /** The dev server, when the project has one: production leaves it alone. */
     devGuildId: string | null;
+    /** Where the stores with `storage: 'redis'` go, when `REDIS_URL` is set. */
+    redis: RedisAddress | null;
 }
 /**
  * Reads what `chapterjs dev` needs from the `.env` file of the project (the

package/dist/cli/env.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseEnv } from 'node:util';
 import { isSnowflake } from '../discord/snowflake.js';
+import { parseRedisUrl } from '../redis/url.js';
 /**
  * Values people leave in a `.env` copied from an example. Whole values only:
  * a real token may start with any letters.
@@ -24,6 +25,27 @@ async function readEnv(projectDir, processEnv) {
         hasFile,
     };
 }
+/**
+ * `REDIS_URL` and `REDIS_PASSWORD`, when they are there: nothing is needed
+ * unless a store asks for Redis, which the files say once they loaded.
+ */
+function redisProblem(read, where) {
+    const url = read('REDIS_URL');
+    const password = read('REDIS_PASSWORD');
+    if (url === '') {
+        if (password !== '') {
+            return {
+                problem: `${where}: REDIS_PASSWORD is set, but REDIS_URL is not.\nAdd REDIS_URL, the address of your Redis (like redis://localhost:6379), or remove REDIS_PASSWORD.`,
+            };
+        }
+        return { redis: null };
+    }
+    const parsed = parseRedisUrl(url, password);
+    if ('problem' in parsed) {
+        return { problem: `${where}: REDIS_URL ${parsed.problem}` };
+    }
+    return { redis: parsed.address };
+}
 const TOKEN_HELP = 'Copy the token of your bot from https://discord.com/developers/applications → your application → Bot → Reset Token.';
 /** What is wrong with a token, if anything. */
 function tokenProblem(token, where) {
@@ -61,7 +83,12 @@ export async function readDevEnv(projectDir, processEnv) {
     else if (!isSnowflake(devGuildId)) {
         problems.push(`.env: DEV_GUILD_ID is "${devGuildId}", which is not a server ID (an ID only has digits).\nIn Discord, right-click your test server → Copy Server ID.`);
     }
-    return problems.length > 0 ? { problems } : { env: { token, devGuildId } };
+    const redis = redisProblem(read, '.env');
+    if ('problem' in redis)
+        problems.push(redis.problem);
+    return problems.length > 0 || 'problem' in redis
+        ? { problems }
+        : { env: { token, devGuildId, redis: redis.redis } };
 }
 /**
  * Reads what `chapterjs start` needs. In production the values often come
@@ -87,7 +114,16 @@ export async function readStartEnv(projectDir, processEnv) {
     if (devGuildId !== '' && !isSnowflake(devGuildId)) {
         problems.push(`DEV_GUILD_ID is "${devGuildId}", which is not a server ID (an ID only has digits).\nRemove it, or copy it again: in Discord, right-click your test server → Copy Server ID.`);
     }
-    return problems.length > 0
+    const redis = redisProblem(read, hasFile ? '.env' : 'Environment');
+    if ('problem' in redis)
+        problems.push(redis.problem);
+    return problems.length > 0 || 'problem' in redis
         ? { problems }
-        : { env: { token, devGuildId: devGuildId === '' ? null : devGuildId } };
+        : {
+            env: {
+                token,
+                devGuildId: devGuildId === '' ? null : devGuildId,
+                redis: redis.redis,
+            },
+        };
 }

package/dist/cli/project.d.ts

@@ -1,7 +1,8 @@
 import { type CommandEntry } from '../commands/tree.js';
 import { type ComponentEntry } from '../components/router.js';
 import { type LoadedStore } from '../store/declaration.js';
-import { type StoreBackend } from '../store/backend.js';
+import { type LoadedRanking } from '../ranking/declaration.js';
+import { type StoreBackend, type StoreStorage } from '../store/backend.js';
 import { type LoadedPresence } from '../presence/declaration.js';
 import { type DeclaredCommand, type DeclaredLanguage } from '../messages/declaration.js';
 import { type LoadedMessages } from '../messages/translate.js';
@@ -31,11 +32,13 @@ export interface ProjectOptions {
      */
     joinsVoice?: boolean;
     /**
-     * Where the stores of the project keep their data. A file per store in
-     * the `data/` folder of the project by default; the first process of a
-     * cluster, through IPC, for the other processes.
+     * Where the stores of the project keep their data, by storage. `file`: a
+     * file per store in the `data/` folder of the project by default, the
+     * first process of a cluster through IPC for the other processes.
+     * `redis`: what the CLI made of `REDIS_URL`; without one, a store that
+     * asks for Redis is reported and left out.
      */
-    stores?: StoreBackend;
+    stores?: Partial<Record<StoreStorage, StoreBackend>>;
     /** Only tests change this. */
     deferAfter?: number;
     /**
@@ -77,6 +80,12 @@ export interface TypesInfo {
 export declare function writeTypes(cwd: string, info?: TypesInfo): Promise<number>;
 /** The kinds of declarations a project is made of: one per feature. */
 export declare const DECLARATIONS: readonly Declaration<unknown>[];
+/** A ranking, with where it is declared. */
+export interface RankingEntry {
+    file: string;
+    export: string;
+    ranking: LoadedRanking;
+}
 /** A store, with where it is declared. */
 export interface StoreEntry {
     file: string;
@@ -111,8 +120,14 @@ export interface Project {
     readonly components: ReadonlyMap<string, ComponentEntry>;
     readonly tasks: ReadonlyMap<string, TaskEntry>;
     readonly stores: ReadonlyMap<string, StoreEntry>;
-    /** Where the stores keep their data: what a cluster serves to its other processes. */
-    readonly storeBackend: StoreBackend;
+    readonly rankings: ReadonlyMap<string, RankingEntry>;
+    /** Where the stores keep their data, by storage: what a cluster serves to its other processes. */
+    readonly storeBackends: ReadonlyMap<StoreStorage, StoreBackend>;
+    /** What is kept in Redis: the names of the stores and of the rankings, sorted. */
+    redisStores(): {
+        stores: string[];
+        rankings: string[];
+    };
     /** The presence declared, or `null` without one. */
     readonly presence: LoadedPresence | null;
     /** The languages of the project, assembled, or `null` without any. */
@@ -166,6 +181,14 @@ export interface Project {
     /** Writes what the stores still have to write. Nothing is kept after this. */
     closeStores(): Promise<void>;
 }
+/**
+ * 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 declare function reportLooseRejections(cwd: string, log: Log): () => void;
 /** Whether the folder is a project: it has a `src` folder. */
 export declare function hasSources(cwd: string, log: Log): Promise<boolean>;
 export declare function createProject(options: ProjectOptions): Project;

package/dist/cli/project.js

@@ -16,7 +16,8 @@ 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 { assembleMessages, commandsDeclarations, languageDeclaration, languageDefaultsDeclaration, messagesDeclarations, scanLanguages, } from '../messages/declaration.js';
@@ -68,9 +69,29 @@ export const DECLARATIONS = [
     componentDeclaration,
     taskDeclaration,
     storeDeclaration,
+    rankingDeclaration,
     presenceDeclaration,
     languageDeclaration,
 ];
+/**
+ * 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()) {
@@ -108,10 +129,11 @@ function sameNames(entries, nameOf, what) {
             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 +143,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,6 +181,7 @@ export function createProject(options) {
     let components = new Map();
     let tasks = new Map();
     let stores = new Map();
+    let rankings = new Map();
     let presence = null;
     /** The files the presence was declared in, to keep it when they break. */
     let presenceFiles = new Set();
@@ -182,7 +214,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;
         },
@@ -213,12 +258,13 @@ export function createProject(options) {
             // 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),
             ];
@@ -272,15 +318,34 @@ export function createProject(options) {
             ], entry => entry.task.name, 'task');
             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'));
+            // 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)
@@ -369,10 +434,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 +471,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,6 +487,7 @@ 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.
@@ -530,7 +601,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,57 @@
+// 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, {
+        onError: message => log.warn(message),
+        onReconnect: () => log.reload(`Redis at ${client.where} is back`),
+    });
+    return new RedisStoreBackend(client, options);
+}
+/** `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;
+    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;
+    }
+}