Kurs Next.js · Moduł 1: Konfiguracja Next.js

Środowisko deweloperskie - narzędzia i praktyki

18 min czytania ·
W tej lekcji4

W Metropolii Quantum inżynierowie kwantowi potrzebują zaawansowanych stacji roboczych, precyzyjnych narzędzi i zoptymalizowanych procesów, aby efektywnie projektować i utrzymywać zaawansowane systemy miasta. Podobnie dla ciebie jako dewelopera Next.js 16 środowisko deweloperskie jest fundamentem produktywności i jakości kodu.

Centrum Dowodzenia Metropolii Quantum

Zacznijmy od skonfigurowania idealnego środowiska deweloperskiego - twojego osobistego Centrum Dowodzenia dla projektów Next.js 16.

Podstawowe narzędzia

1. Edytor kodu - Quantum Terminal

Sercem każdej stacji roboczej inżyniera kwantowego jest Quantum Terminal. Dla deweloperów Next.js 16 Visual Studio Code (VS Code) z dodatkami jest najlepszym wyborem:

# Zainstaluj podstawowy edytor
code --install-extension dbaeumer.vscode-eslint
code --install-extension esbenp.prettier-vscode
code --install-extension bradlc.vscode-tailwindcss
code --install-extension ms-vscode.vscode-typescript-next
code --install-extension dsznajder.es7-react-js-snippets

Konfiguracja VSCode dla projektów Next.js 16 - plik .vscode/settings.json:

{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true
  },
  "typescript.tsdk": "node_modules/typescript/lib",
  "typescript.enablePromptUseWorkspaceTsdk": true,
  "tailwindCSS.includeLanguages": {
    "typescript": "javascript",
    "typescriptreact": "javascript"
  },
  "tailwindCSS.experimental.classRegex": [
    ["cn\\(([^)]*)\\)", "'([^']*)'"]
  ],
  "files.associations": {
    "*.css": "tailwindcss"
  }
}

2. System kontroli wersji - Kwantowe Archiwa

W Metropolii Quantum każda zmiana w systemach miasta jest starannie rejestrowana i przechowywana w Kwantowych Archiwach. W naszym świecie używamy Git:

# Inicjalizacja repozytorium Git dla projektu
git init

# Tworzenie pliku .gitignore dla projektów Next.js
curl -fsSL https://raw.githubusercontent.com/github/gitignore/main/Nextjs.gitignore -o .gitignore

Plik .gitignore dla projektu Next.js 16:

