Effect TS

// It throws a ConfigError (not a generic Error).
// Message: "Missing data at DATABASE_URL: Expected DATABASE_URL to exist in the process context"
// ConfigError is a tagged error — you can catchTag("ConfigError", ...)
// This is why Config is better than process.env:
//   process.env.DATABASE_URL → string | undefined (silent)
//   Config.string("DATABASE_URL") → fails loudly with typed error

import { Config, Effect } from "effect"

// Config.all combines multiple configs into a struct
// Config.nested adds a prefix to ALL keys in the combined config
const dbConfig = Config.nested(
  Config.all({
    host: Config.string("HOST").pipe(Config.withDefault("localhost")),
    port: Config.number("PORT").pipe(Config.withDefault(5432)),
    name: Config.string("NAME"),
  }),
  "DB"
)
// Now reads: DB_HOST, DB_PORT, DB_NAME from env

// TS equivalent: you'd manually do process.env.DB_HOST ?? "localhost"
// and parse parseInt(process.env.DB_PORT ?? "5432") with no type safety

import { HttpClient, HttpClientResponse, FetchHttpClient } from "@effect/platform"
import { Effect, Schema } from "effect"

class Todo extends Schema.Class<Todo>("Todo")({
  id: Schema.Number,
  title: Schema.String,
  completed: Schema.Boolean,
}) {}

const fetchTodo = Effect.gen(function* () {
  const client = yield* HttpClient.HttpClient
  const res = yield* client.get("https://jsonplaceholder.typicode.com/todos/1")
  return yield* HttpClientResponse.schemaBodyJson(Todo)(res)
})

// Fix: provide the HttpClient layer!
// HttpClient is a SERVICE — it needs an implementation.
// TS equivalent: fetch() is global. Effect's HttpClient is injected.
Effect.runPromise(
  fetchTodo.pipe(Effect.provide(FetchHttpClient.layer))
)

import { HttpClient, HttpClientResponse, FetchHttpClient } from "@effect/platform"
import { Effect, Schema } from "effect"

class User extends Schema.Class<User>("User")({
  id: Schema.Number,
  name: Schema.String,
  email: Schema.String,
}) {}

const fetchUser = (id: number) => Effect.gen(function* () {
  const client = yield* HttpClient.HttpClient
  const res = yield* client.get(
    `https://jsonplaceholder.typicode.com/users/${id}`
  )
  // schemaBodyJson decodes AND validates — bad data goes to E channel
  return yield* HttpClientResponse.schemaBodyJson(User)(res)
})
// Type: Effect<User, HttpClientError | ParseError, HttpClient>
// TS equivalent: fetch().then(r => r.json()) gives you "any" — no validation

// Benefit 1: TESTABILITY
// You can provide a mock FileSystem in tests — no temp files needed:
const MockFS = Layer.succeed(FileSystem.FileSystem, {
  readFileString: () => Effect.succeed('{"port": 3000}'),
  // ... other methods
})

// Benefit 2: CROSS-PLATFORM
// Same code runs on Node, Bun, or browser (with different layers):
//   Effect.provide(NodeFileSystem.layer)  — for Node
//   Effect.provide(BunFileSystem.layer)   — for Bun
// Your business logic doesn't import "node:fs" directly.

// Bonus: typed errors. PlatformError tells you exactly what failed
// (NotFound, PermissionDenied, etc.) — no try/catch guessing.

import { FileSystem } from "@effect/platform"
import { Effect, Schema } from "effect"

const AppConfig = Schema.Struct({
  host: Schema.String,
  port: Schema.Number,
})

const migrate = Effect.gen(function* () {
  const fs = yield* FileSystem.FileSystem
  // Read
  const raw = yield* fs.readFileString("config.json")
  // Validate — parse errors go to E channel automatically
  const config = yield* Schema.decodeUnknown(AppConfig)(JSON.parse(raw))
  // Transform and write back
  const updated = { ...config, version: "1.0.0" }
  yield* fs.writeFileString("config.json", JSON.stringify(updated, null, 2))
  return updated
})
// Type: Effect<{host, port, version}, PlatformError | ParseError, FileSystem>

// getUserA is SAFE — tagged template literals parameterize automatically.
// sql`... ${name}` becomes a prepared statement: "SELECT * FROM users WHERE name = $1"
// The value is sent separately — can't break out of the string.

// getUserB is VULNERABLE — string concatenation means name could be:
//   "'; DROP TABLE users; --"
// sql.unsafe() runs raw SQL with no parameterization.

