meocord 4.2.0 → 4.2.2

package/dist/cjs/decorator/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('reflect-metadata');
-var providers = require('../_shared/providers-ChvMqnLd.cjs');
-var controller_decorator = require('../_shared/controller.decorator-CRn9kWob.cjs');
+var providers = require('../_shared/providers-B4MOFBrW.cjs');
+var controller_decorator = require('../_shared/controller.decorator-U2NBWcoU.cjs');
 var inversify = require('inversify');
 require('node:async_hooks');
 require('../enum/index.cjs');
@@ -123,10 +123,10 @@ require('chalk');
  * which has already run the guards, passes through every wrapper.
  */ function applyGuards(descriptor, prototype, propertyKey) {
     const originalMethod = descriptor.value;
-    descriptor.value = async function(...args) {
+    descriptor.value = controller_decorator.wrapsMethod(async function(...args) {
         if (providers.consumeDispatchMark(args[0], this, propertyKey)) return originalMethod.apply(this, args);
         return providers.runDirectCall(this, propertyKey, args, ()=>originalMethod.apply(this, args));
-    };
+    }, originalMethod);
     const wrappers = Reflect.getOwnMetadata(controller_decorator.META.guardWrappers, prototype, propertyKey) ?? 0;
     Reflect.defineMetadata(controller_decorator.META.guardWrappers, wrappers + 1, prototype, propertyKey);
 }
@@ -447,14 +447,14 @@ require('chalk');
         controller_decorator.refuseOnMethod('@Catch', target, propertyKey);
         providers.makeInjectable(target);
         errorTypes.forEach((type, index)=>{
-            if (controller_decorator.isConstructor(type)) return;
+            if (controller_decorator.isConstructible(type)) return;
             const entry = ORDINALS[index] ? `${ORDINALS[index]} entry` : `entry ${index + 1}`;
-            controller_decorator.warnDeprecatedBehaviour(logger, `${target.name}: @Catch's ${entry}, ${controller_decorator.describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
+            controller_decorator.warnDeprecatedBehaviour(logger$1, `${target.name}: @Catch's ${entry}, ${controller_decorator.describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
         });
         Reflect.defineMetadata(controller_decorator.META.catchTypes, errorTypes, target);
     });
 }
-const logger = new controller_decorator.Logger('Catch');
+const logger$1 = new controller_decorator.Logger('Catch');
 const ORDINALS = [
     'first',
     'second',
@@ -555,6 +555,35 @@ const ORDINALS = [
         if (type.labelKey !== undefined) assertLabelKey(appName, name, type.labelKey, i18n);
     }
 }
+/**
+ * Refuses an option that takes a class given anything else, such as an object or an arrow function, where the app is
+ * declared: the startup checks read each class's prototype, and would otherwise fail on it without naming the option.
+ */ function assertClassOptions(appName, { presenter, cooldownStore, controllers, services }) {
+    for (const [name, value, implementing] of [
+        [
+            'presenter',
+            presenter,
+            'ResponsePresenter'
+        ],
+        [
+            'cooldownStore',
+            cooldownStore,
+            'CooldownStore'
+        ]
+    ]){
+        if (value !== undefined && !controller_decorator.isConstructor(value)) {
+            throw controller_decorator.refuse(new TypeError(`${appName}: @MeoCord({ ${name} }) takes a class implementing ${implementing}, not ${controller_decorator.describeValue(value)}.`));
+        }
+    }
+    for (const controller of controllers ?? []){
+        if (!controller_decorator.isConstructor(controller)) throw controller_decorator.refuse(new TypeError(`${appName}: @MeoCord({ controllers }) takes classes, not ${controller_decorator.describeValue(controller)}.`));
+    }
+    // A string or symbol is a token, which a provider has to provide; that is checked as the app is created
+    for (const service of services ?? []){
+        if (controller_decorator.isConstructor(service) || typeof service === 'string' || typeof service === 'symbol') continue;
+        throw controller_decorator.refuse(new TypeError(`${appName}: @MeoCord({ services }) takes classes, or tokens that providers provide, not ${controller_decorator.describeValue(service)}.`));
+    }
+}
 /** Refuses a type's `labelKey` that no message of the app's default catalog has, as it would be shown as the key. */ function assertLabelKey(appName, name, labelKey, i18n) {
     const where = `${appName}: @MeoCord({ messages: { types } }): "${name}" has labelKey`;
     if (typeof labelKey !== 'string') throw controller_decorator.refuse(new TypeError(`${where} ${String(labelKey)}; it takes a message key, such as 'types.${name}'.`));
@@ -599,6 +628,7 @@ const ORDINALS = [
  */ function MeoCord(options) {
     return controller_decorator.declaring((target, propertyKey)=>{
         if (controller_decorator.deprecatedOnMethod('@MeoCord', target, propertyKey)) return;
+        assertClassOptions(target.name, options);
         providers.assertStageEntries('@MeoCord({ guards })', 'guard', target.name, options.guards ?? []);
         providers.assertStageEntries('@MeoCord({ interceptors })', 'interceptor', target.name, options.interceptors ?? []);
         providers.assertStageEntries('@MeoCord({ filters })', 'filter', target.name, options.filters ?? []);
@@ -799,6 +829,7 @@ function Cooldown(options) {
         // Checked where it applies, so the refusal names the handler or controller
         const problem = cooldownProblem(seconds, uses, per, by);
         if (problem) throw controller_decorator.refuse(new Error(`${controller_decorator.decoratedName(target, propertyKey)}: ${problem}`));
+        for (const warning of cooldownWarnings(options))logger.warn(`${controller_decorator.decoratedName(target, propertyKey)}: ${warning}`);
         // Decorators apply bottom-up; prepending keeps them in the order they read.
         if (propertyKey === undefined) {
             const existing = Reflect.getOwnMetadata(controller_decorator.META.classCooldowns, target) ?? [];
@@ -819,6 +850,20 @@ function Cooldown(options) {
  * The longest window, in seconds: half the furthest time a `Date` holds, 8.64e15 ms, so the moment a wait ends, now
  * plus the window, is a real date for a refusal's `retryAt` and the time it shows.
  */ const MAX_SECONDS = 4320000000000;
+const logger = new controller_decorator.Logger('Cooldown');
+/**
+ * What a cooldown's options get wrong that the types refuse, yet still counts: a `bypass` that is not a function, which
+ * fails every call, and a `seconds` that is not a number, read as one. A falsy `bypass` means none.
+ */ function cooldownWarnings({ seconds, bypass }) {
+    const warnings = [];
+    if (bypass && typeof bypass !== 'function') {
+        warnings.push(`@Cooldown takes bypass as a function of the call, returning whether the call skips the cooldown, not ${controller_decorator.describeValue(bypass)}; ` + 'every call it counts fails with it. In the next major version (5.0) it is refused.');
+    }
+    if (typeof seconds !== 'number') {
+        warnings.push(`@Cooldown takes seconds as a number, not ${controller_decorator.describeValue(seconds)}, which it counts as a window of ` + `${Math.round(seconds * 1000)} ms. In the next major version (5.0) it is refused.`);
+    }
+    return warnings;
+}
 /** Why a cooldown's options cannot be counted, or undefined when they can. */ function cooldownProblem(seconds, uses, per, by) {
     if (!(seconds >= 0.001 && seconds <= MAX_SECONDS)) return `@Cooldown needs a number of seconds from 0.001 to ${MAX_SECONDS}, not ${seconds}.`;
     if (!Number.isInteger(uses) || uses < 1) return `@Cooldown needs a whole number of uses of at least 1, not ${uses}.`;