meocord 4.1.1 → 4.2.0

package/dist/cjs/core/index.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-BMMLp2SN.cjs');
+var providers = require('../_shared/providers-ChvMqnLd.cjs');
 var inversify = require('inversify');
 var discord_js = require('discord.js');
-var controller_decorator = require('../_shared/controller.decorator-BywwkU9O.cjs');
+var controller_decorator = require('../_shared/controller.decorator-CRn9kWob.cjs');
 require('node:crypto');
-var shardedCooldownStore = require('../_shared/sharded-cooldown-store-B65iaiAy.cjs');
+var shardedCooldownStore = require('../_shared/sharded-cooldown-store-BdAUTdYs.cjs');
 var path$1 = require('path');
-var startupRoots = require('../_shared/startup-roots-lFc69AxC.cjs');
+var startupRoots = require('../_shared/startup-roots-CQo8mSP8.cjs');
 var enum_index = require('../enum/index.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
@@ -23,7 +23,7 @@ require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-BnM8FbSH.cjs');
+require('../_shared/translate-error-DhDVbT5M.cjs');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -1510,14 +1510,14 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  */ function bindDependencies(container, cls, providers$1) {
     // A provided class is bound by its own provider, wherever in the list that provider comes
     if (container.isBound(cls) || providers$1.has(cls)) return;
-    if (providers.injectedTokens(cls).includes(controller_decorator.ExecutionContext)) throw controller_decorator.refuse(providers.singletonContextError(cls));
+    if (providers.injectedTokens(cls).includes(controller_decorator.ExecutionContext)) return controller_decorator.startupError(providers.singletonContextError(cls));
     providers.assertStartupChecked(container, cls);
     providers.makeInjectable(cls);
     container.bind(cls).toSelf().inSingletonScope();
     // By constructor type or @inject token; an interface-typed parameter records Object, which is skipped
     for (const dep of providers.injectedTokens(cls)){
-        if (dep === controller_decorator.Translator && !container.isBound(controller_decorator.Translator)) throw controller_decorator.refuse(controller_decorator.missingTranslatorError(cls));
-        if (providers.isAppClassToken(dep)) bindDependencies(container, dep, providers$1);
+        if (dep === controller_decorator.Translator && !container.isBound(controller_decorator.Translator)) controller_decorator.startupError(controller_decorator.missingTranslatorError(cls));
+        else if (providers.isAppClassToken(dep)) bindDependencies(container, dep, providers$1);
     }
 }
 /**
@@ -1583,34 +1583,51 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
    *   load, naming the file and the reason, with what to do about it, when a provider cannot
    *   be bound, such as one for a token MeoCord binds itself, when two handlers take one command, or two builder
    *   classes build one, naming both, and for any other mistake it refuses as the app loads, such as two component
-   *   patterns that match the same customIds. In a built application it is logged first, with where in the source it
-   *   comes from, so `isExplainedError()` tells a caller not to log it again; in a shard of process sharding, the
-   *   manager logs it.
+   *   patterns that match the same customIds. Each check reports every error it finds, and the first is thrown,
+   *   unchanged. When there are several, each is logged first, with where in the source it comes from; a lone one is
+   *   logged in a built application. Either way `isExplainedError()` then tells a caller not to log it again; in a
+   *   shard of process sharding, the manager logs it. With `startupErrors: 'all'` in `meocord.config.ts`, the errors
+   *   decorators kept are among them.
    */ static create(target) {
         try {
             return this.createApplication(target);
         } catch (error) {
             // A shard ends, so its manager restarts it, or stops every shard for a refusal, which it logs
             if (shardedCooldownStore.isShardProcess()) endFailedShard(error);
-            else if (controller_decorator.isBuiltApplication() && controller_decorator.isRefusal(error) && !controller_decorator.isExplainedError(error)) {
-                this.logger.error(controller_decorator.describeRefusal(error, process.cwd()));
-                controller_decorator.markExplained(error);
+            else if (controller_decorator.isRefusal(error) && !controller_decorator.isExplainedError(error)) {
+                // Every startup error found together is logged, in a test too; a lone one is logged in a built application
+                if (controller_decorator.logStartupErrors(error, (text)=>this.logger.error(text), 'the bot did not start')) controller_decorator.markExplained(error);
+                else if (controller_decorator.isBuiltApplication()) {
+                    this.logger.error(controller_decorator.describeRefusal(error, process.cwd()));
+                    controller_decorator.markExplained(error);
+                }
             }
             throw error;
         }
     }
     static createApplication(target) {
         const options = Reflect.getMetadata(controller_decorator.META.appOptions, target);
+        // With startupErrors: 'all', what the decorators kept: a built bot's every one, else the app's and its controllers'
+        const declared = controller_decorator.isBuiltApplication() ? controller_decorator.allDeclaredErrors() : controller_decorator.declaredErrorsOf([
+            target,
+            ...options?.controllers ?? []
+        ]);
         if (!options) {
+            // A refused @MeoCord stores no options, so its own errors say why
+            controller_decorator.collectStartupErrors(()=>declared.forEach(controller_decorator.startupError));
             throw controller_decorator.refuse(new Error(`${typeof target === 'function' ? target.name : String(target)}: not decorated with @MeoCord(), so there is no app to create.`));
         }
         const meocordConfig = controller_decorator.loadMeoCordConfig();
         if (!meocordConfig) {
             throw controller_decorator.refuse(new Error(controller_decorator.compiledConfigMessage()));
         }
-        // Before any of the three ways a bot runs, so none registers or dispatches a command only one handler could take
-        startupRoots.assertDistinctCommands(options.controllers);
-        const providers$1 = providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
+        // Before any of the three ways a bot runs, so none registers or dispatches a command only one handler could take; every
+        // error each check finds is reported, the first thrown
+        const providers$1 = controller_decorator.collectStartupErrors(()=>{
+            declared.forEach(controller_decorator.startupError);
+            startupRoots.assertDistinctCommands(options.controllers);
+            return providers.providerMap(options.providers ?? [], '@MeoCord({ providers })');
+        });
         // A themeFor class is bound on its own, as the cooldown store is, and resolved like a service
         const themeResolver = controller_decorator.themeResolverClass(options.themeFor);
         // The app's classes and every class they inject, which the container binds
@@ -1652,153 +1669,174 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                 config: meocordConfig
             });
         }
