@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/common/jsonschema/compiler.go

@@ -0,0 +1,100 @@
+package jsonschema
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+
+	schema "github.com/santhosh-tekuri/jsonschema/v6"
+)
+
+// CompileStage 标识 JSON Schema 编译失败的确定阶段。
+type CompileStage string
+
+const (
+	CompileStageDecode   CompileStage = "decode"
+	CompileStageResource CompileStage = "resource"
+	CompileStageSchema   CompileStage = "schema"
+)
+
+// CompileError 保留编译阶段，让业务适配器维持各自既有错误合同。
+type CompileError struct {
+	Stage CompileStage
+	Err   error
+}
+
+func (e *CompileError) Error() string {
+	if e == nil || e.Err == nil {
+		return "JSON Schema compilation failed"
+	}
+	return e.Err.Error()
+}
+
+func (e *CompileError) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.Err
+}
+
+// CompilerOptions 定义资源 URL 和外部引用策略。
+type CompilerOptions struct {
+	ResourceURL              func(schemaHash string) string
+	RejectExternalReferences bool
+}
+
+// Compiler 提供并发安全的不可变 JSON Schema 编译缓存。
+type Compiler struct {
+	cache   sync.Map
+	options CompilerOptions
+}
+
+// NewCompiler 创建 JSON Schema 编译器。
+func NewCompiler(options CompilerOptions) *Compiler {
+	return &Compiler{options: options}
+}
+
+// Compile 解码、注册并编译 schema；相同原始 schema 在实例内精确复用。
+func (c *Compiler) Compile(schemaRaw json.RawMessage) (*schema.Schema, error) {
+	if c == nil || c.options.ResourceURL == nil {
+		return nil, &CompileError{Stage: CompileStageResource, Err: fmt.Errorf("schema resource URL factory is required")}
+	}
+	digest := sha256.Sum256(schemaRaw)
+	cacheKey := hex.EncodeToString(digest[:])
+	if cached, ok := c.cache.Load(cacheKey); ok {
+		return cached.(*schema.Schema), nil
+	}
+
+	document, err := schema.UnmarshalJSON(bytes.NewReader(schemaRaw))
+	if err != nil {
+		return nil, &CompileError{Stage: CompileStageDecode, Err: err}
+	}
+	compiler := schema.NewCompiler()
+	if c.options.RejectExternalReferences {
+		compiler.UseLoader(rejectingLoader{})
+	}
+	resourceURL := strings.TrimSpace(c.options.ResourceURL(cacheKey))
+	if resourceURL == "" {
+		return nil, &CompileError{Stage: CompileStageResource, Err: fmt.Errorf("schema resource URL is required")}
+	}
+	if err := compiler.AddResource(resourceURL, document); err != nil {
+		return nil, &CompileError{Stage: CompileStageResource, Err: err}
+	}
+	compiled, err := compiler.Compile(resourceURL)
+	if err != nil {
+		return nil, &CompileError{Stage: CompileStageSchema, Err: err}
+	}
+	actual, _ := c.cache.LoadOrStore(cacheKey, compiled)
+	return actual.(*schema.Schema), nil
+}
+
+type rejectingLoader struct{}
+
+// Load 阻止 schema 触发网络或本地文件读取。
+func (rejectingLoader) Load(url string) (any, error) { //nolint:T1 // any 来自第三方 JSON Schema loader 契约。
+	return nil, fmt.Errorf("external schema reference is not allowed: %s", url)
+}

package/dist/resources/templates/go-backend/internal/common/jsonschema/compiler_test.go

