Fiber Internet 1Gbps Bundle
  - Access Plan: 1Gbps
  - Router: Standard WiFi Router / WiFi 6 Router / Customer Owned Router
  - Static IP: None / 1 IP / 5 IP
  - Installation: Standard / Express
  - Contract Term: 12 months / 24 months
  - Add-on: Streaming Pack / Security Pack / Gaming Pack

WiFi 6 Router requires Contract Term >= 12 months.
Express Installation not available in remote area.
5 Static IP requires business customer.
Gaming Pack incompatible with Security Pack in legacy region.
Customer Owned Router requires waiver approval.

JAX-RS resource
QuoteService
PricingService
UI frontend
SQL query
Camunda worker
Integration adapter

valid / invalid / incomplete / requires approval / not eligible

product option selection
characteristic value validation
compatibility check
dependency check
eligibility check
defaulting
cardinality enforcement
configuration explanation
configuration snapshot generation

public record ConfigureProductCommand(
    TenantId tenantId,
    ProductOfferingId offeringId,
    CatalogVersion catalogVersion,
    CustomerContext customerContext,
    InstalledBaseContext installedBaseContext,
    List<ConfigurationSelection> selections,
    ConfigurationMode mode,
    RequestContext requestContext
) {}

public record ConfigurationResult(
    ConfigurationStatus status,
    ProductOfferingId offeringId,
    CatalogVersion catalogVersion,
    List<ResolvedSelection> selections,
    List<AvailableOption> availableOptions,
    List<ConfigurationIssue> issues,
    List<ConfigurationApprovalSignal> approvalSignals,
    ConfigurationExplanation explanation,
    ConfigurationHash configurationHash
) {}

VALID
INCOMPLETE
INVALID
REQUIRES_APPROVAL
NOT_ELIGIBLE
CATALOG_VERSION_NOT_FOUND

public final class ConfigurationModel {
    private final ProductOfferingId offeringId;
    private final CatalogVersion catalogVersion;
    private final Map<NodeId, ConfigNode> nodes;
    private final List<ConfigConstraint> constraints;
    private final List<DefaultRule> defaultRules;
    private final List<EligibilityRule> eligibilityRules;
}

public sealed interface ConfigNode permits ProductNode, OptionGroupNode, OptionNode, CharacteristicNode {
    NodeId id();
    String code();
    String label();
    NodeLifecycle lifecycle();
}

public record OptionGroupNode(
    NodeId id,
    String code,
    String label,
    Cardinality cardinality,
    List<NodeId> optionIds
) implements ConfigNode {}

public record Cardinality(int min, int max) {
    public boolean allows(int selectedCount) {
        return selectedCount >= min && selectedCount <= max;
    }
}

public record ConfigurationSelection(
    ConfigurationPath path,
    String value,
    SelectionSource source
) {}

USER
DEFAULT_RULE
SYSTEM
INSTALLED_BASE
MIGRATION

{
  "selections": [
    { "path": "Router", "value": "wifi6 router" },
    { "path": "contractTerm", "value": "12" }
  ]
}

{
  "selections": [
    { "path": "router", "value": "WIFI6_ROUTER" },
    { "path": "contract_term", "value": "TERM_12_MONTHS" }
  ]
}

public final class SelectionNormalizer {
    public NormalizedSelectionSet normalize(
        ConfigurationModel model,
        List<ConfigurationSelection> rawSelections
    ) {
        // 1. canonicalize path
        // 2. canonicalize value
        // 3. detect duplicate path
        // 4. detect unknown path/value
        // 5. preserve source
        throw new UnsupportedOperationException("implementation later");
    }
}

{
  "code": "UNKNOWN_CONFIGURATION_VALUE",
  "severity": "ERROR",
  "path": "router",
  "message": "Value 'wifi7-router' is not available for option group 'router'."
}

If customer segment = RESIDENTIAL and router not selected,
default router = STANDARD_ROUTER.

public record DefaultRule(
    RuleId id,
    int priority,
    PredicateExpression condition,
    ConfigurationPath targetPath,
    String defaultValue,
    boolean overridable
) {}

Rule A -> router = STANDARD_ROUTER
Rule B -> router = WIFI6_ROUTER

