Упражнения: нарисуй гексагон для своего проекта

1. Зоны:

   • A — Это «антипаттерн-монолит»: содержит бизнес-логику (валидация), инфраструктуру (SQL) и не имеет чёткой зоны. Формально это адаптер с утечкой бизнес-логики.
   • B — Domain (Value Objects). Чистые типы с бизнес-правилами, зависят только от effect.
   • C — Port (Driven Port). Контракт хранилища, определённый через Context.Tag.
   • D — Driving Adapter. HTTP-роутер, знает о HTTP, вызывает Use Case.
   • E — Application (Use Case). Оркестрирует домен и порты, не содержит бизнес-логику.

2. Нарушения во фрагменте A:

   • Прямой import { Database } from "bun:sqlite" — зависимость от конкретной БД
   • Бизнес-правила (title.length === 0, priority < 1 || priority > 5) смешаны с инфраструктурным кодом (db.run)
   • Нет типизированных ошибок — throw new Error вместо доменных ошибок
   • Нет разделения на слои — все три зоны в одной функции

3. Фрагмент B — домен, а не порт, потому что:

   • TodoTitle и Priority — это Value Objects с бизнес-правилами (минимальная длина, диапазон приоритета)
   • Они не описывают взаимодействие с внешним миром — они описывают что такое заголовок и приоритет
   • Порт описывает операции (save, find), а Value Object описывает данные (что такое корректный заголовок)

4. Без Effect.provide:

   • TypeScript выдаст ошибку компиляции: Type 'Effect<Todo, ..., TodoRepository | Clock | IdGenerator>' is not assignable to type 'Effect<Todo, ..., never>'
   • R-канал содержит TodoRepository | Clock | IdGenerator — это незакрытые зависимости
   • Код не скомпилируется, пока все зависимости не будут предоставлены через Effect.provide

import { Context, Effect, Option } from "effect"

// === DRIVEN PORTS ===

// Порт 1: Хранение задач
class TodoRepository extends Context.Tag("TodoRepository")<
  TodoRepository,
  {
    readonly findById: (
      id: TodoId
    ) => Effect.Effect<Todo, TodoNotFound>
    
    readonly save: (
      todo: Todo
    ) => Effect.Effect<void, RepositoryError>
    
    readonly findAll: (
      filter: TodoFilter
    ) => Effect.Effect<ReadonlyArray<Todo>>
    
    readonly delete: (
      id: TodoId
    ) => Effect.Effect<void, TodoNotFound>
    
    readonly existsByTitle: (
      title: TodoTitle
    ) => Effect.Effect<boolean>
  }
>() {}

// Порт 2: Отправка уведомлений
class NotificationService extends Context.Tag("NotificationService")<
  NotificationService,
  {
    readonly send: (
      notification: Notification
    ) => Effect.Effect<void, NotificationError>
  }
>() {}

// Порт 3: Генерация уникальных идентификаторов
class IdGenerator extends Context.Tag("IdGenerator")<
  IdGenerator,
  {
    readonly generate: () => Effect.Effect<TodoId>
  }
>() {}

// Порт 4: Текущее время
class Clock extends Context.Tag("Clock")<
  Clock,
  {
    readonly now: () => Effect.Effect<Date>
  }
>() {}

// Порт 5: Журнал аудита
class AuditLog extends Context.Tag("AuditLog")<
  AuditLog,
  {
    readonly record: (
      entry: AuditEntry
    ) => Effect.Effect<void, AuditError>
  }
>() {}

// === ВСПОМОГАТЕЛЬНЫЕ ДОМЕННЫЕ ТИПЫ ===

interface TodoFilter {
  readonly status?: TodoStatus
  readonly priority?: Priority
}

interface Notification {
  readonly type: "high_priority_created"
  readonly todoId: TodoId
  readonly title: TodoTitle
  readonly priority: Priority
}

interface AuditEntry {
  readonly action: "created" | "completed" | "deleted"
  readonly todoId: TodoId
  readonly timestamp: Date
  readonly details: string
}

Обратите внимание:

• Все типы в портах — доменные (TodoId, Todo, TodoTitle), не инфраструктурные
• Каждый порт имеет типизированные ошибки в E-канале
• TodoFilter, Notification, AuditEntry — доменные типы, не HTTP или SQL

// ============================================
// 1. DOMAIN — domain/todo.ts
// ============================================
import { Schema, Data, Effect, Option } from "effect"

// Value Objects
class TodoId extends Schema.TaggedClass<TodoId>()("TodoId", {
  value: Schema.UUID,
}) {}

class TodoTitle extends Schema.TaggedClass<TodoTitle>()("TodoTitle", {
  value: Schema.String.pipe(
    Schema.trimmed(),
    Schema.minLength(1, { message: () => "Title is required" }),
    Schema.maxLength(200, { message: () => "Title too long" }),
  ),
}) {}