@@ -0,0 +1,41 @@
+package jsonschema
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+)
+
+func TestCompilerCachesSchemaAndRejectsExternalReferences(t *testing.T) {
+	compiler := NewCompiler(CompilerOptions{
+		ResourceURL:              func(hash string) string { return "test-schema://" + hash + ".json" },
+		RejectExternalReferences: true,
+	})
+	raw := json.RawMessage(`{"type":"object","properties":{"name":{"type":"string"}},"additionalProperties":false}`)
+	first, err := compiler.Compile(raw)
+	if err != nil {
+		t.Fatalf("Compile() error = %v", err)
+	}
+	second, err := compiler.Compile(raw)
+	if err != nil {
+		t.Fatalf("Compile(replay) error = %v", err)
+	}
+	if first != second {
+		t.Fatal("Compile() did not reuse cached schema")
+	}
+
+	_, err = compiler.Compile(json.RawMessage(`{"$ref":"https://example.com/schema.json"}`))
+	var compileErr *CompileError
+	if !errors.As(err, &compileErr) || compileErr.Stage != CompileStageSchema {
+		t.Fatalf("Compile(external ref) error = %v", err)
+	}
+}
+
+func TestCompilerClassifiesInvalidJSON(t *testing.T) {
+	compiler := NewCompiler(CompilerOptions{ResourceURL: func(string) string { return "test-schema://schema.json" }})
+	_, err := compiler.Compile(json.RawMessage(`{"type":`))
+	var compileErr *CompileError
+	if !errors.As(err, &compileErr) || compileErr.Stage != CompileStageDecode {
+		t.Fatalf("Compile(invalid JSON) error = %v", err)
+	}
+}

package/dist/resources/templates/go-backend/internal/common/jwksapi/handler.go