// Rule: ALWAYS use tagged templates with SqlClient.
// TS equivalent: same risk exists with any ORM's .raw() method.
// Effect's sql tagged template makes the safe path the easy path.

import { SqlClient, SqlSchema } from "@effect/sql"
import { Effect, Schema } from "effect"

const User = Schema.Struct({
  id: Schema.Number,
  name: Schema.String,
  email: Schema.String,
})

const getAllUsers = Effect.gen(function* () {
  const sql = yield* SqlClient.SqlClient
  // SqlSchema.findAll creates a query that decodes rows with Schema
  const query = SqlSchema.findAll({
    Request: Schema.Void,
    Result: User,
    execute: () => sql`SELECT id, name, email FROM users`
  })
  return yield* query(undefined)
})
// Type: Effect<Array<{id: number, name: string, email: string}>, SqlError | ParseError, SqlClient>
// Every row is validated — if the DB returns unexpected data, you get ParseError.
// TS equivalent: Prisma gives you typed results but can't validate at runtime.

import { Context, Effect, Layer, Schema } from "effect"
import { SqlClient, SqlSchema } from "@effect/sql"

// Service interface — pure capabilities, no implementation details
class UserRepository extends Context.Tag("UserRepository")<
  UserRepository,
  {
    readonly getById: (id: number) => Effect.Effect<User, NotFoundError>
    readonly create: (name: string, email: string) => Effect.Effect<User>
  }
>() {}

// Layer wires the implementation to a real database
const UserRepositoryLive = Layer.effect(
  UserRepository,
  Effect.gen(function* () {
    const sql = yield* SqlClient.SqlClient
    return {
      getById: (id) => Effect.gen(function* () {
        const rows = yield* sql`SELECT * FROM users WHERE id = ${id}`
        if (rows.length === 0) return yield* new NotFoundError({ id })
        return rows[0] as User
      }),
      create: (name, email) => Effect.gen(function* () {
        const rows = yield* sql`INSERT INTO users (name, email) VALUES (${name}, ${email}) RETURNING *`
        return rows[0] as User
      }),
    }
  })
)
// UserRepositoryLive requires SqlClient — compose it into your AppLayer

// Express: app.listen(3000)
// Effect: ManagedRuntime.make(AppLayer) — starts all services, holds the runtime

// NestJS: @Injectable() class UserService {}
// Effect: class UserService extends Context.Tag("UserService")<UserService, {...}>() {}
//         No decorators. The type system IS the DI container.

// Express: app.use(errorHandler)
// Effect: Effect.catchTag("NotFound", handler) at the route/handler level
//         Errors are typed — no middleware guessing what was thrown.

// NestJS: @Module({ providers: [UserService, DbService] })
// Effect: Layer.mergeAll(UserServiceLive, DbServiceLive)
//         Dependencies are resolved at compile time via the R type parameter.

// Express: process.on("SIGTERM", () => server.close())
// Effect: Effect.addFinalizer(() => ...) inside the Layer
//         ManagedRuntime.dispose() triggers ALL finalizers in reverse order.

import { Args, Command, Options } from "@effect/cli"
import { Console, Effect } from "effect"

const inputFile = Args.file({ name: "input", exists: "yes" })
const output = Options.file("output").pipe(
  Options.withAlias("o"),
  Options.withDefault("output.txt")
)
const format = Options.choiceWithValue("format", [
  ["json", "json" as const],
  ["csv", "csv" as const],
]).pipe(Options.withAlias("f"))

const convert = Command.make(
  "convert",
  { inputFile, output, format },
  ({ inputFile, output, format }) =>
    Console.log(`Converting ${inputFile} to ${format}, output: ${output}`)
)
// Type safety: format is "json" | "csv", not string
// inputFile validated to exist on disk
// output has a default — always present

import { Args, Command, Options } from "@effect/cli"
import { Console, Effect } from "effect"

const connection = Options.text("connection").pipe(
  Options.withAlias("c"),
  Options.withDefault("postgres://localhost:5432/mydb")
)

const db = Command.make("db", { connection })

// Subcommand handlers use Effect.flatMap on the parent command
// to access parent config — Command is itself an Effect!
const migrate = Command.make("migrate", {}, () =>
  Effect.flatMap(db, (parent) =>
    Console.log(`Migrating ${parent.connection}`)
  )
)

