meocord 1.8.4 → 2.0.0-beta.2

package/README.md

@@ -41,7 +41,7 @@
 
 ### Prerequisites
 
-- **Runtime**: Node.js (latest LTS) or Bun 1.x+
+- **Runtime**: Node.js 22 or newer, or Bun 1.x+
 - **TypeScript**: 5.0+
 - **Package manager**: npm, yarn, pnpm, or bun
 
@@ -410,6 +410,33 @@ interaction.guildId = 'guild-123'
 
 Works for any discord.js class — interactions, `Message`, `MessageReaction`, and anything else. No per-type maintenance.
 
+**Assignable to the real class** — the returned mock can be passed straight to code that expects the discord.js type. No `as unknown as ButtonInteraction` at the call site.
+
+```typescript
+const interaction = createMockInteraction(ButtonInteraction)
+
+await controller.handleButton(interaction) // takes a real ButtonInteraction
+```
+
+**Property overrides at construction** — pass a second argument to set properties as the mock is built. This is required for anything discord.js declares `readonly` (`ModalSubmitInteraction#customId` and `#fields`, `MessageComponentInteraction#message`, `client`, `guildId` on some classes), since those cannot be assigned afterwards. It is also how you set a property backed by a getter-only prototype accessor, such as `targetUser` or `targetMessage` on a context menu.
+
+```typescript
+import { createMockInteraction, createMockUser } from 'meocord/testing'
+import { ModalSubmitInteraction, UserContextMenuCommandInteraction } from 'discord.js'
+
+const modal = createMockInteraction(ModalSubmitInteraction, {
+  customId: 'wish-import-800000000',
+  fields: { getTextInputValue: () => '{"pulls":[]}' } as unknown as ModalSubmitInteraction['fields'],
+})
+
+const contextMenu = createMockInteraction(UserContextMenuCommandInteraction, {
+  commandName: 'profile',
+  targetUser: createMockUser(),
+})
+```
+
+The override record is typed as `MockProps<T>`, exported from `meocord/testing`. Every key is optional, and a misspelled property name is a compile error.
+
 ### `createChatInputOptions`
 
 Builds a typed options resolver from a plain record. Type routing mirrors the real `CommandInteractionOptionResolver`: wrong-type access returns `null`, `required=true` throws if the option is absent.
@@ -502,6 +529,19 @@ const module = MeoCordTestingModule.create({
 
 `canActivate: () => true` allows the method to run. `() => false` blocks it. Multiple guards chain fluently.
 
+### `overrideProvider`
+
+Replaces a provider already registered on the module. The value is typed as `Partial<T>`, so a double only has to cover the methods the test exercises — a class with a private member could never be satisfied by a full object literal anyway. A misspelled method name is still a compile error.
+
+```typescript
+const module = MeoCordTestingModule.create({
+  controllers: [GreetingSlashController],
+  providers: [{ provide: GreetingService, useValue: realGreetingService }],
+})
+  .overrideProvider(GreetingService).useValue({ buildGreeting: createMockFn() })
+  .compile()
+```
+
 ### Full example
 
 ```typescript

package/dist/cjs/testing/index.cjs

@@ -22,7 +22,13 @@ function isValueProvider(p) {
  * Builder returned by `MeoCordTestingModule.create()`.
  * Call `.compile()` to get the resolved `TestingModule`.
  */ class TestingModuleBuilder {
-    overrideProvider(token) {
+    /**
+   * A double covers the methods under test, not the whole class — and a class
+   * with any private member (a service holding a logger, say) can never be
+   * satisfied by an object literal at all. `Partial<T>` still rejects a
+   * misspelled method name, which is the check that actually earns its keep.
+   * Matches `overrideGuard`, which has always taken `Partial<GuardInterface>`.
+   */ overrideProvider(token) {
         return {
             useValue: (value)=>{
                 this.overrides.set(token, {
@@ -355,8 +361,17 @@ function stubDeep(instance, externalStubs) {
             stubs.set(key, stub);
             return stub;
         },
+        // defineProperty rather than assignment: many discord.js properties are
+        // prototype getters with no setter (targetUser, targetMessage, createdAt),
+        // and a plain write against one of those is a silent no-op. Defining an own
+        // data property shadows the accessor, which is what test setup means.
         set (target, prop, value) {
-            Reflect.set(target, prop, value, target);
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
             return true;
         }
     });
@@ -481,7 +496,7 @@ function findPrototypeMethod(instance, name) {
  * interaction.replied        // → true
  * await interaction.reply({}) // throws — already replied
  * ```
- */ function createMockInteraction(Class) {
+ */ function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
     // Set type fields so all prototype type-guard methods compute the right value
@@ -551,6 +566,19 @@ function findPrototypeMethod(instance, name) {
             }));
         }
     }
