fix: wire account type cache and register product types in seed-demo (#1272)

* fix: wire account type cache and register product types in seed-demo

Three interrelated issues prevented seed-demo from creating internal
accounts with product types on demo:

1. AccountTypeRegistryService was listed in gateway service names but
   never registered on the gRPC server. Wire it in wireReferenceData.

2. Internal account service had no account type cache (nil), causing
   FailedPrecondition when ProductTypeCode is provided. Wire
   LocalAccountTypeCache using the registry as loader.

3. seed-demo didn't register product type definitions before creating
   accounts. Add Step 2.5 to create and activate INVENTORY_KWH and
   ENERGY_TRADING product types via AccountTypeRegistryService.

Also regenerate descriptor.binpb to fix stale proto descriptors that
caused the HTTP transcoder to incorrectly map fields like
instrument_code for newer proto definitions.

* fix: remove dead AlreadyExists guard from seed-demo CreateDraft

CreateDraft uses ON CONFLICT (code, version) DO NOTHING at the DB layer
and returns the existing draft on conflict — it never returns
AlreadyExists. Remove the misleading error handler that could mask
legitimate errors.

* fix: handle activation race conditions in seed-demo product types

Treat AlreadyExists and FailedPrecondition from ActivateAccountType as
non-fatal, so concurrent or repeated seed runs don't fail when the
product type was already activated by another process.

---------

Co-authored-by: Ben Coombs <bjcoombs@users.noreply.github.com>

Author: bjcoombs

cmd/meridian/descriptor.binpb

@@ -75,6 +75,8 @@ import (
 	positionkeepingservice "github.com/meridianhub/meridian/services/position-keeping/service"
 	reconciliationpersistence "github.com/meridianhub/meridian/services/reconciliation/adapters/persistence"
 	reconciliationservice "github.com/meridianhub/meridian/services/reconciliation/service"
+	"github.com/meridianhub/meridian/services/reference-data/accounttype"
+	refcache "github.com/meridianhub/meridian/services/reference-data/cache"
 	refcel "github.com/meridianhub/meridian/services/reference-data/cel"
 	refhandler "github.com/meridianhub/meridian/services/reference-data/handler"
 	refnode "github.com/meridianhub/meridian/services/reference-data/node"
@@ -334,17 +336,24 @@ func registerServices(
 	tracer *observability.Tracer,
 	logger *slog.Logger,
 ) error {
+	// refDataComps is populated by wireReferenceData and used by wireInternalAccount for the account type cache.
+	var refDataComps *refDataComponents
+
 	// Tier 0: No gRPC dependencies
 	for _, wire := range []struct {
 		name string
 		fn   func() error
 	}{
 		{"party", func() error { return wireParty(grpcServer, conns.gormDB("party"), logger) }},
-		{"reference-data", func() error { return wireReferenceData(grpcServer, conns.pgxPool("reference-data"), logger) }},
+		{"reference-data", func() error {
+			var err error
+			refDataComps, err = wireReferenceData(grpcServer, conns.pgxPool("reference-data"), logger)
+			return err
+		}},
 		{"market-information", func() error { return wireMarketInformation(grpcServer, conns.pgxPool("market-information"), logger) }},
 		{"tenant", func() error { return wireTenant(grpcServer, conns.gormDB("tenant"), logger) }},
 		{"internal-account", func() error {
-			return wireInternalAccount(grpcServer, conns.gormDB("internal-account"), logger)
+			return wireInternalAccount(grpcServer, conns.gormDB("internal-account"), refDataComps, logger)
 		}},
 		{"control-plane", func() error { return wireControlPlane(grpcServer, conns.pgxPool("control-plane"), logger) }},
 		{"audit", func() error { return wireAudit(grpcServer, conns.gormDB("tenant"), logger) }}, // audit uses platform DB
@@ -419,36 +428,58 @@ func wireParty(server *grpc.Server, db *gorm.DB, logger *slog.Logger) error {
 	return nil
 }
 
-func wireReferenceData(server *grpc.Server, pool *pgxpool.Pool, logger *slog.Logger) error {
+// refDataComponents holds objects created during wireReferenceData that other
+// services need (e.g., the account type cache loader for internal-account).
+type refDataComponents struct {
+	accountTypeRegistry *accounttype.PostgresRegistry
+	celCompiler         *refcel.Compiler
+}
+
+func wireReferenceData(server *grpc.Server, pool *pgxpool.Pool, logger *slog.Logger) (*refDataComponents, error) {
 	instrumentRegistry, err := refregistry.NewPostgresRegistry(pool)
 	if err != nil {
-		return fmt.Errorf("instrument registry: %w", err)
+		return nil, fmt.Errorf("instrument registry: %w", err)
 	}
 
 	compiler, err := refcel.NewCompiler()
 	if err != nil {
-		return fmt.Errorf("CEL compiler: %w", err)
+		return nil, fmt.Errorf("CEL compiler: %w", err)
 	}
 
 	refDataSvc, err := refhandler.NewService(instrumentRegistry, compiler, logger)
 	if err != nil {
-		return fmt.Errorf("ref data service: %w", err)
+		return nil, fmt.Errorf("ref data service: %w", err)
 	}
 
 	nodeRepo := refnode.NewPostgresRepository(pool)
 	nodeSvc, err := refhandler.NewNodeService(nodeRepo, logger)
 	if err != nil {
-		return fmt.Errorf("node service: %w", err)
+		return nil, fmt.Errorf("node service: %w", err)
 	}
 
 	sagaRegistry := refsaga.NewPostgresRegistry(pool, nil)
 	sagaSvc := refsaga.NewRegistryHandler(sagaRegistry, nil, nil, logger)
 
+	// Account type registry and gRPC service
+	acctTypeReg, err := accounttype.NewPostgresRegistry(pool)
+	if err != nil {
+		return nil, fmt.Errorf("account type registry: %w", err)
+	}
+
+	acctTypeSvc, err := refhandler.NewAccountTypeService(acctTypeReg, instrumentRegistry, compiler, logger)
+	if err != nil {
+		return nil, fmt.Errorf("account type service: %w", err)
+	}
+
 	referencedatav1.RegisterReferenceDataServiceServer(server, refDataSvc)
 	referencedatav1.RegisterNodeServiceServer(server, nodeSvc)
+	referencedatav1.RegisterAccountTypeRegistryServiceServer(server, acctTypeSvc)
 	sagav1.RegisterSagaRegistryServiceServer(server, sagaSvc)
 	logger.Info("registered reference-data service")
-	return nil
+	return &refDataComponents{
+		accountTypeRegistry: acctTypeReg,
+		celCompiler:         compiler,
+	}, nil
 }
 
 func wireMarketInformation(server *grpc.Server, pool *pgxpool.Pool, logger *slog.Logger) error {
@@ -478,9 +509,32 @@ func wireTenant(server *grpc.Server, db *gorm.DB, logger *slog.Logger) error {
 	return nil
 }
 
-func wireInternalAccount(server *grpc.Server, db *gorm.DB, logger *slog.Logger) error {
+// registryAccountTypeLoader adapts accounttype.PostgresRegistry to cache.AccountTypeLoader.
+type registryAccountTypeLoader struct {
+	registry *accounttype.PostgresRegistry
+}
+
+func (l *registryAccountTypeLoader) LoadAccountType(ctx context.Context, code string) (*accounttype.Definition, error) {
+	return l.registry.GetActiveDefinition(ctx, code)
+}
+
+func (l *registryAccountTypeLoader) ListActiveAccountTypes(ctx context.Context) ([]*accounttype.Definition, error) {
+	return l.registry.ListActive(ctx)
+}
+
+func wireInternalAccount(server *grpc.Server, db *gorm.DB, refData *refDataComponents, logger *slog.Logger) error {
 	repo := internalaccountpersistence.NewRepository(db)
-	svc, err := internalaccountservice.NewService(repo)
+
+	var opts []internalaccountservice.Option
+
+	// Wire account type cache if reference-data components are available
+	if refData != nil {
+		loader := &registryAccountTypeLoader{registry: refData.accountTypeRegistry}
+		cache := refcache.NewLocalAccountTypeCache(loader, refData.celCompiler)
+		opts = append(opts, internalaccountservice.WithAccountTypeCache(cache))
+	}
+
+	svc, err := internalaccountservice.NewServiceFull(repo, nil, nil, logger, nil, opts...)
 	if err != nil {
 		return err
 	}

cmd/meridian/main.go

@@ -38,6 +38,7 @@ import (
 	internalaccountv1 "github.com/meridianhub/meridian/api/proto/meridian/internal_account/v1"
 	marketv1 "github.com/meridianhub/meridian/api/proto/meridian/market_information/v1"
 	partyv1 "github.com/meridianhub/meridian/api/proto/meridian/party/v1"
+	referencedatav1 "github.com/meridianhub/meridian/api/proto/meridian/reference_data/v1"
 	tenantv1 "github.com/meridianhub/meridian/api/proto/meridian/tenant/v1"
 	"github.com/meridianhub/meridian/shared/platform/await"
 	"google.golang.org/genproto/googleapis/type/money"
@@ -126,6 +127,12 @@ func run() error {
 	// Tenant-scoped context for all subsequent calls
 	tCtx := withTenant(ctx)
 
+	// 4.5 Register product types (account type definitions)
+	fmt.Println("\n=== Step 2.5: Register Product Types ===")
+	if err := registerProductTypes(tCtx, conn); err != nil {
+		return fmt.Errorf("register product types: %w", err)
+	}
+
 	// 5. Register parties
 	fmt.Println("\n=== Step 3: Register Parties ===")
 	dnoPartyID, gspPartyIDs, customerPartyIDs, err := registerParties(tCtx, conn)
@@ -228,6 +235,94 @@ func applyManifest(ctx context.Context, conn *grpc.ClientConn) error {
 	return nil
 }
 
+// ─── Product Type Registration ───────────────────────────────────────────────
+
+// productTypeDef defines a product type to register.
+type productTypeDef struct {
+	code           string
+	displayName    string
+	description    string
+	normalBalance  referencedatav1.NormalBalance
+	behaviorClass  referencedatav1.BehaviorClass
+	instrumentCode string
+	validationCEL  string
+}
+
+var productTypes = []productTypeDef{
+	{
+		code:           "INVENTORY_KWH",
+		displayName:    "KWH Inventory Account",
+		description:    "Inventory account for tracking kilowatt-hour energy assets at grid supply points",
+		normalBalance:  referencedatav1.NormalBalance_NORMAL_BALANCE_DEBIT,
+		behaviorClass:  referencedatav1.BehaviorClass_BEHAVIOR_CLASS_INVENTORY,
+		instrumentCode: "KWH",
+		validationCEL:  "amount > 0",
+	},
+	{
+		code:           "ENERGY_TRADING",
+		displayName:    "Energy Trading Account",
+		description:    "Customer-facing account for energy trading in GBP and KWH",
+		normalBalance:  referencedatav1.NormalBalance_NORMAL_BALANCE_DEBIT,
+		behaviorClass:  referencedatav1.BehaviorClass_BEHAVIOR_CLASS_CUSTOMER,
+		instrumentCode: "GBP",
+		validationCEL:  "amount > 0",
+	},
+}
+
+// registerProductTypes creates and activates account type definitions via the
+// AccountTypeRegistryService. Each product type is created as a DRAFT then activated.
+// Idempotent: skips types that already exist.
+func registerProductTypes(ctx context.Context, conn *grpc.ClientConn) error {
+	client := referencedatav1.NewAccountTypeRegistryServiceClient(conn)
+
+	for _, pt := range productTypes {
+		// Check if already active
+		_, err := client.GetActiveDefinition(ctx, &referencedatav1.GetActiveDefinitionRequest{
+			Code: pt.code,
+		})
+		if err == nil {
+			fmt.Printf("  Product type: %s (already active)\n", pt.code)
+			continue
+		}
+		if st, ok := status.FromError(err); !ok || st.Code() != codes.NotFound {
+			return fmt.Errorf("check product type %s: %w", pt.code, err)
+		}
+
+		// Create draft (idempotent: ON CONFLICT returns existing draft)
+		draftResp, err := client.CreateDraft(ctx, &referencedatav1.CreateDraftRequest{
+			Code:           pt.code,
+			DisplayName:    pt.displayName,
+			Description:    pt.description,
+			NormalBalance:  pt.normalBalance,
+			BehaviorClass:  pt.behaviorClass,
+			InstrumentCode: pt.instrumentCode,
+			ValidationCel:  pt.validationCEL,
+		})
+		if err != nil {
+			return fmt.Errorf("create draft %s: %w", pt.code, err)
+		}
+
+		// Activate using the ID from the draft response
+		defID := draftResp.GetDefinition().GetId()
+		fmt.Printf("  Product type: %s (draft id=%s, activating...)\n", pt.code, defID)
+
+		_, err = client.ActivateAccountType(ctx, &referencedatav1.ActivateAccountTypeRequest{
+			Id: defID,
+		})
+		if err != nil {
+			if st, ok := status.FromError(err); ok &&
+				(st.Code() == codes.AlreadyExists || st.Code() == codes.FailedPrecondition) {
+				fmt.Printf("  Product type: %s (already active)\n", pt.code)
+				continue
+			}
+			return fmt.Errorf("activate %s (id=%s): %w", pt.code, defID, err)
+		}
+		fmt.Printf("  Product type: %s (activated)\n", pt.code)
+	}
+
+	return nil
+}
+
 // ─── Party Registration ──────────────────────────────────────────────────────
 
 type gspInfo struct {

cmd/seed-demo/main.go

@@ -44,6 +44,15 @@
         "validation": "amount > 0"
       }
     },
+    {
+      "code": "INVENTORY_KWH",
+      "name": "KWH Inventory Account",
+      "normalBalance": "NORMAL_BALANCE_DEBIT",
+      "allowedInstruments": ["KWH"],
+      "policies": {
+        "validation": "amount > 0"
+      }
+    },
     {
       "code": "CARBON_INVENTORY",
       "name": "Carbon Credit Inventory",