chapterjs 0.3.0 → 0.4.0

package/dist/ranking/ranking.d.ts

@@ -0,0 +1,102 @@
+import type { Guild } from '../structures/guild.js';
+import { type StoreStorage } from '../store/backend.js';
+import { type RankingOrder } from '../store/ranking-backend.js';
+import type { StoreScope } from '../store/store.js';
+export type { RankingOrder };
+/** What a file gives to `ranking()`. */
+export interface RankingConfig {
+    /**
+     * `'guild'` (the default): a ranking per server, and a function that
+     * runs in a server reads and writes the ranking of that server, with
+     * nothing to say. `'global'`: one ranking for the whole bot.
+     */
+    scope?: StoreScope;
+    /**
+     * Where the scores are kept: `'file'` (the default), a file in the
+     * `data/` folder of the project, or `'redis'`, the Redis of `REDIS_URL`
+     * in `.env`, where a ranking is a sorted set.
+     */
+    storage?: StoreStorage;
+    /**
+     * Which end comes first: `'highest'` (the default), the highest score
+     * first, or `'lowest'`, the lowest first (a time, a number of tries).
+     */
+    order?: RankingOrder;
+}
+/** A member of a ranking, as `top()` lists them. */
+export interface RankingEntry {
+    /** The id given to `add()` or `set()`: a member, or anything else. */
+    id: string;
+    score: number;
+    /** Where it is, from 1. Equal scores are ordered by id. */
+    rank: number;
+}
+/** A ranking, for one server or for the whole bot. */
+export interface ScopedRanking {
+    /**
+     * Adds `points` (negative to take away) to the score of `id`, starting
+     * from 0, in one go: nothing added meanwhile is lost, even by another
+     * process. Resolves with the new score.
+     */
+    add(id: string, points: number): Promise<number>;
+    /** Sets the score of `id`, whatever it was. */
+    set(id: string, score: number): Promise<void>;
+    /** The score of `id`, or `undefined` when it has none. */
+    score(id: string): Promise<number | undefined>;
+    /** Where `id` is, from 1, or `undefined` when it has no score. */
+    rankOf(id: string): Promise<number | undefined>;
+    /**
+     * The first `count` (10 by default) members, after skipping `skip` (0
+     * by default): `top(10, 10)` is the second page.
+     */
+    top(count?: number, skip?: number): Promise<RankingEntry[]>;
+    /** Forgets the score of `id`. `true` when it had one. */
+    remove(id: string): Promise<boolean>;
+    /** How many members have a score. */
+    size(): Promise<number>;
+    /** Forgets every score. Resolves with how many there were. */
+    clear(): Promise<number>;
+}
+/** What `ranking()` returns: a declaration the framework finds in the exports of a file. */
+export interface Ranking extends ScopedRanking {
+    /**
+     * The same ranking, for one server: what a task, or a function that
+     * runs outside a server, uses to read and write the ranking of that
+     * server.
+     */
+    in(guild: Guild | string): ScopedRanking;
+}
+/** A ranking as the loader knows it: its config, and once loaded, its name. */
+export interface RankingState {
+    readonly config: unknown;
+    name?: string;
+    scope: StoreScope;
+    storage: StoreStorage;
+    order: RankingOrder;
+}
+export declare function rankingStateOf(value: unknown): RankingState | undefined;
+export declare const isRankingDeclaration: (value: unknown) => boolean;
+/** Binds a declared ranking to the name of its export. */
+export declare function bindRanking(declared: unknown, bound: {
+    name: string;
+    scope: StoreScope;
+    storage: StoreStorage;
+    order: RankingOrder;
+}): void;
+/**
+ * Declares a ranking: a score per member, kept in order from one restart
+ * to the next. Export the result from any file of `src/`: the name of the
+ * export is the name of the ranking. Per server unless `scope: 'global'`
+ * is given, the highest score first unless `order: 'lowest'` is.
+ *
+ * ```ts
+ * import { ranking } from 'chapterjs';
+ *
+ * export const xp = ranking();
+ *
+ * // In an event of a message, in a server:
+ * await xp.add(message.author.id, 10);
+ * const best = await xp.top(10);
+ * ```
+ */
+export declare function ranking(config?: RankingConfig): Ranking;

package/dist/ranking/ranking.js

