@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/api/openapi/tooling/test/scalar_asset_localization.test.mjs

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { Script } from 'node:vm';
+import test from 'node:test';
+
+import {
+  localizeScalarBrowserAsset,
+  scalarAssetLocale,
+  scalarAssetLocalizationRevision,
+} from '../scalar_asset_localization.mjs';
+
+const assetPath = resolve(import.meta.dirname, '../../node_modules/@scalar/api-reference/dist/browser/standalone.js');
+
+test('localizes the pinned Scalar browser asset deterministically', async () => {
+  const upstream = await readFile(assetPath);
+  const first = localizeScalarBrowserAsset(upstream);
+  const second = localizeScalarBrowserAsset(upstream);
+
+  assert.deepEqual(first, second);
+  assert.equal(scalarAssetLocale, 'zh-CN');
+  assert.equal(scalarAssetLocalizationRevision, 'onex-zh-CN-v1');
+  assert.match(first.toString(), /未选择身份验证方式/);
+  assert.match(first.toString(), /API 调试客户端/);
+  assert.match(first.toString(), /发送请求/);
+  assert.match(first.toString(), /输入搜索关键词/);
+  assert.match(first.toString(), /HTTP 方法/);
+  assert.match(first.toString(), /关闭分组/);
+  assert.match(first.toString(), /打开分组/);
+  assert.doesNotMatch(first.toString(), /` No authentication selected `/);
+  assert.doesNotMatch(first.toString(), /`Request Example for`/);
+  assert.doesNotMatch(first.toString(), /` Send Request `/);
+  assert.doesNotMatch(first.toString(), /label:`Search`,size:`sm`/);
+  assert.doesNotMatch(first.toString(), /label:`Delete \$\{/);
+  assert.doesNotMatch(first.toString(), /options:\{hideOperationDefaultExamples:e\.layout===`modal`\}/);
+  assert.doesNotMatch(first.toString(), /containerAriaLabel:\{default:`Notifications`\}/);
+  assert.doesNotMatch(first.toString(), /k\(e\.label\)\+` Key`/);
+  assert.doesNotMatch(first.toString(), /`\$\{e\.label\} Key`/);
+  assert.doesNotThrow(() => new Script(first.toString()));
+});
+
+test('rejects unsupported locales and upstream source drift', async () => {
+  const upstream = await readFile(assetPath, 'utf8');
+  const drifted = upstream.replace('`Request Example for`', '`Changed Request Example`');
+  const overCounted = upstream.replace('`Request Example for`', '`Request Example for``Request Example for`');
+
+  assert.throws(() => localizeScalarBrowserAsset(upstream, 'en'), /locale en is not supported/);
+  assert.throws(() => localizeScalarBrowserAsset(drifted), /source drift/);
+  assert.throws(() => localizeScalarBrowserAsset(overCounted), /expected 1, found 2/);
+});

package/dist/resources/templates/go-backend/api/openapi/tooling/test/sdk_generator.test.mjs

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { generateSDKPackages } from '../sdk_generator.mjs';
+
+test('generated SDK text artifacts contain no trailing whitespace', async () => {
+  const [sdkPackage] = await generateSDKPackages({
+    audience: 'public',
+    contractSha256: 'b'.repeat(64),
+    document: {
+      info: { title: 'Fixture API', version: '1.0.0' },
+      openapi: '3.1.1',
+      paths: {
+        '/health': {
+          get: {
+            operationId: 'getHealth',
+            responses: { 200: { description: 'OK' } },
+          },
+        },
+      },
+    },
+    gitRevision: 'a'.repeat(40),
+    service: 'fixture-api',
+    toolVersions: { node: '24.18.0', typescript: '5.9.3' },
+  });
+
+  assert.ok(sdkPackage.files.has('dist/client/utils.gen.d.ts'));
+  for (const [path, content] of sdkPackage.files) {
+    assert.doesNotMatch(content.toString('utf8'), /[ \t]+$/gmu, path);
+  }
+});

package/dist/resources/templates/go-backend/api/openapi/tooling/test/semantic_version.test.mjs

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { compareSemanticVersions, isSemanticVersion, parseSemanticVersion } from '../semantic_version.mjs';
+
+test('semantic version parser accepts the complete SemVer 2.0 grammar', () => {
+  for (const version of [
+    '0.0.0',
+    '1.2.3-alpha',
+    '1.2.3-alpha.1',
+    '1.2.3-0.3.7',
+    '1.2.3-x.7.z.92',
+    '1.2.3+build.001',
+    '1.2.3-beta+exp.sha.5114f85',
+  ]) {
+    assert.equal(isSemanticVersion(version), true, version);
+    assert.equal(parseSemanticVersion(version).raw, version);
+  }
+});
+
+test('semantic version parser rejects leading zeroes and incomplete identifiers', () => {
+  for (const version of [
+    '',
+    '1',
+    '1.2',
+    'v1.2.3',
+    '01.2.3',
+    '1.02.3',
+    '1.2.03',
+    '1.2.3-01',
+    '1.2.3-',
+    '1.2.3+',
+    '1.2.3-alpha..1',
+    '1.2.3+build..1',
+    '1.2.3\n',
+    '1.2.3\r',
+  ]) {
+    assert.equal(isSemanticVersion(version), false, version);
+    assert.throws(() => parseSemanticVersion(version), /invalid semantic version/);
+  }
+});
+
+test('semantic version precedence follows the SemVer 2.0 ordering rules', () => {
+  const ordered = [
+    '1.0.0-alpha',
+    '1.0.0-alpha.1',
+    '1.0.0-alpha.beta',
+    '1.0.0-beta',
+    '1.0.0-beta.2',
+    '1.0.0-beta.11',
+    '1.0.0-rc.1',
+    '1.0.0',
+  ];
+  for (let index = 1; index < ordered.length; index += 1) {
+    assert.equal(compareSemanticVersions(ordered[index - 1], ordered[index]), -1);
+    assert.equal(compareSemanticVersions(ordered[index], ordered[index - 1]), 1);
+  }
+  assert.equal(compareSemanticVersions('1.0.0+build.1', '1.0.0+build.2'), 0);
+  assert.equal(compareSemanticVersions('999999999999999999999.0.0', '1000000000000000000000.0.0'), -1);
+});

package/dist/resources/templates/go-backend/api/openapi/tooling/test/service_contract_inputs.test.mjs

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  isServiceContractBuildInput,
+  serviceContractReviewPathspecs,
+} from '../service_contract_inputs.mjs';
+
+test('service contract build inputs exclude generated artifacts and Go consumers', () => {
+  assert.equal(isServiceContractBuildInput('/services/admin-api/openapi.yaml'), true);
+  assert.equal(isServiceContractBuildInput('/services/admin-api/components/admin.yaml'), true);
+  assert.equal(isServiceContractBuildInput('/services/admin-api/delegated/manifest.json'), true);
+  assert.equal(isServiceContractBuildInput('/services/admin-api/conformance/runtime.arazzo.yaml'), true);
+  assert.equal(isServiceContractBuildInput('/services/admin-api/dist/internal.openapi.json'), false);
+  assert.equal(isServiceContractBuildInput('/services/admin-api/embed.go'), false);
+  assert.equal(isServiceContractBuildInput('/services/admin-api/embed_test.go'), false);
+});
+
+test('operation review pathspecs cover only structured canonical sources', () => {
+  assert.deepEqual(serviceContractReviewPathspecs('backend/api/openapi/services/admin-api'), [
+    ':(glob)backend/api/openapi/services/admin-api/**/*.json',
+    ':(glob)backend/api/openapi/services/admin-api/**/*.yaml',
+    ':(glob)backend/api/openapi/services/admin-api/**/*.yml',
+    ':(glob,exclude)backend/api/openapi/services/admin-api/conformance/**',
+    ':(glob,exclude)backend/api/openapi/services/admin-api/dist/**',
+  ]);
+});

package/dist/resources/templates/go-backend/cmd/internal/runtime/resources.go

@@ -0,0 +1,125 @@
+package runtime
+
+import (
+	"context"
+	"time"
+
+	"github.com/google/wire"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+
+	"{{module}}/internal/core"
+	"{{module}}/internal/core/cache"
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/database"
+	"{{module}}/internal/core/eventbus"
+	"{{module}}/internal/core/logger"
+	"{{module}}/internal/core/observability"
+	"{{module}}/internal/core/queue"
+	"{{module}}/internal/core/schedule"
+)
+
+// ProviderSet 复用源工厂，并将已创建资源的释放交给 Wire 逆序执行。
+var ProviderSet = wire.NewSet(
+	config.Load, core.ProvideLogConfig, core.ProvideDatabaseConfig, core.ProvideRedisConfig,
+	ProvideLogger, ProvideDatabase, ProvideRedis,
+	core.ProvideRedisClient, core.ProvideCacheManagerConfig, core.ProvideCircuitBreakerService,
+	cache.ProvideL1Config, ProvideL1, cache.NewMetrics, cache.NewManager,
+	ProvideEventBus, observability.NewMetricsService, core.ProvideHealthService,
+	core.ProvideTracingConfig, ProvideTracing, core.ProvideSentryConfig, ProvideSentry,
+	ProvideQueue, ProvideScheduler, New,
+)
+
+// ProvideLogger 为 Wire 提供日志与同步释放。
+func ProvideLogger(cfg *config.LogConfig) (*zap.Logger, func(), error) {
+	log, err := logger.New(cfg)
+	if err != nil {
+		return nil, nil, err
+	}
+	return log, func() { _ = log.Sync() }, nil
+}
+
+// ProvideDatabase 将数据库连接池归入进程资源生命周期。
+func ProvideDatabase(cfg *config.DatabaseConfig, log *zap.Logger, metrics *observability.MetricsService) (*gorm.DB, func(), error) {
+	db, err := database.NewDB(cfg, log, metrics)
+	if err != nil {
+		return nil, nil, err
+	}
+	return db, func() {
+		sqlDB, err := db.DB()
+		if err == nil {
+			err = sqlDB.Close()
+		}
+		if err != nil {
+			log.Error("close database", zap.Error(err))
+		}
+	}, nil
+}
+
+// ProvideRedis 将已验证的 Redis 连接归入进程资源生命周期。
+func ProvideRedis(cfg *config.RedisConfig, log *zap.Logger) (*cache.RedisService, func(), error) {
+	client, err := cache.NewRedisService(cfg)
+	if err != nil {
+		return nil, nil, err
+	}
+	return client, func() {
+		if err := client.Close(); err != nil {
+			log.Error("close redis", zap.Error(err))
+		}
+	}, nil
+}
+
+// ProvideL1 在进程退出时停止缓存清理协程。
+func ProvideL1(cfg cache.L1Config, log *zap.Logger) (*cache.L1Cache, func()) {
+	client := cache.NewL1Cache(cfg, log)
+	return client, client.Close
+}
+
+// ProvideEventBus 在释放订阅前等待已派发事件完成。
+func ProvideEventBus(log *zap.Logger) (*eventbus.EventBus, func()) {
+	bus := eventbus.New(log)
+	return bus, bus.Close
+}
+
+// ProvideTracing 在有界超时内提交追踪数据。
+func ProvideTracing(log *zap.Logger, cfg *config.TracingConfig) (*observability.TracingService, func(), error) {
+	service, err := observability.NewTracingService(log, cfg)
+	if err != nil {
+		return nil, nil, err
+	}
+	return service, func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		if err := service.Shutdown(ctx); err != nil {
+			log.Error("close tracing", zap.Error(err))
+		}
+	}, nil
+}
+
+// ProvideSentry 在进程退出时提交待发送诊断。
+func ProvideSentry(log *zap.Logger, cfg *config.SentryConfig) (*observability.SentryService, func(), error) {
+	service, err := core.ProvideSentryService(log, cfg)
+	if err != nil {
+		return nil, nil, err
+	}
+	return service, func() { service.Close(2 * time.Second) }, nil
+}
+
+// ProvideQueue 释放任务生产端的 Redis 连接。
+func ProvideQueue(cfg *config.RedisConfig, log *zap.Logger) (*queue.Client, func(), error) {
+	client, err := queue.NewClient(cfg, log)
+	if err != nil {
+		return nil, nil, err
+	}
+	return client, func() {
+		if err := client.Close(); err != nil {
+			log.Error("close queue client", zap.Error(err))
+		}
+	}, nil
+}
+
+// ProvideScheduler 停止调度并等待正在执行的任务。
+func ProvideScheduler(log *zap.Logger) (*schedule.Scheduler, func()) {
+	scheduler := schedule.New(log)
+	return scheduler, scheduler.Stop
+}

package/dist/resources/templates/go-backend/cmd/internal/runtime/runtime.go

@@ -0,0 +1,102 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+	"{{module}}/api/openapi"
+	"{{module}}/internal/common/middleware"
+	"{{module}}/internal/core/apidocs"
+	"{{module}}/internal/core/cache"
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/eventbus"
+	"{{module}}/internal/core/health"
+	"{{module}}/internal/core/observability"
+	"{{module}}/internal/core/queue"
+	"{{module}}/internal/core/schedule"
+)
+
+// Runtime 持有进程级资源；业务模块通过各自 ProviderSet 注入入口。
+type Runtime struct {
+	Config    *config.Config
+	Log       *zap.Logger
+	DB        *gorm.DB
+	Redis     *cache.RedisService
+	Cache     *cache.Manager
+	Bus       *eventbus.EventBus
+	Health    *health.Service
+	Metrics   *observability.MetricsService
+	Tracing   *observability.TracingService
+	Sentry    *observability.SentryService
+	Queue     *queue.Client
+	Scheduler *schedule.Scheduler
+}
+
+// New 将事件总线与调度器放在资源图末端，使 Wire 在依赖关闭前先停止事件生产并排空订阅。
+func New(cfg *config.Config, log *zap.Logger, db *gorm.DB, redis *cache.RedisService, manager *cache.Manager, h *health.Service, metrics *observability.MetricsService, tracing *observability.TracingService, sentry *observability.SentryService, q *queue.Client, bus *eventbus.EventBus, scheduler *schedule.Scheduler) *Runtime {
+	return &Runtime{Config: cfg, Log: log, DB: db, Redis: redis, Cache: manager, Bus: bus, Health: h, Metrics: metrics, Tracing: tracing, Sentry: sentry, Queue: q, Scheduler: scheduler}
+}
+
+// Router 将实际路由与内嵌契约校验，阻止未登记接口启动。
+func (r *Runtime) Router(service string) (*gin.Engine, error) {
+	if r.Config.IsProduction() {
+		gin.SetMode(gin.ReleaseMode)
+	}
+	document, err := openapi.Document(service)
+	if err != nil {
+		return nil, err
+	}
+	router := gin.New()
+	if err := router.SetTrustedProxies(r.Config.App.TrustedProxies); err != nil {
+		return nil, fmt.Errorf("set trusted proxies: %w", err)
+	}
+	router.Use(otelgin.Middleware(r.Config.Tracing.ServiceName), middleware.RequestID(), middleware.Metrics(r.Metrics), middleware.LoggingWithConfig(r.Log, r.Config.Log), r.Sentry.GinMiddleware(true), middleware.Recovery(r.Log))
+	r.Health.RegisterRoutes(router.Group(""))
+	router.GET("/metrics", gin.WrapH(promhttp.Handler()))
+	if !r.Config.IsProduction() {
+		if err := apidocs.RegisterRoutes(router, document); err != nil {
+			return nil, err
+		}
+	}
+	if err := document.ValidateRoutes(router.Routes()); err != nil {
+		return nil, err
+	}
+	return router, nil
+}
+
+// Serve 在监听成功后报告就绪，并在退出时等待在途 HTTP 请求完成。
+func (r *Runtime) Serve(ctx context.Context, router http.Handler) error {
+	server := &http.Server{Addr: net.JoinHostPort(r.Config.App.Host, fmt.Sprint(r.Config.App.Port)), Handler: router, ReadHeaderTimeout: 10 * time.Second, ReadTimeout: 30 * time.Second, WriteTimeout: 30 * time.Second, IdleTimeout: 60 * time.Second}
+	listener, err := net.Listen("tcp", server.Addr)
+	if err != nil {
+		return fmt.Errorf("listen: %w", err)
+	}
+	r.Health.MarkReady()
+	result := make(chan error, 1)
+	go func() { result <- server.Serve(listener) }()
+	r.Log.Info("server started", zap.String("address", server.Addr))
+	select {
+	case err = <-result:
+		if errors.Is(err, http.ErrServerClosed) {
+			return nil
+		}
+		return err
+	case <-ctx.Done():
+		r.Health.SetReadinessComponent("shutdown", health.ComponentHealth{Status: health.StatusDown})
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		if err = server.Shutdown(shutdownCtx); err != nil {
+			return errors.Join(err, server.Close())
+		}
+		return nil
+	}
+}

package/dist/resources/templates/go-backend/cmd/internal/runtime/runtime_test.go

@@ -0,0 +1,70 @@
+package runtime
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"{{module}}/api/openapi"
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/health"
+	"{{module}}/internal/core/observability"
+)
+
+func TestRouterContractsAndDocumentationVisibility(t *testing.T) {
+	log := zap.NewNop()
+	metrics := observability.NewMetricsService(log)
+	for _, service := range []string{"product-api", "worker"} {
+		for _, env := range []string{"local", "production"} {
+			t.Run(service+"/"+env, func(t *testing.T) {
+				cfg := &config.Config{App: config.AppConfig{Env: env}}
+				app := &Runtime{Config: cfg, Log: log, Metrics: metrics, Health: health.New(log, nil, nil), Sentry: observability.NewSentryService(log, &cfg.Sentry)}
+				router, err := app.Router(service)
+				if err != nil {
+					t.Fatal(err)
+				}
+				response := httptest.NewRecorder()
+				router.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/health/liveness", nil))
+				if response.Code != http.StatusOK {
+					t.Fatalf("liveness status = %d", response.Code)
+				}
+				response = httptest.NewRecorder()
+				router.ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/docs", nil))
+				want := http.StatusOK
+				if env == "production" {
+					want = http.StatusNotFound
+				}
+				if response.Code != want {
+					t.Fatalf("docs status = %d, want %d", response.Code, want)
+				}
+				document, err := openapi.Document(service)
+				if err != nil {
+					t.Fatal(err)
+				}
+				router.GET("/api/v1/unregistered", func(c *gin.Context) { c.Status(http.StatusNoContent) })
+				if err := document.ValidateRoutes(router.Routes()); err == nil {
+					t.Fatal("undocumented business route was accepted")
+				}
+			})
+		}
+	}
+}
+
+func TestServeRejectsOccupiedAddress(t *testing.T) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer listener.Close()
+	cfg := &config.Config{App: config.AppConfig{Host: "127.0.0.1", Port: listener.Addr().(*net.TCPAddr).Port}}
+	log := zap.NewNop()
+	app := &Runtime{Config: cfg, Log: log, Health: health.New(log, nil, nil)}
+	if err := app.Serve(context.Background(), http.NewServeMux()); err == nil || !strings.Contains(err.Error(), "listen") {
+		t.Fatalf("occupied listener error = %v", err)
+	}
+}

package/dist/resources/templates/go-backend/cmd/product-api/lifecycle_test.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	_ "github.com/lib/pq"
+)
+
+func TestInitializationFailureReleasesDatabase(t *testing.T) {
+	dsn := os.Getenv("RUNTIME_TEST_DATABASE_URL")
+	if dsn == "" {
+		t.Skip("RUNTIME_TEST_DATABASE_URL requires an isolated PostgreSQL and Redis runtime")
+	}
+	db, err := sql.Open("postgres", dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	connections := func() int {
+		var count int
+		if err := db.QueryRowContext(ctx, "SELECT count(*) FROM pg_stat_activity WHERE datname = current_database() AND pid <> pg_backend_pid()").Scan(&count); err != nil {
+			t.Fatal(err)
+		}
+		return count
+	}
+	before := connections()
+	t.Setenv("SENTRY_ENABLED", "true")
+	t.Setenv("SENTRY_DSN", "://invalid")
+	_, cleanup, err := InitializeApp()
+	if err == nil {
+		cleanup()
+		t.Fatal("invalid Sentry configuration was accepted")
+	}
+	if !strings.Contains(err.Error(), "initialize sentry") {
+		t.Fatalf("initialization failed before the intended resource boundary: %v", err)
+	}
+	if cleanup != nil {
+		t.Fatal("failed Wire initialization returned a cleanup function")
+	}
+	deadline := time.Now().Add(2 * time.Second)
+	for {
+		after := connections()
+		if after <= before {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("database sessions leaked: before=%d after=%d", before, after)
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+}

package/dist/resources/templates/go-backend/cmd/product-api/main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"go.uber.org/zap"
+)
+
+func main() {
+	log := zap.NewExample()
+	if err := run(); err != nil {
+		log.Error("product API failed", zap.Error(err))
+		os.Exit(1)
+	}
+}
+func run() error {
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+	app, cleanup, err := InitializeApp()
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+	router, err := app.Router("product-api")
+	if err != nil {
+		return err
+	}
+	return app.Serve(ctx, router)
+}

package/dist/resources/templates/go-backend/cmd/product-api/wire.go

@@ -0,0 +1,13 @@
+//go:build wireinject
+
+package main
+
+import (
+	"github.com/google/wire"
+	"{{module}}/cmd/internal/runtime"
+)
+
+func InitializeApp() (*runtime.Runtime, func(), error) {
+	wire.Build(runtime.ProviderSet)
+	return nil, nil, nil
+}

package/dist/resources/templates/go-backend/cmd/product-api/wire_gen.go

@@ -0,0 +1,94 @@
+// 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 (
+	"{{module}}/cmd/internal/runtime"
+	"{{module}}/internal/core"
+	"{{module}}/internal/core/cache"
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/observability"
+)
+
+// Injectors from wire.go:
+
+func InitializeApp() (*runtime.Runtime, func(), error) {
+	configConfig, err := config.Load()
+	if err != nil {
+		return nil, nil, err
+	}
+	logConfig := core.ProvideLogConfig(configConfig)
+	logger, cleanup, err := runtime.ProvideLogger(logConfig)
+	if err != nil {
+		return nil, nil, err
+	}
+	databaseConfig := core.ProvideDatabaseConfig(configConfig)
+	metricsService := observability.NewMetricsService(logger)
+	db, cleanup2, err := runtime.ProvideDatabase(databaseConfig, logger, metricsService)
+	if err != nil {
+		cleanup()
+		return nil, nil, err
+	}
+	redisConfig := core.ProvideRedisConfig(configConfig)
+	redisService, cleanup3, err := runtime.ProvideRedis(redisConfig, logger)
+	if err != nil {
+		cleanup2()
+		cleanup()
+		return nil, nil, err
+	}
+	managerConfig := core.ProvideCacheManagerConfig(configConfig)
+	l1Config := cache.ProvideL1Config(managerConfig)
+	l1Cache, cleanup4 := runtime.ProvideL1(l1Config, logger)
+	circuitBreakerService := core.ProvideCircuitBreakerService(logger)
+	metrics := cache.NewMetrics()
+	manager := cache.NewManager(managerConfig, redisService, l1Cache, circuitBreakerService, metrics, logger)
+	client := core.ProvideRedisClient(redisService)
+	service := core.ProvideHealthService(logger, db, client)
+	tracingConfig := core.ProvideTracingConfig(configConfig)
+	tracingService, cleanup5, err := runtime.ProvideTracing(logger, tracingConfig)
+	if err != nil {
+		cleanup4()
+		cleanup3()
+		cleanup2()
+		cleanup()
+		return nil, nil, err
+	}
+	sentryConfig := core.ProvideSentryConfig(configConfig)
+	sentryService, cleanup6, err := runtime.ProvideSentry(logger, sentryConfig)
+	if err != nil {
+		cleanup5()
+		cleanup4()
+		cleanup3()
+		cleanup2()
+		cleanup()
+		return nil, nil, err
+	}
+	queueClient, cleanup7, err := runtime.ProvideQueue(redisConfig, logger)
+	if err != nil {
+		cleanup6()
+		cleanup5()
+		cleanup4()
+		cleanup3()
+		cleanup2()
+		cleanup()
+		return nil, nil, err
+	}
+	eventBus, cleanup8 := runtime.ProvideEventBus(logger)
+	scheduler, cleanup9 := runtime.ProvideScheduler(logger)
+	runtimeRuntime := runtime.New(configConfig, logger, db, redisService, manager, service, metricsService, tracingService, sentryService, queueClient, eventBus, scheduler)
+	return runtimeRuntime, func() {
+		cleanup9()
+		cleanup8()
+		cleanup7()
+		cleanup6()
+		cleanup5()
+		cleanup4()
+		cleanup3()
+		cleanup2()
+		cleanup()
+	}, nil
+}