Menu
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/microwind/ai-skills --skill nestjsThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Showing SKILL.md
Based on SOC occupation classification
| name | NestJS企业架构 |
| description | 当开发NestJS企业应用时，分析模块设计，优化依赖注入，解决架构问题。验证微服务架构，设计企业级应用，和最佳实践。 |
| license | MIT |
NestJS是构建企业级Node.js应用的渐进式框架。不当的NestJS架构设计会导致代码混乱、性能问题和企业级功能缺失。在设计企业级应用前需要仔细分析架构需求。
核心原则: 好的NestJS架构应该模块化、可扩展、可测试、可维护。坏的NestJS架构会导致代码耦合、性能瓶颈和维护困难。
始终:
触发短语:
问题:
模块结构混乱，依赖关系复杂
错误示例:
- 模块职责不清晰
- 循环依赖问题
- 模块过度耦合
- 缺乏模块边界
解决方案:
1. 明确模块职责边界
2. 使用依赖注入解耦
3. 实施模块化设计原则
4. 建立清晰的模块层次
问题:
依赖注入配置复杂，性能影响
错误示例:
- 不必要的服务注入
- 作用域配置错误
- 循环依赖未处理
- 服务生命周期管理不当
解决方案:
1. 合理设计服务依赖
2. 正确配置作用域
3. 处理循环依赖问题
4. 优化服务生命周期
问题:
服务间通信不稳定，数据一致性问题
错误示例:
- 同步通信阻塞
- 缺乏重试机制
- 数据一致性缺失
- 服务发现失效
解决方案:
1. 使用异步通信模式
2. 实施重试和熔断机制
3. 保证数据一致性
4. 完善服务发现机制
import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
import { join, extname } from 'path';
import { parse } from '@typescript-eslint/parser';
import { TSESTree } from '@typescript-eslint/utils';
interface ModuleInfo {
name: string;
file: string;
imports: string[];
providers: string[];
controllers: string[];
exports: string[];
issues: string[];
}
interface ServiceInfo {
name: string;
file: string;
injectable: boolean;
scope: string;
dependencies: string[];
issues: string[];
}
interface ArchitectureIssue {
severity: 'critical' | 'high' | 'medium' | 'low';
type: string;
file: ;
: ;
: ;
?: ;
}
{
: [] = [];
: [] = [];
: [] = [];
() {}
(): {
: ;
: [];
: [];
: [];
: [];
: ;
} {
{
.();
.();
.();
.();
.();
} (error) {
{
: { : },
: [],
: [],
: [],
: [],
:
};
}
}
(): {
scanDirectory = (: ): [] => {
: [] = [];
{
items = (dir);
( item items) {
fullPath = (dir, item);
stat = (fullPath);
(stat.() && !item.() && item !== ) {
files.(...(fullPath));
} (stat.() && (item) === ) {
files.(fullPath);
}
}
} (error) {
.();
}
files;
};
tsFiles = (.);
( file tsFiles) {
.(file);
}
}
(: ): {
{
content = (filePath, );
ast = (content, {
: ,
: ,
:
});
.(ast, filePath);
.(ast, filePath);
} (error) {
..({
: ,
: ,
: filePath,
: ,
:
});
}
}
(: ., : ): {
= () => {
(node. === && .(node)) {
moduleInfo = .(node, filePath);
(moduleInfo) {
..(moduleInfo);
}
}
};
.(ast, visitNode);
}
(: ., : ): {
= () => {
(node. === && .(node)) {
serviceInfo = .(node, filePath);
(serviceInfo) {
..(serviceInfo);
}
}
};
.(ast, visitNode);
}
(: .): {
(!node.) ;
node..( {
(decorator.. === ) {
decorator.. === ;
}
(decorator.. === &&
decorator... === ) {
decorator... === ;
}
;
});
}
(: .): {
(!node.) ;
node..( {
(decorator.. === ) {
decorator.. === ;
}
(decorator.. === &&
decorator... === ) {
decorator... === ;
}
;
});
}
(: ., : ): | {
(!node.) ;
: = {
: node..,
: filePath,
: [],
: [],
: [],
: [],
: []
};
moduleDecorator = node.?.( .({
...node,
: [d]
} .));
(moduleDecorator && moduleDecorator.. === ) {
decoratorArg = moduleDecorator..[];
(decoratorArg && decoratorArg. === ) {
.(decoratorArg, moduleInfo);
}
}
moduleInfo;
}
(: ., : ): {
( property node.) {
(property. === && property.. === ) {
propertyName = property..;
(property.. === ) {
elements = property..
.( el && el. === )
.( (el .).);
(propertyName) {
:
moduleInfo..(...elements);
;
:
moduleInfo..(...elements);
;
:
moduleInfo..(...elements);
;
:
moduleInfo..(...elements);
;
}
}
}
}
}
(: ., : ): | {
(!node.) ;
: = {
: node..,
: filePath,
: ,
: ,
: [],
: []
};
injectableDecorator = node.?.( .({
...node,
: [d]
} .));
(injectableDecorator) {
serviceInfo. = ;
(injectableDecorator.. === ) {
decoratorArg = injectableDecorator..[];
(decoratorArg && decoratorArg. === ) {
.(decoratorArg, serviceInfo);
}
}
}
.(node, serviceInfo);
serviceInfo;
}
(: ., : ): {
( property node.) {
(property. === &&
property.. === &&
property.. === &&
property.. === ) {
serviceInfo. = property..;
}
}
}
(: ., : ): {
(!node.) ;
( member node..) {
(member. === &&
member. === &&
member.. === &&
member..) {
( param member..) {
(param. === &&
param. &&
param... === &&
param.... === ) {
dependencyType = param....;
serviceInfo..(dependencyType);
}
}
}
}
}
(): {
moduleGraph = .();
cycles = .(moduleGraph);
( cycle cycles) {
..({
: ,
: ,
: cycle[],
: ,
:
});
}
( .) {
( imp .) {
(!.(imp)) {
..();
..({
: ,
: ,
: .,
: ,
:
});
}
}
}
}
(): {
( service .) {
(!service.) {
service..();
..({
: ,
: ,
: service.,
: ,
:
});
}
( dep service.) {
depService = ..( s. === dep);
(depService && !depService.) {
service..();
..({
: ,
: ,
: service.,
: ,
:
});
}
}
}
}
(): {
( .) {
totalElements = .. +
.. +
.. +
..;
(totalElements > ) {
..();
..({
: ,
: ,
: .,
: ,
:
});
}
}
( service .) {
(service. === && service.. > ) {
service..();
..({
: ,
: ,
: service.,
: ,
:
});
}
}
}
(): <, []> {
graph = <, []>();
( .) {
graph.(., .);
}
graph;
}
(: <, []>): [][] {
: [][] = [];
visited = <>();
recursionStack = <>();
: [] = [];
dfs = (: ): {
(recursionStack.(node)) {
cycleStart = path.(node);
cycles.([...path.(cycleStart), node]);
;
}
(visited.(node)) {
;
}
visited.(node);
recursionStack.(node);
path.(node);
neighbors = graph.(node) || [];
( neighbor neighbors) {
((neighbor)) {
;
}
}
recursionStack.(node);
path.();
;
};
( node graph.()) {
(!visited.(node)) {
(node);
}
}
cycles;
}
(: ): {
..(
m..(moduleName) ||
m..(moduleName) ||
m..(moduleName) ||
m..(moduleName)
);
}
(: ., : ): {
(node);
( key node) {
child = (node )[key];
(.(child)) {
( item child) {
(item && item === && item.) {
.(item, visitor);
}
}
} (child && child === && child.) {
.(child, visitor);
}
}
}
() {
summary = {
: ..,
: ..,
: ..,
: ..( i. === ).,
: ..( i. === ).,
: ..( i. === ).,
: ..( i. === ).
};
recommendations = .();
healthScore = .(summary);
{
summary,
: .,
: .,
: .,
recommendations,
healthScore
};
}
(): [] {
: [] = [];
issueTypes = <, >();
( issue .) {
issueTypes.(issue., (issueTypes.(issue.) || ) + );
}
(issueTypes.() > ) {
recommendations.({
: ,
: ,
: ,
:
});
}
(issueTypes.() > ) {
recommendations.({
: ,
: ,
: ,
:
});
}
(issueTypes.() > ) {
recommendations.({
: ,
: ,
: ,
:
});
}
recommendations;
}
(: ): {
score = ;
score -= summary. * ;
score -= summary. * ;
score -= summary. * ;
score -= summary. * ;
.(, score);
}
}
{
() {}
(): {
: [];
: ;
} {
: [] = [];
moduleOptimization = .();
(moduleOptimization) {
optimizations.(moduleOptimization);
}
diOptimization = .();
(diOptimization) {
optimizations.(diOptimization);
}
microserviceOptimization = .();
(microserviceOptimization) {
optimizations.(microserviceOptimization);
}
{
optimizations,
: {
: optimizations.,
: .(optimizations)
}
};
}
(): | {
sharedModulePath = (., , , );
(!(sharedModulePath)) {
{
: ,
: ,
:
};
}
;
}
(): | {
configModulePath = (., , , );
(!(configModulePath)) {
{
: ,
: ,
:
};
}
;
}
(): | {
mainTsPath = (., , );
((mainTsPath)) {
{
content = (mainTsPath, );
(!content.() && !content.()) {
{
: ,
: ,
:
};
}
} (error) {
}
}
;
}
(: []): {
: ;
: ;
: ;
} {
improvements = {
: ,
: ,
:
};
( opt optimizations) {
(opt.) {
:
improvements. += ;
improvements. += ;
;
:
improvements. += ;
improvements. += ;
;
:
improvements. += ;
improvements. += ;
;
}
}
improvements;
}
}
() {
analyzer = ();
report = analyzer.();
.();
.();
.();
.();
.();
.();
( rec report.) {
.();
}
optimizer = ();
optimization = optimizer.();
.();
( opt optimization.) {
.();
}
}
{ , };
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { performance } from 'perf_hooks';
interface RequestMetrics {
method: string;
url: string;
statusCode: number;
duration: number;
timestamp: number;
userAgent: string;
ip: string;
}
interface PerformanceMetrics {
cpuUsage: number;
memoryUsage: NodeJS.MemoryUsage;
activeConnections: number;
requestsPerSecond: number;
}
@Injectable()
export class NestJSPerformanceMonitor implements OnModuleInit, OnModuleDestroy {
private requests: RequestMetrics[] = [];
private startTime = performance.now();
private metricsInterval: NodeJS.Timeout;
() {
.();
}
() {
(.) {
(.);
}
}
() {
: = {
: req.,
: req.,
: res.,
duration,
: .(),
: req.[] || ,
: req. || req.. ||
};
..(metrics);
(.. > ) {
..();
}
}
(): {
: ;
: ;
: ;
: ;
: [];
} {
requestStats = .();
performanceStats = .();
routeStats = .();
{
: .(),
: performance.() - .,
requestStats,
performanceStats,
routeStats
};
}
() {
(.. === ) {
{
: ,
: ,
: ,
: ,
: ,
:
};
}
totalRequests = ..;
uptime = performance.() - .;
requestsPerSecond = totalRequests / (uptime / );
responseTimes = ..( r.);
averageResponseTime = responseTimes.( sum + time, ) / totalRequests;
errorRequests = ..( r. >= );
errorRate = (errorRequests. / totalRequests) * ;
{
totalRequests,
requestsPerSecond,
averageResponseTime,
errorRate,
: .(responseTimes, ),
: .(responseTimes, )
};
}
(): {
memUsage = process.();
{
: process.(). / ,
: memUsage,
: ,
: .()
};
}
() {
routeStats = <, >();
( req .) {
routeKey = ;
(!routeStats.(routeKey)) {
routeStats.(routeKey, {
: ,
: ,
: ,
:
});
}
stats = routeStats.(routeKey);
stats.++;
stats. += req.;
stats. = stats. / stats.;
(req. >= ) {
stats.++;
}
}
.(routeStats.())
.( ({ route, ...stats }))
.( b. - a.)
.(, );
}
(: [], : ): {
(values. === ) ;
sorted = values.( a - b);
index = .(sorted. * (percentile / ));
sorted[.(index, sorted. - )];
}
(): {
now = performance.();
recentRequests = ..( now - r. < );
recentRequests. / ;
}
() {
. = ( {
.();
}, );
}
() {
metrics = .();
.(, {
: metrics.,
: metrics.,
: metrics.
});
}
}
() {
{
startTime = performance.();
res.(, {
duration = performance.() - startTime;
monitor.(req, res, duration);
});
();
};
}
{ } ;
{ } ;
{ , } ;
({
: [
,
{
: ,
: {
(monitor);
},
: []
}
]
})
{}