@dereekb/nestjs 13.11.18 → 13.12.0

package/discord/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dereekb/nestjs/discord",
-  "version": "13.11.18",
+  "version": "13.12.0",
   "peerDependencies": {
-    "@dereekb/nestjs": "13.11.18",
-    "@dereekb/rxjs": "13.11.18",
-    "@dereekb/util": "13.11.18",
+    "@dereekb/nestjs": "13.12.0",
+    "@dereekb/rxjs": "13.12.0",
+    "@dereekb/util": "13.12.0",
     "@nestjs/common": "^11.1.19",
     "@nestjs/config": "^4.0.4",
     "discord.js": "^14.26.3",

package/discord/src/lib/discord.api.spec.client.d.ts

@@ -0,0 +1,20 @@
+import { DiscordApi } from './discord.api';
+/**
+ * Shared, process-singleton Discord test client.
+ *
+ * Integration spec files import {@link getSharedDiscordTestClient} so that at most one
+ * `client.login()` call occurs per vitest worker process, regardless of how many spec
+ * files participate. This keeps the bot's daily gateway-session quota intact during
+ * normal development.
+ */
+export interface SharedDiscordTestClient {
+    readonly discordApi: DiscordApi;
+    readonly testChannelId: string;
+}
+/**
+ * Returns the shared logged-in test client, creating it on first call and reusing it
+ * on subsequent calls within the same process.
+ *
+ * @returns The cached {@link SharedDiscordTestClient}.
+ */
+export declare function getSharedDiscordTestClient(): Promise<SharedDiscordTestClient>;

package/eslint/index.cjs.js

@@ -126,6 +126,59 @@ function _unsupported_iterable_to_array(o, minLen) {
     }
     return tokenName;
 }