@@ -0,0 +1,83 @@
+package jwksapi
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/jwtkeyring"
+)
+
+// Handler 发布 Identity 与 IAM 签名域的统一 RFC 7517 公钥集。
+type Handler struct {
+	registry     *jwtkeyring.Registry
+	keySetSHA256 string
+}
+
+// KeySetDigestProvider 提供当前统一公钥集的稳定内容摘要。
+type KeySetDigestProvider interface {
+	KeySetSHA256() (string, error)
+}
+
+var _ KeySetDigestProvider = (*Handler)(nil)
+
+// NewHandler 装载公开密钥并构建 kid 全局唯一的 JWKS 注册表。
+func NewHandler(cfg *config.Config) (*Handler, error) {
+	if cfg == nil {
+		return nil, fmt.Errorf("JWKS configuration is required")
+	}
+	identityRing, err := jwtkeyring.Load(jwtkeyring.Config{
+		ActiveKeyID:        cfg.Identity.AccessToken.SigningKeyID,
+		PublicKeyDirectory: cfg.Identity.AccessToken.PublicKeyDirectory,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("load identity JWKS key ring: %w", err)
+	}
+	iamRing, err := jwtkeyring.Load(jwtkeyring.Config{
+		ActiveKeyID:        cfg.InternalService.ServiceTokenSigning.KeyID,
+		PublicKeyDirectory: cfg.InternalService.ServiceTokenSigning.PublicKeyDirectory,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("load IAM JWKS key ring: %w", err)
+	}
+	registry := jwtkeyring.NewRegistry()
+	if err := registry.Register("identity-access-token", identityRing); err != nil {
+		return nil, err
+	}
+	if err := registry.Register("iam-service-token", iamRing); err != nil {
+		return nil, err
+	}
+	canonicalKeySet, err := json.Marshal(registry.JSONWebKeySet())
+	if err != nil {
+		return nil, fmt.Errorf("marshal canonical JWKS: %w", err)
+	}
+	digest := sha256.Sum256(canonicalKeySet)
+	return &Handler{
+		registry:     registry,
+		keySetSHA256: hex.EncodeToString(digest[:]),
+	}, nil
+}
+
+// RegisterRoutes 注册统一公钥端点。
+func (h *Handler) RegisterRoutes(root *gin.RouterGroup) {
+	root.GET("/.well-known/jwks.json", h.Get)
+}
+
+// Get 返回可缓存的统一 JWKS。
+func (h *Handler) Get(c *gin.Context) {
+	c.Header("Cache-Control", "public, max-age=300, stale-while-revalidate=300")
+	c.JSON(http.StatusOK, h.registry.JSONWebKeySet())
+}
+
+// KeySetSHA256 返回稳定排序后统一 JWKS 规范 JSON 的 SHA-256 摘要。
+func (h *Handler) KeySetSHA256() (string, error) {
+	if h == nil || h.keySetSHA256 == "" {
+		return "", fmt.Errorf("JWKS key set digest is unavailable")
+	}
+	return h.keySetSHA256, nil
+}

package/dist/resources/templates/go-backend/internal/common/jwksapi/handler_test.go

@@ -0,0 +1,104 @@
+package jwksapi
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha256"
+	"crypto/x509"
+	"encoding/hex"
+	"encoding/json"
+	"encoding/pem"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/require"
+
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/jwtkeyring"
+)
+
+func TestHandlerPublishesStableUnifiedJWKS(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	identityDirectory := t.TempDir()
+	iamDirectory := t.TempDir()
+	writeJWKSPublicKey(t, identityDirectory, "z-identity", generateJWKSKey(t))
+	writeJWKSPublicKey(t, iamDirectory, "a-iam", generateJWKSKey(t))
+	handler, err := NewHandler(&config.Config{
+		Identity: config.IdentityConfig{AccessToken: config.IdentityAccessTokenConfig{
+			SigningKeyID: "z-identity", PublicKeyDirectory: identityDirectory,
+		}},
+		InternalService: config.InternalServiceConfig{ServiceTokenSigning: config.ServiceTokenSigningConfig{
+			KeyID: "a-iam", PublicKeyDirectory: iamDirectory,
+		}},
+	})
+	require.NoError(t, err)
+
+	recorder := httptest.NewRecorder()
+	context, _ := gin.CreateTestContext(recorder)
+	context.Request = httptest.NewRequest(http.MethodGet, "/.well-known/jwks.json", nil)
+	handler.Get(context)
+
+	require.Equal(t, http.StatusOK, recorder.Code)
+	require.Equal(t, "public, max-age=300, stale-while-revalidate=300", recorder.Header().Get("Cache-Control"))
+	var result jwtkeyring.JSONWebKeySet
+	require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &result))
+	require.Len(t, result.Keys, 2)
+	require.Equal(t, "a-iam", result.Keys[0].KeyID)
+	require.Equal(t, "z-identity", result.Keys[1].KeyID)
+	for _, key := range result.Keys {
+		require.Equal(t, "RSA", key.KeyType)
+		require.Equal(t, "RS256", key.Algorithm)
+		require.NotEmpty(t, key.Modulus)
+		require.NotEmpty(t, key.Exponent)
+	}
+	canonicalKeySet, err := json.Marshal(result)
+	require.NoError(t, err)
+	wantDigest := sha256.Sum256(canonicalKeySet)
+	gotDigest, err := handler.KeySetSHA256()
+	require.NoError(t, err)
+	require.Equal(t, hex.EncodeToString(wantDigest[:]), gotDigest)
+	require.Regexp(t, "^[0-9a-f]{64}$", gotDigest)
+}
+
+func TestNewHandlerRejectsKeyIDCollisionAcrossSigningDomains(t *testing.T) {
+	identityDirectory := t.TempDir()
+	iamDirectory := t.TempDir()
+	key := generateJWKSKey(t)
+	writeJWKSPublicKey(t, identityDirectory, "shared-key", key)
+	writeJWKSPublicKey(t, iamDirectory, "shared-key", key)
+
+	_, err := NewHandler(&config.Config{
+		Identity: config.IdentityConfig{AccessToken: config.IdentityAccessTokenConfig{
+			SigningKeyID: "shared-key", PublicKeyDirectory: identityDirectory,
+		}},
+		InternalService: config.InternalServiceConfig{ServiceTokenSigning: config.ServiceTokenSigningConfig{
+			KeyID: "shared-key", PublicKeyDirectory: iamDirectory,
+		}},
+	})
+	require.ErrorContains(t, err, "duplicated across signing domains")
+}
+
+func TestNilHandlerRejectsKeySetDigestRead(t *testing.T) {
+	var handler *Handler
+	_, err := handler.KeySetSHA256()
+	require.ErrorContains(t, err, "digest is unavailable")
+}
+
+func generateJWKSKey(t *testing.T) *rsa.PublicKey {
+	t.Helper()
+	key, err := rsa.GenerateKey(rand.Reader, 2048)
+	require.NoError(t, err)
+	return &key.PublicKey
+}
+
+func writeJWKSPublicKey(t *testing.T, directory, keyID string, key *rsa.PublicKey) {
+	t.Helper()
+	der, err := x509.MarshalPKIXPublicKey(key)
+	require.NoError(t, err)
+	encoded := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: der})
+	require.NoError(t, os.WriteFile(filepath.Join(directory, keyID+".pem"), encoded, 0o600))
+}