+    // Applied last so an explicit prop wins over the type fields and the reply
+    // state machine. defineProperty rather than assignment for the same reason the
+    // Proxy uses it: several of these shadow a getter-only prototype accessor.
+    if (props !== undefined) {
+        for (const [key, value] of Object.entries(props)){
+            Object.defineProperty(instance, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
     return stubDeep(instance, stubs);
 }
 // ---------------------------------------------------------------------------
@@ -719,7 +747,14 @@ function createMockMessage() {
  * interaction.options.getSubcommand()  // → 'notes'
  * interaction.options.getNumber('uid') // → 12345678
  * ```
- */ function createChatInputOptions(opts = {}) {
+ */ // `any` is the default rather than `CacheType` because TypeScript types a generic
+// class's `prototype` with `any` for its parameters, and createMockInteraction infers
+// T from exactly that — `createMockInteraction(ChatInputCommandInteraction)` produces
+// an interaction whose `options` is `CommandInteractionOptionResolver<any>`. Defaulting
+// to `CacheType` instead makes CacheTypeReducer widen getChannel's return with a `null`
+// the target rejects, and the resolver stops being assignable to the property it exists
+// to fill. Pass Cached explicitly when the interaction under test is pinned.
+function createChatInputOptions(opts = {}) {
     const { subcommandGroup = null, subcommand = null, ...values } = opts;
     function resolveOrThrow(name, value, required) {
         if (value === null) {

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "1.2.6";
+var version = "0.0.0-development";
 var packageJson = {
 	version: version};
 

package/dist/esm/testing/meocord-testing-module.js

@@ -19,7 +19,13 @@ function isValueProvider(p) {
  * Builder returned by `MeoCordTestingModule.create()`.
  * Call `.compile()` to get the resolved `TestingModule`.
  */ class TestingModuleBuilder {
-    overrideProvider(token) {
+    /**
+   * A double covers the methods under test, not the whole class — and a class
+   * with any private member (a service holding a logger, say) can never be
+   * satisfied by an object literal at all. `Partial<T>` still rejects a
+   * misspelled method name, which is the check that actually earns its keep.
+   * Matches `overrideGuard`, which has always taken `Partial<GuardInterface>`.
+   */ overrideProvider(token) {
         return {
             useValue: (value)=>{
                 this.overrides.set(token, {

package/dist/esm/testing/mock-interaction.js

@@ -48,8 +48,17 @@ function stubDeep(instance, externalStubs) {
             stubs.set(key, stub);
             return stub;
         },
+        // defineProperty rather than assignment: many discord.js properties are
+        // prototype getters with no setter (targetUser, targetMessage, createdAt),
+        // and a plain write against one of those is a silent no-op. Defining an own
+        // data property shadows the accessor, which is what test setup means.
         set (target, prop, value) {
-            Reflect.set(target, prop, value, target);
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
             return true;
         }
     });
@@ -174,7 +183,7 @@ function findPrototypeMethod(instance, name) {
  * interaction.replied        // → true
  * await interaction.reply({}) // throws — already replied
  * ```
- */ function createMockInteraction(Class) {
+ */ function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
     // Set type fields so all prototype type-guard methods compute the right value
@@ -244,6 +253,19 @@ function findPrototypeMethod(instance, name) {
             }));
         }
     }