# dependencies
/node_modules
/.pnp
.pnp.*
.yarn/*
!.yarn/patches
!.yarn/plugins
!.yarn/releases
!.yarn/versions

# testing
/coverage

# next.js
/.next/
/out/

# production
/build

# misc
.DS_Store
*.pem

# debug
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*

# env files (can opt-in for committing if needed)
.env*

# vercel
.vercel

# typescript
*.tsbuildinfo
next-env.d.ts

Tak wygląda .gitignore z create-next-app w Next.js 16. Zwróć uwagę na wiersz .env*: od Next.js 15 ignorowane są wszystkie pliki środowiskowe, nie tylko .env*.local, żeby sekrety nie trafiły przypadkiem do repozytorium. Jeśli chcesz zapisać w nim plik z przykładowymi wartościami, dodaj wyjątek, np. !.env.example.

3. Zarządzanie pakietami - Matryca Zasobów Kwantowych

Inżynierowie w Metropolii Quantum korzystają z Matrycy Zasobów Kwantowych, aby uzyskiwać dokładnie te komponenty, których potrzebują. My korzystamy z npm, yarn lub pnpm:

# Inicjalizacja projektu Next.js 16 z Tailwind CSS i TypeScript
npx create-next-app@latest quantum-project
# Wybierz "Yes, use recommended defaults": TypeScript, ESLint,
# Tailwind CSS, App Router i AGENTS.md w jednym kroku

Opcjonalnie, możesz skonfigurować pnpm dla lepszej wydajności:

# Instalacja pnpm
npm install -g pnpm

# Inicjalizacja projektu z pnpm
pnpm dlx create-next-app@latest quantum-project

Narzędzia zwiększające produktywność

1. ESLint - Kwantowy Detektor Anomalii

W Metropolii Quantum zaawansowane skanery nieustannie monitorują kod w poszukiwaniu potencjalnych błędów i nieoptymalnych wzorców. W świecie Next.js 16 ESLint pełni tę funkcję:

npm install --save-dev eslint-plugin-jsx-a11y

Pakiet eslint-config-next zawiera już zalecane reguły wtyczek react i react-hooks oraz rejestruje wtyczkę jsx-a11y z kilkoma regułami dostępności, dlatego doinstalowujemy tylko eslint-plugin-jsx-a11y, żeby włączyć jej pełny zalecany zestaw. Konfiguracja ESLint w pliku eslint.config.mjs:

// eslint.config.mjs
import { defineConfig, globalIgnores } from 'eslint/config';
import nextVitals from 'eslint-config-next/core-web-vitals';
import nextTs from 'eslint-config-next/typescript';
import jsxA11y from 'eslint-plugin-jsx-a11y';

const eslintConfig = defineConfig([
  ...nextVitals,
  ...nextTs,
  {
    rules: {
      ...jsxA11y.flatConfigs.recommended.rules,
      'react/react-in-jsx-scope': 'off',
      'react/prop-types': 'off',
      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
      'jsx-a11y/anchor-is-valid': ['error', {
        components: ['Link'],
        specialLink: ['hrefLeft', 'hrefRight'],
        aspects: ['invalidHref', 'preferButton'],
      }],
    },
  },
  globalIgnores(['.next/**', 'out/**', 'build/**', 'next-env.d.ts']),
]);

export default eslintConfig;

Reguły wpisane po rozwinięciu zestawu recommended nadpisują jego ustawienia, dlatego anchor-is-valid rozumie komponent Link z Next.js. Ustawienie wersji Reacta (settings.react.version) nie jest już potrzebne, bo eslint-config-next wykrywa ją automatycznie.

2. Prettier - Kwantowy Harmonizator Kodu

Tak jak w Metropolii Quantum wszystkie struktury muszą być idealnie zharmonizowane, tak twój kod powinien być spójnie sformatowany:

npm install --save-dev prettier eslint-config-prettier

Konfiguracja Prettier w pliku .prettierrc:

{
  "semi": true,
  "singleQuote": true,
  "tabWidth": 2,
  "printWidth": 100,
  "trailingComma": "es5",
  "bracketSpacing": true,
  "arrowParens": "avoid"
}

I dodaj konfigurację eslint-config-prettier na końcu tablicy w eslint.config.mjs, żeby wyłączyć reguły ESLinta kolidujące z formatowaniem:

// eslint.config.mjs (fragment)
import prettier from 'eslint-config-prettier/flat';

const eslintConfig = defineConfig([
  ...nextVitals,
  ...nextTs,
  // ...reszta konfiguracji
  prettier,
  globalIgnores(['.next/**', 'out/**', 'build/**', 'next-env.d.ts']),
]);

3. Husky i lint-staged - Automatyczne Straże Kwantowe

W Metropolii Quantum, zanim jakikolwiek kod zostanie wprowadzony do systemów miasta, przechodzi przez szereg automatycznych testów i walidacji. Podobnie możemy skonfigurować Husky i lint-staged:

npm install --save-dev husky lint-staged
npx husky init
echo "npx lint-staged" > .husky/pre-commit

Konfiguracja lint-staged w package.json:

{
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "eslint --fix",
      "prettier --write"
    ],
    "*.{json,css,md}": [
      "prettier --write"
    ]
  }
}

4. TypeScript - Kwantowy System Typów

W Metropolii Quantum wszystkie komponenty muszą dokładnie przestrzegać swoich specyfikacji, aby zapewnić bezpieczeństwo całego systemu. TypeScript zapewnia podobne bezpieczeństwo dla twojego kodu:

# TypeScript jest już zainstalowany w projekcie Next.js 16
# Skonfigurujmy ściślejsze reguły TypeScript

Konfiguracja tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2017",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "forceConsistentCasingInFileNames": true,
    "noEmit": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "react-jsx",
    "incremental": true,
    "plugins": [
      {
        "name": "next"
      }
    ],
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts", "**/*.mts"],
  "exclude": ["node_modules"]
}