package/dist/resources/templates/go-backend/internal/common/locale/locale.go

@@ -0,0 +1,145 @@
+package locale
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+const (
+	DefaultCode      = "en"
+	AdminDefaultCode = "cn"
+)
+
+var supportedCodes = []string{
+	"en",
+	"cn",
+	"tw",
+	"de",
+	"es",
+	"fr",
+	"it",
+	"ja",
+	"ko",
+	"pt",
+	"hi",
+	"ar",
+}
+
+var supportedCodeSet = buildSupportedCodeSet()
+
+func buildSupportedCodeSet() map[string]struct{} {
+	result := make(map[string]struct{}, len(supportedCodes))
+	for _, code := range supportedCodes {
+		result[code] = struct{}{}
+	}
+	return result
+}
+
+func SupportedCodes() []string {
+	result := make([]string, len(supportedCodes))
+	copy(result, supportedCodes)
+	return result
+}
+
+func NormalizeCode(value string) string {
+	code := strings.ToLower(strings.TrimSpace(strings.ReplaceAll(value, "_", "-")))
+	switch code {
+	case "en", "en-us", "en-gb":
+		return "en"
+	case "cn", "zh", "zh-cn", "zh-hans", "zh-hans-cn":
+		return "cn"
+	case "tw", "hk", "zh-tw", "zh-hk", "zh-hant", "zh-hant-tw", "zh-hant-hk":
+		return "tw"
+	case "ja", "jp", "ja-jp":
+		return "ja"
+	case "ko", "ko-kr":
+		return "ko"
+	case "de", "de-de":
+		return "de"
+	case "es", "es-es":
+		return "es"
+	case "fr", "fr-fr":
+		return "fr"
+	case "it", "it-it":
+		return "it"
+	case "pt", "pt-br", "pt-pt":
+		return "pt"
+	case "hi", "in", "hi-in":
+		return "hi"
+	case "ar", "ar-sa":
+		return "ar"
+	}
+	return ""
+}
+
+func NormalizeCodeOrDefault(value string, fallback string) string {
+	if code := NormalizeCode(value); code != "" {
+		return code
+	}
+	if code := NormalizeCode(fallback); code != "" {
+		return code
+	}
+	return DefaultCode
+}
+
+func IsShortCode(value string) bool {
+	code := strings.TrimSpace(value)
+	if code == "" || code != strings.ToLower(code) {
+		return false
+	}
+	_, ok := supportedCodeSet[code]
+	return ok
+}
+
+func NormalizeTextMap(input map[string]string) map[string]string {
+	if len(input) == 0 {
+		return map[string]string{}
+	}
+	result := make(map[string]string, len(input))
+	for key, value := range input {
+		code := NormalizeCode(key)
+		text := strings.TrimSpace(value)
+		if code == "" || text == "" {
+			continue
+		}
+		if _, exists := result[code]; exists {
+			continue
+		}
+		result[code] = text
+	}
+	return result
+}
+
+func NormalizeLocaleRootedMap[T any](input map[string]T) map[string]T {
+	if len(input) == 0 {
+		return map[string]T{}
+	}
+	result := make(map[string]T, len(input))
+	for key, value := range input {
+		code := NormalizeCode(key)
+		if code == "" {
+			continue
+		}
+		if _, exists := result[code]; exists {
+			continue
+		}
+		result[code] = value
+	}
+	return result
+}
+
+func NormalizeRawTextMap(raw json.RawMessage) (json.RawMessage, error) {
+	if len(raw) == 0 {
+		return json.RawMessage(`{}`), nil
+	}
+	var input map[string]string
+	if err := json.Unmarshal(raw, &input); err != nil {
+		return nil, err
+	}
+	normalized := NormalizeTextMap(input)
+	payload, err := json.Marshal(normalized)
+	if err != nil {
+		return nil, err
+	}
+	return payload, nil
+}