+    // Applied last so an explicit prop wins over the type fields and the reply
+    // state machine. defineProperty rather than assignment for the same reason the
+    // Proxy uses it: several of these shadow a getter-only prototype accessor.
+    if (props !== undefined) {
+        for (const [key, value] of Object.entries(props)){
+            Object.defineProperty(instance, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
     return stubDeep(instance, stubs);
 }
 // ---------------------------------------------------------------------------
@@ -412,7 +434,14 @@ function createMockMessage() {
  * interaction.options.getSubcommand()  // → 'notes'
  * interaction.options.getNumber('uid') // → 12345678
  * ```
- */ function createChatInputOptions(opts = {}) {
+ */ // `any` is the default rather than `CacheType` because TypeScript types a generic
+// class's `prototype` with `any` for its parameters, and createMockInteraction infers
+// T from exactly that — `createMockInteraction(ChatInputCommandInteraction)` produces
+// an interaction whose `options` is `CommandInteractionOptionResolver<any>`. Defaulting
+// to `CacheType` instead makes CacheTypeReducer widen getChannel's return with a `null`
+// the target rejects, and the resolver stops being assignable to the property it exists
+// to fill. Pass Cached explicitly when the interaction under test is pinned.
+function createChatInputOptions(opts = {}) {
     const { subcommandGroup = null, subcommand = null, ...values } = opts;
     function resolveOrThrow(name, value, required) {
         if (value === null) {

package/dist/types/decorator/index.d.ts

@@ -1,4 +1,4 @@
-import { C as CommandType } from '../controller.enum-QA-IuReF.js';
+import { CommandType } from '../enum/index.js';
 import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, ButtonInteraction, StringSelectMenuInteraction, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, ModalSubmitInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
 import { ReactionHandlerOptions, GuardInterface } from '../interface/index.js';
 import { ServiceIdentifier } from 'inversify';

package/dist/types/interface/index.d.ts

@@ -1,6 +1,6 @@
 import { User, PartialUser, BaseInteraction, Message, MessageReaction } from 'discord.js';
 import { Configuration } from 'webpack';
-import { R as ReactionHandlerAction } from '../controller.enum-QA-IuReF.js';
+import { ReactionHandlerAction } from '../enum/index.js';
 
 /**
  * MeoCord Framework

package/dist/types/testing/index.d.ts

@@ -1,6 +1,6 @@
 import { ServiceIdentifier, Container } from 'inversify';
 import { GuardInterface } from '../interface/index.js';
-import { CommandInteractionOptionResolver, Channel, Client, Guild, Message, User } from 'discord.js';
+import { CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User } from 'discord.js';
 import 'webpack';
 import '../controller.enum-QA-IuReF.js';
 
@@ -40,8 +40,15 @@ declare class TestingModuleBuilder {
     private readonly overrides;
     private readonly guardOverrides;
     constructor(options: TestingModuleOptions);
+    /**
+     * A double covers the methods under test, not the whole class — and a class
+     * with any private member (a service holding a logger, say) can never be
+     * satisfied by an object literal at all. `Partial<T>` still rejects a
+     * misspelled method name, which is the check that actually earns its keep.
+     * Matches `overrideGuard`, which has always taken `Partial<GuardInterface>`.
+     */
     overrideProvider<T>(token: ServiceIdentifier<T>): {
-        useValue: (value: T) => TestingModuleBuilder;
+        useValue: (value: Partial<T>) => TestingModuleBuilder;
     };
     overrideGuard(guard: new (...args: any[]) => GuardInterface): {
         useValue: (stub: Partial<GuardInterface>) => TestingModuleBuilder;
@@ -143,10 +150,35 @@ declare function createMockFn<T extends (...args: any[]) => any = (...args: any[
  * Recursively transforms all methods of T into MockedFunction and all
  * nested objects into DeepMocked. Depth cap at 5 prevents infinite recursion
  * on circular discord.js types (e.g. Guild ↔ GuildMember).
- * -readonly removes readonly modifiers so test setup can write any property.
+ *
+ * Intersected with `T` so the mock is accepted wherever the real class is
+ * expected. A mapped type alone can never be: it iterates `keyof T`, and the
+ * private members classes use as brands — discord.js stamps
+ * `private readonly _cacheType` on `BaseInteraction` — are not in `keyof T`.
+ * Without the intersection every call site has to launder the mock through
+ * `as unknown as T`, which defeats the point of typing it at all.
+ *
+ * The intersection is honest rather than a convenient lie: the object really is
+ * `Object.create(Class.prototype)`, so its prototype chain is the real one, and
+ * TypeScript `private` is erased at runtime.
+ *
+ * `readonly` survives from the `T` side, so properties the class declares
+ * readonly cannot be assigned after construction. Pass those to the factory as
+ * {@link MockProps} instead.
  */
 type DeepMocked<T, Depth extends number[] = []> = Depth['length'] extends 5 ? T : {
     -readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? MockedFunction<(...args: A) => R> : T[K] extends object ? DeepMocked<T[K], [...Depth, 0]> : T[K];
+} & T;
+/**
+ * Property overrides accepted at construction by the mock factories.
+ *
+ * Setup belongs here rather than in a post-construction assignment: the returned
+ * mock is assignable to the real discord.js class, so anything that class declares
+ * `readonly` — `ModalSubmitInteraction#customId`, `#fields`, `MessageComponentInteraction#message`
+ * — cannot be written afterwards without a cast.
+ */
+type MockProps<T> = {
+    -readonly [K in keyof T]?: T[K] extends (...args: any[]) => any ? (...args: any[]) => any : T[K];
 };
 interface InteractionClass<T> {
     prototype: T;
@@ -179,7 +211,7 @@ interface InteractionClass<T> {
  * await interaction.reply({}) // throws — already replied
  * ```
  */
-declare function createMockInteraction<T extends object>(Class: InteractionClass<T>): DeepMocked<T>;
+declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props?: MockProps<T>): DeepMocked<T>;
 /** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */
 declare const createMockUser: () => DeepMocked<User>;
 /**
@@ -240,7 +272,7 @@ interface ChatInputOptions {
  * interaction.options.getNumber('uid') // → 12345678
  * ```
  */
-declare function createChatInputOptions(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver>;
+declare function createChatInputOptions<Cached extends CacheType = any>(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver<Cached>>;
 
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };
-export type { ChatInputOptions, ClassProvider, DeepMocked, Mock, MockInstance, MockResult, MockState, MockedFunction, Provider, TestingModuleOptions, ValueProvider };
+export type { ChatInputOptions, ClassProvider, DeepMocked, Mock, MockInstance, MockProps, MockResult, MockState, MockedFunction, Provider, TestingModuleOptions, ValueProvider };

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "1.8.4",
+  "version": "2.0.0-beta.2",
   "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "lint": "eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
     "build": "rm -rf ./dist && rollup -c",
@@ -72,13 +75,13 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@swc/core": "1.15.43",
-    "chalk": "^5.6.2",
+    "@swc/core": "1.15.47",
+    "chalk": "^6.0.0",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
     "dayjs": "^1.11.21",
     "dotenv": "^17.4.2",
-    "inversify": "^8.1.1",
+    "inversify": "^8.2.3",
     "jiti": "^2.7.0",
     "lodash-es": "^4.18.1",
     "nodemon": "^3.1.14",
@@ -87,7 +90,7 @@
     "swc-loader": "^0.2.7",
     "terser-webpack-plugin": "^5.6.1",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
-    "webpack": "^5.108.3",
+    "webpack": "^5.109.2",
     "webpack-node-externals": "^3.0.0"
   },
   "devDependencies": {
@@ -102,27 +105,27 @@
     "@semantic-release/release-notes-generator": "^14.1.1",
     "@types/lodash-es": "^4.17.12",
     "@types/webpack-node-externals": "^3.0.4",
-    "@typescript-eslint/parser": "^8.62.1",
-    "discord.js": "^14.26.4",
-    "eslint": "^10.6.0",
+    "@typescript-eslint/parser": "^8.67.0",
+    "discord.js": "^14.27.0",
+    "eslint": "^10.8.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-headers": "^1.3.4",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "globals": "^17.7.0",
+    "globals": "^17.11.0",
     "husky": "^9.1.7",
-    "prettier": "^3.9.4",
-    "rollup": "^4.62.2",
+    "prettier": "^3.9.6",
+    "rollup": "^4.62.4",
     "rollup-plugin-copy": "^3.5.0",
-    "rollup-plugin-dts": "^6.4.1",
-    "semantic-release": "^25.0.5",
+    "rollup-plugin-dts": "^6.5.1",
+    "semantic-release": "^25.0.9",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.1",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "unplugin-swc": "^1.5.5",
-    "vitest": "^3.2.4"
+    "typescript-eslint": "^8.67.0",
+    "@vitest/coverage-istanbul": "^4.1.10",
+    "unplugin-swc": "^1.5.11",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "discord.js": "^14.26.4",