+/**
+ * Returns the first class decorator that is both in `classDecorators` and imported from '@nestjs/common'.
+ *
+ * @param classNode - The ClassDeclaration AST node.
+ * @param classDecorators - Class decorator names that trigger this rule.
+ * @param nestjsImports - Identifiers known to be imported from '@nestjs/common'.
+ * @returns The matched decorator node, or undefined when none matches.
+ */ function findMatchedClassDecorator(classNode, classDecorators, nestjsImports) {
+    var decorators = classNode.decorators;
+    if (!decorators || decorators.length === 0) return undefined;
+    return decorators.find(function(d) {
+        var name = getDecoratorName(d);
+        return classDecorators.has(name) && nestjsImports.has(name);
+    });
+}
+/**
+ * Returns the constructor parameter list of a class declaration, if a constructor is present.
+ *
+ * @param classNode - The ClassDeclaration AST node.
+ * @returns The parameter list, or undefined when there's no constructor.
+ */ function findConstructorParams(classNode) {
+    var constructor = classNode.body.body.find(function(member) {
+        return member.type === 'MethodDefinition' && member.kind === 'constructor';
+    });
+    return constructor === null || constructor === void 0 ? void 0 : constructor.value.params;
+}
+/**
+ * Builds the fixer for converting a type-only import into a value import so it
+ * can be used as an `@Inject()` token at runtime.
+ *
+ * @param fixer - The ESLint fixer instance.
+ * @param typeImportInfo - Info about the type-only import to convert.
+ * @returns The fixer command produced by `fixer.removeRange`.
+ */ function buildTypeOnlyImportFix(fixer, typeImportInfo) {
+    var fixResult;
+    if (typeImportInfo.isDeclarationLevel) {
+        // `import type { X } from '...'` → `import { X } from '...'`
+        var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
+        fixResult = fixer.removeRange([
+            importKeywordEnd,
+            importKeywordEnd + 'type '.length
+        ]);
+    } else {
+        // `import { type X }` → `import { X }`
+        var specRange = typeImportInfo.specifier.range;
+        var importedRange = typeImportInfo.specifier.imported.range;
+        fixResult = fixer.removeRange([
+            specRange[0],
+            importedRange[0]
+        ]);
+    }
+    return fixResult;
+}
 /**
  * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
  *
@@ -239,128 +292,108 @@ function _unsupported_iterable_to_array(o, minLen) {
                 }
             },
             ClassDeclaration: function ClassDeclaration(classNode) {
-                var decorators = classNode.decorators;
-                var matchedClassDecorator = decorators && decorators.length > 0 ? decorators.find(function(d) {
-                    var name = getDecoratorName(d);
-                    return classDecorators.has(name) && nestjsImports.has(name);
-                }) : undefined;
-                var constructor = matchedClassDecorator ? classNode.body.body.find(function(member) {
-                    return member.type === 'MethodDefinition' && member.kind === 'constructor';
-                }) : undefined;
-                var params = constructor === null || constructor === void 0 ? void 0 : constructor.value.params;
-                var shouldCheckParams = Boolean(matchedClassDecorator && params && params.length > 0);
-                if (shouldCheckParams) {
-                    var classDecoratorName = getDecoratorName(matchedClassDecorator);
-                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                var matchedClassDecorator = findMatchedClassDecorator(classNode, classDecorators, nestjsImports);
+                if (!matchedClassDecorator) return;
+                var params = findConstructorParams(classNode);
+                if (!params || params.length === 0) return;
+                var classDecoratorName = getDecoratorName(matchedClassDecorator);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var param = _step.value;
+                        processConstructorParam(param, classDecoratorName);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
                     try {
-                        var _loop = function() {
-                            var param = _step.value;
-                            var paramDecoratorsOnNode = param.decorators;
-                            var hasValidDecorator = paramDecoratorsOnNode && paramDecoratorsOnNode.length > 0 && paramDecoratorsOnNode.some(function(d) {
-                                return paramDecorators.has(getDecoratorName(d));
-                            });
-                            if (hasValidDecorator) {
-                                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                try {
-                                    var _loop = function() {
-                                        var decorator = _step1.value;
-                                        var tokenName = getInjectTokenFromDecorator(decorator);
-                                        if (tokenName) {
-                                            var typeImportInfo = typeOnlyImports.get(tokenName);
-                                            if (typeImportInfo) {
-                                                context.report({
-                                                    node: decorator,
-                                                    messageId: 'typeOnlyInjectToken',
-                                                    data: {
-                                                        token: tokenName
-                                                    },
-                                                    fix: function fix(fixer) {
-                                                        var fixResult;
-                                                        if (typeImportInfo.isDeclarationLevel) {
-                                                            // `import type { X } from '...'` → `import { X } from '...'`
-                                                            // Remove 'type ' after 'import '
-                                                            var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
-                                                            fixResult = fixer.removeRange([
-                                                                importKeywordEnd,
-                                                                importKeywordEnd + 'type '.length
-                                                            ]);
-                                                        } else {
-                                                            // `import { type X }` → `import { X }`
-                                                            // The specifier range includes 'type X', so remove 'type ' prefix
-                                                            var specRange = typeImportInfo.specifier.range;
-                                                            var importedRange = typeImportInfo.specifier.imported.range;
-                                                            fixResult = fixer.removeRange([
-                                                                specRange[0],
-                                                                importedRange[0]
-                                                            ]);
-                                                        }
-                                                        return fixResult;
-                                                    }
-                                                });
-                                                // Remove from tracking so we don't report the same import twice
-                                                typeOnlyImports.delete(tokenName);
-                                            }
-                                        }
-                                    };
-                                    // Has @Inject() — check if the injection token is a type-only import
-                                    for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                                } catch (err) {
-                                    _didIteratorError = true;
-                                    _iteratorError = err;
-                                } finally{
-                                    try {
-                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                            _iterator.return();
-                                        }
-                                    } finally{
-                                        if (_didIteratorError) {
-                                            throw _iteratorError;
-                                        }
-                                    }
-                                }
-                            } else {
-                                // Missing @Inject() entirely
-                                var tokenName = getInjectTokenName(param);
-                                context.report({
-                                    node: param,
-                                    messageId: 'missingInject',
-                                    data: {
-                                        name: getParamName(param),
-                                        classDecorator: classDecoratorName
-                                    },
-                                    fix: tokenName ? function(fixer) {
-                                        var fixes = [];
-                                        fixes.push(fixer.insertTextBefore(param, "@Inject(".concat(tokenName, ") ")));
-                                        if (!nestjsImports.has('Inject') && nestjsImportNode) {
-                                            var lastSpecifier = nestjsImportNode.specifiers[nestjsImportNode.specifiers.length - 1];
-                                            if (lastSpecifier) {
-                                                fixes.push(fixer.insertTextAfter(lastSpecifier, ', Inject'));
-                                            }
-                                            nestjsImports.add('Inject');
-                                        }
-                                        return fixes;
-                                    } : undefined
-                                });
-                            }
-                        };
-                        for(var _iterator = params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                    } catch (err) {
-                        _didIteratorError = true;
-                        _iteratorError = err;
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
                     } finally{
-                        try {
-                            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                _iterator.return();
-                            }
-                        } finally{
-                            if (_didIteratorError) {
-                                throw _iteratorError;
-                            }
+                        if (_didIteratorError) {
+                            throw _iteratorError;
                         }
                     }
                 }
             }
         };
+        function processConstructorParam(param, classDecoratorName) {
+            var paramDecoratorsOnNode = param.decorators;
+            var hasValidDecorator = paramDecoratorsOnNode && paramDecoratorsOnNode.length > 0 && paramDecoratorsOnNode.some(function(d) {
+                return paramDecorators.has(getDecoratorName(d));
+            });
+            if (hasValidDecorator) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var decorator = _step.value;
+                        reportTypeOnlyTokenIfAny(decorator);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            } else {
+                reportMissingInject(param, classDecoratorName);
+            }
+        }
+        function reportTypeOnlyTokenIfAny(decorator) {
+            var tokenName = getInjectTokenFromDecorator(decorator);
+            if (!tokenName) return;
+            var typeImportInfo = typeOnlyImports.get(tokenName);
+            if (!typeImportInfo) return;
+            context.report({
+                node: decorator,
+                messageId: 'typeOnlyInjectToken',
+                data: {
+                    token: tokenName
+                },
+                fix: function fix(fixer) {
+                    return buildTypeOnlyImportFix(fixer, typeImportInfo);
+                }
+            });
+            // Remove from tracking so we don't report the same import twice
+            typeOnlyImports.delete(tokenName);
+        }
+        function reportMissingInject(param, classDecoratorName) {
+            var tokenName = getInjectTokenName(param);
+            context.report({
+                node: param,
+                messageId: 'missingInject',
+                data: {
+                    name: getParamName(param),
+                    classDecorator: classDecoratorName
+                },
+                fix: tokenName ? function(fixer) {
+                    return buildMissingInjectFix(fixer, param, tokenName);
+                } : undefined
+            });
+        }
+        function buildMissingInjectFix(fixer, param, tokenName) {
+            var fixes = [
+                fixer.insertTextBefore(param, "@Inject(".concat(tokenName, ") "))
+            ];
+            if (!nestjsImports.has('Inject') && nestjsImportNode) {
+                var lastSpecifier = nestjsImportNode.specifiers[nestjsImportNode.specifiers.length - 1];
+                if (lastSpecifier) {
+                    fixes.push(fixer.insertTextAfter(lastSpecifier, ', Inject'));
+                }
+                nestjsImports.add('Inject');
+            }
+            return fixes;
+        }
     }
 };
 

package/eslint/index.esm.js

@@ -124,6 +124,59 @@ function _unsupported_iterable_to_array(o, minLen) {
     }
     return tokenName;
 }
+/**
+ * Returns the first class decorator that is both in `classDecorators` and imported from '@nestjs/common'.
+ *
+ * @param classNode - The ClassDeclaration AST node.
+ * @param classDecorators - Class decorator names that trigger this rule.
+ * @param nestjsImports - Identifiers known to be imported from '@nestjs/common'.
+ * @returns The matched decorator node, or undefined when none matches.
+ */ function findMatchedClassDecorator(classNode, classDecorators, nestjsImports) {
+    var decorators = classNode.decorators;
+    if (!decorators || decorators.length === 0) return undefined;
+    return decorators.find(function(d) {
+        var name = getDecoratorName(d);
+        return classDecorators.has(name) && nestjsImports.has(name);
+    });
+}
+/**
+ * Returns the constructor parameter list of a class declaration, if a constructor is present.
+ *
+ * @param classNode - The ClassDeclaration AST node.
+ * @returns The parameter list, or undefined when there's no constructor.
+ */ function findConstructorParams(classNode) {
+    var constructor = classNode.body.body.find(function(member) {
+        return member.type === 'MethodDefinition' && member.kind === 'constructor';
+    });
+    return constructor === null || constructor === void 0 ? void 0 : constructor.value.params;
+}
+/**
+ * Builds the fixer for converting a type-only import into a value import so it
+ * can be used as an `@Inject()` token at runtime.
+ *
+ * @param fixer - The ESLint fixer instance.
+ * @param typeImportInfo - Info about the type-only import to convert.
+ * @returns The fixer command produced by `fixer.removeRange`.
+ */ function buildTypeOnlyImportFix(fixer, typeImportInfo) {
+    var fixResult;
+    if (typeImportInfo.isDeclarationLevel) {
+        // `import type { X } from '...'` → `import { X } from '...'`
+        var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
+        fixResult = fixer.removeRange([
+            importKeywordEnd,
+            importKeywordEnd + 'type '.length
+        ]);
+    } else {
+        // `import { type X }` → `import { X }`
+        var specRange = typeImportInfo.specifier.range;
+        var importedRange = typeImportInfo.specifier.imported.range;
+        fixResult = fixer.removeRange([
+            specRange[0],
+            importedRange[0]
+        ]);
+    }
+    return fixResult;
+}
 /**
  * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
  *
@@ -237,128 +290,108 @@ function _unsupported_iterable_to_array(o, minLen) {
                 }
             },
             ClassDeclaration: function ClassDeclaration(classNode) {
-                var decorators = classNode.decorators;
-                var matchedClassDecorator = decorators && decorators.length > 0 ? decorators.find(function(d) {
-                    var name = getDecoratorName(d);
-                    return classDecorators.has(name) && nestjsImports.has(name);
-                }) : undefined;
-                var constructor = matchedClassDecorator ? classNode.body.body.find(function(member) {
-                    return member.type === 'MethodDefinition' && member.kind === 'constructor';
-                }) : undefined;
-                var params = constructor === null || constructor === void 0 ? void 0 : constructor.value.params;
-                var shouldCheckParams = Boolean(matchedClassDecorator && params && params.length > 0);
-                if (shouldCheckParams) {
-                    var classDecoratorName = getDecoratorName(matchedClassDecorator);
-                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                var matchedClassDecorator = findMatchedClassDecorator(classNode, classDecorators, nestjsImports);
+                if (!matchedClassDecorator) return;
+                var params = findConstructorParams(classNode);
+                if (!params || params.length === 0) return;
+                var classDecoratorName = getDecoratorName(matchedClassDecorator);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var param = _step.value;
+                        processConstructorParam(param, classDecoratorName);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
                     try {
-                        var _loop = function() {
-                            var param = _step.value;
-                            var paramDecoratorsOnNode = param.decorators;
-                            var hasValidDecorator = paramDecoratorsOnNode && paramDecoratorsOnNode.length > 0 && paramDecoratorsOnNode.some(function(d) {
-                                return paramDecorators.has(getDecoratorName(d));
-                            });
-                            if (hasValidDecorator) {
-                                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                try {
-                                    var _loop = function() {
-                                        var decorator = _step1.value;
-                                        var tokenName = getInjectTokenFromDecorator(decorator);
-                                        if (tokenName) {
-                                            var typeImportInfo = typeOnlyImports.get(tokenName);
-                                            if (typeImportInfo) {
-                                                context.report({
-                                                    node: decorator,
-                                                    messageId: 'typeOnlyInjectToken',
-                                                    data: {
-                                                        token: tokenName
-                                                    },
-                                                    fix: function fix(fixer) {
-                                                        var fixResult;
-                                                        if (typeImportInfo.isDeclarationLevel) {
-                                                            // `import type { X } from '...'` → `import { X } from '...'`
-                                                            // Remove 'type ' after 'import '
-                                                            var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
-                                                            fixResult = fixer.removeRange([
-                                                                importKeywordEnd,
-                                                                importKeywordEnd + 'type '.length
-                                                            ]);
-                                                        } else {
-                                                            // `import { type X }` → `import { X }`
-                                                            // The specifier range includes 'type X', so remove 'type ' prefix
-                                                            var specRange = typeImportInfo.specifier.range;
-                                                            var importedRange = typeImportInfo.specifier.imported.range;
-                                                            fixResult = fixer.removeRange([
-                                                                specRange[0],
-                                                                importedRange[0]
-                                                            ]);
-                                                        }
-                                                        return fixResult;
-                                                    }
-                                                });
-                                                // Remove from tracking so we don't report the same import twice
-                                                typeOnlyImports.delete(tokenName);
-                                            }
-                                        }
-                                    };
-                                    // Has @Inject() — check if the injection token is a type-only import
-                                    for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                                } catch (err) {
-                                    _didIteratorError = true;
-                                    _iteratorError = err;
-                                } finally{
-                                    try {
-                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                            _iterator.return();
-                                        }
-                                    } finally{
-                                        if (_didIteratorError) {
-                                            throw _iteratorError;
-                                        }
-                                    }
-                                }
-                            } else {
-                                // Missing @Inject() entirely
-                                var tokenName = getInjectTokenName(param);
-                                context.report({
-                                    node: param,
-                                    messageId: 'missingInject',
-                                    data: {
-                                        name: getParamName(param),
-                                        classDecorator: classDecoratorName
-                                    },
-                                    fix: tokenName ? function(fixer) {
-                                        var fixes = [];
-                                        fixes.push(fixer.insertTextBefore(param, "@Inject(".concat(tokenName, ") ")));
-                                        if (!nestjsImports.has('Inject') && nestjsImportNode) {
-                                            var lastSpecifier = nestjsImportNode.specifiers[nestjsImportNode.specifiers.length - 1];
-                                            if (lastSpecifier) {
-                                                fixes.push(fixer.insertTextAfter(lastSpecifier, ', Inject'));
-                                            }
-                                            nestjsImports.add('Inject');
-                                        }
-                                        return fixes;
-                                    } : undefined
-                                });
-                            }
-                        };
-                        for(var _iterator = params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                    } catch (err) {
-                        _didIteratorError = true;
-                        _iteratorError = err;
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
                     } finally{
-                        try {
-                            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                _iterator.return();
-                            }
-                        } finally{
-                            if (_didIteratorError) {
-                                throw _iteratorError;
-                            }
+                        if (_didIteratorError) {
+                            throw _iteratorError;
                         }
                     }
                 }
             }
         };
+        function processConstructorParam(param, classDecoratorName) {
+            var paramDecoratorsOnNode = param.decorators;
+            var hasValidDecorator = paramDecoratorsOnNode && paramDecoratorsOnNode.length > 0 && paramDecoratorsOnNode.some(function(d) {
+                return paramDecorators.has(getDecoratorName(d));
+            });
+            if (hasValidDecorator) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = paramDecoratorsOnNode[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var decorator = _step.value;
+                        reportTypeOnlyTokenIfAny(decorator);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            } else {
+                reportMissingInject(param, classDecoratorName);
+            }
+        }
+        function reportTypeOnlyTokenIfAny(decorator) {
+            var tokenName = getInjectTokenFromDecorator(decorator);
+            if (!tokenName) return;
+            var typeImportInfo = typeOnlyImports.get(tokenName);
+            if (!typeImportInfo) return;
+            context.report({
+                node: decorator,
+                messageId: 'typeOnlyInjectToken',
+                data: {
+                    token: tokenName
+                },
+                fix: function fix(fixer) {
+                    return buildTypeOnlyImportFix(fixer, typeImportInfo);
+                }
+            });
+            // Remove from tracking so we don't report the same import twice
+            typeOnlyImports.delete(tokenName);
+        }
+        function reportMissingInject(param, classDecoratorName) {
+            var tokenName = getInjectTokenName(param);
+            context.report({
+                node: param,
+                messageId: 'missingInject',
+                data: {
+                    name: getParamName(param),
+                    classDecorator: classDecoratorName
+                },
+                fix: tokenName ? function(fixer) {
+                    return buildMissingInjectFix(fixer, param, tokenName);
+                } : undefined
+            });
+        }
+        function buildMissingInjectFix(fixer, param, tokenName) {
+            var fixes = [
+                fixer.insertTextBefore(param, "@Inject(".concat(tokenName, ") "))
+            ];
+            if (!nestjsImports.has('Inject') && nestjsImportNode) {
+                var lastSpecifier = nestjsImportNode.specifiers[nestjsImportNode.specifiers.length - 1];
+                if (lastSpecifier) {
+                    fixes.push(fixer.insertTextAfter(lastSpecifier, ', Inject'));
+                }
+                nestjsImports.add('Inject');
+            }
+            return fixes;
+        }
     }
 };
 

package/eslint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/nestjs/eslint",
-  "version": "13.11.18",
+  "version": "13.12.0",
   "peerDependencies": {
     "@typescript-eslint/utils": "8.59.3"
   },

package/mailgun/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/mailgun",
-  "version": "13.11.18",
+  "version": "13.12.0",
   "peerDependencies": {
-    "@dereekb/date": "13.11.18",
-    "@dereekb/model": "13.11.18",
-    "@dereekb/nestjs": "13.11.18",
-    "@dereekb/rxjs": "13.11.18",
-    "@dereekb/util": "13.11.18",
+    "@dereekb/date": "13.12.0",
+    "@dereekb/model": "13.12.0",
+    "@dereekb/nestjs": "13.12.0",
+    "@dereekb/rxjs": "13.12.0",
+    "@dereekb/util": "13.12.0",
     "@nestjs/common": "^11.1.19",
     "@nestjs/config": "^4.0.4",
     "form-data": "^4.0.5",

package/openai/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/openai",
-  "version": "13.11.18",
+  "version": "13.12.0",
   "peerDependencies": {
-    "@dereekb/date": "13.11.18",
-    "@dereekb/model": "13.11.18",
-    "@dereekb/nestjs": "13.11.18",
-    "@dereekb/rxjs": "13.11.18",
-    "@dereekb/util": "13.11.18",
+    "@dereekb/date": "13.12.0",
+    "@dereekb/model": "13.12.0",
+    "@dereekb/nestjs": "13.12.0",
+    "@dereekb/rxjs": "13.12.0",
+    "@dereekb/util": "13.12.0",
     "@nestjs/common": "^11.1.19",
     "@nestjs/config": "^4.0.4",
     "express": "^5.2.1",