Platform Node

npm install @effect/platform-node

import { NodeHttpServer } from "@effect/platform-node"
import { HttpServerResponse } from "@effect/platform"
import * as Effect from "effect/Effect"

const app = HttpServerResponse.text("Hello from Node.js!")

const server = NodeHttpServer.layer({ port: 3000 })

Effect.runFork(
  app.pipe(
    Effect.provide(server)
  )
)

import { NodeHttpClient } from "@effect/platform-node"
import { HttpClient } from "@effect/platform"
import * as Effect from "effect/Effect"

const program = HttpClient.get("https://api.github.com/users/Effect-TS").pipe(
  Effect.flatMap((_) => _.json),
  Effect.scoped,
  Effect.provide(NodeHttpClient.layer)
)

import { NodeFileSystem } from "@effect/platform-node"
import { FileSystem } from "@effect/platform"
import * as Effect from "effect/Effect"

const readConfig = Effect.gen(function* () {
  const fs = yield* FileSystem
  const content = yield* fs.readFileString("config.json")
  return JSON.parse(content)
}).pipe(
  Effect.provide(NodeFileSystem.layer)
)

import { NodeChildProcessSpawner } from "@effect/platform-node"
import { ChildProcessSpawner } from "@effect/platform"
import * as Effect from "effect/Effect"

const runCommand = Effect.gen(function* () {
  const spawner = yield* ChildProcessSpawner
  const result = yield* spawner.spawn("ls", ["-la"])
  return result.stdout
}).pipe(
  Effect.provide(NodeChildProcessSpawner.layer)
)

import { NodeSocket } from "@effect/platform-node"
import * as Effect from "effect/Effect"
import * as Stream from "effect/Stream"

const client = NodeSocket.makeNet({
  host: "localhost",
  port: 8080
})

import { NodeSocketServer } from "@effect/platform-node"

const server = NodeSocketServer.layerNet({
  port: 8080
}, (socket) => 
  // Handle socket connection
  Effect.succeed(void 0)
)

import { NodeRedis } from "@effect/platform-node"
import * as Effect from "effect/Effect"

const program = Effect.gen(function* () {
  const redis = yield* NodeRedis.Redis
  yield* redis.set("key", "value")
  const value = yield* redis.get("key")
  return value
}).pipe(
  Effect.provide(NodeRedis.layer({
    host: "localhost",
    port: 6379
  }))
)

import { NodeWorker } from "@effect/platform-node"
import { Worker } from "@effect/platform"
import * as Effect from "effect/Effect"

const pool = NodeWorker.layerManager({
  size: 4,
  spawn: () => new Worker("./worker.js")
})

import { NodeStream } from "@effect/platform-node"
import * as Stream from "effect/Stream"
import * as fs from "node:fs"

const readStream = fs.createReadStream("file.txt")
const effectStream = NodeStream.fromReadable(
  () => readStream,
  (error) => new Error(String(error))
)

import { NodePath } from "@effect/platform-node"
import { Path } from "@effect/platform"
import * as Effect from "effect/Effect"

const program = Effect.gen(function* () {
  const path = yield* Path
  return path.join("/home", "user", "documents")
}).pipe(
  Effect.provide(NodePath.layer)
)

import { NodeTerminal } from "@effect/platform-node"
import { Terminal } from "@effect/platform"
import * as Effect from "effect/Effect"

const program = Effect.gen(function* () {
  const terminal = yield* Terminal
  yield* terminal.display("Hello, terminal!\n")
}).pipe(
  Effect.provide(NodeTerminal.layer)
)

import { NodeRuntime } from "@effect/platform-node"
import * as Effect from "effect/Effect"

const program = Effect.gen(function* () {
  // All Node.js services are available
  const fs = yield* FileSystem
  const http = yield* HttpClient
  // ... use any Node.js service
})

Effect.runFork(
  program.pipe(
    Effect.provide(NodeRuntime.layer)
  )
)

import { NodeHttpServer } from "@effect/platform-node"

const server = NodeHttpServer.layer({
  port: 3000,
  host: "0.0.0.0",
  // Additional options...
})