@@ -0,0 +1,129 @@
+// What a file declares with `ranking()`: scores per member, kept in order,
+// per server by default, from one restart to the next. Named by its
+// export, like a store: `export const xp = ranking()` is the ranking `xp`.
+// Its scores live where its `storage` says, through the rankings of that
+// backend (`store/ranking-backend.ts`): sorted sets in Redis, entries of
+// the store backend anywhere else.
+import { storeBackend } from '../store/backend.js';
+import { rankingsOf, } from '../store/ranking-backend.js';
+import { currentGuildId, guildIdOf, scopeParts } from '../store/scope.js';
+const STATE = Symbol.for('chapterjs.ranking');
+export function rankingStateOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    return value[STATE];
+}
+export const isRankingDeclaration = (value) => rankingStateOf(value) !== undefined;
+/** Binds a declared ranking to the name of its export. */
+export function bindRanking(declared, bound) {
+    const state = rankingStateOf(declared);
+    if (!state)
+        throw new TypeError('Not a ranking.');
+    Object.assign(state, bound);
+}
+const checkId = (id) => {
+    if (typeof id !== 'string' || id === '') {
+        throw new TypeError(`The id of a member of a ranking is a text that is not empty, got ${JSON.stringify(id) ?? typeof id}. Write an id as a text: member.id, not a number.`);
+    }
+    return id;
+};
+const checkScore = (value, what) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new TypeError(`${what} is a number, got ${JSON.stringify(value) ?? typeof value}.`);
+    }
+    return value;
+};
+const checkCount = (value, what) => {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new TypeError(`${what} is a whole number, 0 or more, got ${JSON.stringify(value) ?? typeof value}.`);
+    }
+    return value;
+};
+/** The ranking as its functions see it: the backend, the name, the scope. */
+function scoped(state, guildOf) {
+    const ready = () => {
+        if (!state.name) {
+            throw new Error('This ranking was not loaded by ChapterJS: a ranking is exported from a file of src/ (export const name = ranking()), and used once the bot started.');
+        }
+        return {
+            backend: rankingsOf(storeBackend(state.storage, state.name)),
+            name: state.name,
+            scope: scopeParts('ranking', state.name, state.scope, guildOf),
+        };
+    };
+    return {
+        async add(id, points) {
+            const { backend, name, scope } = ready();
+            return backend.add(name, scope, checkId(id), checkScore(points, 'What add() adds'));
+        },
+        async set(id, score) {
+            const { backend, name, scope } = ready();
+            await backend.set(name, scope, checkId(id), checkScore(score, 'The score set()'));
+        },
+        async score(id) {
+            const { backend, name, scope } = ready();
+            return backend.score(name, scope, checkId(id));
+        },
+        async rankOf(id) {
+            const { backend, name, scope } = ready();
+            const rank = await backend.rank(name, scope, checkId(id), state.order);
+            return rank === undefined ? undefined : rank + 1;
+        },
+        async top(count = 10, skip = 0) {
+            const { backend, name, scope } = ready();
+            checkCount(count, 'How many top() lists');
+            checkCount(skip, 'How many top() skips');
+            const ranked = await backend.range(name, scope, state.order, skip, count);
+            return ranked.map((entry, index) => ({
+                id: entry.id,
+                score: entry.score,
+                rank: skip + index + 1,
+            }));
+        },
+        async remove(id) {
+            const { backend, name, scope } = ready();
+            return backend.remove(name, scope, checkId(id));
+        },
+        async size() {
+            const { backend, name, scope } = ready();
+            return backend.size(name, scope);
+        },
+        async clear() {
+            const { backend, name, scope } = ready();
+            return backend.clear(name, scope);
+        },
+    };
+}
+/**
+ * Declares a ranking: a score per member, kept in order from one restart
+ * to the next. Export the result from any file of `src/`: the name of the
+ * export is the name of the ranking. Per server unless `scope: 'global'`
+ * is given, the highest score first unless `order: 'lowest'` is.
+ *
+ * ```ts
+ * import { ranking } from 'chapterjs';
+ *
+ * export const xp = ranking();
+ *
+ * // In an event of a message, in a server:
+ * await xp.add(message.author.id, 10);
+ * const best = await xp.top(10);
+ * ```
+ */
+export function ranking(config = {}) {
+    const state = {
+        config,
+        scope: 'guild',
+        storage: 'file',
+        order: 'highest',
+    };
+    const declared = {
+        ...scoped(state, () => currentGuildId() ?? null),
+        in: guild => {
+            const id = guildIdOf(guild);
+            return scoped(state, () => id);
+        },
+    };
+    Object.defineProperty(declared, STATE, { value: state });
+    return declared;
+}

