Effect TS

// TypeScript: manual dependency wiring
interface Database {
  query(sql: string): Promise<unknown[]>
}

function createDatabase(pool: Pool): Database {
  return { query: (sql) => pool.query(sql) }
}

// Caller must remember to pass the right pool.
// Nothing prevents passing the wrong one.
// Nothing tracks which functions need a Database.
const db = createDatabase(pool)
const users = await db.query("SELECT * FROM users")

import { Effect, Context } from "effect"

// === Option 1: Effect.Service (recommended) ===
class Database extends Effect.Service<Database>()("Database", {
  effect: Effect.gen(function* () ({
    query: (sql: string) => Effect.tryPromise(() => pool.query(sql))
  })),
  dependencies: [ConnectionPool.Default]
}) {}

// Auto-generated:
// Database.Default — includes all dependencies
// Database.DefaultWithoutDependencies — requires them externally

const getUsers = Effect.gen(function* () {
  const db = yield* Database  // pulls from context, adds Database to R
  return yield* db.query("SELECT * FROM users")
})
// Type: Effect<User[], SqlError, Database>

// === Option 2: Context.GenericTag (lower-level) ===
interface Logger {
  readonly log: (msg: string) => Effect.Effect<void>
}
const Logger = Context.GenericTag<Logger>("Logger")

const program = Effect.gen(function* () {
  const logger = yield* Logger
  yield* logger.log("hello")
})
// Type: Effect<void, never, Logger>

// Provide and run
program.pipe(
  Effect.provideService(Logger, {
    log: (msg) => Effect.sync(() => console.log(msg))
  }),
  Effect.runPromise
)

// TypeScript: you wire dependencies by hand in main()
function createConfig() {
  return { logLevel: "INFO", connection: "postgres://..." }
}
function createLogger(config: Config) {
  return { log: (msg: string) => console.log(`[${config.logLevel}] ${msg}`) }
}
function createDatabase(config: Config, logger: Logger) {
  return { query: (sql: string) => { logger.log(sql); /* ... */ } }
}

// The order matters. Forget a step? Runtime error.
// Two things need config? You pass it twice manually.
const config = createConfig()
const logger = createLogger(config)
const db = createDatabase(config, logger)

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

// ── 1. Layer.succeed: wrap a plain value ──
// Use for config, constants — things that don't need setup
class Config extends Context.Tag("Config")<Config, {
  readonly logLevel: string
  readonly connection: string
}>() {}

const ConfigLive = Layer.succeed(Config, {
  logLevel: "INFO",
  connection: "postgres://localhost/mydb"
})
// Layer<Config, never, never>
// "I provide Config. I need nothing."

// ── 2. Layer.effect: build a service that needs other services ──
class Logger extends Context.Tag("Logger")<Logger, {
  readonly log: (msg: string) => Effect.Effect<void>
}>() {}

const LoggerLive = Layer.effect(
  Logger,
  Effect.gen(function* () {
    const config = yield* Config   // ← I need Config to build Logger
    return {
      log: (msg) => Effect.sync(() =>
        console.log(`[${config.logLevel}] ${msg}`)
      )
    }
  })
)
// Layer<Logger, never, Config>
// "I provide Logger. I need Config."

// ── 3. Layer.provide: satisfy a layer's dependencies ──
// LoggerLive needs Config. Give it ConfigLive.
const LoggerResolved = LoggerLive.pipe(Layer.provide(ConfigLive))
// Layer<Logger, never, never>  ← resolved! No more dependencies.

// ── 4. Layer.merge: bundle resolved layers together ──
// Your program needs both Config AND Logger?
// Merge the resolved layers into one:
const AppLive = Layer.merge(ConfigLive, LoggerResolved)
// Layer<Config | Logger, never, never>
// Both resolved. Nothing left to wire.

// ── 5. Putting it all together ──
class Database extends Context.Tag("Database")<Database, {
  readonly query: (sql: string) => Effect.Effect<unknown>
}>() {}

const DatabaseLive = Layer.effect(
  Database,
  Effect.gen(function* () {
    const config = yield* Config
    const logger = yield* Logger
    return {
      query: (sql) => Effect.gen(function* () {
        yield* logger.log(`Executing: ${sql}`)
        return { result: `data from ${config.connection}` }
      })
    }
  })
)
// Layer<Database, never, Config | Logger>

// Database needs Config+Logger. AppLive provides both.
const MainLive = DatabaseLive.pipe(Layer.provide(AppLive))
// Layer<Database, never, never>  ← fully resolved!

const program = Effect.gen(function* () {
  const db = yield* Database
  return yield* db.query("SELECT * FROM users")
})

Effect.runPromise(Effect.provide(program, MainLive))