Decision Tables in TypeScript: An Underrated Pattern for Cleaner Code

When building complex software systems, developers often resort to lengthy if-else or switch statements to handle decision-making logic.

While these approaches can work, they quickly become unmanageable as the number of conditions grows. This is where decision tables come in.

A powerful yet underused pattern that simplifies complex decision-making in a clean, maintainable fashion.

In this article, we'll explore what decision tables are, why you should use them, and how to implement them in TypeScript to handle complex logic with ease.

What is a decision table?

A decision table is a structured way to map various combinations of input conditions to corresponding actions or outcomes. Think of it as a table where each row represents a unique combination of input variables, and the corresponding column defines the output or action. This allows you to visualize all possible scenarios in one place, making it easier to manage and understand.

For example, let's say you're building an e-commerce platform and need to send different email templates to users based on their customer status, purchase history, available promotions, and preferred language.

With 3 boolean variables (isGoldCustomer, isFirstPurchase, isPromoAvailable) and one enum variable (emailLanguage), there are 24 possible combinations to handle.

But instead of writing 24 if-else or switch cases, a decision table provides a cleaner solution.

Why Use Decision Tables?

Decision tables offer several advantages over traditional conditional logic:

• Improved Readability: A single table captures all possible combinations, making it easier to understand at a glance.
• Easier Maintenance: Modifying logic becomes as simple as updating a single row in the table rather than combing through lines of nested conditions.
• Scalability: Decision tables can handle more complex decision-making scenarios without becoming unmanageable.

Let's dive into how to implement a decision table in TypeScript.

How to implement a decision table in TypeScript

The easiest way to implement a decision table in TypeScript is to use an array of objects. Each object represents a row in the decision table.
Then you can use the array's find method to find the row that matches the input variables and return the corresponding output value.

type TEmailLanguage = 'en' | 'es' | 'fr';

interface IDecisionTableRow {
  //These are the input values that determine the output value
  isGoldCustomer: boolean;
  isFirstPurchase: boolean;
  isPromoAvailable: boolean;
  emailLanguage: TEmailLanguage;

  // The last property is the output value
  template: string;
};

const DECISION_TABLE: IDecisionTableRow[] = [
  {
    isGoldCustomer: true,
    isFirstPurchase: true,
    isPromoAvailable: true,
    emailLanguage: 'en',
    template: 'welcome_en.html',
  },
  {
    isGoldCustomer: true,
    isFirstPurchase: true,
    isPromoAvailable: true,
    emailLanguage: 'es',
    template: 'welcome_es.html',
  },
  {
    isGoldCustomer: true,
    isFirstPurchase: true,
    isPromoAvailable: true,
    emailLanguage: 'fr',
    template: 'welcome_fr.html',
  },
  // more rows...
];

const getTemplate = (
  isGoldCustomer: boolean,
  isFirstPurchase: boolean,
  isPromoAvailable: boolean,
  emailLanguage: EmailLanguage
): string => {
  const row = decisionTable.find(
    (row) =>
      row.emailLanguage === emailLanguage &&
      row.isGoldCustomer === isGoldCustomer &&
      row.isFirstPurchase === isFirstPurchase &&
      row.isPromoAvailable === isPromoAvailable 
  );

  if (!row) {
    throw new Error('No matching row in decision table');
  }

  return row.template;
};

In this example, we have an array of objects called DECISION_TABLE that represents the decision table.
Each object has 4 properties that represent the input variables and 1 property that represents the output value.

The getTemplate function takes the input variables as arguments and uses the find method to find the row in the decision table that matches the input variables.

If no row is found, the function throws an error.

And that's it! You now have a clean, maintainable way to handle complex logic that depends on multiple input variables.

Additional Considerations

• Rule Prioritization: If multiple rules match the input conditions, you may need to define a priority mechanism to determine the correct output.
• Default Values: Consider providing a default output in case no matching rule is found.
• Data Validation: Implement validation to ensure that input values are valid and within expected ranges.

Conclusion

Decision tables offer a powerful and effective approach to managing complex decision-making logic in TypeScript. By providing a clear and structured representation of rules, they enhance code readability, maintainability, and scalability. By adopting decision tables in your projects, you can improve the overall quality and efficiency of your codebase.

So next time you find yourself writing a bunch of if-else statements or switch statements to handle a complex logic, consider using a decision table instead.

Happy coding!