package/dist/redis/client.d.ts

@@ -0,0 +1,36 @@
+import { type RedisReply } from './protocol.js';
+import { type RedisAddress } from './url.js';
+export interface RedisClientOptions {
+    /** The connection could not be made, or was lost: said once per outage. */
+    onError?: (message: string) => void;
+    /** The connection is back after an outage. */
+    onReconnect?: () => void;
+    /** How long a connection attempt may take. */
+    connectTimeout?: number;
+    /** The first wait before trying again, doubled each time up to `maxRetryDelay`. */
+    retryDelay?: number;
+    maxRetryDelay?: number;
+}
+/** One connection to Redis, which only opens when a command needs it. */
+export declare class RedisClient {
+    #private;
+    readonly address: RedisAddress;
+    constructor(address: RedisAddress, options?: RedisClientOptions);
+    /** `host:port` and the database, for messages. */
+    get where(): string;
+    /** Whether a command sent now goes out at once. */
+    get connected(): boolean;
+    /**
+     * Sends a command and resolves with its reply. An error reply (`-ERR`)
+     * rejects with a `RedisError`; a connection that fails or is lost
+     * rejects with what happened, in plain words.
+     */
+    send(...args: readonly (string | number)[]): Promise<RedisReply>;
+    /**
+     * Makes sure Redis answers: the connection is opened, logged in and on
+     * the right database, or the reason it can't be is thrown.
+     */
+    ping(): Promise<void>;
+    /** Ends the connection; every command sent from now on fails. */
+    close(): Promise<void>;
+}

package/dist/redis/client.js