Tak wygląda tsconfig.json w projekcie Next.js 16 uzupełniony o opcję noUncheckedIndexedAccess (noImplicitAny i strictNullChecks włącza już "strict": true). create-next-app ustawia "jsx": "react-jsx" i "moduleResolution": "bundler", a w include dopisuje katalog .next/dev/types, bo next dev zapisuje teraz swoje pliki osobno w .next/dev.

Narzędzia testowe - Kwantowe Symulacje

Inżynierowie w Metropolii Quantum przeprowadzają tysiące symulacji przed każdą zmianą, aby zapewnić, że systemy miasta będą działać bez zarzutu. Odpowiednikiem w świecie Next.js 16 są narzędzia testowe:

1. Jest i React Testing Library - Podstawowe Symulacje

npm install --save-dev jest @testing-library/react @testing-library/jest-dom jest-environment-jsdom

Plik konfiguracyjny jest.config.js:

const nextJest = require('next/jest');

const createJestConfig = nextJest({
  // Folder, gdzie znajduje się plik next.config.js i folder node_modules
  dir: './',
});

// Konfiguracja Jest
const customJestConfig = {
  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
  testEnvironment: 'jest-environment-jsdom',
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },
};

// eksportujemy tę konfigurację
module.exports = createJestConfig(customJestConfig);

Plik setupu jest.setup.js:

// Rozszerzenia dla Jest
import '@testing-library/jest-dom';

Skrypty testowe w package.json:

{
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch"
  }
}

2. Cypress - Zaawansowane Symulacje

npm install --save-dev cypress

Inicjalizacja Cypress:

npx cypress open

Dodaj skrypty do package.json:

{
  "scripts": {
    "cypress": "cypress open",
    "cypress:headless": "cypress run"
  }
}

3. Storybook - Biblioteka Komponentów Kwantowych

npm create storybook@latest

Kreator zapyta, czy użyć wersji opartej na Vite, czy na Webpacku. Skonfiguruj Storybook dla Next.js 16 w pliku .storybook/main.ts:

// .storybook/main.ts
import type { StorybookConfig } from '@storybook/nextjs-vite';

const config: StorybookConfig = {
  stories: ['../src/**/*.mdx', '../src/**/*.stories.@(js|jsx|ts|tsx)'],
  addons: ['@storybook/addon-docs'],
  framework: '@storybook/nextjs-vite',
  staticDirs: ['../public'],
};

export default config;

Framework @storybook/nextjs-vite zna specyfikę Next.js, m.in. next/image, next/font i routing, dlatego dokumentacja Storybooka poleca go dla większości projektów Next.js. Wersję opartą na Webpacku (@storybook/nextjs) wybierz tylko wtedy, gdy potrzebujesz własnej konfiguracji Webpacka lub Babela.

Praktyki zoptymalizowanego rozwoju

W Metropolii Quantum każdy inżynier przestrzega ściśle określonych standardów i procedur. Przyjrzyjmy się najlepszym praktykom dla deweloperów Next.js 16.

1. Struktura projektu - Blueprint Metropolii

Podobnie jak Metropolia Quantum jest podzielona na precyzyjnie zaprojektowane sektory, twój projekt Next.js 16 powinien mieć przejrzystą strukturę:

quantum-voyages/
  ├── .husky/                # Konfiguracja Husky
  ├── .vscode/               # Konfiguracja VS Code
  ├── public/                # Statyczne zasoby
  ├── src/
  │   ├── app/               # App Router - trasy i strony
  │   │   ├── (auth)/        # Grupowanie logiczne dla autoryzacji
  │   │   │   ├── login/
  │   │   │   └── register/
  │   │   ├── destinations/  # Trasa dla destynacji
  │   │   ├── bookings/      # Trasa dla rezerwacji
  │   │   ├── api/           # Endpointy API
  │   │   └── layout.tsx     # Główny layout
  │   ├── components/        # Komponenty React
  │   │   ├── ui/            # Elementy interfejsu
  │   │   └── features/      # Komponenty specyficzne dla funkcji
  │   ├── hooks/             # Niestandardowe hooki React
  │   ├── lib/               # Funkcje narzędziowe i logika biznesowa
  │   ├── styles/            # Globalne style i motywy
  │   ├── types/             # Definicje typów TypeScript
  │   └── utils/             # Funkcje narzędziowe
  ├── tests/                 # Testy integracyjne i end-to-end
  │   ├── e2e/               # Testy Cypress
  │   └── integration/       # Testy integracyjne
  ├── .env.example           # Przykładowy plik zmiennych środowiskowych
  ├── .gitignore             # Ignorowane pliki Git
  ├── .prettierrc            # Konfiguracja Prettier
  ├── eslint.config.mjs      # Konfiguracja ESLint (flat config)
  ├── jest.config.js         # Konfiguracja Jest
  ├── next.config.ts         # Konfiguracja Next.js
  ├── package.json           # Zależności i skrypty
  ├── postcss.config.mjs     # Konfiguracja PostCSS (dla Tailwind CSS 4)
  └── tsconfig.json          # Konfiguracja TypeScript

2. Konwencje nazewnictwa - Protokoły Kwantowe

W Metropolii Quantum każdy element ma swoją precyzyjną nazwę, która odzwierciedla jego funkcję. Podobnie w kodzie:

// Komponenty: PascalCase, pliki .tsx
// components/ui/QuantumButton.tsx
export default function QuantumButton() {
  return <button className="bg-blue-500 text-white px-4 py-2 rounded">Quantum</button>;
}

// Funkcje narzędziowe: camelCase, pliki .ts
// utils/formatDate.ts
export function formatDate(date: Date): string {
  return new Intl.DateTimeFormat('pl-PL').format(date);
}

// Hooki: nazwa zaczyna się od 'use', camelCase, pliki .ts
// hooks/useQuantumState.ts
export function useQuantumState(initialValue: number) {
  const [state, setState] = useState(initialValue);
  //
  return { state, increment, decrement };
}

// Konteksty: nazwa kończy się na 'Context', PascalCase
// contexts/QuantumContext.tsx
export const QuantumContext = createContext<QuantumContextType | null>(null);

3. Przepływ pracy w Gicie - Protokoły kontroli wersji Metropolii

W Metropolii Quantum każda zmiana w systemach miasta musi przejść przez precyzyjny proces zatwierdzania i wdrażania. W świecie programistycznym warto stosować model Gitflow:

# Tworzenie nowej funkcji
git checkout -b feature/quantum-navigation

# Commity z opisowymi wiadomościami
git commit -m "feat: Add quantum navigation component"
git commit -m "fix: Repair positioning in quantum nav"
git commit -m "docs: Add JSdoc comments to navigation functions"

# Zakończenie funkcji i merge do developa
git checkout develop
git merge feature/quantum-navigation

Standardy wiadomości commit (Conventional Commits):

  1. feat: nowa funkcjonalność
  2. fix: naprawa błędu
  3. docs: zmiany w dokumentacji
  4. style: formatowanie kodu
  5. refactor: refaktoryzacja kodu
  6. test: dodanie lub aktualizacja testów
  7. chore: aktualizacje zadań budowy, narzędzi itp.

4. Podejście do komponentów - Projektowanie Kwantowych Modułów

Atomic Design

W Metropolii Quantum wszystkie systemy są budowane z podstawowych cząstek kwantowych, które łączą się w coraz bardziej złożone struktury. Podobny model - Atomic Design - możemy zastosować w projektowaniu interfejsu:

  1. Atoms - podstawowe komponenty: przyciski, inputy, etykiety
  2. Molecules - grupy atomów: formularze wyszukiwania, nawigacja
  3. Organisms - złożone sekcje UI: nagłówki, stopki, panele boczne
  4. Templates - układy stron
  5. Pages - konkretne instancje szablonów z danymi