DEFAULT_RULE_CONFLICT

Express Installation eligible only if location.serviceable = true and region != REMOTE.
5 Static IP eligible only for BUSINESS customer.

public record CustomerContext(
    CustomerId customerId,
    CustomerSegment segment,
    AccountType accountType,
    LocationContext location,
    RiskClass riskClass,
    Map<String, String> attributes
) {}

public record EligibilityRule(
    RuleId id,
    NodeId targetNodeId,
    PredicateExpression condition,
    String failureCode,
    String failureMessage
) {}

EQ(field, value)
NE(field, value)
IN(field, values)
NOT_IN(field, values)
GTE(field, number)
LTE(field, number)
AND(...)
OR(...)
NOT(...)

Jika A dipilih, B harus ada.

WIFI6_ROUTER requires CONTRACT_TERM in {TERM_12_MONTHS, TERM_24_MONTHS}

public record DependencyConstraint(
    RuleId id,
    ConfigurationPath whenPath,
    String whenValue,
    ConfigurationPath requiredPath,
    Set<String> allowedRequiredValues,
    Severity severity
) implements ConfigConstraint {}

if (selectionSet.has(whenPath, whenValue)) {
    if (!selectionSet.hasAny(requiredPath, allowedRequiredValues)) {
        issues.add(ConfigurationIssue.error(
            "MISSING_REQUIRED_DEPENDENCY",
            requiredPath,
            "WIFI6_ROUTER requires contract term 12 or 24 months."
        ));
    }
}

A dan B tidak boleh dipilih bersamaan.

public record MutuallyExclusiveConstraint(
    RuleId id,
    ConfigurationPath leftPath,
    String leftValue,
    ConfigurationPath rightPath,
    String rightValue,
    Severity severity
) implements ConfigConstraint {}

if (selectionSet.has(leftPath, leftValue) && selectionSet.has(rightPath, rightValue)) {
    issues.add(ConfigurationIssue.error(
        "MUTUALLY_EXCLUSIVE_SELECTION",
        leftPath,
        "Gaming Pack cannot be combined with Security Pack."
    ));
}

Router: min 1, max 1
Add-ons: min 0, max 3
Static IP: min 1, max 1

int selected = selectionSet.countSelected(group.path());
if (!group.cardinality().allows(selected)) {
    issues.add(ConfigurationIssue.error(
        "CARDINALITY_VIOLATION",
        group.path(),
        "Option group 'router' requires exactly 1 selection."
    ));
}

contract_term_months in {12, 24, 36}
number_of_static_ip between 0 and 5
bandwidth_mbps in {100, 500, 1000}

public sealed interface ValueDomain permits EnumValueDomain, NumericRangeDomain, TextPatternDomain {}

public record EnumValueDomain(Set<String> allowedValues) implements ValueDomain {}
public record NumericRangeDomain(BigDecimal min, BigDecimal max, BigDecimal step) implements ValueDomain {}
public record TextPatternDomain(String regex) implements ValueDomain {}

Customer Owned Router requires technical waiver approval.
Contract term 36 months for residential customer requires sales manager approval.

public record ConfigurationApprovalSignal(
    String code,
    ApprovalPolicyCode policyCode,
    ConfigurationPath path,
    String selectedValue,
    String reason
) {}

if (selectionSet.has("router", "CUSTOMER_OWNED_ROUTER")) {
    approvalSignals.add(new ConfigurationApprovalSignal(
        "CUSTOMER_OWNED_ROUTER_WAIVER",
        new ApprovalPolicyCode("TECHNICAL_WAIVER"),
        ConfigurationPath.of("router"),
        "CUSTOMER_OWNED_ROUTER",
        "Customer owned router requires technical waiver approval."
    ));
}

VALID + approvalSignals not empty => REQUIRES_APPROVAL

Default router depends on customer segment.
Default contract term depends on router.
Eligibility of installation depends on location.
Available add-on depends on access plan and region.