const seedFile = Args.file({ name: "seed-file" })
const seed = Command.make("seed", { seedFile }, ({ seedFile }) =>
  Effect.flatMap(db, (parent) =>
    Console.log(`Seeding ${parent.connection} from ${seedFile}`)
  )
)

const command = db.pipe(Command.withSubcommands([migrate, seed]))
// $ db --connection postgres://prod:5432/app migrate
// $ db seed data.sql

import { it, expect } from "@effect/vitest"
import { Context, Effect, Layer, Ref } from "effect"

// ... (service definitions above)

it.effect("sends email notification", () =>
  Effect.gen(function* () {
    // Use Ref to capture sent emails
    const sent = yield* Ref.make<Array<{ to: string; body: string }>>([])

    // Mock EmailClient that records calls instead of sending
    const MockEmail = Layer.succeed(EmailClient, {
      send: (to, body) => Ref.update(sent, (arr) => [...arr, { to, body }])
    })

    // Provide mock to the real NotificationService
    const testLayer = NotificationServiceLive.pipe(Layer.provide(MockEmail))

    yield* Effect.gen(function* () {
      const svc = yield* NotificationService
      yield* svc.notify("alice", "Hello!")
    }).pipe(Effect.provide(testLayer))

    const emails = yield* Ref.get(sent)
    expect(emails).toEqual([{ to: "alice@example.com", body: "Hello!" }])
  })
)
// No jest.mock. No monkey-patching. Layer swaps are type-checked.

import { it, expect } from "@effect/vitest"
import { Effect, TestClock, Fiber, Ref, Schedule } from "effect"

it.effect("retries with delay", () =>
  Effect.gen(function* () {
    const attempts = yield* Ref.make(0)

    const unstable = Effect.gen(function* () {
      const count = yield* Ref.updateAndGet(attempts, (n) => n + 1)
      if (count < 3) return yield* Effect.fail("not yet")
      return "success"
    })

    // Retry up to 2 times, 1 second between each
    const withRetry = unstable.pipe(
      Effect.retry(Schedule.recurs(2).pipe(Schedule.intersect(Schedule.spaced("1 second"))))
    )

    // Fork so TestClock can control time
    const fiber = yield* Effect.fork(withRetry)

    // Advance past both retry delays
    yield* TestClock.adjust("1 second") // triggers retry #1
    yield* TestClock.adjust("1 second") // triggers retry #2

    const result = yield* Fiber.join(fiber)
    expect(result).toBe("success")
    expect(yield* Ref.get(attempts)).toBe(3)
  })
)
// This test runs instantly — TestClock skips the real waits.
// TS equivalent: vi.useFakeTimers() + vi.advanceTimersByTime(1000)
// But TestClock is fiber-aware — only sleeping fibers are affected.

// Issue 1: floatingEffect
// Effect.succeed("hello") creates an Effect but doesn't use it.
// Fix: yield* Effect.succeed("hello") or remove it.

// Issue 2: missingStarInYieldEffectGen
// "yield" instead of "yield*" in Effect.gen. Effect won't execute.
// Fix: yield* Effect.fail("oops")

// Issue 3: tryCatchInEffectGen
// try/catch inside Effect.gen — errors should flow through E channel.
// Fix: use Effect.catchAll or Effect.catchTag instead of try/catch.
// Also: console.log should be Console.log (globalConsoleInEffect)

// Issue 4: floatingEffect + unnecessaryEffectGen
// "result" holds an Effect but is never yielded.
// Also: single-yield gen is unnecessary — just use Console.log("done") directly.
// Fix: yield* Console.log("done")

// A) floatingEffect
// Effect.succeed(42) is created but never yielded, returned, or assigned to
// anything that gets used. The effect is "floating" — it does nothing.

// B) runEffectInsideEffect
// Calling Effect.runSync() inside Effect.gen is an anti-pattern.
// You're escaping the Effect system and losing error tracking.
// Fix: yield* innerEffect directly.

// C) layerMergeAllWithDependencies
// Layer.mergeAll is for independent layers. DbLive depends on ConfigLive,
// so they have interdependencies. Fix: DbLive.pipe(Layer.provide(ConfigLive))

// D) asyncFunction
// This async function uses fetch and could be converted to Effect.gen
// with HttpClient for full type safety. The diagnostic suggests the refactor.

// E) multipleEffectProvide
// Chained .provide() calls should be combined into one:
// Effect.provide(Layer.merge(SomeLayer, OtherLayer))
// Multiple provides can cause unexpected layer instantiation.