components/
  ├── atoms/
  │   ├── Button.tsx
  │   ├── Input.tsx
  │   └── Label.tsx
  ├── molecules/
  │   ├── SearchForm.tsx
  │   └── NavLink.tsx
  ├── organisms/
  │   ├── Header.tsx
  │   └── Footer.tsx
  └── templates/
      ├── DashboardLayout.tsx
      └── AuthLayout.tsx

Komponenty oparte na wzorcu "Kompozycji i API"

Tak jak w Metropolii Quantum każdy moduł ma swój interfejs i może być łączony z innymi modułami, nasze komponenty powinny być zaprojektowane modułowo:

// Przykład komponentu z wzorcem kompozycji
import { ReactNode } from 'react';

interface CardProps {
  className?: string;
  children: ReactNode;
}

export function Card({ className, children }: CardProps) {
  return <div className={`rounded-lg shadow ${className}`}>{children}</div>;
}

Card.Header = function CardHeader({ className, children }: CardProps) {
  return <div className={`p-4 border-b ${className}`}>{children}</div>;
};

Card.Body = function CardBody({ className, children }: CardProps) {
  return <div className={`p-4 ${className}`}>{children}</div>;
};

Card.Footer = function CardFooter({ className, children }: CardProps) {
  return <div className={`p-4 border-t ${className}`}>{children}</div>;
};

// Użycie
<Card className="bg-white">
  <Card.Header>Quantum Navigation</Card.Header>
  <Card.Body>Zawartość karty</Card.Body>
  <Card.Footer>Actions</Card.Footer>
</Card>

5. Automatyzacja zadań - Kwantowe Automatyczne Systemy

W Metropolii Quantum wiele procesów jest zautomatyzowanych, aby inżynierowie mogli skupić się na innowacjach. Podobnie w projekcie Next.js 16:

// package.json
{
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "eslint",
    "format": "prettier --write .",
    "test": "jest",
    "test:watch": "jest --watch",
    "e2e": "cypress open",
    "storybook": "storybook dev -p 6006",
    "build-storybook": "storybook build",
    "prepare": "husky",
    "type-check": "tsc --noEmit",
    "validate": "npm-run-all --parallel lint type-check test"
  }
}

Skrypt validate uruchamia kilka poleceń naraz narzędziem npm-run-all, które trzeba doinstalować: npm install --save-dev npm-run-all2 (pakiet npm-run-all2 dostarcza polecenie npm-run-all).

6. Zarządzanie stanem - Kwantowe Zarządzanie Danymi

W Metropolii Quantum dane przepływają przez miasto za pomocą złożonego systemu kwantowego. W aplikacji Next.js 16 również potrzebujemy efektywnego zarządzania stanem:

Lokalne zarządzanie stanem

// Korzystanie z useState i useReducer dla prostego zarządzania stanem
"use client";

import { useState } from 'react';

export default function QuantumCounter() {
  const [count, setCount] = useState(0);

  return (
    <div className="flex items-center gap-4">
      <button
        onClick={() => setCount(c => c - 1)}
        className="px-3 py-1 bg-red-500 text-white rounded"
      >
        -
      </button>
      <span className="text-xl">{count}</span>
      <button
        onClick={() => setCount(c => c + 1)}
        className="px-3 py-1 bg-green-500 text-white rounded"
      >
        +
      </button>
    </div>
  );
}

Zarządzanie stanem na poziomie aplikacji

// Context API - dla średniej wielkości aplikacji
// contexts/QuantumStateContext.tsx
"use client";

import { createContext, useContext, useReducer, ReactNode } from 'react';

type State = {
  destinations: string[];
  selectedDestination: string | null;
};

type Action =
  | { type: 'ADD_DESTINATION'; payload: string }
  | { type: 'SELECT_DESTINATION'; payload: string };

const initialState: State = {
  destinations: ['Mars', 'Europa', 'Titan'],
  selectedDestination: null,
};

