Start z Goat

Goat to nowoczesny generator kodu i środowisko automatyzacji, które pomaga szybko rozwijać kompletne aplikacje bez utraty kontroli nad kodem.

Zamiast traktować generowanie jako jednorazowe tworzenie szablonu projektu, Goat pozwala bezpiecznie i selektywnie wprowadzać kolejne zmiany do istniejącej aplikacji. Wygenerowany kod pozostaje zwykłym kodem źródłowym — możesz go ręcznie modyfikować, rozwijać i commitować dokładnie tak, jak pozostałą część projektu.

Nowy projekt możesz utworzyć za pomocą:

goat init ./my-project \
  --name my-project \
  --git-repo https://github.com/your-user/my-project.git

Polecenie inicjalizuje aplikację na podstawie przygotowanego repozytorium Git i tworzy gotowy punkt startowy do dalszej pracy.

Domyślny starter Goat dostarcza aplikację opartą na Go oraz Angularze, ale sam mechanizm generatora jest elastyczny i może zostać dostosowany do architektury oraz konwencji konkretnego projektu.

Po co Goat?

Duża część pracy nad aplikacjami biznesowymi jest powtarzalna: modele danych, DTO, DAO, formularze, endpointy, walidacja, migracje czy podstawowe operacje CRUD.

Goat automatyzuje tę warstwę, dzięki czemu możesz skoncentrować się na tym, co faktycznie odróżnia aplikację:

  • logice biznesowej,
  • bezpieczeństwie,
  • jakości interfejsu,
  • integracjach,
  • wydajności,
  • funkcjonalnościach dostarczających wartość użytkownikom.

Jednocześnie wspólny model aplikacji pomaga zachować spójność pomiędzy frontendem i backendem. Na jego podstawie mogą być generowane między innymi encje, DTO, DAO, endpointy API oraz odpowiadające im elementy interfejsu.

Generator ma przyspieszać pracę, a nie zamykać użytkownika w narzuconym modelu generowania.

Dlatego możesz korzystać z Goat tam, gdzie daje realną oszczędność czasu, a następnie swobodnie rozwijać wygenerowany kod ręcznie.

Bezpieczne wykonywanie skryptów

Jednym z głównych założeń Goat jest izolacja automatyzacji od systemu hosta.

Typowe narzędzia developerskie często wykonują skrypty instalacyjne bezpośrednio na komputerze programisty. Przykładowo npm install może uruchamiać kod pochodzący z instalowanych zależności.

Goat ogranicza powierzchnię takiego ryzyka.

Skrypty uruchamiane przez Goat działają w izolowanym środowisku i mogą operować wyłącznie na zasobach, które zostały im jawnie udostępnione. W typowym scenariuszu oznacza to przede wszystkim bieżący katalog projektu.

Dzięki temu automatyzacja:

  • nie otrzymuje swobodnego dostępu do systemu hosta,
  • nie powinna modyfikować plików poza aktualnym projektem,
  • może uruchamiać narzędzia takie jak Node.js, npm czy PostgreSQL bez instalowania ich lokalnie,
  • zachowuje podobne środowisko działania na różnych systemach operacyjnych.

Docker stanowi tutaj warstwę izolacji i przenośności, natomiast Goat dostarcza wygodny sposób definiowania oraz uruchamiania całych procesów developerskich.

Generator, który dopasowuje się do projektu

Goat nie zakłada, że wygenerowany kod ma pozostać nietykalny.

Kod możesz swobodnie edytować ręcznie. Generator powinien natomiast wprowadzać zmiany możliwie lokalnie i świadomie, zamiast za każdym razem nadpisywać całe moduły aplikacji.

Dzięki temu możliwe jest połączenie dwóch sposobów pracy:

generowania tego, co powtarzalne oraz ręcznego rozwijania tego, co specyficzne dla projektu.

Takie podejście jest szczególnie ważne w większych projektach, w których generator musi współistnieć z kodem rozwijanym przez programistów przez wiele miesięcy lub lat.

Goat i AI

Ograniczony, deklaratywny model projektu dobrze współpracuje również z narzędziami AI.

Zamiast analizować dużą część repozytorium, model może często pracować na znacznie mniejszym opisie domeny oraz konfiguracji generatora.

Pozwala to:

  • ograniczyć ilość kodu przekazywanego do modelu,
  • zmniejszyć koszt wykorzystania AI,
  • skrócić czas analizy projektu,
  • ograniczyć liczbę miejsc, które AI musi modyfikować,
  • zwiększyć przewidywalność generowanych zmian.

AI może więc pomagać przede wszystkim w modyfikowaniu modelu i intencji aplikacji, podczas gdy Goat zajmuje się konsekwentnym przełożeniem tych zmian na kod.

