with-composition

Code SHOULD Follow "Composition of Concerns"

Structure and compose files, folders, modules, classes, methods, and interactions using "Composition of Concerns" instead of "Seperation of Concerns", while continually balancing the need to remain DRY and maintaining simple abstractions with intuitive consumer interfaces.

Goal: Embrace composition over separation by grouping tightly related behavior and state into cohesive backend-friendly units. This guide highlights JavaScript/TypeScript-native idioms for building high-cohesion modules, without unnecessary indirection, especially suited for APIs, CLIs, workers, or services.

---

1. Encapsulated Service via Closure

Use when: You want private internal state and controlled method exposure without using class.

function createAuthService() {
  let token = null
  return {
    login(user, pass) {
      token = Buffer.from(`${user}:${pass}`).toString('base64')
    },
    isAuthenticated() {
      return !!token
    },
    getToken() {
      return token
    }
  }
}

---

2. Class with Private Fields

Use when: You need a stateful object with strict encapsulation and reusable methods.

class RateLimiter {
  #requests = new Map()

  check(ip) {
    const now = Date.now()
    const window = 60000
    const count = this.#requests.get(ip) || []
    const recent = count.filter(ts => now - ts < window)
    recent.push(now)
    this.#requests.set(ip, recent)
    return recent.length <= 100
  }
}

---

3. Closure-Based Module Pattern

Use when: You want composable singletons for CLI tools, daemons, or backend modules.

function createConfig() {
  let settings = {}
  return {
    load(path) {
      settings = JSON.parse(Deno.readTextFileSync(path))
    },
    get(key) {
      return settings[key]
    }
  }
}

---

4. Reducer-Driven Domain Handler

Use when: You want pure-function command handlers for domain logic.

function accountReducer(state, action) {
  switch (action.type) {
    case 'credit':
      return { ...state, balance: state.balance + action.amount }
    case 'debit':
      return { ...state, balance: state.balance - action.amount }
    default:
      return state
  }
}