giuseppe-trisciuoglio/developer-kit

nx-monorepo

Provides comprehensive Nx monorepo management guidance for TypeScript/JavaScript projects.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill nx-monorepo

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

Nx Monorepo

Overview

Provides guidance for Nx monorepo management in TypeScript/JavaScript projects. Covers workspace creation, project generation, task execution, caching strategies, Module Federation, and CI/CD integration.

When to Use

Use this skill when:

  • Creating a new Nx workspace or initializing Nx in an existing project
  • Generating applications, libraries, or components with Nx generators
  • Running affected commands or executing tasks across multiple projects
  • Setting up CI/CD pipelines for Nx projects (GitHub Actions, CircleCI, etc.)
  • Configuring Module Federation with React or Next.js
  • Implementing NestJS backend applications within Nx
  • Managing TypeScript package libraries with buildable and publishable libs
  • Setting up remote caching or Nx Cloud
  • Optimizing monorepo build times and caching strategies
  • Debugging dependency graph issues or circular dependencies

Trigger phrases: "create Nx workspace", "Nx monorepo", "generate Nx app", "Nx affected", "Nx CI/CD", "Module Federation Nx", "Nx Cloud"

Instructions

Workspace Creation

  1. Create a new workspace with interactive setup:
bash
   npx create-nx-workspace@latest

Follow prompts to select preset (Integrated, Standalone, Package-based) and framework stack.

  1. Initialize Nx in an existing project:
bash
   nx@latest init
  1. Create with specific preset (non-interactive):
bash
   npx create-nx-workspace@latest my-workspace --preset=react

Verify: nx show projects lists the new workspace projects

Project Generation

  1. Generate a React application:
bash
   nx g @nx/react:app my-app
  1. Generate a library:
bash
   # React library
   nx g @nx/react:lib my-lib

   # TypeScript library
   nx g @nx/js:lib my-util

Verify: nx show projects lists the new lib

  1. Generate a component in lib:
bash
   nx g @nx/react:component my-comp --project=my-lib
  1. Generate NestJS backend:
bash
   nx g @nx/nest:app my-api

Verify: nx show projects lists my-api and nx run my-api:build succeeds

Task Execution

  1. Run tasks for affected projects only:
bash
   nx affected -t lint test build
  1. Run tasks across all projects:
bash
   # Build all projects
   nx run-many -t build

   # Test specific projects
   nx run-many -t test -p=my-app,my-lib

   # Test by pattern
   nx run-many -t test --projects=*-app
  1. Run specific target on single project:
bash
   nx run my-app:build
  1. Visualize dependency graph:
bash
   nx graph

Project Configuration

Each project has a project.json defining targets, executor, and configurations:

json
{
  "name": "my-app",
  "projectType": "application",
  "sourceRoot": "apps/my-app/src",
  "targets": {
    "build": {
      "executor": "@nx/react:webpack",
      "outputs": ["{workspaceRoot}/dist/apps/my-app"],
      "configurations": {
        "production": {
          "optimization": true
        }
      }
    },
    "test": {
      "executor": "@nx/vite:test"
    }
  },
  "tags": ["type:app", "scope:frontend"]
}

Dependency Management

  1. Set up project dependencies:
json
   {
     "targets": {
       "build": {
         "dependsOn": [
           { "projects": ["shared-ui"], "target": "build" }
         ]
       }
     }
   }
  1. Use tags for organization:
json
   { "tags": ["type:ui", "scope:frontend", "platform:web"] }

Module Federation (Nx 17+)

  1. Generate a remote (micro-frontend):
bash
   nx g @nx/react:remote checkout --host=dashboard
  1. Generate a host:
bash
   nx g @nx/react:host dashboard

CI/CD Setup

Use affected commands in CI to only build/test changed projects:

yaml
# .github/workflows/ci.yml
- run: npx nx affected -t lint --parallel
- run: npx nx affected -t test --parallel
- run: npx nx affected -t build --parallel

Examples

Example 1: Create New React Workspace

Input: "Create a new Nx workspace with React and TypeScript"

Steps:

bash
npx create-nx-workspace@latest my-workspace
# Select: Integrated Monorepo → React → Integrated monorepo (Nx Cloud)

Verify: cd my-workspace && nx show projects lists the created app

Expected Result: Workspace created with:

  • apps/ directory with React app
  • libs/ directory for shared libraries
  • nx.json with cache configuration
  • CI/CD workflow files ready

Example 2: Run Tests for Changed Projects

Input: "Run tests only for projects affected by recent changes"

Command:

bash
nx affected -t test --base=main~1 --head=main

Expected Result: Only tests for projects affected by changes between commits are executed, leveraging cached results from previous runs.

