Menú
De forma predeterminada está seleccionado el prompt que primero revisa el origen. Puedes cambiar a un comando directo o descargar una copia local.
Lee SKILL.md y los archivos complementarios que muestra SkillsMP antes de decidir si quieres instalarlo.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/microwind/ai-skills --skill nestjsEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Basado en la clasificación ocupacional SOC
Mostrando SKILL.md
| 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);
},
: []
}
]
})
{}