package/dist/resources/templates/go-backend/internal/common/locale/locale_test.go

@@ -0,0 +1,75 @@
+package locale
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func TestNormalizeCode(t *testing.T) {
+	cases := map[string]string{
+		"en-US": "en",
+		"zh-CN": "cn",
+		"zh-TW": "tw",
+		"zh-HK": "tw",
+		"ja-JP": "ja",
+		"jp":    "ja",
+		"hi-IN": "hi",
+		"in":    "hi",
+		"de":    "de",
+		"id-ID": "",
+		"bad-x": "",
+	}
+	for input, want := range cases {
+		if got := NormalizeCode(input); got != want {
+			t.Fatalf("NormalizeCode(%q) = %q, want %q", input, got, want)
+		}
+	}
+}
+
+func TestNormalizeTextMap(t *testing.T) {
+	got := NormalizeTextMap(map[string]string{
+		"en-US": "English",
+		"zh-CN": "中文",
+		"ja-JP": "日本語",
+		"hi-IN": "हिंदी",
+		"bad-x": "ignored",
+	})
+	want := map[string]string{
+		"en": "English",
+		"cn": "中文",
+		"ja": "日本語",
+		"hi": "हिंदी",
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("NormalizeTextMap() = %v, want %v", got, want)
+	}
+}
+
+func TestIsShortCode(t *testing.T) {
+	if !IsShortCode("cn") {
+		t.Fatal("IsShortCode(cn) = false, want true")
+	}
+	if IsShortCode("zh-CN") {
+		t.Fatal("IsShortCode(zh-CN) = true, want false")
+	}
+	if IsShortCode("jp") {
+		t.Fatal("IsShortCode(jp) = true, want false")
+	}
+	if IsShortCode("zz") {
+		t.Fatal("IsShortCode(zz) = true, want false")
+	}
+}
+
+func TestNormalizeLocaleRootedMap(t *testing.T) {
+	got := NormalizeLocaleRootedMap(map[string]json.RawMessage{
+		"en-US": json.RawMessage(`{"email":{}}`),
+		"zh-CN": json.RawMessage(`{"sms":{}}`),
+	})
+	if _, ok := got["en"]; !ok {
+		t.Fatalf("normalized map missing en: %v", got)
+	}
+	if _, ok := got["cn"]; !ok {
+		t.Fatalf("normalized map missing cn: %v", got)
+	}
+}

package/dist/resources/templates/go-backend/internal/common/mediaref/mediaref.go

@@ -0,0 +1,54 @@
+package mediaref
+
+import "strings"
+
+// NormalizeURL 去除媒体 URL 边界空白。
+func NormalizeURL(value string) string {
+	return strings.TrimSpace(value)
+}
+
+// NormalizeOptionalURL 去除可选媒体 URL 边界空白，空值归一为 nil。
+func NormalizeOptionalURL(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	trimmed := strings.TrimSpace(*value)
+	if trimmed == "" {
+		return nil
+	}
+	return &trimmed
+}
+
+// ApplyOptionalURLAsset 统一应用指针 URL 字段和资产引用字段。
+func ApplyOptionalURLAsset(currentURL **string, currentAssetID **int64, nextURL *string, nextAssetID *int64) {
+	if nextURL != nil {
+		normalizedURL := NormalizeOptionalURL(nextURL)
+		*currentURL = normalizedURL
+		if normalizedURL == nil || nextAssetID == nil {
+			*currentAssetID = nil
+		}
+	}
+	if nextAssetID != nil {
+		*currentAssetID = nextAssetID
+		if nextURL == nil {
+			*currentURL = nil
+		}
+	}
+}
+
+// ApplyStringURLAsset 统一应用字符串 URL 字段和资产引用字段。
+func ApplyStringURLAsset(currentURL *string, currentAssetID **int64, nextURL *string, nextAssetID *int64) {
+	if nextURL != nil {
+		normalizedURL := NormalizeURL(*nextURL)
+		*currentURL = normalizedURL
+		if normalizedURL == "" || nextAssetID == nil {
+			*currentAssetID = nil
+		}
+	}
+	if nextAssetID != nil {
+		*currentAssetID = nextAssetID
+		if nextURL == nil {
+			*currentURL = ""
+		}
+	}
+}