Example 3: Generate and Build a Shared Library

Input: "Create a shared UI library and use it in the app"

Steps:

bash
# Generate library
nx g @nx/react:lib shared-ui

# Generate component in library
nx g @nx/react:component button --project=shared-ui

# Import in app (tsconfig paths auto-configured)
import { Button } from '@my-workspace/shared-ui'

Verify: nx run shared-ui:build completes successfully and nx graph shows the dependency link to your app

Expected Result: Buildable library at libs/shared-ui with proper TypeScript path mapping configured.

Example 4: Set Up Module Federation

Input: "Configure Module Federation for micro-frontends"

Steps:

bash
# Create host app
nx g @nx/react:host dashboard

# Add remote to host
nx g @nx/react:remote product-catalog --host=dashboard

# Start dev servers
nx run dashboard:serve
nx run product-catalog:serve

Verify: Both servers start without errors and nx graph shows dashboard → product-catalog remote connection

Expected Result: Two separate applications running where product-catalog loads dynamically into dashboard at runtime.

Example 5: Debug Build Dependencies

Input: "Why is my app rebuilding when unrelated lib changes?"

Diagnosis:

bash
# Show project graph
nx graph --focused=my-app

# Check implicit dependencies
nx show project my-app --json | grep implicitDependencies

Solution: Add explicit dependency configuration or use namedInputs in nx.json to exclude certain files from triggering builds.

Verify Fix Worked: Make a change to the unrelated lib, run nx affected -t build — my-app should not appear in the affected projects list.

Best Practices

  • Always use `nx affected` in CI to only test/build changed projects
  • Organize libs by domain/business capability, not by technical layer
  • Use tags consistently (type:app|lib, scope:frontend|backend|shared)
  • Prevent circular dependencies by configuring workspaceLayout boundaries in nx.json
  • Enable remote caching with Nx Cloud for team productivity
  • Keep project.json simple - use defaults from nx.json when possible
  • Leverage generators instead of manual file creation for consistency
  • Configure `namedInputs` to exclude test files from production cache keys
  • Use Module Federation for independent deployment of micro-frontends
  • Keep workspace generators in tools/ for project-specific scaffolding

Constraints and Warnings

  • Node.js 18.10+ is required for Nx 17+
  • Windows users: Use WSL or Git Bash for best experience
  • First-time setup may take longer due to package installation
  • Large monorepos (50+ projects) should use distributed task execution
  • Module Federation requires webpack 5+ and specific Nx configuration
  • Some generators require additional plugins to be installed first
  • Cache location: Default ~/.nx/cache can grow large; configure cacheDirectory in nx.json if needed
  • Circular dependencies will cause build failures; use nx graph to visualize
  • Preset migration: Converting between Integrated/Standalone/Package-based requires manual effort

Reference Files

For detailed guidance on specific topics, consult:

TopicReference File
Workspace setup, basic commandsreferences/basics.md
Generators (app, lib, component)references/generators.md
React, Next.js, Expo patternsreferences/react.md
NestJS backend patternsreferences/nestjs.md
TypeScript packagesreferences/typescript.md
CI/CD (GitHub, CircleCI, etc.)references/ci-cd.md
Caching, affected, advancedreferences/advanced.md

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
giuseppe-trisciuoglio
커뮤니티

drizzle-orm-patterns

Provides comprehensive Drizzle ORM patterns for schema definition, CRUD operations, relations, queries, transactions, and migrations. Proactively use for any Drizzle ORM development including defining database schemas, writing type-safe queries, implementing relations, managing transactions, and setting up migrations with Drizzle Kit. Supports PostgreSQL, MySQL, SQLite, MSSQL, and CockroachDB.

1시간 설치 수
2
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

adr-drafting

Creates new Architecture Decision Record (ADR) documents for significant architectural changes using a consistent template and repository-aware naming and storage guidance. Use when a user or agent decides on an architectural change, needs to document technical rationale, or wants to add a new ADR to the project history.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

clean-architecture

Provides implementation patterns for Clean Architecture, Hexagonal Architecture (Ports & Adapters), and Domain-Driven Design in PHP 8.3+ with Symfony 7.x. Use when architecting enterprise PHP applications with entities/value objects/aggregates, refactoring legacy code to modern patterns, implementing domain-driven design with Symfony, or creating testable backends with clear separation of concerns.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

langchain4j-spring-boot-integration

Provides integration patterns for LangChain4j with Spring Boot. Configures AI model beans, sets up chat memory with Spring context, integrates RAG pipelines with Spring Data, and handles auto-configuration, dependency injection, and Spring ecosystem integration. Use when embedding LangChain4j into Spring Boot applications, building Java LLM applications with @Bean configuration, or setting up Spring AI patterns.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일