249 lines
12 KiB
Go
249 lines
12 KiB
Go
// Code generated by Wire. DO NOT EDIT.
|
|
|
|
//go:generate go run -mod=mod github.com/google/wire/cmd/wire
|
|
//go:build !wireinject
|
|
// +build !wireinject
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"github.com/Wei-Shaw/sub2api/ent"
|
|
"github.com/Wei-Shaw/sub2api/internal/config"
|
|
"github.com/Wei-Shaw/sub2api/internal/handler"
|
|
"github.com/Wei-Shaw/sub2api/internal/handler/admin"
|
|
"github.com/Wei-Shaw/sub2api/internal/repository"
|
|
"github.com/Wei-Shaw/sub2api/internal/server"
|
|
"github.com/Wei-Shaw/sub2api/internal/server/middleware"
|
|
"github.com/Wei-Shaw/sub2api/internal/service"
|
|
"github.com/redis/go-redis/v9"
|
|
"log"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
import (
|
|
_ "embed"
|
|
_ "github.com/Wei-Shaw/sub2api/ent/runtime"
|
|
)
|
|
|
|
// Injectors from wire.go:
|
|
|
|
func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
|
|
configConfig, err := config.ProvideConfig()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
client, err := repository.ProvideEnt(configConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
db, err := repository.ProvideSQLDB(client)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
userRepository := repository.NewUserRepository(client, db)
|
|
settingRepository := repository.NewSettingRepository(client)
|
|
settingService := service.NewSettingService(settingRepository, configConfig)
|
|
redisClient := repository.ProvideRedis(configConfig)
|
|
emailCache := repository.NewEmailCache(redisClient)
|
|
emailService := service.NewEmailService(settingRepository, emailCache)
|
|
turnstileVerifier := repository.NewTurnstileVerifier()
|
|
turnstileService := service.NewTurnstileService(settingService, turnstileVerifier)
|
|
emailQueueService := service.ProvideEmailQueueService(emailService)
|
|
authService := service.NewAuthService(userRepository, configConfig, settingService, emailService, turnstileService, emailQueueService)
|
|
userService := service.NewUserService(userRepository)
|
|
authHandler := handler.NewAuthHandler(configConfig, authService, userService)
|
|
userHandler := handler.NewUserHandler(userService)
|
|
apiKeyRepository := repository.NewApiKeyRepository(client)
|
|
groupRepository := repository.NewGroupRepository(client, db)
|
|
userSubscriptionRepository := repository.NewUserSubscriptionRepository(client)
|
|
apiKeyCache := repository.NewApiKeyCache(redisClient)
|
|
apiKeyService := service.NewApiKeyService(apiKeyRepository, userRepository, groupRepository, userSubscriptionRepository, apiKeyCache, configConfig)
|
|
apiKeyHandler := handler.NewAPIKeyHandler(apiKeyService)
|
|
usageLogRepository := repository.NewUsageLogRepository(client, db)
|
|
usageService := service.NewUsageService(usageLogRepository, userRepository)
|
|
usageHandler := handler.NewUsageHandler(usageService, apiKeyService)
|
|
redeemCodeRepository := repository.NewRedeemCodeRepository(client)
|
|
billingCache := repository.NewBillingCache(redisClient)
|
|
billingCacheService := service.NewBillingCacheService(billingCache, userRepository, userSubscriptionRepository, configConfig)
|
|
subscriptionService := service.NewSubscriptionService(groupRepository, userSubscriptionRepository, billingCacheService)
|
|
redeemCache := repository.NewRedeemCache(redisClient)
|
|
redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client)
|
|
redeemHandler := handler.NewRedeemHandler(redeemService)
|
|
subscriptionHandler := handler.NewSubscriptionHandler(subscriptionService)
|
|
dashboardService := service.NewDashboardService(usageLogRepository)
|
|
dashboardHandler := admin.NewDashboardHandler(dashboardService)
|
|
accountRepository := repository.NewAccountRepository(client, db)
|
|
proxyRepository := repository.NewProxyRepository(client, db)
|
|
proxyExitInfoProber := repository.NewProxyExitInfoProber()
|
|
adminService := service.NewAdminService(userRepository, groupRepository, accountRepository, proxyRepository, apiKeyRepository, redeemCodeRepository, billingCacheService, proxyExitInfoProber)
|
|
adminUserHandler := admin.NewUserHandler(adminService)
|
|
groupHandler := admin.NewGroupHandler(adminService)
|
|
claudeOAuthClient := repository.NewClaudeOAuthClient()
|
|
oAuthService := service.NewOAuthService(proxyRepository, claudeOAuthClient)
|
|
openAIOAuthClient := repository.NewOpenAIOAuthClient()
|
|
openAIOAuthService := service.NewOpenAIOAuthService(proxyRepository, openAIOAuthClient)
|
|
geminiOAuthClient := repository.NewGeminiOAuthClient(configConfig)
|
|
geminiCliCodeAssistClient := repository.NewGeminiCliCodeAssistClient()
|
|
geminiOAuthService := service.NewGeminiOAuthService(proxyRepository, geminiOAuthClient, geminiCliCodeAssistClient, configConfig)
|
|
geminiQuotaService := service.NewGeminiQuotaService(configConfig, settingRepository)
|
|
rateLimitService := service.NewRateLimitService(accountRepository, usageLogRepository, configConfig, geminiQuotaService)
|
|
claudeUsageFetcher := repository.NewClaudeUsageFetcher()
|
|
accountUsageService := service.NewAccountUsageService(accountRepository, usageLogRepository, claudeUsageFetcher, geminiQuotaService)
|
|
geminiTokenCache := repository.NewGeminiTokenCache(redisClient)
|
|
geminiTokenProvider := service.NewGeminiTokenProvider(accountRepository, geminiTokenCache, geminiOAuthService)
|
|
gatewayCache := repository.NewGatewayCache(redisClient)
|
|
antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
|
|
antigravityTokenProvider := service.NewAntigravityTokenProvider(accountRepository, geminiTokenCache, antigravityOAuthService)
|
|
httpUpstream := repository.NewHTTPUpstream(configConfig)
|
|
antigravityGatewayService := service.NewAntigravityGatewayService(accountRepository, gatewayCache, antigravityTokenProvider, rateLimitService, httpUpstream)
|
|
accountTestService := service.NewAccountTestService(accountRepository, oAuthService, openAIOAuthService, geminiTokenProvider, antigravityGatewayService, httpUpstream)
|
|
concurrencyCache := repository.ProvideConcurrencyCache(redisClient, configConfig)
|
|
concurrencyService := service.ProvideConcurrencyService(concurrencyCache, accountRepository, configConfig)
|
|
crsSyncService := service.NewCRSSyncService(accountRepository, proxyRepository, oAuthService, openAIOAuthService, geminiOAuthService)
|
|
accountHandler := admin.NewAccountHandler(adminService, oAuthService, openAIOAuthService, geminiOAuthService, rateLimitService, accountUsageService, accountTestService, concurrencyService, crsSyncService)
|
|
oAuthHandler := admin.NewOAuthHandler(oAuthService)
|
|
openAIOAuthHandler := admin.NewOpenAIOAuthHandler(openAIOAuthService, adminService)
|
|
geminiOAuthHandler := admin.NewGeminiOAuthHandler(geminiOAuthService)
|
|
antigravityOAuthHandler := admin.NewAntigravityOAuthHandler(antigravityOAuthService)
|
|
proxyHandler := admin.NewProxyHandler(adminService)
|
|
adminRedeemHandler := admin.NewRedeemHandler(adminService)
|
|
settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService)
|
|
updateCache := repository.NewUpdateCache(redisClient)
|
|
gitHubReleaseClient := repository.NewGitHubReleaseClient()
|
|
serviceBuildInfo := provideServiceBuildInfo(buildInfo)
|
|
updateService := service.ProvideUpdateService(updateCache, gitHubReleaseClient, serviceBuildInfo)
|
|
systemHandler := handler.ProvideSystemHandler(updateService)
|
|
adminSubscriptionHandler := admin.NewSubscriptionHandler(subscriptionService)
|
|
adminUsageHandler := admin.NewUsageHandler(usageService, apiKeyService, adminService)
|
|
adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, settingHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler)
|
|
pricingRemoteClient := repository.NewPricingRemoteClient()
|
|
pricingService, err := service.ProvidePricingService(configConfig, pricingRemoteClient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
billingService := service.NewBillingService(configConfig, pricingService)
|
|
identityCache := repository.NewIdentityCache(redisClient)
|
|
identityService := service.NewIdentityService(identityCache)
|
|
timingWheelService := service.ProvideTimingWheelService()
|
|
deferredService := service.ProvideDeferredService(accountRepository, timingWheelService)
|
|
gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService)
|
|
geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService)
|
|
gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService)
|
|
openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService)
|
|
openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService)
|
|
handlerSettingHandler := handler.ProvideSettingHandler(settingService, buildInfo)
|
|
handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, handlerSettingHandler)
|
|
jwtAuthMiddleware := middleware.NewJWTAuthMiddleware(authService, userService)
|
|
adminAuthMiddleware := middleware.NewAdminAuthMiddleware(authService, userService, settingService)
|
|
apiKeyAuthMiddleware := middleware.NewApiKeyAuthMiddleware(apiKeyService, subscriptionService, configConfig)
|
|
engine := server.ProvideRouter(configConfig, handlers, jwtAuthMiddleware, adminAuthMiddleware, apiKeyAuthMiddleware, apiKeyService, subscriptionService)
|
|
httpServer := server.ProvideHTTPServer(configConfig, engine)
|
|
tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, configConfig)
|
|
antigravityQuotaRefresher := service.ProvideAntigravityQuotaRefresher(accountRepository, proxyRepository, antigravityOAuthService, configConfig)
|
|
v := provideCleanup(client, redisClient, tokenRefreshService, pricingService, emailQueueService, billingCacheService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, antigravityQuotaRefresher)
|
|
application := &Application{
|
|
Server: httpServer,
|
|
Cleanup: v,
|
|
}
|
|
return application, nil
|
|
}
|
|
|
|
// wire.go:
|
|
|
|
type Application struct {
|
|
Server *http.Server
|
|
Cleanup func()
|
|
}
|
|
|
|
func provideServiceBuildInfo(buildInfo handler.BuildInfo) service.BuildInfo {
|
|
return service.BuildInfo{
|
|
Version: buildInfo.Version,
|
|
BuildType: buildInfo.BuildType,
|
|
}
|
|
}
|
|
|
|
func provideCleanup(
|
|
entClient *ent.Client,
|
|
rdb *redis.Client,
|
|
tokenRefresh *service.TokenRefreshService,
|
|
pricing *service.PricingService,
|
|
emailQueue *service.EmailQueueService,
|
|
billingCache *service.BillingCacheService,
|
|
oauth *service.OAuthService,
|
|
openaiOAuth *service.OpenAIOAuthService,
|
|
geminiOAuth *service.GeminiOAuthService,
|
|
antigravityOAuth *service.AntigravityOAuthService,
|
|
antigravityQuota *service.AntigravityQuotaRefresher,
|
|
) func() {
|
|
return func() {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
cleanupSteps := []struct {
|
|
name string
|
|
fn func() error
|
|
}{
|
|
{"TokenRefreshService", func() error {
|
|
tokenRefresh.Stop()
|
|
return nil
|
|
}},
|
|
{"PricingService", func() error {
|
|
pricing.Stop()
|
|
return nil
|
|
}},
|
|
{"EmailQueueService", func() error {
|
|
emailQueue.Stop()
|
|
return nil
|
|
}},
|
|
{"BillingCacheService", func() error {
|
|
billingCache.Stop()
|
|
return nil
|
|
}},
|
|
{"OAuthService", func() error {
|
|
oauth.Stop()
|
|
return nil
|
|
}},
|
|
{"OpenAIOAuthService", func() error {
|
|
openaiOAuth.Stop()
|
|
return nil
|
|
}},
|
|
{"GeminiOAuthService", func() error {
|
|
geminiOAuth.Stop()
|
|
return nil
|
|
}},
|
|
{"AntigravityOAuthService", func() error {
|
|
antigravityOAuth.Stop()
|
|
return nil
|
|
}},
|
|
{"AntigravityQuotaRefresher", func() error {
|
|
antigravityQuota.Stop()
|
|
return nil
|
|
}},
|
|
{"Redis", func() error {
|
|
return rdb.Close()
|
|
}},
|
|
{"Ent", func() error {
|
|
return entClient.Close()
|
|
}},
|
|
}
|
|
|
|
for _, step := range cleanupSteps {
|
|
if err := step.fn(); err != nil {
|
|
log.Printf("[Cleanup] %s failed: %v", step.name, err)
|
|
|
|
} else {
|
|
log.Printf("[Cleanup] %s succeeded", step.name)
|
|
}
|
|
}
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
log.Printf("[Cleanup] Warning: cleanup timed out after 10 seconds")
|
|
default:
|
|
log.Printf("[Cleanup] All cleanup steps completed")
|
|
}
|
|
}
|
|
}
|