type TodoStatus = "active" | "completed"

// Entity
class Todo extends Schema.TaggedClass<Todo>()("Todo", {
  id: TodoId,
  title: TodoTitle,
  status: Schema.Literal("active", "completed"),
  createdAt: Schema.Date,
}) {
  complete(): Effect.Effect<Todo, InvalidTransition> {
    if (this.status === "completed") {
      return Effect.fail(new InvalidTransition({
        from: "completed",
        to: "completed",
        reason: "Todo already completed",
      }))
    }
    return Effect.succeed(new Todo({ ...this, status: "completed" }))
  }
}

// Domain Errors
class TodoNotFound extends Data.TaggedError("TodoNotFound")<{
  readonly id: TodoId
}> {}

class InvalidTransition extends Data.TaggedError("InvalidTransition")<{
  readonly from: TodoStatus
  readonly to: TodoStatus
  readonly reason: string
}> {}

class DuplicateTitle extends Data.TaggedError("DuplicateTitle")<{
  readonly title: TodoTitle
}> {}

class ValidationError extends Data.TaggedError("ValidationError")<{
  readonly message: string
}> {}

class RepositoryError extends Data.TaggedError("RepositoryError")<{
  readonly operation: string
  readonly cause: unknown
}> {}

// ============================================
// 2. PORTS — ports/index.ts
// ============================================
import { Context, Effect } from "effect"

class TodoRepository extends Context.Tag("TodoRepository")<
  TodoRepository,
  {
    readonly findById: (id: TodoId) => Effect.Effect<Todo, TodoNotFound>
    readonly save: (todo: Todo) => Effect.Effect<void, RepositoryError>
    readonly findAll: (filter: { readonly onlyActive: boolean }) => Effect.Effect<ReadonlyArray<Todo>>
    readonly existsByTitle: (title: TodoTitle) => Effect.Effect<boolean>
  }
>() {}

class Clock extends Context.Tag("Clock")<
  Clock,
  { readonly now: () => Effect.Effect<Date> }
>() {}

class IdGenerator extends Context.Tag("IdGenerator")<
  IdGenerator,
  { readonly generate: () => Effect.Effect<TodoId> }
>() {}

// ============================================
// 3. APPLICATION — application/use-cases.ts
// ============================================
import { Effect, Schema } from "effect"

// Use Case: createTodo
const createTodo = (input: {
  readonly title: string
}): Effect.Effect<
  Todo,
  ValidationError | DuplicateTitle | RepositoryError,
  TodoRepository | Clock | IdGenerator
> =>
  Effect.gen(function* () {
    const repo = yield* TodoRepository
    const clock = yield* Clock
    const idGen = yield* IdGenerator

    // Валидация через доменный тип
    const title = yield* Schema.decode(TodoTitle)({ value: input.title }).pipe(
      Effect.mapError((e) => new ValidationError({ message: String(e) }))
    )

    // Бизнес-правило: уникальность
    const exists = yield* repo.existsByTitle(title)
    if (exists) yield* Effect.fail(new DuplicateTitle({ title }))

    // Создание Entity
    const todo = new Todo({
      id: yield* idGen.generate(),
      title,
      status: "active",
      createdAt: yield* clock.now(),
    })

    yield* repo.save(todo)
    return todo
  })

// Use Case: completeTodo
const completeTodo = (
  todoId: TodoId
): Effect.Effect<
  Todo,
  TodoNotFound | InvalidTransition | RepositoryError,
  TodoRepository
> =>
  Effect.gen(function* () {
    const repo = yield* TodoRepository
    const todo = yield* repo.findById(todoId)
    const completed = yield* todo.complete()
    yield* repo.save(completed)
    return completed
  })

// Use Case: listTodos
const listTodos = (filter: {
  readonly onlyActive: boolean
}): Effect.Effect<ReadonlyArray<Todo>, never, TodoRepository> =>
  Effect.gen(function* () {
    const repo = yield* TodoRepository
    return yield* repo.findAll(filter)
  })

// ============================================
// 4. ADAPTER — adapters/sqlite/todo-repository.ts
// ============================================
import { Layer, Effect } from "effect"

class SqliteClient extends Context.Tag("SqliteClient")<
  SqliteClient,
  { readonly db: Database }
>() {}

interface TodoRow {
  readonly id: string
  readonly title: string
  readonly completed: number
  readonly created_at: string
}

const rowToTodo = (row: TodoRow): Effect.Effect<Todo, RepositoryError> =>
  Schema.decode(Todo)({
    id: { value: row.id },
    title: { value: row.title },
    status: row.completed === 1 ? "completed" as const : "active" as const,
    createdAt: new Date(row.created_at),
  }).pipe(
    Effect.mapError((e) => new RepositoryError({ operation: "decode", cause: e }))
  )