package/dist/resources/templates/go-backend/internal/common/mediaref/mediaref_test.go

@@ -0,0 +1,77 @@
+package mediaref
+
+import "testing"
+
+func TestApplyOptionalURLAssetStoresCacheWithAsset(t *testing.T) {
+	t.Parallel()
+
+	var currentURL *string
+	var currentAssetID *int64
+	nextURL := " https://cdn.example.com/cover.webp "
+	nextAssetID := int64(11)
+
+	ApplyOptionalURLAsset(&currentURL, &currentAssetID, &nextURL, &nextAssetID)
+
+	if currentURL == nil || *currentURL != "https://cdn.example.com/cover.webp" {
+		t.Fatalf("expected trimmed URL cache, got %v", currentURL)
+	}
+	if currentAssetID == nil || *currentAssetID != nextAssetID {
+		t.Fatalf("expected asset id %d, got %v", nextAssetID, currentAssetID)
+	}
+}
+
+func TestApplyOptionalURLAssetClearsStaleAssetForURLOnly(t *testing.T) {
+	t.Parallel()
+
+	currentURLValue := "https://cdn.example.com/old.webp"
+	currentURL := &currentURLValue
+	currentAssetIDValue := int64(10)
+	currentAssetID := &currentAssetIDValue
+	nextURL := "https://external.example.com/new.webp"
+
+	ApplyOptionalURLAsset(&currentURL, &currentAssetID, &nextURL, nil)
+
+	if currentURL == nil || *currentURL != nextURL {
+		t.Fatalf("expected URL-only cache, got %v", currentURL)
+	}
+	if currentAssetID != nil {
+		t.Fatalf("expected stale asset id to be cleared, got %v", *currentAssetID)
+	}
+}
+
+func TestApplyOptionalURLAssetClearsStaleURLForAssetOnly(t *testing.T) {
+	t.Parallel()
+
+	currentURLValue := "https://cdn.example.com/old.webp"
+	currentURL := &currentURLValue
+	currentAssetIDValue := int64(10)
+	currentAssetID := &currentAssetIDValue
+	nextAssetID := int64(12)
+
+	ApplyOptionalURLAsset(&currentURL, &currentAssetID, nil, &nextAssetID)
+
+	if currentURL != nil {
+		t.Fatalf("expected stale URL cache to be cleared, got %v", *currentURL)
+	}
+	if currentAssetID == nil || *currentAssetID != nextAssetID {
+		t.Fatalf("expected asset id %d, got %v", nextAssetID, currentAssetID)
+	}
+}
+
+func TestApplyStringURLAssetClearsStaleURLForAssetOnly(t *testing.T) {
+	t.Parallel()
+
+	currentURL := "https://cdn.example.com/old.webp"
+	currentAssetIDValue := int64(10)
+	currentAssetID := &currentAssetIDValue
+	nextAssetID := int64(12)
+
+	ApplyStringURLAsset(&currentURL, &currentAssetID, nil, &nextAssetID)
+
+	if currentURL != "" {
+		t.Fatalf("expected stale URL cache to be cleared, got %q", currentURL)
+	}
+	if currentAssetID == nil || *currentAssetID != nextAssetID {
+		t.Fatalf("expected asset id %d, got %v", nextAssetID, currentAssetID)
+	}
+}