Nie oznacza to jednak konieczności pracy wyłącznie na poziomie modelu. Jeżeli konkretna zmiana jest prostsza do wykonania bezpośrednio w kodzie, wygenerowane pliki mogą być normalnie edytowane.

Dla kogo jest ten projekt

Wybierz Goat, gdy tworzysz aplikację opartą na danych strukturalnych, formularzach, API i panelu zarządzania oraz chcesz szybko przejść od modelu domeny do działającego systemu.

Podstawowy workflow jest prosty:

  1. tworzysz projekt za pomocą goat init,
  2. opisujesz encje i relacje w herd/_model.goat,
  3. uruchamiasz generator,
  4. Goat tworzy lub aktualizuje powiązane elementy aplikacji,
  5. rozwijasz wygenerowany kod tam, gdzie potrzebna jest własna logika.

Goat szczególnie dobrze sprawdza się tam, gdzie aplikacja zawiera dużo powtarzalnej infrastruktury, ale jednocześnie wymaga własnej logiki biznesowej i dalszego ręcznego rozwoju.

Wymagania

  • Docker,
  • Go — jeśli uruchamiasz polecenia go run ./scripts ... bezpośrednio na hoście,
  • Git oraz standardowe narzędzia powłoki.

Nie musisz instalować PostgreSQL ani Node.js bezpośrednio na komputerze. Skrypty herd/*.goat mogą uruchamiać wymagane narzędzia i usługi wewnątrz kontenerów.

Szybki start

1. Utwórz projekt

W nowym katalogu uruchom:

goat init ./my-project \
  --name my-project \
  --git-repo https://github.com/your-user/my-project.git

Polecenie tworzy nowy projekt na podstawie przygotowanego repozytorium Git.

Dzięki temu od razu otrzymujesz kompletną strukturę projektu, w tym:

  • przykładowy model aplikacji,
  • konfigurację generatora,
  • skrypty .goat,
  • przykładowe dane fixture,
  • dokumentację dopasowaną do aktualnej wersji projektu,
  • backend i frontend gotowe do dalszego rozwoju.

goat init służy więc nie tylko do utworzenia pustego projektu, ale do przygotowania kompletnego środowiska startowego, które można od razu uruchomić, analizować i modyfikować.

2. Skonfiguruj środowisko

Uzupełnij lokalny plik:

.env

Nie umieszczaj prawdziwych sekretów w repozytorium.

Wartości takie jak hasła do bazy czy GOAT_JWT_SECRET powinny pozostać lokalne lub być dostarczane przez system zarządzania sekretami danego środowiska.

3. Uruchom środowisko developerskie

Uruchom:

goat run:script --path=herd/dev.goat

Jeżeli korzystasz bezpośrednio z narzędzi źródłowych projektu, możesz również użyć:

go run ./scripts run:script --path=herd/dev.goat

Skrypt przygotowuje kompletne lokalne środowisko developerskie.

Podczas pierwszego uruchomienia Goat między innymi:

  • uruchamia wymagane usługi,
  • generuje aplikację,
  • przygotowuje bazę danych,
  • wykonuje migracje,
  • buduje wymagane elementy projektu,
  • ładuje dane z herd/fixture.goat,
  • uruchamia backend i frontend.

4. Otwórz aplikację

Po zakończeniu inicjalizacji aplikacja jest dostępna pod:

http://localhost:8080

Dodatkowe usługi:

  • pgAdmin: http://localhost:5050,
  • PostgreSQL: localhost:5433.

Dzięki fixture'om dostarczanym przez projekt od pierwszego uruchomienia możesz zobaczyć nie tylko działającą aplikację, ale również przykładowe dane i dokumentację odpowiadającą aktualnie używanej wersji Goat.

Co dalej?

Po uruchomieniu projektu najczęściej będziesz pracować w następującym cyklu:

zmiana modelu lub kodu
        ↓
goat re
        ↓
sprawdzenie zmian
        ↓
ręczne dopracowanie
        ↓
testy

Model aplikacji znajduje się w:

herd/_model.goat

Po jego zmianie możesz ponownie wygenerować kod:

goat re

Następnie sprawdź rezultat:

git diff

i uruchom testy:

goat run:script --path=herd/test.goat

Następne kroki

  • Poznaj [architekturę projektu](/doc/pl/architektura).
  • Skonfiguruj [lokalne środowisko](/doc/pl/konfiguracja).
  • Zobacz, jak zmieniać [model danych i generować kod](/doc/pl/model-i-generowanie).
  • Poznaj [lokalny workflow developerski](/doc/pl/rozwoj-lokalny).
  • Sprawdź [testowanie i dostępne komendy](/doc/pl/testowanie).