chapterjs 0.3.0 → 0.4.0

package/dist/cli/start.js

@@ -2,6 +2,8 @@
 // Nothing is reloaded, commands are registered for every server, and a
 // large bot is spread over several processes by itself.
 import { IpcStoreBackend } from '../store/ipc-backend.js';
+import { NowhereToKeepError } from '../store/backend.js';
+import { checkRedis, describeRedisStores, redisStores } from './redis.js';
 import { registerCommands } from '../commands/register.js';
 import { buildCommands } from '../commands/tree.js';
 import { GLOBAL_REQUESTS_PER_SECOND } from '../discord/api.js';
@@ -13,7 +15,7 @@ import { connectToPrimary, planProcesses, REFUSED, runCluster, } from './cluster
 import { loadBundle, readBuild } from './build.js';
 import { readStartEnv } from './env.js';
 import { describeIntents, ensurePrivilegedIntents, fetchApplication, } from './preflight.js';
-import { createProject, explain } from './project.js';
+import { createProject, explain, reportLooseRejections, } from './project.js';
 /** Runs until stopped. Resolves with the exit code of the process. */
 export async function start(options) {
     const { cwd, log, signal } = options;
@@ -49,25 +51,30 @@ export async function start(options) {
         }
         return 1;
     }
+    // Every process reaches Redis itself: it is made to be shared.
+    const redis = read.env.redis ? redisStores(read.env.redis, log) : null;
     const project = createProject({
         cwd,
         version: options.version,
         log,
         built: files,
         joinsVoice: built.info.voice === true,
-        // A process started by another keeps no data: the first one does, for
-        // all of them.
-        ...(assignment
-            ? {
-                stores: new IpcStoreBackend({
-                    send: message => {
-                        if (process.connected)
-                            process.send?.(message);
-                    },
-                    on: listener => process.on('message', listener),
-                }),
-            }
-            : {}),
+        stores: {
+            // A process started by another keeps no file: the first one does,
+            // for all of them.
+            ...(assignment
+                ? {
+                    file: new IpcStoreBackend({
+                        send: message => {
+                            if (process.connected)
+                                process.send?.(message);
+                        },
+                        on: listener => process.on('message', listener),
+                    }),
+                }
+                : {}),
+            ...(redis ? { redis } : {}),
+        },
         ...(options.deferAfter === undefined
             ? {}
             : { deferAfter: options.deferAfter }),
@@ -77,7 +84,12 @@ export async function start(options) {
         for (const failure of failures)
             project.report(failure);
         if (!assignment) {
-            log.error(`${failures.length === 1 ? 'This file' : `These ${failures.length} files`} of the build can't run any more, so the bot was not started. Run "chapterjs build" again: it says what to fix.`);
+            // A store kept in Redis without REDIS_URL is about the environment,
+            // not the build.
+            const unkept = failures.every(failure => failure.error instanceof NowhereToKeepError);
+            log.error(unkept
+                ? 'The bot was not started. Give REDIS_URL to the bot the way your host does it (its "environment variables" or "secrets"), or in a .env file in this folder.'
+                : `${failures.length === 1 ? 'This file' : `These ${failures.length} files`} of the build can't run any more, so the bot was not started. Run "chapterjs build" again: it says what to fix.`);
         }
         return 1;
     }
@@ -94,10 +106,18 @@ export async function start(options) {
             ? { guildFilter: (id) => id !== devGuildId }
             : {}),
     };
+    // A promise of the files left alone is an error of the file, not the end
+    // of the bot: in every process, since every one runs the files.
+    const loose = reportLooseRejections(cwd, log);
     try {
         if (assignment)
             return await runShare(project, options, connection, assignment);
-        // 3. What Discord must agree with, checked once for every process.
+        // 3. What Redis, then Discord, must agree with, checked once for every
+        // process.
+        if (!(await checkRedis(project, redis, log))) {
+            await project.closeStores();
+            return 1;
+        }
         const rest = new RestClient({
             token,
             version: options.version,
@@ -132,6 +152,9 @@ export async function start(options) {
             log.success(`Online as ${user} in ${guilds} ${guilds === 1 ? 'server' : 'servers'}${split ? ` (${split})` : ''}`);
             log.info(`Intents computed from your files: ${describeIntents(intents)}`);
             (project.isEmpty() ? log.info : log.success)(project.summary());
+            const kept = describeRedisStores(project, redis);
+            if (kept)
+                log.info(kept);
         };
         if (processes === 1) {
             return await runAlone(project, options, connection, online);
@@ -146,7 +169,7 @@ export async function start(options) {
             signal,
             identifyInterval,
             write: options.write,
-            stores: project.storeBackend,
+            stores: project.storeBackends.get('file'),
             onReady: ({ user, guilds }) => online(user, guilds),
             onRestart: (index, why) => log.warn(`Process ${index + 1} of ${processes} stopped by itself (${why}): starting it again. Its servers are back in a moment.`),
         });
@@ -162,6 +185,9 @@ export async function start(options) {
         explain(error, log);
         return assignment ? REFUSED : 1;
     }
+    finally {
+        loose();
+    }
 }
 /** Runs a bot until it is stopped or Discord refuses it. */
 async function run(project, connection, stopped, connected, { tasks = true } = {}) {

package/dist/cli/test.js

@@ -67,7 +67,7 @@ function where(error, cwd) {
 }
 /** Runs the whole project in a fresh world; `close` ends it. */
 async function startSession(project, observer, stores) {
-    stores.clear();
+    stores.reset();
     observer.reset();
     const world = new World();
     await world.start();
@@ -179,7 +179,9 @@ async function run(options, src, output) {
         cwd,
         version: options.version,
         log: capture.log,
-        stores,
+        // Every store, wherever it says it keeps its data, is in memory here:
+        // a test never needs a Redis, and starts from nothing.
+        stores: { file: stores, redis: stores },
         observe: observer.observe,
     });
     await writeTypes(cwd);