@@ -0,0 +1,252 @@
+// The one connection of the process to Redis, on Node's `net` and `tls`
+// and nothing else. Commands are sent in order and answered in order
+// (RESP pipelines by itself), so every call is a promise of its reply.
+// The connection is opened on the first command, logs in and picks the
+// database by itself, and comes back alone when it was lost: a command
+// sent meanwhile fails at once with why, instead of waiting for nobody.
+// https://redis.io/docs/latest/commands/auth/ and /commands/select/
+import { connect as connectTcp } from 'node:net';
+import { connect as connectTls } from 'node:tls';
+import { encodeCommand, RedisError, ReplyReader, } from './protocol.js';
+import { describeRedis } from './url.js';
+/** A thrown reason, in plain words, with what to do. */
+function explain(address, error) {
+    const where = `Redis at ${describeRedis(address)}`;
+    // Already said in these words (a password refused during the handshake).
+    if (error instanceof Error && error.message.startsWith(where)) {
+        return error.message;
+    }
+    if (error instanceof RedisError) {
+        if (error.code === 'WRONGPASS') {
+            return `${where} refused the password: check REDIS_PASSWORD (or the password in REDIS_URL) in .env.`;
+        }
+        if (error.code === 'NOAUTH') {
+            return `${where} asks for a password: set REDIS_PASSWORD (or the password in REDIS_URL) in .env.`;
+        }
+        if (error.code === 'NOPERM') {
+            return `${where} refused the user: check the user in REDIS_URL, and what it may do.`;
+        }
+        return `${where} refused the connection: ${error.message}`;
+    }
+    const code = error?.code;
+    switch (code) {
+        case 'ECONNREFUSED':
+            return `${where} can't be reached: nothing answers there. Start Redis, or check REDIS_URL in .env.`;
+        case 'ENOTFOUND':
+        case 'EAI_AGAIN':
+            return `${where} can't be reached: the host is unknown. Check REDIS_URL in .env.`;
+        case 'ETIMEDOUT':
+            return `${where} can't be reached: it did not answer in time. Check REDIS_URL in .env, and that the machine lets you reach it.`;
+        case 'ECONNRESET':
+        case 'EPIPE':
+            return `${where} closed the connection.`;
+        default:
+            return `${where} can't be reached: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+/** One connection to Redis, which only opens when a command needs it. */
+export class RedisClient {
+    address;
+    #options;
+    #socket = null;
+    #state = 'idle';
+    /** Commands sent, waiting for their reply, in order. */
+    #waiting = [];
+    /** Commands given while connecting, sent once the connection is ready. */
+    #queue = [];
+    /** Why the last attempt failed: what a command gets while waiting to retry. */
+    #outage = null;
+    #wasReady = false;
+    #attempts = 0;
+    #retryTimer = null;
+    constructor(address, options = {}) {
+        this.address = address;
+        this.#options = {
+            connectTimeout: 5000,
+            retryDelay: 1000,
+            maxRetryDelay: 30_000,
+            ...options,
+        };
+    }
+    /** `host:port` and the database, for messages. */
+    get where() {
+        return describeRedis(this.address);
+    }
+    /** Whether a command sent now goes out at once. */
+    get connected() {
+        return this.#state === 'ready';
+    }
+    /**
+     * Sends a command and resolves with its reply. An error reply (`-ERR`)
+     * rejects with a `RedisError`; a connection that fails or is lost
+     * rejects with what happened, in plain words.
+     */
+    send(...args) {
+        return new Promise((resolve, reject) => {
+            const pending = { resolve, reject };
+            switch (this.#state) {
+                case 'closed':
+                    reject(new Error(`Redis at ${this.where} is closed: the bot stopped.`));
+                    return;
+                case 'ready':
+                    this.#write(args, pending);
+                    return;
+                case 'connecting':
+                    this.#queue.push({ args, pending });
+                    return;
+                case 'idle':
+                    if (this.#outage && this.#retryTimer) {
+                        reject(new Error(this.#outage));
+                        return;
+                    }
+                    this.#queue.push({ args, pending });
+                    this.#connect();
+            }
+        });
+    }
+    /**
+     * Makes sure Redis answers: the connection is opened, logged in and on
+     * the right database, or the reason it can't be is thrown.
+     */
+    async ping() {
+        const reply = await this.send('PING');
+        if (reply !== 'PONG') {
+            throw new Error(`Redis at ${this.where} answered ${JSON.stringify(reply)} to PING: is REDIS_URL the address of a Redis server?`);
+        }
+    }
+    #write(args, pending) {
+        this.#waiting.push(pending);
+        this.#socket.write(encodeCommand(args));
+    }
+    #connect() {
+        this.#state = 'connecting';
+        const { host, port } = this.address;
+        const socket = this.address.tls
+            ? connectTls({ host, port, servername: host })
+            : connectTcp({ host, port });
+        this.#socket = socket;
+        socket.setNoDelay(true);
+        const reader = new ReplyReader();
+        const timer = setTimeout(() => {
+            socket.destroy(Object.assign(new Error('timed out'), { code: 'ETIMEDOUT' }));
+        }, this.#options.connectTimeout);
+        // The end of this connection, whenever it comes: while connecting, or
+        // once it served. Told once: a destroyed socket says error, then close.
+        let ended = false;
+        const fail = (error) => {
+            clearTimeout(timer);
+            if (ended)
+                return;
+            ended = true;
+            if (socket !== this.#socket)
+                return;
+            this.#socket = null;
+            socket.destroy();
+            const message = explain(this.address, error);
+            // Everything sent or about to be sent fails: nobody is there.
+            const waiting = this.#waiting;
+            const queue = this.#queue;
+            this.#waiting = [];
+            this.#queue = [];
+            for (const pending of waiting)
+                pending.reject(new Error(message));
+            for (const { pending } of queue)
+                pending.reject(new Error(message));
+            if (this.#state === 'closed')
+                return;
+            this.#state = 'idle';
+            if (this.#outage === null) {
+                this.#options.onError?.(`${message} Trying again every few seconds.`);
+            }
+            const delay = Math.min(this.#options.retryDelay * 2 ** this.#attempts, this.#options.maxRetryDelay);
+            this.#attempts++;
+            this.#outage = `${message} Trying again in ${Math.round(delay / 1000) || 1} s.`;
+            this.#retryTimer = setTimeout(() => {
+                this.#retryTimer = null;
+                if (this.#state === 'idle')
+                    this.#connect();
+            }, delay);
+            this.#retryTimer.unref();
+        };
+        socket.on('error', fail);
+        socket.on('close', () => fail(Object.assign(new Error('closed'), { code: 'ECONNRESET' })));
+        socket.on('data', chunk => {
+            reader.push(chunk);
+            try {
+                let reply;
+                while ((reply = reader.next()) !== undefined) {
+                    const pending = this.#waiting.shift();
+                    if (!pending)
+                        continue;
+                    if (reply instanceof RedisError) {
+                        // A password refused, or missing, is about the connection, not
+                        // the command: said in the words of .env.
+                        pending.reject(reply.code === 'NOAUTH' || reply.code === 'WRONGPASS'
+                            ? new Error(explain(this.address, reply))
+                            : reply);
+                    }
+                    else
+                        pending.resolve(reply);
+                }
+            }
+            catch (error) {
+                socket.destroy(error);
+            }
+        });
+        socket.once(this.address.tls ? 'secureConnect' : 'connect', () => {
+            this.#handshake(socket)
+                .then(() => {
+                clearTimeout(timer);
+                if (this.#state !== 'connecting' || socket !== this.#socket)
+                    return;
+                this.#state = 'ready';
+                this.#attempts = 0;
+                const back = this.#outage !== null && this.#wasReady;
+                this.#outage = null;
+                this.#wasReady = true;
+                if (back)
+                    this.#options.onReconnect?.();
+                const queue = this.#queue;
+                this.#queue = [];
+                for (const { args, pending } of queue)
+                    this.#write(args, pending);
+            })
+                .catch(fail);
+        });
+    }
+    /** Logs in and picks the database, as the first commands of a connection. */
+    async #handshake(socket) {
+        const { username, password, db } = this.address;
+        const steps = [];
+        const ask = (...args) => {
+            steps.push(new Promise((resolve, reject) => {
+                this.#waiting.push({ resolve, reject });
+                socket.write(encodeCommand(args));
+            }));
+        };
+        if (password !== null) {
+            ask('AUTH', ...(username === null ? [password] : [username, password]));
+        }
+        if (db !== 0)
+            ask('SELECT', String(db));
+        await Promise.all(steps);
+    }
+    /** Ends the connection; every command sent from now on fails. */
+    async close() {
+        this.#state = 'closed';
+        if (this.#retryTimer) {
+            clearTimeout(this.#retryTimer);
+            this.#retryTimer = null;
+        }
+        const socket = this.#socket;
+        this.#socket = null;
+        const message = `Redis at ${this.where} is closed: the bot stopped.`;
+        for (const pending of this.#waiting)
+            pending.reject(new Error(message));
+        for (const { pending } of this.#queue)
+            pending.reject(new Error(message));
+        this.#waiting = [];
+        this.#queue = [];
+        socket?.destroy();
+    }
+}

package/dist/redis/protocol.d.ts

@@ -0,0 +1,22 @@
+/** What Redis answers: a text, a number, nothing, or a list of those. */
+export type RedisReply = string | number | null | RedisReply[];
+/** A `-ERR …` reply: Redis refused the command and says why. */
+export declare class RedisError extends Error {
+    name: string;
+    /** The first word of the message: `ERR`, `WRONGPASS`, `NOAUTH`… */
+    readonly code: string;
+    constructor(message: string);
+}
+/** A command as Redis reads it: an array of bulk strings. */
+export declare function encodeCommand(args: readonly (string | number)[]): Buffer;
+/**
+ * Reads replies out of the bytes received so far. `push()` adds what
+ * arrived, `next()` gives the next whole reply, or `undefined` while a
+ * reply is still incomplete: what was read of it is kept for the next
+ * push, so a reply cut anywhere by the network is read whole.
+ */
+export declare class ReplyReader {
+    #private;
+    push(chunk: Buffer): void;
+    next(): RedisReply | undefined;
+}

package/dist/redis/protocol.js

@@ -0,0 +1,99 @@
+// RESP, the protocol of Redis, on nothing but Buffers: how a command is
+// written on the wire, and how what comes back is read, one reply at a
+// time, from bytes that arrive in any number of pieces. RESP2 only: every
+// Redis speaks it, and the few commands the framework sends need no more.
+// https://redis.io/docs/latest/develop/reference/protocol-spec/
+/** A `-ERR …` reply: Redis refused the command and says why. */
+export class RedisError extends Error {
+    name = 'RedisError';
+    /** The first word of the message: `ERR`, `WRONGPASS`, `NOAUTH`… */
+    code;
+    constructor(message) {
+        super(message);
+        this.code = message.split(' ', 1)[0] ?? '';
+    }
+}
+const CRLF = '\r\n';
+/** A command as Redis reads it: an array of bulk strings. */
+export function encodeCommand(args) {
+    const parts = [Buffer.from(`*${args.length}${CRLF}`)];
+    for (const arg of args) {
+        const bytes = Buffer.from(String(arg));
+        parts.push(Buffer.from(`$${bytes.length}${CRLF}`), bytes, Buffer.from(CRLF));
+    }
+    return Buffer.concat(parts);
+}
+/**
+ * Reads replies out of the bytes received so far. `push()` adds what
+ * arrived, `next()` gives the next whole reply, or `undefined` while a
+ * reply is still incomplete: what was read of it is kept for the next
+ * push, so a reply cut anywhere by the network is read whole.
+ */
+export class ReplyReader {
+    #buffer = Buffer.alloc(0);
+    push(chunk) {
+        this.#buffer =
+            this.#buffer.length === 0 ? chunk : Buffer.concat([this.#buffer, chunk]);
+    }
+    next() {
+        const read = this.#read(0);
+        if (!read)
+            return undefined;
+        this.#buffer = this.#buffer.subarray(read.end);
+        return read.reply;
+    }
+    /** A line ending in CRLF from `start`: its text and where the next starts. */
+    #line(start) {
+        const at = this.#buffer.indexOf(CRLF, start);
+        if (at === -1)
+            return null;
+        return { text: this.#buffer.toString('utf8', start, at), end: at + 2 };
+    }
+    #read(start) {
+        if (start >= this.#buffer.length)
+            return null;
+        const type = this.#buffer[start];
+        const line = this.#line(start + 1);
+        if (!line)
+            return null;
+        switch (type) {
+            case 0x2b: // +
+                return { reply: line.text, end: line.end };
+            case 0x2d: // -
+                return { reply: new RedisError(line.text), end: line.end };
+            case 0x3a: // :
+                return { reply: Number(line.text), end: line.end };
+            case 0x24: {
+                // $
+                const length = Number(line.text);
+                if (length === -1)
+                    return { reply: null, end: line.end };
+                const end = line.end + length + 2;
+                if (this.#buffer.length < end)
+                    return null;
+                return {
+                    reply: this.#buffer.toString('utf8', line.end, line.end + length),
+                    end,
+                };
+            }
+            case 0x2a: {
+                // *
+                const count = Number(line.text);
+                if (count === -1)
+                    return { reply: null, end: line.end };
+                const items = [];
+                let at = line.end;
+                for (let index = 0; index < count; index++) {
+                    const item = this.#read(at);
+                    if (!item)
+                        return null;
+                    items.push(item.reply);
+                    at = item.end;
+                }
+                return { reply: items, end: at };
+            }
+            default:
+                throw new Error(`Redis answered something that is not RESP (a line starting with ${JSON.stringify(String.fromCharCode(type ?? 0))}): is REDIS_URL the address of a Redis server?`);
+        }
+    }
+}

package/dist/redis/url.d.ts

@@ -0,0 +1,24 @@
+/** Where Redis is and how to connect: what the client is created with. */
+export interface RedisAddress {
+    host: string;
+    port: number;
+    /** `rediss://`: the connection is encrypted with TLS. */
+    tls: boolean;
+    /** The user of the ACL, when the URL names one; the default user otherwise. */
+    username: string | null;
+    password: string | null;
+    /** The database index: `0` unless the URL ends with `/N`. */
+    db: number;
+}
+export declare const REDIS_URL_HELP = "Write it like redis://localhost:6379 (rediss:// for a TLS connection, /1 at the end for a database other than 0), with the user and password when there are some: redis://user:password@host:6379.";
+/** `host:port`, and the database when it is not the first: what messages show. Never the password. */
+export declare const describeRedis: (address: RedisAddress) => string;
+/**
+ * Reads a `REDIS_URL`, with the `REDIS_PASSWORD` set beside it winning over
+ * the one of the URL. Answers what is wrong when it is not a Redis address.
+ */
+export declare function parseRedisUrl(text: string, password: string): {
+    address: RedisAddress;
+} | {
+    problem: string;
+};