const SqliteTodoRepository = Layer.effect(
  TodoRepository,
  Effect.gen(function* () {
    const { db } = yield* SqliteClient

    return {
      findById: (id) =>
        Effect.gen(function* () {
          const row = db.query("SELECT * FROM todos WHERE id = ?")
            .get(id.value) as TodoRow | null
          if (!row) return yield* Effect.fail(new TodoNotFound({ id }))
          return yield* rowToTodo(row)
        }),

      save: (todo) =>
        Effect.try({
          try: () => {
            db.run(
              "INSERT OR REPLACE INTO todos (id, title, completed, created_at) VALUES (?, ?, ?, ?)",
              [todo.id.value, todo.title.value, todo.status === "completed" ? 1 : 0, todo.createdAt.toISOString()]
            )
          },
          catch: (e) => new RepositoryError({ operation: "save", cause: e }),
        }),

      findAll: (filter) =>
        Effect.gen(function* () {
          const sql = filter.onlyActive
            ? "SELECT * FROM todos WHERE completed = 0"
            : "SELECT * FROM todos"
          const rows = db.query(sql).all() as ReadonlyArray<TodoRow>
          return yield* Effect.forEach(rows, rowToTodo)
        }),

      existsByTitle: (title) =>
        Effect.sync(() => {
          const row = db.query("SELECT 1 FROM todos WHERE title = ?")
            .get(title.value)
          return row !== null
        }),
    }
  })
)

Что изменилось:

• Бизнес-правила теперь в Domain (Value Objects, Entity.complete())
• Контракт хранилища — в Port (Context.Tag)
• Оркестрация — в Application (Use Cases)
• SQL-запросы — в Adapter (SqliteTodoRepository)
• Зависимости от инфраструктуры — только в адаптере
• Dependency Rule соблюдён: стрелки зависимостей указывают внутрь

             DRIVING                                      DRIVEN
             (входящие)                                   (исходящие)

  ┌────────────────┐                                ┌──────────────────┐
  │   HTTP Server  │                                │   SQLite DB      │
  │   (REST API)   │                                │   (bun:sqlite)   │
  └───────┬────────┘                                └────────▲─────────┘
          │ Driving                                          │ Driven
          │ Adapter                                          │ Adapter
          │                                                  │
          ▼                                                  │
  ┌───────────────┐     ╔═══════════════════════╗    ┌──────┴────────┐
  │ HTTP Router + │     ║                       ║    │ SQLite Todo   │
  │ Handler       │────►║   APPLICATION CORE    ║───►│ Repository    │
  └───────────────┘     ║                       ║    └───────────────┘
                        ║  ┌─────────────────┐  ║
  ┌───────────────┐     ║  │   USE CASES     │  ║    ┌───────────────┐
  │ CLI Parser +  │     ║  │  createTodo()   │  ║    │ Console       │
  │ Handler       │────►║  │  completeTodo() │  ║───►│ Notification  │
  └───────┬────────┘    ║  │  listTodos()    │  ║    └───────▲───────┘
          │             ║  └────────┬────────┘  ║            │
          │             ║           │            ║    ┌───────┴───────┐
  ┌───────┴────────┐    ║  ┌────────▼────────┐  ║    │ SMTP          │
  │ CLI Client     │    ║  │   DOMAIN        │  ║    │ Notification  │
  │ (терминал)     │    ║  │  Todo Entity    │  ║    └───────────────┘
  └────────────────┘    ║  │  Value Objects  │  ║
                        ║  │  Errors         │  ║    ┌───────────────┐
  ┌────────────────┐    ║  │  Events         │  ║    │ System Clock  │
  │ Test Runner    │    ║  └─────────────────┘  ║───►│ (Date)        │
  │ (bun:test)     │───►║                       ║    └───────▲───────┘
  └────────────────┘    ║  PORTS:               ║            │
                        ║  • TodoRepository ◄───╫────────────┤
                        ║  • NotificationSvc ◄──╫────────────┤
                        ║  • Clock ◄────────────╫────────────┤
                        ║  • IdGenerator ◄──────╫──┐         │
                        ║  • AuditLog ◄─────────╫┐ │  ┌──────┴────────┐
                        ╚═══════════════════════╝│ │  │ UUID Generator│
                                                 │ │  │ (crypto)      │
                                                 │ │  └───────────────┘
                                                 │ │
                                                 │ └──┌───────────────┐
                                                 │    │ InMemory      │
                                                 │    │ Audit Log     │
                                                 │    └───────────────┘
                                                 │
                                                 └────┌───────────────┐
                                                      │ File Audit    │
                                                      │ Log           │
                                                      └───────────────┘

  СТРЕЛКИ ЗАВИСИМОСТЕЙ:
  ──► = "зависит от" / "знает о"
  
  Все стрелки от адаптеров указывают ВНУТРЬ (к Application Core)
  Application Core НЕ ИМЕЕТ стрелок наружу