function reducer(state: State, action: Action): State {
  switch (action.type) {
    case 'ADD_DESTINATION':
      return {
        ...state,
        destinations: [...state.destinations, action.payload],
      };
    case 'SELECT_DESTINATION':
      return {
        ...state,
        selectedDestination: action.payload,
      };
    default:
      return state;
  }
}

const QuantumStateContext = createContext<{
  state: State;
  dispatch: React.Dispatch<Action>;
} | undefined>(undefined);

export function QuantumStateProvider({ children }: { children: ReactNode }) {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <QuantumStateContext.Provider value={{ state, dispatch }}>
      {children}
    </QuantumStateContext.Provider>
  );
}

export function useQuantumState() {
  const context = useContext(QuantumStateContext);
  if (context === undefined) {
    throw new Error('useQuantumState must be used within a QuantumStateProvider');
  }
  return context;
}

Dla większych aplikacji warto rozważyć biblioteki zarządzania stanem, takie jak Zustand, Jotai czy Redux Toolkit.

7. Strategia API - Protokoły komunikacji kwantowej

W Metropolii Quantum systemy komunikują się za pomocą precyzyjnych protokołów. W Next.js 16 mamy kilka opcji implementacji API:

Route Handlers

// app/api/destinations/route.ts
import { NextResponse } from 'next/server';

export async function GET() {
  // Pobieranie danych z bazy danych lub zewnętrznego API
  const destinations = [
    { id: 1, name: 'Mars', distance: '54.6M km' },
    { id: 2, name: 'Europa', distance: '628.3M km' },
    { id: 3, name: 'Titan', distance: '1.2B km' },
  ];

  return NextResponse.json(destinations);
}

export async function POST(request: Request) {
  const body = await request.json();

  // Walidacja i logika biznesowa
  if (!body.name) {
    return NextResponse.json(
      { error: 'Name is required' },
      { status: 400 }
    );
  }

  // Zapisywanie do bazy danych...

  return NextResponse.json(
    { id: 4, name: body.name, distance: body.distance },
    { status: 201 }
  );
}

Akcje serwerowe (Server Actions)

// app/destinations/actions.ts
'use server';

import { revalidatePath } from 'next/cache';
import { redirect } from 'next/navigation';

export async function addDestination(formData: FormData) {
  const name = formData.get('name') as string;
  const distance = formData.get('distance') as string;

  if (!name || !distance) {
    return { error: 'Name and distance are required' };
  }

  // Zapisywanie do bazy danych...

  // Odświeżenie danych
  revalidatePath('/destinations');
  redirect('/destinations');
}

React Query dla zarządzania stanem API

npm install @tanstack/react-query @tanstack/react-query-devtools
// app/providers.tsx
'use client';

import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
import { useState, ReactNode } from 'react';

export function Providers({ children }: { children: ReactNode }) {
  const [queryClient] = useState(() => new QueryClient());

  return (
    <QueryClientProvider client={queryClient}>
      {children}
      <ReactQueryDevtools initialIsOpen={false} />
    </QueryClientProvider>
  );
}
// components/DestinationsList.tsx
'use client';

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';

async function fetchDestinations() {
  const res = await fetch('/api/destinations');
  if (!res.ok) throw new Error('Failed to fetch destinations');
  return res.json();
}

export default function DestinationsList() {
  const queryClient = useQueryClient();

  const { data: destinations, isLoading, error } = useQuery({
    queryKey: ['destinations'],
    queryFn: fetchDestinations,
  });

  const mutation = useMutation({
    mutationFn: async (newDestination) => {
      const res = await fetch('/api/destinations', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(newDestination),
      });
      return res.json();
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ['destinations'] });
    },
  });

  if (isLoading) return <div>Ładowanie destynacji...</div>;
  if (error) return <div>Błąd: {error.message}</div>;

  return (
    <div>
      <h2 className="text-2xl font-bold mb-4">Dostępne destynacje</h2>
      <ul className="space-y-2">
        {destinations.map((dest) => (
          <li key={dest.id} className="p-3 bg-gray-100 rounded">
            {dest.name} - {dest.distance}
          </li>
        ))}
      </ul>
    </div>
  );
}

