Type-Safe Lightweight DDD with
Effect Schema

Who I am

• Yuichi Goto
• @_yasaichi
• @yasaichi.bsky.social
• @yasaichi

Professional Background

• Backend Engineer since 2015
• Co-author of Perfect Ruby on Rails
• Working at EARTHBRAIN since 2023

About EARTHBRAIN

• Founded in July 2021
• 200 employees (including 50 developers)
• Provides Smart Construction® solutions

About Smart Construction®

• A digital solution enhancing safety, productivity, and sustainability in the construction industry
• Integrates interconnected software and hardware products
• Used in over 20 countries worldwide

Background and Purpose

• This presentation is based on my recent experience rewriting a legacy API gateway, which is now in production.
• The new API gateway leverages Deno, NestJS, and Effect.
• In this presentation, I will:
  • Explore potential challenges in adopting Effect
  • Demonstrate our practical approach to Effect

What is Effect(-TS)?

• A cutting-edge TypeScript library that became stable in April this year [1]
• Enables building typed, robust, and scalable applications using the Effect System [2]—a concept in computer science [3].
• Provides standard library-like features (which we'll explore in detail later)

The Effect type: powerful Promise

Effect<Success, Error, Requirements>

• Success:: Represents the success type
• Error: Represents the error type
• Requirements: Represents required dependencies

Two potential challenges

• The need for an additional adapter layer
• A shift to a different programming paradigm

Examples of functions requiring wrapping

• Database I/O: db.insert (Drizzle) , sql (postgres)
• File I/O: fs.readFile, fs.writeFile
• Network I/O: fetch, http.get
• Storage I/O: localStorage.setItem
• Any other functions that indirectly perform these operations

Examples of adapter implementations

• @effect/platform: Provides adapters like Command, FileSystem, HttpClient, KeyValueStore, and more
• @effect/sql: Offers SQL client adapters for mysql2, postgres, drizzle-orm, and more

Two primary ways of composing Effects

• Using pipe: Combines Effect.andThen and Effect.all to manage control flow and concurrency
• Using Effect.gen: Works with the yield* keyword to delegate generator* iteration to an underlying iterator

The underlying concepts

• pipe: F# pipes (cf. Hack pipes, currently at TC39 Stage 2 [5])
• Effect.gen: Iterators and Generators, commonly used but often hidden in everyday programming
• Effect.andThen: Functors and Monads^*, concepts that many developers find challenging

What happened in our recent project

• Partial adoption of the Effect type and value in specific areas (e.g., NestJS Guards)
• Team faced challenges with Effect code readability and composition.
• Using pipe with Functors and Monads proved more complex than expected.

Recap so far

• The Effect type's powerful expression and composability enable building type-safe applications.
• The Effect value is not a built-in JavaScript object, which leads to two potential challenges:
  • The need for an additional adapter layer
  • A shift to a different programming paradigm

The other Effect features still shine

• Option and Either (Result)
• Pattern matching
• Schema validation (previously provided by @effect/schema)

Our recent approach to Effect

• Leveraging features unrelated to the Effect type, thereby avoiding the challenges discussed earlier
• Implementing lightweight Domain-Driven Design (DDD) with this approach to maximize type safety

Summary

• Our achievement: Implementing domain rules and recoverable errors at the type level, verifiable during static analysis
• How we accomplished this:
  • Entity layer: Through Effect Schema and discriminated unions
  • Other layers: Using pattern matching and Option/Either types