-        // Every class the app runs, its stages and presenter included, checked before binding, where inversify would
-        // otherwise fail first with an error about compiler options, or a guard only at its first call
-        const stages = providers.appStages(target);
-        const runs = startupRoots.startupClasses({
-            controllers: options.controllers,
-            services: options.services ?? [],
-            providers: providers$1,
-            stages,
-            presenter: options.presenter,
-            cooldownStore: options.cooldownStore,
-            themeFor: options.themeFor,
-            observers: providers.appObservers(target)
-        });
-        startupRoots.assertStartupClasses(runs, {
-            translator: options.i18n !== undefined || providers$1.has(controller_decorator.Translator)
-        });
-        const container = new inversify.Container();
-        const translator = options.i18n !== undefined || providers$1.has(controller_decorator.Translator);
-        providers.markStartupChecked(container, [
-            ...runs.classes,
-            ...providers.meocordClasses()
-        ], startupRoots.lateGuardCheck(providers$1, translator));
-        providers.bindGlobalStages(container, stages);
-        // Bind the Discord client as a constant value
-        const discordClient = new discord_js.Client(shardedCooldownStore.clientOptionsWithSharding(this.effectiveConfig(meocordConfig), options.clientOptions));
-        container.bind(discord_js.Client).toConstantValue(discordClient);
-        if (options.i18n) {
-            container.bind(controller_decorator.Translator).toConstantValue(options.i18n);
-            providers.bindsOwnToken(container, controller_decorator.Translator);
-        }
-        // Bound before the app's classes, so a class that injects it gets this instance; filled once they are bound
-        const appClasses = [];
-        container.bind(providers.HandlerRegistry).toConstantValue(new providers.HandlerRegistry(appClasses, options.messages, ()=>options.i18n));
-        container.bind(providers.ShardContext).toConstantValue(new providers.ShardContext(discordClient, (service, method, args)=>Reflect.get(discordClient, providers.SHARD_CALL_KEY)(service, method, args)));
-        providers.bindsOwnToken(container, providers.HandlerRegistry);
-        providers.bindsOwnToken(container, providers.ShardContext);
-        container.bind(providers.COOLDOWN_POLICY).toConstantValue(providers.cooldownPolicyFrom(options));
-        // A store of the app's own is resolved like a service, so it can inject its client
-        if (options.cooldownStore) {
-            bindDependencies(container, options.cooldownStore, providers$1);
-            container.bind(controller_decorator.CooldownStore).toService(options.cooldownStore);
-        } else {
-            container.bind(controller_decorator.CooldownStore).toConstantValue(new controller_decorator.MemoryCooldownStore());
-        }
-        // A class that injects the token depends on the app's store, the one unit whose hooks run
-        providers.bindsOwnToken(container, controller_decorator.CooldownStore, options.cooldownStore);
-        // After MeoCord's own tokens, which a provider may not replace, and before the app's classes, so
-        // a class token that is provided is not also bound as itself
-        for (const [token, provider] of providers$1){
-            if (container.isBound(token)) {
-                throw controller_decorator.refuse(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${providers.tokenName(token)}, which MeoCord binds itself.`));
+        // The checks of what the app binds and runs report every error each finds, and the first is thrown
+        return controller_decorator.collectStartupErrors(()=>{
+            // Every class the app runs, its stages and presenter included, checked before binding, where inversify would
+            // otherwise fail first with an error about compiler options, or a guard only at its first call
+            const stages = providers.appStages(target);
+            const runs = startupRoots.startupClasses({
+                controllers: options.controllers,
+                services: options.services ?? [],
+                providers: providers$1,
+                stages,
+                presenter: options.presenter,
+                cooldownStore: options.cooldownStore,
+                themeFor: options.themeFor,
+                observers: providers.appObservers(target)
+            });
+            startupRoots.assertStartupClasses(runs, {
+                translator: options.i18n !== undefined || providers$1.has(controller_decorator.Translator)
+            });
+            // Outside a built application, the kept errors of the stages and other classes the app's classes reach
+            if (!controller_decorator.isBuiltApplication()) controller_decorator.declaredErrorsOf(runs.classes).forEach(controller_decorator.startupError);
+            // The checks of the wiring below run on classes that passed these, so a mistake in one is not reported again there
+            controller_decorator.stopOnStartupErrors();
+            // The checks bind into this container and change nothing else: what they bind is made once all have passed
+            const container = new inversify.Container();
+            const translator = options.i18n !== undefined || providers$1.has(controller_decorator.Translator);
+            providers.markStartupChecked(container, [
+                ...runs.classes,
+                ...providers.meocordClasses()
+            ], startupRoots.lateGuardCheck(providers$1, translator));
+            providers.bindGlobalStages(container, stages);
+            // Bound now, so no provider stands in for it; made once the checks pass, the one Client the app logs in with
+            const clientOptions = shardedCooldownStore.clientOptionsWithSharding(this.effectiveConfig(meocordConfig), options.clientOptions);
+            container.bind(discord_js.Client).toDynamicValue(()=>new discord_js.Client(clientOptions)).inSingletonScope();
+            if (options.i18n) {
+                container.bind(controller_decorator.Translator).toConstantValue(options.i18n);
+                providers.bindsOwnToken(container, controller_decorator.Translator);
             }
-            providers.bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers$1));
-        }
-        // Bind all controllers and their transitive dependencies
-        for (const ctrl of options.controllers){
-            bindDependencies(container, ctrl, providers$1);
-        }
-        for (const svc of options.services ?? []){
-            bindDependencies(container, svc, providers$1);
-        }
-        if (themeResolver) bindDependencies(container, themeResolver, providers$1);
-        // Observers are services too: bound here so their lifecycle hooks run in dependency order
-        const observers = providers.appObservers(target);
-        for (const observer of observers)bindDependencies(container, observer, providers$1);
-        // Providers first, then the services, the controllers and the observers, each after what it depends on. The app's
-        // own classes, which a class injecting CooldownStore does not make of the store
-        const order = providers.resolutionOrder(container, providers$1, [
-            ...providers$1.keys(),
-            ...options.services ?? [],
-            ...themeResolver ? [
-                themeResolver
-            ] : [],
-            ...options.controllers,
-            ...observers
-        ], {
-            followOwnTokens: false
-        });
-        appClasses.push(...order.filter((token)=>{
-            const provider = providers$1.get(token);
-            return providers.isAppClassToken(token) && (!provider || providers.isClassProvider(provider) && provider.useClass === token);
-        }));
-        providers.assertProvided(container, providers$1, runs.classes, '@MeoCord({ providers })');
-        // The store first, after only what it injects: it is ready before anything a call reaches, and shuts down last
-        const store = options.cooldownStore;
-        const lifecycle = (store ? providers.resolutionOrder(container, providers$1, [
-            store,
-            ...order
-        ]) : order).map((token)=>({
-                token,
-                name: providers.tokenName(token),
-                dependencies: providers.tokenDependencies(container, providers$1, token),
-                ...token === store && {
-                    cooldownStore: true
-                }
-            }));
-        // What ShardContext.call reaches: the app's classes, and the classes its providers stand in for
-        const callable = [
-            ...new Set([
-                ...appClasses,
-                ...[
-                    ...providers$1.keys()
-                ].filter(providers.isAppClassToken)
-            ])
-        ];
-        // From another shard a call names its class, so with process sharding every name it can reach is one class's
-        if (meocordConfig.sharding?.mode === 'process') {
-            const names = new Set();
-            for (const cls of callable){
-                if (names.has(cls.name)) {
-                    throw controller_decorator.refuse(new Error(`${cls.name}: two classes have this name; with process sharding, ShardContext.call finds a class in another ` + 'shard by its name, so give each controller, service and provided class a distinct name.'));
+            // Bound before the app's classes, so a class that injects it gets this instance; filled once they are bound
+            const appClasses = [];
+            container.bind(providers.HandlerRegistry).toConstantValue(new providers.HandlerRegistry(appClasses, options.messages, ()=>options.i18n));
+            container.bind(providers.ShardContext).toDynamicValue(()=>{
+                const client = container.get(discord_js.Client);
+                return new providers.ShardContext(client, (service, method, args)=>Reflect.get(client, providers.SHARD_CALL_KEY)(service, method, args));
+            }).inSingletonScope();
+            providers.bindsOwnToken(container, providers.HandlerRegistry);
+            providers.bindsOwnToken(container, providers.ShardContext);
+            container.bind(providers.COOLDOWN_POLICY).toConstantValue(providers.cooldownPolicyFrom(options));
+            // A store of the app's own is resolved like a service, so it can inject its client
+            if (options.cooldownStore) {
+                bindDependencies(container, options.cooldownStore, providers$1);
+                container.bind(controller_decorator.CooldownStore).toService(options.cooldownStore);
+            } else {
+                container.bind(controller_decorator.CooldownStore).toConstantValue(new controller_decorator.MemoryCooldownStore());
+            }
+            // A class that injects the token depends on the app's store, the one unit whose hooks run
+            providers.bindsOwnToken(container, controller_decorator.CooldownStore, options.cooldownStore);
+            // After MeoCord's own tokens, which a provider may not replace, and before the app's classes, so
+            // a class token that is provided is not also bound as itself
+            for (const [token, provider] of providers$1){
+                if (container.isBound(token)) {
+                    controller_decorator.startupError(new Error(`${target.name}: @MeoCord({ providers }) cannot provide ${providers.tokenName(token)}, which MeoCord binds itself.`));
+                    continue;
                 }
-                names.add(cls.name);
+                providers.bindProvider(container, provider, (cls)=>bindDependencies(container, cls, providers$1));
             }
-        }
-        Reflect.set(discordClient, providers.SHARD_CALL_KEY, providers.shardCallHandler(container, ()=>callable, 'this app'));
-        // Stamp every class the app runs with the container, so @UseGuard resolves guards on a direct call to any of them
-        for (const cls of runs.classes){
-            Reflect.defineMetadata(controller_decorator.META.container, container, cls);
-        }
-        providers.prepareHandlerStages(container, appClasses);
-        providers.bindObservers(container, observers);
-        // Run by start() before it logs in: what may inject a provided value is resolved once every factory
-        // has made its value, including those that return a promise
-        const logger = this.logger;
-        const startup = async ()=>{
-            try {
-                await providers.resolveProviders(container, providers$1, order);
-            } catch (error) {
-                logger.error(`${error.message}. The bot cannot start without it.`);
-                logger.debug('Provider failure:', error.cause);
-                controller_decorator.markExplained(error);
-                throw error;
+            // Bind all controllers and their transitive dependencies
+            for (const ctrl of options.controllers){
+                bindDependencies(container, ctrl, providers$1);
             }
-            // The listed services are made now, so constructors that attach listeners or connect run before login
             for (const svc of options.services ?? []){
-                container.get(svc);
+                bindDependencies(container, svc, providers$1);
+            }
+            if (themeResolver) bindDependencies(container, themeResolver, providers$1);
+            // Observers are services too: bound here so their lifecycle hooks run in dependency order
+            const observers = providers.appObservers(target);
+            for (const observer of observers)bindDependencies(container, observer, providers$1);
+            // What follows walks what these bound, so a class refused here is not reported again as missing
+            controller_decorator.stopOnStartupErrors();
+            // Providers first, then the services, the controllers and the observers, each after what it depends on. The app's
+            // own classes, which a class injecting CooldownStore does not make of the store
+            const order = providers.resolutionOrder(container, providers$1, [
+                ...providers$1.keys(),
+                ...options.services ?? [],
+                ...themeResolver ? [
+                    themeResolver
+                ] : [],
+                ...options.controllers,
+                ...observers
+            ], {
+                followOwnTokens: false
+            });
+            appClasses.push(...order.filter((token)=>{
+                const provider = providers$1.get(token);
+                return providers.isAppClassToken(token) && (!provider || providers.isClassProvider(provider) && provider.useClass === token);
+            }));
+            providers.assertProvided(container, providers$1, runs.classes, '@MeoCord({ providers })');
+            // The store first, after only what it injects: it is ready before anything a call reaches, and shuts down last
+            const store = options.cooldownStore;
+            const lifecycle = (store ? providers.resolutionOrder(container, providers$1, [
+                store,
+                ...order
+            ]) : order).map((token)=>({
+                    token,
+                    name: providers.tokenName(token),
+                    dependencies: providers.tokenDependencies(container, providers$1, token),
+                    ...token === store && {
+                        cooldownStore: true
+                    }
+                }));
+            // What ShardContext.call reaches: the app's classes, and the classes its providers stand in for
+            const callable = [
+                ...new Set([
+                    ...appClasses,
+                    ...[
+                        ...providers$1.keys()
+                    ].filter(providers.isAppClassToken)
+                ])
+            ];
+            // From another shard a call names its class, so with process sharding every name it can reach is one class's
+            if (meocordConfig.sharding?.mode === 'process') {
+                const names = new Set();
+                for (const cls of callable){
+                    if (names.has(cls.name)) {
+                        controller_decorator.startupError(new Error(`${cls.name}: two classes have this name; with process sharding, ShardContext.call finds a class in another ` + 'shard by its name, so give each controller, service and provided class a distinct name.'));
+                        continue;
+                    }
+                    names.add(cls.name);
+                }
             }
-            if (shardedCooldownStore.shardingRole(meocordConfig) === 'shard' && container.get(controller_decorator.CooldownStore) instanceof controller_decorator.MemoryCooldownStore) {
-                warnPerShardCooldowns(options.controllers, logger);
+            providers.prepareHandlerStages(container, appClasses);
+            providers.bindObservers(container, observers);
+            // Read here with the rest, so a pattern that cannot be read is reported with them, before the dispatcher warns
+            providers.buildMessageRoutes(options.controllers, options.messages);
+            // Every check has run, and touched only the container: from here the app is made, once none found an error
+            controller_decorator.stopOnStartupErrors();
+            const discordClient = container.get(discord_js.Client);
+            Reflect.set(discordClient, providers.SHARD_CALL_KEY, providers.shardCallHandler(container, ()=>callable, 'this app'));
+            // Stamp every class the app runs with the container, so @UseGuard resolves guards on a direct call to any of them
+            for (const cls of runs.classes){
+                Reflect.defineMetadata(controller_decorator.META.container, container, cls);
             }
-            providers.bindAppPresenter(container, target, discordClient);
-            providers.registerClientTheme(discordClient, container);
-            controller_decorator.registerClientTranslator(discordClient, options.i18n);
-        };
-        return new MeoCordApp(options.controllers, container, discordClient, meocordConfig.discordToken, options.activities, appClasses, meocordConfig.shutdownTimeout, startup, lifecycle, options.messages, // In development only, unless the app says otherwise
-        options.warnUnanswered ?? process.env.NODE_ENV === 'development');
+            providers.prepareThemes(container, appClasses);
+            // Run by start() before it logs in: what may inject a provided value is resolved once every factory
+            // has made its value, including those that return a promise
+            const logger = this.logger;
+            const startup = async ()=>{
+                try {
+                    await providers.resolveProviders(container, providers$1, order);
+                } catch (error) {
+                    logger.error(`${error.message}. The bot cannot start without it.`);
+                    logger.debug('Provider failure:', error.cause);
+                    controller_decorator.markExplained(error);
+                    throw error;
+                }
+                // The listed services are made now, so constructors that attach listeners or connect run before login
+                for (const svc of options.services ?? []){
+                    container.get(svc);
+                }
+                if (shardedCooldownStore.shardingRole(meocordConfig) === 'shard' && container.get(controller_decorator.CooldownStore) instanceof controller_decorator.MemoryCooldownStore) {
+                    warnPerShardCooldowns(options.controllers, logger);
+                }
+                providers.bindAppPresenter(container, target, discordClient);
+                providers.registerClientTheme(discordClient, container);
+                controller_decorator.registerClientTranslator(discordClient, options.i18n);
+            };
+            return new MeoCordApp(options.controllers, container, discordClient, meocordConfig.discordToken, options.activities, appClasses, meocordConfig.shutdownTimeout, startup, lifecycle, options.messages, // In development only, unless the app says otherwise
+            options.warnUnanswered ?? process.env.NODE_ENV === 'development');
+        });
     }
 }
 MeoCordFactory.logger = new controller_decorator.Logger();