8. Ciągła integracja i wdrażanie (CI/CD) - Kwantowy Potok Produkcyjny

W Metropolii Quantum nowe technologie są systematycznie testowane i wdrażane za pomocą w pełni zautomatyzowanego procesu. Podobnie możemy skonfigurować CI/CD dla naszego projektu:

GitHub Actions dla CI/CD

Plik .github/workflows/ci.yml:

name: CI

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v7

    - name: Setup Node.js
      uses: actions/setup-node@v7
      with:
        node-version: '24'
        cache: 'npm'

    - name: Install dependencies
      run: npm ci

    - name: Lint
      run: npm run lint

    - name: Type check
      run: npm run type-check

    - name: Test
      run: npm test

    - name: Build
      run: npm run build

Wdrażanie na Vercelu

Skonfiguruj integrację z Vercelem, aby każdy push do głównej gałęzi automatycznie wdrażał aplikację:

  1. Połącz swoje repozytorium z Vercelem
  2. Skonfiguruj zmienne środowiskowe
  3. Używaj podglądów (Preview Deployments) dla pull requestów
  4. Automatyczne wdrażanie na produkcję po połączeniu z główną gałęzią

Zaawansowane techniki deweloperskie

1. Monitorowanie wydajności - Kwantowa telemetria

W Metropolii Quantum inżynierowie stale monitorują wydajność wszystkich systemów. W naszej aplikacji Next.js 16:

// app/layout.tsx
import { SpeedInsights } from '@vercel/speed-insights/next';
import { Analytics } from '@vercel/analytics/react';

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="pl">
      <body>
        {children}
        <SpeedInsights />
        <Analytics />
      </body>
    </html>
  );
}

2. Progresywne ulepszenia i dostępność - Uniwersalne dostosowanie kwantowe

W Metropolii Quantum każdy obywatel musi mieć dostęp do systemów miasta, niezależnie od swoich ograniczeń. Podobnie, nasza aplikacja powinna być dostępna dla wszystkich:

// components/ui/QuantumButton.tsx z ulepszoną dostępnością
"use client";

import { ButtonHTMLAttributes, forwardRef } from 'react';

interface QuantumButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
  variant?: 'primary' | 'secondary' | 'danger';
  size?: 'sm' | 'md' | 'lg';
  isLoading?: boolean;
}

export const QuantumButton = forwardRef<HTMLButtonElement, QuantumButtonProps>(
  ({
    variant = 'primary',
    size = 'md',
    className = '',
    isLoading = false,
    disabled,
    children,
    ...props
  }, ref) => {
    // Mapowanie wariantów na klasy
    const variantClasses = {
      primary: 'bg-blue-600 hover:bg-blue-700 text-white',
      secondary: 'bg-gray-200 hover:bg-gray-300 text-gray-800',
      danger: 'bg-red-600 hover:bg-red-700 text-white',
    };

    // Mapowanie rozmiarów na klasy
    const sizeClasses = {
      sm: 'text-sm px-2 py-1',
      md: 'text-base px-4 py-2',
      lg: 'text-lg px-6 py-3',
    };

    return (
      <button
        ref={ref}
        className={`rounded font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 ${variantClasses[variant]} ${sizeClasses[size]} ${isLoading || disabled ? 'opacity-70 cursor-not-allowed' : ''} ${className}`}
        disabled={isLoading || disabled}
        {...props}
      >
        {isLoading ? (
          <span className="flex items-center justify-center">
            <svg className="animate-spin -ml-1 mr-2 h-4 w-4 text-current" fill="none" viewBox="0 0 24 24">
              <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
              <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
            </svg>
            Ładowanie...
          </span>
        ) : children}
      </button>
    );
  }
);
QuantumButton.displayName = 'QuantumButton';

3. Dokumentowanie kodu - Kwantowy Archiwista

W Metropolii Quantum każdy system jest dokładnie udokumentowany, aby przyszli inżynierowie mogli z łatwością go zrozumieć. W naszym projekcie:

