@dereekb/nestjs 13.6.12 → 13.6.14

package/discord/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dereekb/nestjs/discord",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "peerDependencies": {
-    "@dereekb/nestjs": "13.6.12",
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/nestjs": "13.6.14",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",
     "discord.js": "^14.25.1",

package/eslint/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/eslint/index.cjs.js

@@ -0,0 +1,382 @@
+'use strict';
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * The import source that NestJS decorators come from.
+ */ var NESTJS_COMMON_MODULE = '@nestjs/common';
+/**
+ * NestJS class decorators that make a class eligible for dependency injection.
+ */ var NESTJS_CLASS_DECORATORS = new Set([
+    'Injectable',
+    'Controller',
+    'Resolver'
+]);
+/**
+ * Decorators that count as valid parameter injection markers.
+ * Any parameter with at least one of these is considered properly annotated.
+ */ var VALID_PARAM_DECORATORS = new Set([
+    'Inject',
+    'Optional',
+    'Self',
+    'SkipSelf',
+    'Host'
+]);
+/**
+ * Extracts the decorator name from a decorator node.
+ *
+ * @example
+ * ```
+ * // Returns 'Injectable' for both:
+ * // @Injectable()
+ * // @Injectable
+ * ```
+ *
+ * @param decorator - The decorator AST node
+ * @returns The decorator name, or empty string if unrecognized
+ */ function getDecoratorName(decorator) {
+    var expression = decorator.expression;
+    if (expression.type === 'CallExpression') {
+        if (expression.callee.type === 'Identifier') {
+            return expression.callee.name;
+        }
+        if (expression.callee.type === 'MemberExpression' && expression.callee.property.type === 'Identifier') {
+            return expression.callee.property.name;
+        }
+    }
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    return '';
+}
+/**
+ * Extracts the injection token name from a decorator like @Inject(TokenName).
+ *
+ * @param decorator - The decorator AST node
+ * @returns The token identifier name, or null if not a simple identifier
+ */ function getInjectTokenFromDecorator(decorator) {
+    var expression = decorator.expression;
+    if (expression.type === 'CallExpression' && expression.callee.type === 'Identifier' && expression.callee.name === 'Inject') {
+        var firstArg = expression.arguments[0];
+        if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'Identifier') {
+            return firstArg.name;
+        }
+    }
+    return null;
+}
+/**
+ * Extracts the parameter name from a constructor parameter node.
+ *
+ * @param param - The parameter AST node
+ * @returns The parameter name for error reporting
+ */ function getParamName(param) {
+    if (param.type === 'TSParameterProperty') {
+        var inner = param.parameter;
+        if (inner.type === 'Identifier') {
+            return inner.name;
+        }
+        if (inner.type === 'AssignmentPattern' && inner.left.type === 'Identifier') {
+            return inner.left.name;
+        }
+    }
+    if (param.type === 'Identifier') {
+        return param.name;
+    }
+    if (param.type === 'AssignmentPattern' && param.left.type === 'Identifier') {
+        return param.left.name;
+    }
+    return '(unknown)';
+}
+/**
+ * Gets the class-typed injection token name from a parameter's type annotation, if available.
+ *
+ * Returns the type name only for simple TSTypeReference identifiers (i.e. class names like `FooApi`).
+ * Returns null for primitives, union types, generics, or any non-simple type reference.
+ *
+ * @param param - The parameter AST node
+ * @returns The type name to use as injection token, or null if not auto-fixable
+ */ function getInjectTokenName(param) {
+    var _target_typeAnnotation, _typeAnnotation_typeName;
+    var target = param.type === 'TSParameterProperty' ? param.parameter : param;
+    var typeAnnotation = (_target_typeAnnotation = target.typeAnnotation) === null || _target_typeAnnotation === void 0 ? void 0 : _target_typeAnnotation.typeAnnotation;
+    if ((typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.type) === 'TSTypeReference' && ((_typeAnnotation_typeName = typeAnnotation.typeName) === null || _typeAnnotation_typeName === void 0 ? void 0 : _typeAnnotation_typeName.type) === 'Identifier' && !typeAnnotation.typeArguments) {
+        return typeAnnotation.typeName.name;
+    }
+    return null;
+}
+/**
+ * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
+ *
+ * Required when emitDecoratorMetadata is disabled — without it, NestJS cannot infer
+ * constructor parameter types and will throw at runtime if @Inject() is missing.
+ *
+ * Only applies to decorators imported from '@nestjs/common', so Angular @Injectable()
+ * classes are not affected.
+ *
+ * Also flags injection tokens that are type-only imports (`import type { X }` or
+ * `import { type X }`), since those cannot be used as values at runtime.
+ *
+ * Auto-fixes:
+ * - Missing @Inject(): adds `@Inject(ClassName)` for simple class-typed parameters
+ * - Type-only imports: removes the `type` modifier from the import specifier
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
+ */ var nestjsRequireInjectRule = {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Require @Inject() decorator on constructor parameters in NestJS injectable classes',
+            recommended: true
+        },
+        messages: {
+            missingInject: 'Constructor parameter "{{name}}" in @{{classDecorator}}() class must have an @Inject() decorator. Without emitDecoratorMetadata, NestJS cannot infer the injection token and will throw at runtime.',
+            typeOnlyInjectToken: '@Inject({{token}}) uses "{{token}}" which is a type-only import. It must be a value import to be used as an injection token at runtime.'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalClassDecorators: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Additional class decorator names (beyond Injectable, Controller, Resolver) that should trigger this rule.'
+                    },
+                    additionalParamDecorators: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Additional parameter decorator names (beyond Inject, Optional, Self, SkipSelf, Host) to treat as valid injection markers.'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create: function create(context) {
+        var options = context.options[0] || {};
+        var classDecorators = new Set(_to_consumable_array(NESTJS_CLASS_DECORATORS).concat(_to_consumable_array(options.additionalClassDecorators || [])));
+        var paramDecorators = new Set(_to_consumable_array(VALID_PARAM_DECORATORS).concat(_to_consumable_array(options.additionalParamDecorators || [])));
+        /**
+         * Tracks identifiers imported from '@nestjs/common'.
+         * Only decorators whose local name appears in this set will trigger the rule.
+         */ var nestjsImports = new Set();
+        /**
+         * Tracks all type-only imports across the file, keyed by local identifier name.
+         * Used to detect when @Inject(Token) uses a type-only import.
+         */ var typeOnlyImports = new Map();
+        /**
+         * Reference to the '@nestjs/common' ImportDeclaration node, used for adding
+         * the Inject import if it's missing during auto-fix.
+         */ var nestjsImportNode = null;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                var isDeclarationTypeOnly = node.importKind === 'type';
+                if (node.source.value === NESTJS_COMMON_MODULE) {
+                    nestjsImportNode = node;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = node.specifiers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var specifier = _step.value;
+                        if (specifier.type !== 'ImportSpecifier') {
+                            continue;
+                        }
+                        var localName = specifier.local.name;
+                        // Track @nestjs/common imports
+                        if (node.source.value === NESTJS_COMMON_MODULE) {
+                            nestjsImports.add(localName);
+                        }
+                        // Track type-only imports from any source
+                        var isTypeOnly = isDeclarationTypeOnly || specifier.importKind === 'type';
+                        if (isTypeOnly) {
+                            typeOnlyImports.set(localName, {
+                                specifier: specifier,
+                                declaration: node,
+                                isDeclarationLevel: isDeclarationTypeOnly
+                            });
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            },
+            ClassDeclaration: function ClassDeclaration(classNode) {
+                var decorators = classNode.decorators;
+                if (!decorators || decorators.length === 0) {
+                    return;
+                }
+                var matchedClassDecorator = decorators.find(function(d) {
+                    var name = getDecoratorName(d);
+                    return classDecorators.has(name) && nestjsImports.has(name);
+                });
+                if (!matchedClassDecorator) {
+                    return;
+                }
+                var classDecoratorName = getDecoratorName(matchedClassDecorator);
+                var constructor = classNode.body.body.find(function(member) {
+                    return member.type === 'MethodDefinition' && member.kind === 'constructor';
+                });
+                if (!(constructor === null || constructor === void 0 ? void 0 : constructor.value.params) || constructor.value.params.length === 0) {
+                    return;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                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) {
+                            // 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
+                            });
+                        } else {
+                            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) {
+                                                    if (typeImportInfo.isDeclarationLevel) {
+                                                        // `import type { X } from '...'` → `import { X } from '...'`
+                                                        // Remove 'type ' after 'import '
+                                                        var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
+                                                        return fixer.removeRange([
+                                                            importKeywordEnd,
+                                                            importKeywordEnd + 'type '.length
+                                                        ]);
+                                                    }
+                                                    // `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;
+                                                    return fixer.removeRange([
+                                                        specRange[0],
+                                                        importedRange[0]
+                                                    ]);
+                                                }
+                                            });
+                                            // 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;
+                                    }
+                                }
+                            }
+                        }
+                    };
+                    for(var _iterator = constructor.value.params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _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;
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+
+/**
+ * ESLint plugin for NestJS rules.
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
+ */ var nestjsEslintPlugin = {
+    rules: {
+        'require-nest-inject': nestjsRequireInjectRule
+    }
+};
+
+exports.nestjsEslintPlugin = nestjsEslintPlugin;
+exports.nestjsRequireInjectRule = nestjsRequireInjectRule;

package/eslint/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/eslint/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/eslint/index.esm.js

@@ -0,0 +1,379 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * The import source that NestJS decorators come from.
+ */ var NESTJS_COMMON_MODULE = '@nestjs/common';
+/**
+ * NestJS class decorators that make a class eligible for dependency injection.
+ */ var NESTJS_CLASS_DECORATORS = new Set([
+    'Injectable',
+    'Controller',
+    'Resolver'
+]);
+/**
+ * Decorators that count as valid parameter injection markers.
+ * Any parameter with at least one of these is considered properly annotated.
+ */ var VALID_PARAM_DECORATORS = new Set([
+    'Inject',
+    'Optional',
+    'Self',
+    'SkipSelf',
+    'Host'
+]);
+/**
+ * Extracts the decorator name from a decorator node.
+ *
+ * @example
+ * ```
+ * // Returns 'Injectable' for both:
+ * // @Injectable()
+ * // @Injectable
+ * ```
+ *
+ * @param decorator - The decorator AST node
+ * @returns The decorator name, or empty string if unrecognized
+ */ function getDecoratorName(decorator) {
+    var expression = decorator.expression;
+    if (expression.type === 'CallExpression') {
+        if (expression.callee.type === 'Identifier') {
+            return expression.callee.name;
+        }
+        if (expression.callee.type === 'MemberExpression' && expression.callee.property.type === 'Identifier') {
+            return expression.callee.property.name;
+        }
+    }
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    return '';
+}
+/**
+ * Extracts the injection token name from a decorator like @Inject(TokenName).
+ *
+ * @param decorator - The decorator AST node
+ * @returns The token identifier name, or null if not a simple identifier
+ */ function getInjectTokenFromDecorator(decorator) {
+    var expression = decorator.expression;
+    if (expression.type === 'CallExpression' && expression.callee.type === 'Identifier' && expression.callee.name === 'Inject') {
+        var firstArg = expression.arguments[0];
+        if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'Identifier') {
+            return firstArg.name;
+        }
+    }
+    return null;
+}
+/**
+ * Extracts the parameter name from a constructor parameter node.
+ *
+ * @param param - The parameter AST node
+ * @returns The parameter name for error reporting
+ */ function getParamName(param) {
+    if (param.type === 'TSParameterProperty') {
+        var inner = param.parameter;
+        if (inner.type === 'Identifier') {
+            return inner.name;
+        }
+        if (inner.type === 'AssignmentPattern' && inner.left.type === 'Identifier') {
+            return inner.left.name;
+        }
+    }
+    if (param.type === 'Identifier') {
+        return param.name;
+    }
+    if (param.type === 'AssignmentPattern' && param.left.type === 'Identifier') {
+        return param.left.name;
+    }
+    return '(unknown)';
+}
+/**
+ * Gets the class-typed injection token name from a parameter's type annotation, if available.
+ *
+ * Returns the type name only for simple TSTypeReference identifiers (i.e. class names like `FooApi`).
+ * Returns null for primitives, union types, generics, or any non-simple type reference.
+ *
+ * @param param - The parameter AST node
+ * @returns The type name to use as injection token, or null if not auto-fixable
+ */ function getInjectTokenName(param) {
+    var _target_typeAnnotation, _typeAnnotation_typeName;
+    var target = param.type === 'TSParameterProperty' ? param.parameter : param;
+    var typeAnnotation = (_target_typeAnnotation = target.typeAnnotation) === null || _target_typeAnnotation === void 0 ? void 0 : _target_typeAnnotation.typeAnnotation;
+    if ((typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.type) === 'TSTypeReference' && ((_typeAnnotation_typeName = typeAnnotation.typeName) === null || _typeAnnotation_typeName === void 0 ? void 0 : _typeAnnotation_typeName.type) === 'Identifier' && !typeAnnotation.typeArguments) {
+        return typeAnnotation.typeName.name;
+    }
+    return null;
+}
+/**
+ * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
+ *
+ * Required when emitDecoratorMetadata is disabled — without it, NestJS cannot infer
+ * constructor parameter types and will throw at runtime if @Inject() is missing.
+ *
+ * Only applies to decorators imported from '@nestjs/common', so Angular @Injectable()
+ * classes are not affected.
+ *
+ * Also flags injection tokens that are type-only imports (`import type { X }` or
+ * `import { type X }`), since those cannot be used as values at runtime.
+ *
+ * Auto-fixes:
+ * - Missing @Inject(): adds `@Inject(ClassName)` for simple class-typed parameters
+ * - Type-only imports: removes the `type` modifier from the import specifier
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
+ */ var nestjsRequireInjectRule = {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Require @Inject() decorator on constructor parameters in NestJS injectable classes',
+            recommended: true
+        },
+        messages: {
+            missingInject: 'Constructor parameter "{{name}}" in @{{classDecorator}}() class must have an @Inject() decorator. Without emitDecoratorMetadata, NestJS cannot infer the injection token and will throw at runtime.',
+            typeOnlyInjectToken: '@Inject({{token}}) uses "{{token}}" which is a type-only import. It must be a value import to be used as an injection token at runtime.'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalClassDecorators: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Additional class decorator names (beyond Injectable, Controller, Resolver) that should trigger this rule.'
+                    },
+                    additionalParamDecorators: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Additional parameter decorator names (beyond Inject, Optional, Self, SkipSelf, Host) to treat as valid injection markers.'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create: function create(context) {
+        var options = context.options[0] || {};
+        var classDecorators = new Set(_to_consumable_array(NESTJS_CLASS_DECORATORS).concat(_to_consumable_array(options.additionalClassDecorators || [])));
+        var paramDecorators = new Set(_to_consumable_array(VALID_PARAM_DECORATORS).concat(_to_consumable_array(options.additionalParamDecorators || [])));
+        /**
+         * Tracks identifiers imported from '@nestjs/common'.
+         * Only decorators whose local name appears in this set will trigger the rule.
+         */ var nestjsImports = new Set();
+        /**
+         * Tracks all type-only imports across the file, keyed by local identifier name.
+         * Used to detect when @Inject(Token) uses a type-only import.
+         */ var typeOnlyImports = new Map();
+        /**
+         * Reference to the '@nestjs/common' ImportDeclaration node, used for adding
+         * the Inject import if it's missing during auto-fix.
+         */ var nestjsImportNode = null;
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                var isDeclarationTypeOnly = node.importKind === 'type';
+                if (node.source.value === NESTJS_COMMON_MODULE) {
+                    nestjsImportNode = node;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = node.specifiers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var specifier = _step.value;
+                        if (specifier.type !== 'ImportSpecifier') {
+                            continue;
+                        }
+                        var localName = specifier.local.name;
+                        // Track @nestjs/common imports
+                        if (node.source.value === NESTJS_COMMON_MODULE) {
+                            nestjsImports.add(localName);
+                        }
+                        // Track type-only imports from any source
+                        var isTypeOnly = isDeclarationTypeOnly || specifier.importKind === 'type';
+                        if (isTypeOnly) {
+                            typeOnlyImports.set(localName, {
+                                specifier: specifier,
+                                declaration: node,
+                                isDeclarationLevel: isDeclarationTypeOnly
+                            });
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            },
+            ClassDeclaration: function ClassDeclaration(classNode) {
+                var decorators = classNode.decorators;
+                if (!decorators || decorators.length === 0) {
+                    return;
+                }
+                var matchedClassDecorator = decorators.find(function(d) {
+                    var name = getDecoratorName(d);
+                    return classDecorators.has(name) && nestjsImports.has(name);
+                });
+                if (!matchedClassDecorator) {
+                    return;
+                }
+                var classDecoratorName = getDecoratorName(matchedClassDecorator);
+                var constructor = classNode.body.body.find(function(member) {
+                    return member.type === 'MethodDefinition' && member.kind === 'constructor';
+                });
+                if (!(constructor === null || constructor === void 0 ? void 0 : constructor.value.params) || constructor.value.params.length === 0) {
+                    return;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                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) {
+                            // 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
+                            });
+                        } else {
+                            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) {
+                                                    if (typeImportInfo.isDeclarationLevel) {
+                                                        // `import type { X } from '...'` → `import { X } from '...'`
+                                                        // Remove 'type ' after 'import '
+                                                        var importKeywordEnd = typeImportInfo.declaration.range[0] + 'import '.length;
+                                                        return fixer.removeRange([
+                                                            importKeywordEnd,
+                                                            importKeywordEnd + 'type '.length
+                                                        ]);
+                                                    }
+                                                    // `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;
+                                                    return fixer.removeRange([
+                                                        specRange[0],
+                                                        importedRange[0]
+                                                    ]);
+                                                }
+                                            });
+                                            // 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;
+                                    }
+                                }
+                            }
+                        }
+                    };
+                    for(var _iterator = constructor.value.params[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _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;
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+
+/**
+ * ESLint plugin for NestJS rules.
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
+ */ var nestjsEslintPlugin = {
+    rules: {
+        'require-nest-inject': nestjsRequireInjectRule
+    }
+};
+
+export { nestjsEslintPlugin, nestjsRequireInjectRule };

package/eslint/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@dereekb/nestjs/eslint",
+  "version": "13.6.14",
+  "peerDependencies": {
+    "@typescript-eslint/utils": ">=8.0.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

package/eslint/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

package/eslint/src/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { nestjsRequireInjectRule, type NestjsRequireInjectRuleOptions } from './require-inject.rule';
+export { nestjsEslintPlugin } from './plugin';

package/eslint/src/lib/plugin.d.ts

@@ -0,0 +1,16 @@
+import { type NestjsRequireInjectRuleDefinition } from './require-inject.rule';
+/**
+ * ESLint plugin interface for NestJS rules.
+ */
+export interface NestjsEslintPlugin {
+    readonly rules: {
+        readonly 'require-nest-inject': NestjsRequireInjectRuleDefinition;
+    };
+}
+/**
+ * ESLint plugin for NestJS rules.
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
+ */
+export declare const nestjsEslintPlugin: NestjsEslintPlugin;

package/eslint/src/lib/require-inject.rule.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Options for the require-nest-inject rule.
+ */
+export interface NestjsRequireInjectRuleOptions {
+    /**
+     * Additional class decorator names (beyond Injectable, Controller, Resolver) that should trigger this rule.
+     */
+    readonly additionalClassDecorators?: string[];
+    /**
+     * Additional parameter decorator names (beyond Inject, Optional, Self, SkipSelf, Host) to treat as valid injection markers.
+     */
+    readonly additionalParamDecorators?: string[];
+}
+type AstNode = any;
+/**
+ * ESLint rule definition for require-nest-inject.
+ */
+export interface NestjsRequireInjectRuleDefinition {
+    readonly meta: {
+        readonly type: 'problem';
+        readonly fixable: 'code';
+        readonly docs: {
+            readonly description: string;
+            readonly recommended: boolean;
+        };
+        readonly messages: {
+            readonly missingInject: string;
+            readonly typeOnlyInjectToken: string;
+        };
+        readonly schema: readonly object[];
+    };
+    create(context: {
+        options: NestjsRequireInjectRuleOptions[];
+        report: (descriptor: {
+            node: AstNode;
+            messageId: string;
+            data: Record<string, string>;
+            fix?: (fixer: AstNode) => AstNode;
+        }) => void;
+        sourceCode: {
+            getText: (node: AstNode) => string;
+        };
+    }): Record<string, (node: AstNode) => void>;
+}
+/**
+ * ESLint rule requiring @Inject() on all constructor parameters in NestJS injectable classes.
+ *
+ * Required when emitDecoratorMetadata is disabled — without it, NestJS cannot infer
+ * constructor parameter types and will throw at runtime if @Inject() is missing.
+ *
+ * Only applies to decorators imported from '@nestjs/common', so Angular @Injectable()
+ * classes are not affected.
+ *
+ * Also flags injection tokens that are type-only imports (`import type { X }` or
+ * `import { type X }`), since those cannot be used as values at runtime.
+ *
+ * Auto-fixes:
+ * - Missing @Inject(): adds `@Inject(ClassName)` for simple class-typed parameters
+ * - Type-only imports: removes the `type` modifier from the import specifier
+ *
+ * Register as a plugin in your flat ESLint config, then enable individual rules
+ * under the chosen plugin prefix (e.g. 'dereekb-nestjs/require-nest-inject').
+ */
+export declare const nestjsRequireInjectRule: NestjsRequireInjectRuleDefinition;
+export {};

package/index.cjs.js

@@ -155,6 +155,7 @@ function _ts_generator$1(thisArg, body) {
  * ```
  *
  * @param config - Filesystem configuration with base path.
+ * @returns An {@link AssetLoader} backed by the local filesystem.
  */ function nodeJsLocalAssetLoader(config) {
     var basePath = config.basePath;
     var getFn = function getFn(ref) {
@@ -198,6 +199,7 @@ function _ts_generator$1(thisArg, body) {
  * ```
  *
  * @param config - Local filesystem config and optional remote fetch config.
+ * @returns NestJS {@link ModuleMetadata} that provides an {@link AssetLoader}.
  */ function appAssetLoaderModuleMetadata(config) {
     var local = nodeJsLocalAssetLoader(config.local);
     var remote = rxjs.fetchAssetLoader(config.remote);

package/index.esm.js

@@ -153,6 +153,7 @@ function _ts_generator$1(thisArg, body) {
  * ```
  *
  * @param config - Filesystem configuration with base path.
+ * @returns An {@link AssetLoader} backed by the local filesystem.
  */ function nodeJsLocalAssetLoader(config) {
     var basePath = config.basePath;
     var getFn = function getFn(ref) {
@@ -196,6 +197,7 @@ function _ts_generator$1(thisArg, body) {
  * ```
  *
  * @param config - Local filesystem config and optional remote fetch config.
+ * @returns NestJS {@link ModuleMetadata} that provides an {@link AssetLoader}.
  */ function appAssetLoaderModuleMetadata(config) {
     var local = nodeJsLocalAssetLoader(config.local);
     var remote = fetchAssetLoader(config.remote);

package/mailgun/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/mailgun",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "peerDependencies": {
-    "@dereekb/date": "13.6.12",
-    "@dereekb/model": "13.6.12",
-    "@dereekb/nestjs": "13.6.12",
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/date": "13.6.14",
+    "@dereekb/model": "13.6.14",
+    "@dereekb/nestjs": "13.6.14",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",
     "form-data": "^4.0.0",

package/openai/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/openai",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "peerDependencies": {
-    "@dereekb/date": "13.6.12",
-    "@dereekb/model": "13.6.12",
-    "@dereekb/nestjs": "13.6.12",
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/date": "13.6.14",
+    "@dereekb/model": "13.6.14",
+    "@dereekb/nestjs": "13.6.14",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",
     "express": "^5.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/nestjs",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "types": "./src/index.d.ts",
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
@@ -41,6 +41,12 @@
       "import": "./discord/index.cjs.mjs",
       "default": "./discord/index.cjs.js"
     },
+    "./eslint": {
+      "module": "./eslint/index.esm.js",
+      "types": "./eslint/index.d.ts",
+      "import": "./eslint/index.cjs.mjs",
+      "default": "./eslint/index.cjs.js"
+    },
     "./package.json": "./package.json",
     ".": {
       "module": "./index.esm.js",
@@ -50,8 +56,8 @@
     }
   },
   "peerDependencies": {
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "discord.js": "^14.25.1",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",

package/src/lib/asset/asset.loader.node.d.ts

@@ -27,5 +27,6 @@ export interface NodeJsLocalAssetLoaderConfig {
  * ```
  *
  * @param config - Filesystem configuration with base path.
+ * @returns An {@link AssetLoader} backed by the local filesystem.
  */
 export declare function nodeJsLocalAssetLoader(config: NodeJsLocalAssetLoaderConfig): AssetLoader;

package/src/lib/asset/asset.nest.d.ts

@@ -33,5 +33,6 @@ export interface AppAssetLoaderModuleMetadataConfig {
  * ```
  *
  * @param config - Local filesystem config and optional remote fetch config.
+ * @returns NestJS {@link ModuleMetadata} that provides an {@link AssetLoader}.
  */
 export declare function appAssetLoaderModuleMetadata(config: AppAssetLoaderModuleMetadataConfig): ModuleMetadata;

package/stripe/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/stripe",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "peerDependencies": {
-    "@dereekb/date": "13.6.12",
-    "@dereekb/model": "13.6.12",
-    "@dereekb/nestjs": "13.6.12",
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/date": "13.6.14",
+    "@dereekb/model": "13.6.14",
+    "@dereekb/nestjs": "13.6.14",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",
     "express": "^5.0.0",

package/typeform/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/typeform",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "peerDependencies": {
-    "@dereekb/date": "13.6.12",
-    "@dereekb/model": "13.6.12",
-    "@dereekb/nestjs": "13.6.12",
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/date": "13.6.14",
+    "@dereekb/model": "13.6.14",
+    "@dereekb/nestjs": "13.6.14",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",
     "@typeform/api-client": "^2.5.1",

package/vapiai/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/nestjs/vapiai",
-  "version": "13.6.12",
+  "version": "13.6.14",
   "peerDependencies": {
-    "@dereekb/date": "13.6.12",
-    "@dereekb/model": "13.6.12",
-    "@dereekb/nestjs": "13.6.12",
-    "@dereekb/rxjs": "13.6.12",
-    "@dereekb/util": "13.6.12",
+    "@dereekb/date": "13.6.14",
+    "@dereekb/model": "13.6.14",
+    "@dereekb/nestjs": "13.6.14",
+    "@dereekb/rxjs": "13.6.14",
+    "@dereekb/util": "13.6.14",
     "@nestjs/common": "^11.1.17",
     "@nestjs/config": "^4.0.3",
     "@vapi-ai/server-sdk": "^0.11.0",