Initial commit: Open sourcing all of the Maple Open Technologies code.

2025-12-02 14:33:08 -05:00 · 2025-12-02 14:33:08 -05:00 · 755d54a99d
commit 755d54a99d
2010 changed files with 448675 additions and 0 deletions
--- a/cloud/maplepress-backend/internal/service/site/authenticate.go
+++ b/cloud/maplepress-backend/internal/service/site/authenticate.go
@ -0,0 +1,35 @@
+package site
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// AuthenticateAPIKeyService handles API key authentication operations
+type AuthenticateAPIKeyService interface {
+	AuthenticateByAPIKey(ctx context.Context, input *siteusecase.AuthenticateAPIKeyInput) (*siteusecase.AuthenticateAPIKeyOutput, error)
+}
+
+type authenticateAPIKeyService struct {
+	authenticateUC *siteusecase.AuthenticateAPIKeyUseCase
+	logger         *zap.Logger
+}
+
+// NewAuthenticateAPIKeyService creates a new AuthenticateAPIKeyService
+func NewAuthenticateAPIKeyService(
+	authenticateUC *siteusecase.AuthenticateAPIKeyUseCase,
+	logger *zap.Logger,
+) AuthenticateAPIKeyService {
+	return &authenticateAPIKeyService{
+		authenticateUC: authenticateUC,
+		logger:         logger.Named("authenticate-apikey-service"),
+	}
+}
+
+// AuthenticateByAPIKey authenticates an API key
+func (s *authenticateAPIKeyService) AuthenticateByAPIKey(ctx context.Context, input *siteusecase.AuthenticateAPIKeyInput) (*siteusecase.AuthenticateAPIKeyOutput, error) {
+	return s.authenticateUC.Execute(ctx, input)
+}
--- a/cloud/maplepress-backend/internal/service/site/create.go
+++ b/cloud/maplepress-backend/internal/service/site/create.go
@ -0,0 +1,112 @@
+package site
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gocql/gocql"
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// CreateSiteService handles site creation operations
+type CreateSiteService interface {
+	CreateSite(ctx context.Context, tenantID gocql.UUID, input *siteusecase.CreateSiteInput) (*siteusecase.CreateSiteOutput, error)
+}
+
+type createSiteService struct {
+	// Focused usecases
+	validateDomainUC      *siteusecase.ValidateDomainUseCase
+	generateAPIKeyUC      *siteusecase.GenerateAPIKeyUseCase
+	generateVerifyTokenUC *siteusecase.GenerateVerificationTokenUseCase
+	createSiteEntityUC    *siteusecase.CreateSiteEntityUseCase
+	saveSiteToRepoUC      *siteusecase.SaveSiteToRepoUseCase
+
+	logger *zap.Logger
+}
+
+// NewCreateSiteService creates a new CreateSiteService
+func NewCreateSiteService(
+	validateDomainUC *siteusecase.ValidateDomainUseCase,
+	generateAPIKeyUC *siteusecase.GenerateAPIKeyUseCase,
+	generateVerifyTokenUC *siteusecase.GenerateVerificationTokenUseCase,
+	createSiteEntityUC *siteusecase.CreateSiteEntityUseCase,
+	saveSiteToRepoUC *siteusecase.SaveSiteToRepoUseCase,
+	logger *zap.Logger,
+) CreateSiteService {
+	return &createSiteService{
+		validateDomainUC:      validateDomainUC,
+		generateAPIKeyUC:      generateAPIKeyUC,
+		generateVerifyTokenUC: generateVerifyTokenUC,
+		createSiteEntityUC:    createSiteEntityUC,
+		saveSiteToRepoUC:      saveSiteToRepoUC,
+		logger:                logger.Named("create-site-service"),
+	}
+}
+
+// CreateSite orchestrates the site creation workflow
+func (s *createSiteService) CreateSite(ctx context.Context, tenantID gocql.UUID, input *siteusecase.CreateSiteInput) (*siteusecase.CreateSiteOutput, error) {
+	s.logger.Info("creating site",
+		zap.String("tenant_id", tenantID.String()),
+		zap.String("domain", input.Domain))
+
+	// Step 1: Validate domain availability
+	if err := s.validateDomainUC.Execute(ctx, input.Domain); err != nil {
+		s.logger.Error("domain validation failed",
+			zap.String("domain", input.Domain),
+			zap.Error(err))
+		return nil, err
+	}
+
+	// Step 2: Generate API key
+	apiKeyResult, err := s.generateAPIKeyUC.Execute(input.TestMode)
+	if err != nil {
+		s.logger.Error("API key generation failed", zap.Error(err))
+		return nil, fmt.Errorf("failed to generate API key: %w", err)
+	}
+
+	// Step 3: Generate verification token
+	verificationToken, err := s.generateVerifyTokenUC.Execute()
+	if err != nil {
+		s.logger.Error("verification token generation failed", zap.Error(err))
+		return nil, fmt.Errorf("failed to generate verification token: %w", err)
+	}
+
+	// Step 4: Create site entity (no plan tier - usage-based billing)
+	site, err := s.createSiteEntityUC.Execute(&siteusecase.CreateSiteEntityInput{
+		TenantID:          tenantID,
+		Domain:            input.Domain,
+		SiteURL:           input.SiteURL,
+		APIKeyHash:        apiKeyResult.HashedKey,
+		APIKeyPrefix:      apiKeyResult.Prefix,
+		APIKeyLastFour:    apiKeyResult.LastFour,
+		VerificationToken: verificationToken,
+		IPAddress:         input.IPAddress,
+	})
+	if err != nil {
+		s.logger.Error("failed to create site entity", zap.Error(err))
+		return nil, err
+	}
+
+	// Step 5: Save site to repository
+	if err := s.saveSiteToRepoUC.Execute(ctx, site); err != nil {
+		s.logger.Error("failed to save site", zap.Error(err))
+		return nil, err
+	}
+
+	s.logger.Info("site created successfully",
+		zap.String("site_id", site.ID.String()),
+		zap.String("domain", site.Domain))
+
+	// Step 6: Build output
+	return &siteusecase.CreateSiteOutput{
+		ID:                site.ID.String(),
+		Domain:            site.Domain,
+		SiteURL:           site.SiteURL,
+		APIKey:            apiKeyResult.PlaintextKey, // PLAINTEXT - only shown once!
+		VerificationToken: verificationToken,
+		Status:            site.Status,
+		SearchIndexName:   site.SearchIndexName,
+	}, nil
+}
--- a/cloud/maplepress-backend/internal/service/site/delete.go
+++ b/cloud/maplepress-backend/internal/service/site/delete.go
@ -0,0 +1,77 @@
+package site
+
+import (
+	"context"
+
+	"github.com/gocql/gocql"
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// DeleteSiteService handles site deletion operations
+type DeleteSiteService interface {
+	DeleteSite(ctx context.Context, tenantID gocql.UUID, input *siteusecase.DeleteSiteInput) (*siteusecase.DeleteSiteOutput, error)
+}
+
+type deleteSiteService struct {
+	// Focused usecases
+	validateSiteForDeletionUC *siteusecase.ValidateSiteForDeletionUseCase
+	deleteSiteFromRepoUC      *siteusecase.DeleteSiteFromRepoUseCase
+
+	logger *zap.Logger
+}
+
+// NewDeleteSiteService creates a new DeleteSiteService
+func NewDeleteSiteService(
+	validateSiteForDeletionUC *siteusecase.ValidateSiteForDeletionUseCase,
+	deleteSiteFromRepoUC *siteusecase.DeleteSiteFromRepoUseCase,
+	logger *zap.Logger,
+) DeleteSiteService {
+	return &deleteSiteService{
+		validateSiteForDeletionUC: validateSiteForDeletionUC,
+		deleteSiteFromRepoUC:      deleteSiteFromRepoUC,
+		logger:                    logger.Named("delete-site-service"),
+	}
+}
+
+// DeleteSite orchestrates the site deletion workflow
+func (s *deleteSiteService) DeleteSite(ctx context.Context, tenantID gocql.UUID, input *siteusecase.DeleteSiteInput) (*siteusecase.DeleteSiteOutput, error) {
+	s.logger.Info("deleting site",
+		zap.String("tenant_id", tenantID.String()),
+		zap.String("site_id", input.SiteID))
+
+	// Step 1: Parse site ID
+	siteID, err := gocql.ParseUUID(input.SiteID)
+	if err != nil {
+		s.logger.Error("invalid site ID", zap.Error(err))
+		return nil, err
+	}
+
+	// Step 2: Validate site exists before deletion
+	site, err := s.validateSiteForDeletionUC.Execute(ctx, tenantID, siteID)
+	if err != nil {
+		s.logger.Error("site validation failed",
+			zap.String("site_id", input.SiteID),
+			zap.Error(err))
+		return nil, err
+	}
+
+	// Step 3: Delete site from repository (all tables)
+	if err := s.deleteSiteFromRepoUC.Execute(ctx, tenantID, siteID); err != nil {
+		s.logger.Error("failed to delete site from repository",
+			zap.String("site_id", input.SiteID),
+			zap.Error(err))
+		return nil, err
+	}
+
+	s.logger.Info("site deleted successfully",
+		zap.String("site_id", input.SiteID),
+		zap.String("domain", site.Domain))
+
+	// Step 4: Build output
+	return &siteusecase.DeleteSiteOutput{
+		Success: true,
+		Message: "Site deleted successfully",
+	}, nil
+}
--- a/cloud/maplepress-backend/internal/service/site/get.go
+++ b/cloud/maplepress-backend/internal/service/site/get.go
@ -0,0 +1,36 @@
+package site
+
+import (
+	"context"
+
+	"github.com/gocql/gocql"
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// GetSiteService handles getting a single site
+type GetSiteService interface {
+	GetSite(ctx context.Context, tenantID gocql.UUID, input *siteusecase.GetSiteInput) (*siteusecase.GetSiteOutput, error)
+}
+
+type getSiteService struct {
+	getUC  *siteusecase.GetSiteUseCase
+	logger *zap.Logger
+}
+
+// NewGetSiteService creates a new GetSiteService
+func NewGetSiteService(
+	getUC *siteusecase.GetSiteUseCase,
+	logger *zap.Logger,
+) GetSiteService {
+	return &getSiteService{
+		getUC:  getUC,
+		logger: logger.Named("get-site-service"),
+	}
+}
+
+// GetSite retrieves a site by ID
+func (s *getSiteService) GetSite(ctx context.Context, tenantID gocql.UUID, input *siteusecase.GetSiteInput) (*siteusecase.GetSiteOutput, error) {
+	return s.getUC.Execute(ctx, tenantID, input)
+}
--- a/cloud/maplepress-backend/internal/service/site/list.go
+++ b/cloud/maplepress-backend/internal/service/site/list.go
@ -0,0 +1,36 @@
+package site
+
+import (
+	"context"
+
+	"github.com/gocql/gocql"
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// ListSitesService handles listing sites
+type ListSitesService interface {
+	ListSites(ctx context.Context, tenantID gocql.UUID, input *siteusecase.ListSitesInput) (*siteusecase.ListSitesOutput, error)
+}
+
+type listSitesService struct {
+	listUC *siteusecase.ListSitesUseCase
+	logger *zap.Logger
+}
+
+// NewListSitesService creates a new ListSitesService
+func NewListSitesService(
+	listUC *siteusecase.ListSitesUseCase,
+	logger *zap.Logger,
+) ListSitesService {
+	return &listSitesService{
+		listUC: listUC,
+		logger: logger.Named("list-sites-service"),
+	}
+}
+
+// ListSites retrieves all sites for a tenant
+func (s *listSitesService) ListSites(ctx context.Context, tenantID gocql.UUID, input *siteusecase.ListSitesInput) (*siteusecase.ListSitesOutput, error) {
+	return s.listUC.Execute(ctx, tenantID, input)
+}
--- a/cloud/maplepress-backend/internal/service/site/provider.go
+++ b/cloud/maplepress-backend/internal/service/site/provider.go
@ -0,0 +1,80 @@
+package site
+
+import (
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// ProvideCreateSiteService creates a new CreateSiteService for dependency injection
+func ProvideCreateSiteService(
+	validateDomainUC *siteusecase.ValidateDomainUseCase,
+	generateAPIKeyUC *siteusecase.GenerateAPIKeyUseCase,
+	generateVerifyTokenUC *siteusecase.GenerateVerificationTokenUseCase,
+	createSiteEntityUC *siteusecase.CreateSiteEntityUseCase,
+	saveSiteToRepoUC *siteusecase.SaveSiteToRepoUseCase,
+	logger *zap.Logger,
+) CreateSiteService {
+	return NewCreateSiteService(
+		validateDomainUC,
+		generateAPIKeyUC,
+		generateVerifyTokenUC,
+		createSiteEntityUC,
+		saveSiteToRepoUC,
+		logger,
+	)
+}
+
+// ProvideGetSiteService creates a new GetSiteService for dependency injection
+func ProvideGetSiteService(
+	getUC *siteusecase.GetSiteUseCase,
+	logger *zap.Logger,
+) GetSiteService {
+	return NewGetSiteService(getUC, logger)
+}
+
+// ProvideListSitesService creates a new ListSitesService for dependency injection
+func ProvideListSitesService(
+	listUC *siteusecase.ListSitesUseCase,
+	logger *zap.Logger,
+) ListSitesService {
+	return NewListSitesService(listUC, logger)
+}
+
+// ProvideDeleteSiteService creates a new DeleteSiteService for dependency injection
+func ProvideDeleteSiteService(
+	validateSiteForDeletionUC *siteusecase.ValidateSiteForDeletionUseCase,
+	deleteSiteFromRepoUC *siteusecase.DeleteSiteFromRepoUseCase,
+	logger *zap.Logger,
+) DeleteSiteService {
+	return NewDeleteSiteService(
+		validateSiteForDeletionUC,
+		deleteSiteFromRepoUC,
+		logger,
+	)
+}
+
+// ProvideRotateAPIKeyService creates a new RotateAPIKeyService for dependency injection
+func ProvideRotateAPIKeyService(
+	getSiteUC *siteusecase.GetSiteUseCase,
+	generateAPIKeyUC *siteusecase.GenerateAPIKeyUseCase,
+	updateSiteAPIKeyUC *siteusecase.UpdateSiteAPIKeyUseCase,
+	updateSiteAPIKeyToRepoUC *siteusecase.UpdateSiteAPIKeyToRepoUseCase,
+	logger *zap.Logger,
+) RotateAPIKeyService {
+	return NewRotateAPIKeyService(
+		getSiteUC,
+		generateAPIKeyUC,
+		updateSiteAPIKeyUC,
+		updateSiteAPIKeyToRepoUC,
+		logger,
+	)
+}
+
+// ProvideAuthenticateAPIKeyService creates a new AuthenticateAPIKeyService for dependency injection
+func ProvideAuthenticateAPIKeyService(
+	authenticateUC *siteusecase.AuthenticateAPIKeyUseCase,
+	logger *zap.Logger,
+) AuthenticateAPIKeyService {
+	return NewAuthenticateAPIKeyService(authenticateUC, logger)
+}
--- a/cloud/maplepress-backend/internal/service/site/rotate_apikey.go
+++ b/cloud/maplepress-backend/internal/service/site/rotate_apikey.go
@ -0,0 +1,114 @@
+package site
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/gocql/gocql"
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// RotateAPIKeyService handles API key rotation operations
+type RotateAPIKeyService interface {
+	RotateAPIKey(ctx context.Context, tenantID gocql.UUID, input *siteusecase.RotateAPIKeyInput) (*siteusecase.RotateAPIKeyOutput, error)
+}
+
+type rotateAPIKeyService struct {
+	// Focused usecases
+	getSiteUC                 *siteusecase.GetSiteUseCase
+	generateAPIKeyUC          *siteusecase.GenerateAPIKeyUseCase
+	updateSiteAPIKeyUC        *siteusecase.UpdateSiteAPIKeyUseCase
+	updateSiteAPIKeyToRepoUC  *siteusecase.UpdateSiteAPIKeyToRepoUseCase
+
+	logger *zap.Logger
+}
+
+// NewRotateAPIKeyService creates a new RotateAPIKeyService
+func NewRotateAPIKeyService(
+	getSiteUC *siteusecase.GetSiteUseCase,
+	generateAPIKeyUC *siteusecase.GenerateAPIKeyUseCase,
+	updateSiteAPIKeyUC *siteusecase.UpdateSiteAPIKeyUseCase,
+	updateSiteAPIKeyToRepoUC *siteusecase.UpdateSiteAPIKeyToRepoUseCase,
+	logger *zap.Logger,
+) RotateAPIKeyService {
+	return &rotateAPIKeyService{
+		getSiteUC:                getSiteUC,
+		generateAPIKeyUC:         generateAPIKeyUC,
+		updateSiteAPIKeyUC:       updateSiteAPIKeyUC,
+		updateSiteAPIKeyToRepoUC: updateSiteAPIKeyToRepoUC,
+		logger:                   logger.Named("rotate-apikey-service"),
+	}
+}
+
+// RotateAPIKey orchestrates the API key rotation workflow
+func (s *rotateAPIKeyService) RotateAPIKey(ctx context.Context, tenantID gocql.UUID, input *siteusecase.RotateAPIKeyInput) (*siteusecase.RotateAPIKeyOutput, error) {
+	s.logger.Info("rotating API key",
+		zap.String("tenant_id", tenantID.String()),
+		zap.String("site_id", input.SiteID))
+
+	// Step 1: Get current site
+	siteOutput, err := s.getSiteUC.Execute(ctx, tenantID, &siteusecase.GetSiteInput{
+		ID: input.SiteID,
+	})
+	if err != nil {
+		s.logger.Error("failed to get site",
+			zap.String("site_id", input.SiteID),
+			zap.Error(err))
+		return nil, err
+	}
+	site := siteOutput.Site
+
+	// Step 2: Store old key info for response and rotation
+	oldKeyLastFour := site.APIKeyLastFour
+	oldAPIKeyHash := site.APIKeyHash
+
+	// Step 3: Determine test mode from existing API key prefix
+	// If current key starts with "test_", generate a test key; otherwise generate live key
+	testMode := len(site.APIKeyPrefix) >= 5 && site.APIKeyPrefix[:5] == "test_"
+
+	s.logger.Info("generating new API key",
+		zap.Bool("test_mode", testMode),
+		zap.String("current_key_prefix", site.APIKeyPrefix),
+		zap.String("site_id", input.SiteID))
+	apiKeyResult, err := s.generateAPIKeyUC.Execute(testMode)
+	if err != nil {
+		s.logger.Error("failed to generate new API key", zap.Error(err))
+		return nil, fmt.Errorf("failed to generate API key: %w", err)
+	}
+
+	// Step 4: Update site entity with new key details
+	s.updateSiteAPIKeyUC.Execute(&siteusecase.UpdateSiteAPIKeyInput{
+		Site:           site,
+		NewAPIKeyHash:  apiKeyResult.HashedKey,
+		NewKeyPrefix:   apiKeyResult.Prefix,
+		NewKeyLastFour: apiKeyResult.LastFour,
+	})
+
+	// Step 5: Update site API key in repository (all tables)
+	// Use UpdateSiteAPIKeyToRepoUC to properly handle sites_by_apikey table (delete old + insert new)
+	if err := s.updateSiteAPIKeyToRepoUC.Execute(ctx, &siteusecase.UpdateSiteAPIKeyToRepoInput{
+		Site:          site,
+		OldAPIKeyHash: oldAPIKeyHash,
+	}); err != nil {
+		s.logger.Error("failed to update site with new API key", zap.Error(err))
+		return nil, err
+	}
+
+	// Step 6: Build output
+	rotatedAt := time.Now()
+
+	s.logger.Info("API key rotated successfully",
+		zap.String("site_id", input.SiteID),
+		zap.String("old_key_last_four", oldKeyLastFour),
+		zap.String("new_key_prefix", apiKeyResult.Prefix),
+		zap.String("new_key_last_four", apiKeyResult.LastFour))
+
+	return &siteusecase.RotateAPIKeyOutput{
+		NewAPIKey:      apiKeyResult.PlaintextKey, // PLAINTEXT - only shown once!
+		OldKeyLastFour: oldKeyLastFour,
+		RotatedAt:      rotatedAt,
+	}, nil
+}
--- a/cloud/maplepress-backend/internal/service/site/verify.go
+++ b/cloud/maplepress-backend/internal/service/site/verify.go
@ -0,0 +1,53 @@
+package site
+
+import (
+	"context"
+
+	"github.com/gocql/gocql"
+	"go.uber.org/zap"
+
+	siteusecase "codeberg.org/mapleopentech/monorepo/cloud/maplepress-backend/internal/usecase/site"
+)
+
+// VerifySiteService handles site verification operations
+type VerifySiteService interface {
+	VerifySite(ctx context.Context, tenantID gocql.UUID, siteID gocql.UUID, input *siteusecase.VerifySiteInput) (*siteusecase.VerifySiteOutput, error)
+}
+
+type verifySiteService struct {
+	verifySiteUC *siteusecase.VerifySiteUseCase
+	logger       *zap.Logger
+}
+
+// NewVerifySiteService creates a new VerifySiteService
+func NewVerifySiteService(
+	verifySiteUC *siteusecase.VerifySiteUseCase,
+	logger *zap.Logger,
+) VerifySiteService {
+	return &verifySiteService{
+		verifySiteUC: verifySiteUC,
+		logger:       logger.Named("verify-site-service"),
+	}
+}
+
+// ProvideVerifySiteService provides VerifySiteService for dependency injection
+func ProvideVerifySiteService(
+	verifySiteUC *siteusecase.VerifySiteUseCase,
+	logger *zap.Logger,
+) VerifySiteService {
+	return NewVerifySiteService(verifySiteUC, logger)
+}
+
+// VerifySite verifies a site using the verification token
+func (s *verifySiteService) VerifySite(
+	ctx context.Context,
+	tenantID gocql.UUID,
+	siteID gocql.UUID,
+	input *siteusecase.VerifySiteInput,
+) (*siteusecase.VerifySiteOutput, error) {
+	s.logger.Info("verifying site",
+		zap.String("tenant_id", tenantID.String()),
+		zap.String("site_id", siteID.String()))
+
+	return s.verifySiteUC.Execute(ctx, tenantID, siteID, input)
+}