public ConfigurationResult configure(ConfigureProductCommand command) {
    ConfigurationModel model = modelLoader.load(
        command.tenantId(),
        command.offeringId(),
        command.catalogVersion()
    );

    EvaluationState state = EvaluationState.from(command);

    for (int i = 0; i < MAX_PASSES; i++) {
        EvaluationState before = state.snapshot();

        state = normalizer.apply(model, state);
        state = installedBaseResolver.apply(model, state);
        state = defaultRuleEvaluator.apply(model, state);
        state = eligibilityEvaluator.apply(model, state);
        state = constraintEvaluator.apply(model, state);
        state = approvalSignalEvaluator.apply(model, state);

        if (state.semanticallyEquals(before)) {
            break;
        }

        if (i == MAX_PASSES - 1) {
            state.addIssue(ConfigurationIssue.error(
                "CONFIGURATION_EVALUATION_DID_NOT_CONVERGE",
                null,
                "Configuration evaluation did not converge. Check cyclic rules."
            ));
        }
    }

    return resultAssembler.assemble(model, state);
}

A requires B
B excludes A

Default A if B
Default B if A not selected

public final class RuleGraphValidator {
    public List<CatalogIssue> validate(ConfigurationModel model) {
        DirectedGraph<RuleNode> graph = buildRuleGraph(model);
        return graph.findCycles().stream()
            .map(cycle -> CatalogIssue.error(
                "CONFIGURATION_RULE_CYCLE",
                cycle.describe()
            ))
            .toList();
    }
}

{
  "path": "static_ip",
  "options": [
    {
      "value": "NO_STATIC_IP",
      "available": true
    },
    {
      "value": "ONE_STATIC_IP",
      "available": true
    },
    {
      "value": "FIVE_STATIC_IP",
      "available": false,
      "reasonCode": "BUSINESS_CUSTOMER_REQUIRED",
      "reason": "5 Static IP is only available for business customers."
    }
  ]
}

public record ConfigurationExplanation(
    List<ExplanationEntry> entries
) {}

public record ExplanationEntry(
    String ruleId,
    String ruleType,
    ConfigurationPath path,
    String selectedValue,
    ExplanationOutcome outcome,
    String message
) {}

{
  "ruleId": "RULE_STATIC_IP_BUSINESS_ONLY",
  "ruleType": "ELIGIBILITY",
  "path": "static_ip",
  "selectedValue": "FIVE_STATIC_IP",
  "outcome": "FAILED",
  "message": "5 Static IP requires customer segment BUSINESS. Current segment is RESIDENTIAL."
}

{
  "catalogVersion": "cat-2026-07-01",
  "offeringId": "fiber-1gbps-bundle",
  "selections": [
    { "path": "access_plan", "value": "FIBER_1GBPS" },
    { "path": "router", "value": "WIFI6_ROUTER" },
    { "path": "contract_term", "value": "TERM_12_MONTHS" }
  ]
}

{
  "schemaVersion": "configuration-snapshot.v1",
  "catalogVersion": "cat-2026-07-01",
  "offeringId": "fiber-1gbps-bundle",
  "status": "REQUIRES_APPROVAL",
  "configurationHash": "sha256:...",
  "selections": [
    {
      "path": "router",
      "value": "CUSTOMER_OWNED_ROUTER",
      "source": "USER"
    }
  ],
  "issues": [],
  "approvalSignals": [
    {
      "code": "CUSTOMER_OWNED_ROUTER_WAIVER",
      "policyCode": "TECHNICAL_WAIVER"
    }
  ]
}

CREATE TABLE product_configuration_session (
  id uuid PRIMARY KEY,
  tenant_id uuid NOT NULL,
  customer_id uuid,
  offering_id uuid NOT NULL,
  catalog_version text NOT NULL,
  status text NOT NULL,
  configuration_hash text,
  selections jsonb NOT NULL,
  issues jsonb NOT NULL,
  approval_signals jsonb NOT NULL,
  explanation jsonb,
  created_at timestamptz NOT NULL DEFAULT now(),
  updated_at timestamptz NOT NULL DEFAULT now(),
  created_by text NOT NULL,
  row_version bigint NOT NULL DEFAULT 0
);

CREATE INDEX idx_configuration_session_tenant_customer
ON product_configuration_session (tenant_id, customer_id, updated_at DESC);