/**
 * Komponent nawigacyjny dla podróży kosmicznych.
 *
 * @component
 * @example
 * ~~~tsx
 * <QuantumNavigation
 *   destinations={['Mars', 'Europa', 'Titan']}
 *   onSelectDestination={(dest) => console.log(`Wybrano ${dest}`)}
 * />
 * ~~~
 */
export interface QuantumNavigationProps {
  /** Lista dostępnych destynacji */
  destinations: string[];
  /** Callback wywoływany po wybraniu destynacji */
  onSelectDestination: (destination: string) => void;
  /** Aktualnie wybrana destynacja (opcjonalna) */
  selectedDestination?: string;
}

export function QuantumNavigation({
  destinations,
  onSelectDestination,
  selectedDestination
}: QuantumNavigationProps) {
  return (
    <nav className="p-4 bg-gradient-to-r from-indigo-500 to-purple-600 rounded-lg text-white">
      <h2 className="text-xl font-semibold mb-2">Nawigacja Quantum</h2>
      <ul className="space-y-1">
        {destinations.map((dest) => (
          <li key={dest}>
            <button
              className={`w-full text-left px-3 py-2 rounded hover:bg-white/20 ${
                selectedDestination === dest ? 'bg-white/30 font-medium' : ''
              }`}
              onClick={() => onSelectDestination(dest)}
            >
              {dest}
            </button>
          </li>
        ))}
      </ul>
    </nav>
  );
}

4. Współpraca w zespole - Kwantowy Kolektyw

W Metropolii Quantum inżynierowie pracują w zsynchronizowanych zespołach, aby osiągnąć maksymalną efektywność. Podobnie, zespół deweloperów Next.js 16 powinien mieć jasne procesy współpracy:

  1. Code Reviews - każdy pull request powinien być przeglądany przez co najmniej jednego innego dewelopera
  2. Pair Programming - trudniejsze problemy rozwiązuj w parach
  3. Standupy - krótkie codzienne spotkania dla synchronizacji pracy
  4. Sprint Planning - planowanie zadań na najbliższy sprint
  5. Retrospektywy - regularne spotkania w celu omówienia, co działa, a co można poprawić

Podsumowanie

Podobnie jak inżynierowie Metropolii Quantum potrzebują zaawansowanych narzędzi i optymalnych procesów, deweloperzy Next.js 16 potrzebują dobrze skonfigurowanego środowiska deweloperskiego. Dzięki przedstawionym narzędziom i praktykom możesz:

  1. Zwiększyć produktywność - automatyzacja powtarzalnych zadań
  2. Poprawić jakość kodu - linting, testowanie, typowanie
  3. Ułatwić współpracę - spójne konwencje, CI/CD, przejrzysta struktura
  4. Przyspieszyć rozwój - szybki feedback, efektywne debugowanie
  5. Zapewnić wysoką jakość - automatyczne testy, przeglądy kodu

Pamiętaj, że podobnie jak Metropolia Quantum nieustannie się rozwija, tak i twoje środowisko deweloperskie powinno ewoluować wraz z projektem i zespołem. Regularnie przeglądaj i aktualizuj swoje narzędzia i procesy, aby utrzymać maksymalną wydajność i jakość kodu.

Cała wiedza i narzędzia przedstawione w tym module umożliwią ci efektywne tworzenie zaawansowanych aplikacji przy użyciu Next.js 16 - podobnie jak inżynierowie kwantowi w Metropolii wykorzystują swoje narzędzia do projektowania technologii jutra.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Które narzędzie odpowiada za automatyczne formatowanie kodu przy zapisie pliku?

  2. 2. Do czego służą Husky i lint-staged w projekcie?

  3. 3. Który menedżer pakietów oszczędza miejsce na dysku dzięki współdzielonemu magazynowi pakietów?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kolejność kroków pracy z funkcją w przepływie Gitflow

  1. PytanieNarzędzie do formatowania kodu
  2. PytanieHusky i lint-staged
  3. PytanieMenedżer pakietów oszczędzający dysk
  4. Ułóż w kolejnościPrzepływ Git dla nowej funkcji

Przydatne artykuły