Query event types: implement repo

server/internal/adapters/psql/application_test.go

@@ -34,7 +34,7 @@ func TestApplicationRepository_FindAll(t *testing.T) {
 		result, err := applicationRepo.FindAll(
 			ctx,
 			domain.EnvironmentID(env.ID),
-			iam.OrgID(env.ID),
+			"", //TODO: add me
 			query.NewPaginationParams(tests.ToPtr(30), tests.ToPtr(5)),
 		)
 		require.NoError(t, err)
@@ -49,7 +49,12 @@ func TestApplicationRepository_FindAll(t *testing.T) {
 
 		for i := 0; i < totalPages; i++ {
 			currentPage := i + 1
-			result, err := applicationRepo.FindAll(ctx, domain.EnvironmentID(env.ID), iam.OrgID(env.ID), query.NewPaginationParams(&currentPage, &perPage))
+			result, err := applicationRepo.FindAll(
+				ctx,
+				domain.EnvironmentID(env.ID),
+				"", //TODO: add me
+				query.NewPaginationParams(&currentPage, &perPage),
+			)
 			require.NoError(t, err)
 			require.NotEmpty(t, result.Data)
 			require.Equal(t, perPage, result.PerPage)

server/internal/adapters/psql/event_type.go

@@ -10,6 +10,7 @@ import (
 	"github.com/subscribeddotdev/subscribed/server/internal/domain/iam"
 	"github.com/volatiletech/null/v8"
 	"github.com/volatiletech/sqlboiler/v4/boil"
+	"github.com/volatiletech/sqlboiler/v4/queries/qm"
 )
 
 type EventTypeRepository struct {
@@ -47,5 +48,46 @@ func (e EventTypeRepository) FindAll(
 	orgID iam.OrgID,
 	pagination query.PaginationParams,
 ) (query.Paginated[[]domain.EventType], error) {
-	return query.Paginated[[]domain.EventType]{}, nil
+	total, err := models.EventTypes(models.EventTypeWhere.OrgID.EQ(orgID.String())).Count(ctx, e.db)
+	if err != nil {
+		return query.Paginated[[]domain.EventType]{}, fmt.Errorf("error counting event types: %v", err)
+	}
+
+	rows, err := models.EventTypes(
+		models.EventTypeWhere.OrgID.EQ(orgID.String()),
+		qm.Offset(mapPaginationParamsToSqlOffset(pagination)),
+		qm.Limit(pagination.Limit()),
+		qm.OrderBy("created_at DESC"),
+	).All(ctx, e.db)
+	if err != nil {
+		return query.Paginated[[]domain.EventType]{}, fmt.Errorf("error querying event types: %v", err)
+	}
+
+	return query.Paginated[[]domain.EventType]{
+		Total:       int(total),
+		PerPage:     len(rows),
+		CurrentPage: pagination.Page(),
+		TotalPages:  getPaginationTotalPages(total, pagination.Limit()),
+		Data:        mapRowsToEventTypes(rows),
+	}, nil
+}
+
+func mapRowsToEventTypes(rows []*models.EventType) []domain.EventType {
+	eventTypes := make([]domain.EventType, len(rows))
+	for i, row := range rows {
+		eventType := domain.UnMarshallEventType(
+			domain.EventTypeID(row.ID),
+			row.OrgID,
+			row.Name,
+			row.Description.String,
+			row.Schema.String,
+			row.SchemaExample.String,
+			row.CreatedAt,
+			row.ArchivedAt.Ptr(),
+		)
+
+		eventTypes[i] = *eventType
+	}
+
+	return eventTypes
 }

server/internal/adapters/psql/event_type_test.go

@@ -0,0 +1,56 @@
+package psql_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/subscribeddotdev/subscribed/server/internal/app/query"
+	"github.com/subscribeddotdev/subscribed/server/internal/domain"
+	"github.com/subscribeddotdev/subscribed/server/internal/domain/iam"
+	"github.com/subscribeddotdev/subscribed/server/tests"
+	"github.com/subscribeddotdev/subscribed/server/tests/fixture"
+)
+
+func TestEventTypesRepository_FindAll(t *testing.T) {
+	ff := fixture.NewFactory(t, ctx, db)
+	org := ff.NewOrganization().Save()
+
+	eventTypesFixtureCount := 20
+	for i := 0; i < eventTypesFixtureCount; i++ {
+		ff.NewEventType().WithOrgID(org.ID).Save()
+	}
+
+	t.Run("return_an_empty_slice_when_page_is_out_of_bounds", func(t *testing.T) {
+		result, err := eventTypeRepo.FindAll(
+			ctx,
+			iam.OrgID(org.ID),
+			query.NewPaginationParams(tests.ToPtr(30), tests.ToPtr(5)),
+		)
+		require.NoError(t, err)
+		require.Empty(t, result.Data)
+		require.Equal(t, 0, result.PerPage)
+	})
+
+	t.Run("iteratively_query_event_types_from_different_pages", func(t *testing.T) {
+		perPage := 5
+		totalPages := eventTypesFixtureCount / 5
+		queriedAppIDs := make(map[string]domain.EventType)
+
+		for i := 0; i < totalPages; i++ {
+			currentPage := i + 1
+			result, err := eventTypeRepo.FindAll(ctx, iam.OrgID(org.ID), query.NewPaginationParams(&currentPage, &perPage))
+			require.NoError(t, err)
+			require.NotEmpty(t, result.Data)
+			require.Equal(t, perPage, result.PerPage)
+			require.Equal(t, currentPage, result.CurrentPage)
+			require.Equal(t, eventTypesFixtureCount, result.Total)
+			require.Equal(t, totalPages, result.TotalPages)
+
+			for _, app := range result.Data {
+				_, exists := queriedAppIDs[app.ID().String()]
+				require.Falsef(t, exists, "event type must not have already been returned: app id '%s'", app.ID())
+				queriedAppIDs[app.ID().String()] = app
+			}
+		}
+	})
+}

server/internal/adapters/psql/main_test.go

@@ -18,6 +18,7 @@ var (
 	ctx              context.Context
 	environmentRepo  *psql.EnvironmentRepository
 	applicationRepo  *psql.ApplicationRepository
+	eventTypeRepo    *psql.EventTypeRepository
 	endpointRepo     *psql.EndpointRepository
 	organizationRepo *psql.OrganizationRepository
 	apiKeyRepo       *psql.ApiKeyRepository
@@ -51,6 +52,7 @@ func TestMain(m *testing.M) {
 	organizationRepo = psql.NewOrganizationRepository(db)
 	apiKeyRepo = psql.NewApiKeyRepository(db)
 	msgRepo = psql.NewMessageRepository(db)
+	eventTypeRepo = psql.NewEventTypeRepository(db)
 
 	os.Exit(m.Run())
 }

server/tests/components/event_types_test.go

@@ -1,12 +1,14 @@
 package components_test
 
 import (
+	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/brianvoe/gofakeit/v6"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/subscribeddotdev/subscribed/server/internal/adapters/models"
 	"github.com/subscribeddotdev/subscribed/server/tests/client"
 	"github.com/subscribeddotdev/subscribed/server/tests/fixture"
 )
@@ -18,10 +20,40 @@ func TestEventTypes(t *testing.T) {
 	token := signIn(t, member.Email, password)
 	apiClient := getClientWithToken(t, token)
 
-	resp, err := apiClient.CreateEventType(ctx, client.CreateEventTypeRequest{
-		Name:        gofakeit.AppName(),
-		Description: toPtr(gofakeit.Sentence(20)),
+	t.Run("create_event_type", func(t *testing.T) {
+		resp, err := apiClient.CreateEventType(ctx, client.CreateEventTypeRequest{
+			Name:        fmt.Sprintf("%s.%s", gofakeit.Noun(), gofakeit.Verb()),
+			Description: toPtr(gofakeit.Sentence(20)),
+		})
+		require.NoError(t, err)
+		assert.Equal(t, http.StatusCreated, resp.StatusCode)
+	})
+
+	t.Run("get_all_event_types_by_org_id", func(t *testing.T) {
+		eventTypesFixtureCount := 20
+		eventTypesFixture := make([]models.EventType, eventTypesFixtureCount)
+
+		for i := 0; i < eventTypesFixtureCount; i++ {
+			eventTypesFixture[i] = ff.NewEventType().WithOrgID(org.ID).Save()
+		}
+
+		perPage := 5
+		totalPages := eventTypesFixtureCount / 5
+
+		for i := 0; i < totalPages; i++ {
+			currentPage := i + 1
+			resp, err := apiClient.GetEventTypesWithResponse(ctx, &client.GetEventTypesParams{
+				Limit: &perPage,
+				Page:  &currentPage,
+			})
+
+			require.NoError(t, err)
+			require.Equal(t, http.StatusOK, resp.StatusCode())
+			require.NotEmpty(t, resp.JSON200.Data)
+			require.Equal(t, currentPage, resp.JSON200.Pagination.CurrentPage)
+			require.GreaterOrEqual(t, resp.JSON200.Pagination.Total, eventTypesFixtureCount)
+			require.Equal(t, perPage, resp.JSON200.Pagination.PerPage)
+			require.Equal(t, totalPages, resp.JSON200.Pagination.TotalPages)
+		}
 	})
-	require.NoError(t, err)
-	assert.Equal(t, http.StatusCreated, resp.StatusCode)
 }

server/tests/fixture/fixture.go

@@ -3,7 +3,9 @@ package fixture
 import (
 	"context"
 	"database/sql"
+	"fmt"
 	"os"
+	"strings"
 	"testing"
 	"time"
 
@@ -92,8 +94,9 @@ func (f *Factory) NewEventType() *EventType {
 	return &EventType{
 		factory: f,
 		model: models.EventType{
-			ID:   domain.NewEventTypeID().String(),
-			Name: gofakeit.Verb(),
+			ID:          domain.NewEventTypeID().String(),
+			Name:        strings.ToLower(fmt.Sprintf("%s.%s.%s", gofakeit.Verb(), gofakeit.Verb(), gofakeit.Verb())),
+			Description: null.StringFrom(gofakeit.SentenceSimple()),
 		},
 	}
 }