CREATE TABLE quote_item_configuration_snapshot (
  quote_item_id uuid PRIMARY KEY,
  tenant_id uuid NOT NULL,
  catalog_version text NOT NULL,
  offering_id uuid NOT NULL,
  configuration_hash text NOT NULL,
  snapshot jsonb NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now()
);

public interface ProductConfigurationSessionMapper {
    ProductConfigurationSessionRow findById(
        @Param("tenantId") UUID tenantId,
        @Param("id") UUID id
    );

    int insert(ProductConfigurationSessionRow row);

    int updateResult(
        @Param("tenantId") UUID tenantId,
        @Param("id") UUID id,
        @Param("status") String status,
        @Param("configurationHash") String configurationHash,
        @Param("selections") String selectionsJson,
        @Param("issues") String issuesJson,
        @Param("approvalSignals") String approvalSignalsJson,
        @Param("explanation") String explanationJson,
        @Param("expectedRowVersion") long expectedRowVersion
    );
}

<update id="updateResult">
  UPDATE product_configuration_session
  SET status = #{status},
      configuration_hash = #{configurationHash},
      selections = #{selections}::jsonb,
      issues = #{issues}::jsonb,
      approval_signals = #{approvalSignals}::jsonb,
      explanation = #{explanation}::jsonb,
      updated_at = now(),
      row_version = row_version + 1
  WHERE tenant_id = #{tenantId}
    AND id = #{id}
    AND row_version = #{expectedRowVersion}
</update>

POST /api/v1/configurations/evaluate

{
  "offeringId": "fiber-1gbps-bundle",
  "catalogVersion": "cat-2026-07-01",
  "customerContext": {
    "customerId": "cust-123",
    "segment": "RESIDENTIAL",
    "location": {
      "region": "JAKARTA",
      "serviceable": true
    }
  },
  "selections": [
    { "path": "router", "value": "WIFI6_ROUTER" },
    { "path": "contract_term", "value": "TERM_12_MONTHS" }
  ]
}

{
  "status": "VALID",
  "catalogVersion": "cat-2026-07-01",
  "offeringId": "fiber-1gbps-bundle",
  "configurationHash": "sha256:abc123",
  "selections": [
    { "path": "router", "value": "WIFI6_ROUTER", "source": "USER" },
    { "path": "contract_term", "value": "TERM_12_MONTHS", "source": "USER" }
  ],
  "issues": [],
  "approvalSignals": [],
  "links": {
    "price": "/api/v1/prices/evaluate"
  }
}

configuration-domain/
  ConfigurationModel
  ConfigNode
  ConfigConstraint
  EvaluationState
  ConfigurationResult

configuration-application/
  ConfigureProductUseCase
  ConfigurationModelLoader
  ConfigurationResultAssembler

configuration-infrastructure/
  PostgreSqlConfigurationSessionRepository
  CatalogConfigurationModelRepository
  RedisConfigurationModelCache

configuration-api/
  ConfigurationResource
  ConfigurationRequestDto
  ConfigurationResponseDto

public final class ProductConfigurationEngine {
    private final SelectionNormalizer normalizer;
    private final InstalledBaseSelectionResolver installedBaseResolver;
    private final DefaultRuleEvaluator defaultRuleEvaluator;
    private final EligibilityEvaluator eligibilityEvaluator;
    private final ConstraintEvaluator constraintEvaluator;
    private final ApprovalSignalEvaluator approvalSignalEvaluator;
    private final AvailableOptionCalculator availableOptionCalculator;
    private final ConfigurationExplanationBuilder explanationBuilder;
    private final ConfigurationHashCalculator hashCalculator;

    public ConfigurationResult evaluate(
        ConfigurationModel model,
        ConfigureProductCommand command
    ) {
        EvaluationState state = EvaluationState.initial(command);

        state = normalizer.evaluate(model, state);
        state = installedBaseResolver.evaluate(model, state);
        state = defaultRuleEvaluator.evaluate(model, state);
        state = eligibilityEvaluator.evaluate(model, state);
        state = constraintEvaluator.evaluate(model, state);
        state = approvalSignalEvaluator.evaluate(model, state);

        List<AvailableOption> availableOptions =
            availableOptionCalculator.calculate(model, state);

        ConfigurationExplanation explanation =
            explanationBuilder.build(model, state);

        ConfigurationHash hash =
            hashCalculator.calculate(model, state.resolvedSelections());

        return ConfigurationResultAssembler.assemble(
            model,
            state,
            availableOptions,
            explanation,
            hash
        );
    }
}

public interface ConfigurationModelRepository {
    ConfigurationModel load(
        TenantId tenantId,
        ProductOfferingId offeringId,
        CatalogVersion catalogVersion
    );
}

config-model:v1:{tenantId}:{catalogVersion}:{offeringId}

cache compiled configuration model
cache allowed option result for anonymous context if safe
cache reference data by version

store final quote configuration only in Redis
store approval decision only in Redis
store installed base truth in Redis
mutate catalog model in Redis

catalog config model: long TTL + versioned key
session result: short TTL optional
customer-context-sensitive result: careful; often not cacheable globally

ConfigurationEvaluated
ConfigurationBecameInvalid
ConfigurationRequiresApproval
QuoteItemConfigurationSnapshotCreated

Publish durable event only when state matters to the business or another service.

configuration result VALID/REQUIRES_APPROVAL
  -> pricing engine resolves charges for resolved selections
  -> pricing result references configurationHash

public record PriceEvaluationCommand(
    TenantId tenantId,
    ProductOfferingId offeringId,
    CatalogVersion catalogVersion,
    ConfigurationHash configurationHash,
    List<ResolvedSelection> selections,
    CustomerContext customerContext
) {}

create quote revision
copy previous quote item
apply new configuration
reprice
rerun approval if needed

router = WIFI6_ROUTER
installation = EXPRESS
static_ip = ONE_STATIC_IP

Reserve Fiber Access
Ship WiFi 6 Router
Schedule Express Installation
Allocate Static IP
Activate Service

Quote item configuration status must be VALID or APPROVED_REQUIRES_APPROVAL_RESOLVED.

Fiber Internet 500Mbps
Standard Router
No Static IP
12 months contract

existing asset selections
requested modifications
catalog rules for target offering/action

INSTALLED_BASE
USER
SYSTEM

For MODIFY bandwidth upgrade, router can remain unchanged if compatible.
For DISCONNECT, installation option is not required.
For ADD static IP, business customer rule applies.

RequiredRuleEvaluatorTest
CardinalityEvaluatorTest
MutuallyExclusiveEvaluatorTest
DependencyEvaluatorTest
EligibilityEvaluatorTest
DefaultRuleEvaluatorTest
ApprovalSignalEvaluatorTest

residential_customer_selects_wifi6_router_with_12_month_term_is_valid
residential_customer_selects_5_static_ip_is_not_eligible
business_customer_selects_5_static_ip_is_valid
customer_owned_router_requires_approval
security_pack_and_gaming_pack_is_invalid
missing_router_is_incomplete

same input -> same configurationHash
selection order changed -> same configurationHash
catalog version changed -> different configurationHash

cycle detection
unknown target path
rule references retired option
default conflict
cardinality impossible
eligibility expression invalid

load catalog from PostgreSQL via MyBatis
cache model in Redis
save configuration session
save quote item snapshot
publish outbox event

load compiled model
normalize selections
evaluate rules
compute available options
return result

{
  "offeringId": "fiber-1gbps-bundle",
  "catalogVersion": "cat-2026-07-01",
  "customerContext": {
    "segment": "RESIDENTIAL",
    "location": {
      "region": "JAKARTA",
      "serviceable": true
    }
  },
  "selections": [
    { "path": "router", "value": "WIFI6_ROUTER" },
    { "path": "static_ip", "value": "FIVE_STATIC_IP" },
    { "path": "contract_term", "value": "TERM_12_MONTHS" }
  ]
}

WIFI6_ROUTER requires TERM_12_MONTHS or TERM_24_MONTHS.
FIVE_STATIC_IP requires segment BUSINESS.
Router exactly one required.

{
  "status": "INVALID",
  "issues": [
    {
      "code": "NOT_ELIGIBLE",
      "path": "static_ip",
      "selectedValue": "FIVE_STATIC_IP",
      "message": "5 Static IP is only available for business customers."
    }
  ],
  "approvalSignals": [],
  "configurationHash": "sha256:..."
}