作用域

Scope 数据类型是 Effect 中以安全和可组合方式管理资源的核心构造。

作用域表示一个或多个资源的生命周期。当作用域关闭时，其中的所有资源都会被释放，确保没有资源泄漏。作用域还允许添加终结器，用于定义如何释放资源。

使用 Scope 数据类型，您可以：

• 添加终结器：终结器指定资源的清理逻辑。
• 关闭作用域：当作用域关闭时，所有资源都会被释放，终结器会被执行。

示例（管理作用域）

import { Scope, Effect, Console, Exit } from "effect"

const program =
  // 创建一个新的作用域
  Scope.make().pipe(
    // 添加终结器 1
    Effect.tap((scope) =>
      Scope.addFinalizer(scope, Console.log("终结器 1"))
    ),
    // 添加终结器 2
    Effect.tap((scope) =>
      Scope.addFinalizer(scope, Console.log("终结器 2"))
    ),
    // 关闭作用域
    Effect.andThen((scope) =>
      Scope.close(scope, Exit.succeed("作用域成功关闭"))
    )
  )

Effect.runPromise(program)
/*
输出：
终结器 2 <-- 终结器按相反顺序关闭
终结器 1
*/

在上面的示例中，终结器被添加到作用域中，当作用域关闭时，终结器按相反顺序执行。

这种相反顺序很重要，因为它确保资源按正确的顺序释放。

例如，如果您获取了一个网络连接，然后访问远程服务器上的文件，必须在关闭网络连接之前先关闭文件，以避免错误。

addFinalizer

Effect.addFinalizer 函数是一个高级 API，允许您向 Effect 的作用域添加终结器。终结器是一段代码，保证在关联的作用域关闭时运行。终结器的行为可以根据 Exit 值而变化，该值表示作用域是如何关闭的——是成功关闭还是出现错误。

示例（在成功时添加终结器）

Using Effect.gen

import { Effect, Console } from "effect"

//      ┌─── Effect<string, never, Scope>
//      ▼
const program = Effect.gen(function* () {
  yield* Effect.addFinalizer((exit) =>
    Console.log(`终结器已执行。退出状态：${exit._tag}`)
  )
  return "some result"
})

// 将 Effect 包装在作用域中
//
//      ┌─── Effect<string, never, never>
//      ▼
const runnable = Effect.scoped(program)

Effect.runPromiseExit(runnable).then(console.log)
/*
输出：
终结器已执行。退出状态：Success
{ _id: 'Exit', _tag: 'Success', value: 'some result' }
*/

Using pipe

import { Effect, Console } from "effect"

//      ┌─── Effect<string, never, Scope>
//      ▼
const program = Effect.addFinalizer((exit) =>
  Console.log(`终结器已执行。退出状态：${exit._tag}`)
).pipe(Effect.andThen(Effect.succeed("some result")))

// 将 Effect 包装在作用域中
//
//      ┌─── Effect<string, never, never>
//      ▼
const runnable = Effect.scoped(program)

Effect.runPromiseExit(runnable).then(console.log)
/*
输出：
终结器已执行。退出状态：Success
{ _id: 'Exit', _tag: 'Success', value: 'some result' }
*/

在此示例中，我们使用 Effect.addFinalizer 添加一个终结器，该终结器在作用域关闭后记录退出状态。终结器将在 Effect 完成时执行，并记录 Effect 是成功完成还是失败。

类型签名：

const program: Effect<string, never, Scope>

显示工作流需要一个 Scope 来运行。您可以使用 Effect.scoped 函数提供此 Scope，该函数创建一个新的作用域，在其中运行 Effect，并确保在作用域关闭时执行终结器。

终结器执行顺序

终结器按添加顺序的相反顺序执行， 确保资源按正确的顺序释放，就像 栈展开一样。

示例（在失败时添加终结器）

Using Effect.gen

import { Effect, Console } from "effect"

//      ┌─── Effect<never, string, Scope>
//      ▼
const program = Effect.gen(function* () {
  yield* Effect.addFinalizer((exit) =>
    Console.log(`终结器已执行。退出状态：${exit._tag}`)
  )
  return yield* Effect.fail("Uh oh!")
})

// 将 Effect 包装在作用域中
//
//      ┌─── Effect<never, string, never>
//      ▼
const runnable = Effect.scoped(program)

Effect.runPromiseExit(runnable).then(console.log)
/*
输出：
终结器已执行。退出状态：Failure
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'Uh oh!' }
}
*/

Using pipe

import { Effect, Console } from "effect"

//      ┌─── Effect<never, string, Scope>
//      ▼
const program = Effect.addFinalizer((exit) =>
  Console.log(`终结器已执行。退出状态：${exit._tag}`)
).pipe(Effect.andThen(Effect.fail("Uh oh!")))

// 将 Effect 包装在作用域中
//
//      ┌─── Effect<never, string, never>
//      ▼
const runnable = Effect.scoped(program)

Effect.runPromiseExit(runnable).then(console.log)
/*
输出：
终结器已执行。退出状态：Failure
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'Uh oh!' }
}
*/

在这种情况下，即使 Effect 失败，终结器也会执行。日志输出反映了终结器在失败后运行，并记录失败详情。

示例（在中断时添加终结器）

Using Effect.gen

import { Effect, Console } from "effect"

//      ┌─── Effect<never, never, Scope>
//      ▼
const program = Effect.gen(function* () {
  yield* Effect.addFinalizer((exit) =>
    Console.log(`终结器已执行。退出状态：${exit._tag}`)
  )
  return yield* Effect.interrupt
})

// 将 Effect 包装在作用域中
//
//      ┌─── Effect<never, never, never>
//      ▼
const runnable = Effect.scoped(program)

Effect.runPromiseExit(runnable).then(console.log)
/*
输出：
终结器已执行。退出状态：Failure
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: {
    _id: 'Cause',
    _tag: 'Interrupt',
    fiberId: {
      _id: 'FiberId',
      _tag: 'Runtime',
      id: 0,
      startTimeMillis: ...
    }
  }
}
*/

Using pipe

import { Effect, Console } from "effect"

//      ┌─── Effect<never, never, Scope>
//      ▼
const program = Effect.addFinalizer((exit) =>
  Console.log(`终结器已执行。退出状态：${exit._tag}`)
).pipe(Effect.andThen(Effect.interrupt))

// 将 Effect 包装在作用域中
//
//      ┌─── Effect<never, never, never>
//      ▼
const runnable = Effect.scoped(program)

Effect.runPromiseExit(runnable).then(console.log)
/*
输出：
终结器已执行。退出状态：Failure
{
  _id: 'Exit',
  _tag: 'Failure',
  cause: {
    _id: 'Cause',
    _tag: 'Interrupt',
    fiberId: {
      _id: 'FiberId',
      _tag: 'Runtime',
      id: 0,
      startTimeMillis: ...
    }
  }
}
*/

此示例显示了当 Effect 被中断时终结器的行为。终结器在中断后运行，退出状态反映了 Effect 在执行过程中被停止。

手动创建和关闭作用域

当您在单个操作中使用多个作用域资源时，了解它们的作用域如何交互非常重要。 默认情况下，这些作用域会合并为一个，但您可以通过手动创建和关闭它们来更精细地控制每个作用域何时关闭。

让我们首先看看作用域默认是如何合并的：

示例（合并作用域）

import { Effect, Console } from "effect"

const task1 = Effect.gen(function* () {
  console.log("任务 1")
  yield* Effect.addFinalizer(() => Console.log("任务 1 后的终结器"))
})

const task2 = Effect.gen(function* () {
  console.log("任务 2")
  yield* Effect.addFinalizer(() => Console.log("任务 2 后的终结器"))
})

const program = Effect.gen(function* () {
  // 两个任务的作用域合并为一个
  yield* task1
  yield* task2
})

Effect.runPromise(Effect.scoped(program))
/*
输出：
任务 1
任务 2
任务 2 后的终结器
任务 1 后的终结器
*/

在这种情况下，task1 和 task2 的作用域合并为单个作用域，当程序运行时，它按特定顺序输出任务及其终结器。

如果您想更好地控制每个作用域何时关闭，可以手动创建和关闭它们：

示例（手动创建和关闭作用域）

import { Console, Effect, Exit, Scope } from "effect"

const task1 = Effect.gen(function* () {
  console.log("任务 1")
  yield* Effect.addFinalizer(() => Console.log("任务 1 后的终结器"))
})

const task2 = Effect.gen(function* () {
  console.log("任务 2")
  yield* Effect.addFinalizer(() => Console.log("任务 2 后的终结器"))
})

const program = Effect.gen(function* () {
  const scope1 = yield* Scope.make()
  const scope2 = yield* Scope.make()

  // 将 task1 的作用域扩展到 scope1
  yield* task1.pipe(Scope.extend(scope1))

  // 将 task2 的作用域扩展到 scope2
  yield* task2.pipe(Scope.extend(scope2))

  // 手动关闭 scope1 和 scope2
  yield* Scope.close(scope1, Exit.void)
  yield* Console.log("做其他事情")
  yield* Scope.close(scope2, Exit.void)
})

Effect.runPromise(program)
/*
输出：
任务 1
任务 2
任务 1 后的终结器
做其他事情
任务 2 后的终结器
*/

在此示例中，我们创建了两个独立的作用域 scope1 和 scope2，并将每个任务的作用域扩展到其各自的作用域中。当您运行程序时，它以不同的顺序输出任务及其终结器。

扩展作用域

Scope.extend 函数允许您将需要作用域的 Effect 工作流的作用域扩展到另一个作用域中，而不会在 工作流完成执行时关闭作用域。这允许您将 作用域值扩展到更大的作用域中。

您可能想知道当作用域关闭时，但该作用域内的任务尚未完成时会发生什么。 需要注意的关键点是，作用域关闭不会强制任务被中断。

示例（关闭包含待处理任务的作用域）

import { Console, Effect, Exit, Scope } from "effect"

const task = Effect.gen(function* () {
  yield* Effect.sleep("1 second")
  console.log("已执行")
  yield* Effect.addFinalizer(() => Console.log("任务终结器"))
})

const program = Effect.gen(function* () {
  const scope = yield* Scope.make()

  // 立即关闭作用域
  yield* Scope.close(scope, Exit.void)
  console.log("作用域已关闭")

  // 即使作用域已关闭，此任务仍会执行
  yield* task.pipe(Scope.extend(scope))
})

Effect.runPromise(program)
/*
输出：
作用域已关闭
已执行 <-- 1秒后
任务终结器
*/

定义资源

acquireRelease

Effect.acquireRelease(acquire, release) 函数允许您定义在不再需要时获取和安全释放的资源。这对于管理文件句柄、数据库连接或网络套接字等资源非常有用。

要使用 Effect.acquireRelease，您需要定义两个操作：

1. 获取资源：描述资源获取的 Effect，例如打开文件或建立数据库连接。
2. 释放资源：确保资源正确释放的清理 Effect，例如关闭文件或连接。

获取过程是不可中断的，以确保部分资源获取不会使您的系统处于不一致状态。

Effect.acquireRelease 函数保证一旦资源成功获取，当 Scope 关闭时，其释放步骤总是会执行。

示例（定义简单资源）

import { Effect } from "effect"

// 定义资源的接口
interface MyResource {
  readonly contents: string
  readonly close: () => Promise<void>
}

// 模拟资源获取
const getMyResource = (): Promise<MyResource> =>
  Promise.resolve({
    contents: "lorem ipsum",
    close: () =>
      new Promise((resolve) => {
        console.log("资源已释放")
        resolve()
      })
  })

// 定义如何获取资源
const acquire = Effect.tryPromise({
  try: () =>
    getMyResource().then((res) => {
      console.log("资源已获取")
      return res
    }),
  catch: () => new Error("getMyResourceError")
})

// 定义如何释放资源
const release = (res: MyResource) => Effect.promise(() => res.close())

// 创建资源管理工作流
//
//      ┌─── Effect<MyResource, Error, Scope>
//      ▼
const resource = Effect.acquireRelease(acquire, release)

在上面的代码中，Effect.acquireRelease 函数创建了一个需要 Scope 的资源工作流：

const resource: Effect<MyResource, Error, Scope>

这意味着工作流需要一个 Scope 来运行，当作用域关闭时，资源将自动释放。

您现在可以通过使用 Effect.andThen 或类似函数链接操作来使用资源。

我们可以通过使用 Effect.andThen 或其他 Effect 操作符来继续使用资源，只要我们想要。例如，以下是我们如何读取内容：

示例（使用资源）

import { Effect } from "effect"

// Define an interface for a resource
interface MyResource {
  readonly contents: string
  readonly close: () => Promise<void>
}

// Simulate resource acquisition
const getMyResource = (): Promise<MyResource> =>
  Promise.resolve({
    contents: "lorem ipsum",
    close: () =>
      new Promise((resolve) => {
        console.log("Resource released")
        resolve()
      })
  })

// Define how the resource is acquired
const acquire = Effect.tryPromise({
  try: () =>
    getMyResource().then((res) => {
      console.log("Resource acquired")
      return res
    }),
  catch: () => new Error("getMyResourceError")
})

// Define how the resource is released
const release = (res: MyResource) => Effect.promise(() => res.close())

// Create the resource management workflow
const resource = Effect.acquireRelease(acquire, release)

//      ┌─── Effect<void, Error, Scope>
//      ▼
const program = Effect.gen(function* () {
  const res = yield* resource
  console.log(`内容是 ${res.contents}`)
})

为了确保正确的资源管理，当您完成资源使用时应该关闭 Scope。Effect.scoped 函数通过创建一个 Scope、运行 Effect，然后在 Effect 完成时关闭 Scope 来为您处理这个问题。

示例（使用 Effect.scoped 提供 Scope）

import { Effect } from "effect"

// Define an interface for a resource
interface MyResource {
  readonly contents: string
  readonly close: () => Promise<void>
}

// Simulate resource acquisition
const getMyResource = (): Promise<MyResource> =>
  Promise.resolve({
    contents: "lorem ipsum",
    close: () =>
      new Promise((resolve) => {
        console.log("Resource released")
        resolve()
      })
  })

// Define how the resource is acquired
const acquire = Effect.tryPromise({
  try: () =>
    getMyResource().then((res) => {
      console.log("Resource acquired")
      return res
    }),
  catch: () => new Error("getMyResourceError")
})

// Define how the resource is released
const release = (res: MyResource) => Effect.promise(() => res.close())

// Create the resource management workflow
const resource = Effect.acquireRelease(acquire, release)

//      ┌─── Effect<void, Error, never>
//      ▼
const program = Effect.scoped(
  Effect.gen(function* () {
    const res = yield* resource
    console.log(`内容是 ${res.contents}`)
  })
)

// 我们现在有一个准备运行的工作流
Effect.runPromise(program)
/*
资源已获取
内容是 lorem ipsum
资源已释放
*/

示例模式：顺序操作

在某些场景中，您可能需要执行一系列链式操作，其中每个操作的成功都依赖于前一个操作。但是，如果任何操作失败，您希望撤销所有先前成功操作的效果。当您需要确保要么所有操作都成功，要么都没有任何效果时，这种模式非常有价值。

让我们通过一个实现此模式的示例。假设我们想在应用程序中创建一个”工作空间”，这涉及创建一个 S3 存储桶、一个 ElasticSearch 索引和一个依赖于前两者的数据库条目。

首先，我们为所需的服务定义域模型：

• S3
• ElasticSearch
• Database

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

class S3Error extends Data.TaggedError("S3Error")<{}> {}

interface Bucket {
  readonly name: string
}

class S3 extends Context.Tag("S3")<
  S3,
  {
    readonly createBucket: Effect.Effect<Bucket, S3Error>
    readonly deleteBucket: (bucket: Bucket) => Effect.Effect<void>
  }
>() {}

class ElasticSearchError extends Data.TaggedError(
  "ElasticSearchError"
)<{}> {}

interface Index {
  readonly id: string
}

class ElasticSearch extends Context.Tag("ElasticSearch")<
  ElasticSearch,
  {
    readonly createIndex: Effect.Effect<Index, ElasticSearchError>
    readonly deleteIndex: (index: Index) => Effect.Effect<void>
  }
>() {}

class DatabaseError extends Data.TaggedError("DatabaseError")<{}> {}

interface Entry {
  readonly id: string
}

class Database extends Context.Tag("Database")<
  Database,
  {
    readonly createEntry: (
      bucket: Bucket,
      index: Index
    ) => Effect.Effect<Entry, DatabaseError>
    readonly deleteEntry: (entry: Entry) => Effect.Effect<void>
  }
>() {}

接下来，我们为工作空间定义三个创建操作和整体事务（make）。

import { Effect, Context, Exit, Data } from "effect"

class S3Error extends Data.TaggedError("S3Error")<{}> {}

interface Bucket {
  readonly name: string
}

class S3 extends Context.Tag("S3")<
  S3,
  {
    readonly createBucket: Effect.Effect<Bucket, S3Error>
    readonly deleteBucket: (bucket: Bucket) => Effect.Effect<void>
  }
>() {}

class ElasticSearchError extends Data.TaggedError(
  "ElasticSearchError"
)<{}> {}

interface Index {
  readonly id: string
}

class ElasticSearch extends Context.Tag("ElasticSearch")<
  ElasticSearch,
  {
    readonly createIndex: Effect.Effect<Index, ElasticSearchError>
    readonly deleteIndex: (index: Index) => Effect.Effect<void>
  }
>() {}

class DatabaseError extends Data.TaggedError("DatabaseError")<{}> {}

interface Entry {
  readonly id: string
}

class Database extends Context.Tag("Database")<
  Database,
  {
    readonly createEntry: (
      bucket: Bucket,
      index: Index
    ) => Effect.Effect<Entry, DatabaseError>
    readonly deleteEntry: (entry: Entry) => Effect.Effect<void>
  }
>() {}

// 创建存储桶，并定义在操作失败时删除存储桶的释放函数
const createBucket = Effect.gen(function* () {
  const { createBucket, deleteBucket } = yield* S3
  return yield* Effect.acquireRelease(createBucket, (bucket, exit) =>
    // Effect.acquireRelease 操作的释放函数负责在主 Effect 完成后
    // 处理获取的资源（存储桶）。无论主 Effect 成功还是失败，
    // 都会调用此函数。如果主 Effect 失败，Exit.isFailure(exit)
    // 将为 true，函数将通过调用 deleteBucket(bucket) 执行回滚。
    // 如果主 Effect 成功，Exit.isFailure(exit) 将为 false，
    // 函数将返回 Effect.void，表示成功但无操作的 Effect。
    Exit.isFailure(exit) ? deleteBucket(bucket) : Effect.void
  )
})

// 创建索引，并定义在操作失败时删除索引的释放函数
const createIndex = Effect.gen(function* () {
  const { createIndex, deleteIndex } = yield* ElasticSearch
  return yield* Effect.acquireRelease(createIndex, (index, exit) =>
    Exit.isFailure(exit) ? deleteIndex(index) : Effect.void
  )
})

// 在数据库中创建条目，并定义在操作失败时删除条目的释放函数
const createEntry = (bucket: Bucket, index: Index) =>
  Effect.gen(function* () {
    const { createEntry, deleteEntry } = yield* Database
    return yield* Effect.acquireRelease(
      createEntry(bucket, index),
      (entry, exit) =>
        Exit.isFailure(exit) ? deleteEntry(entry) : Effect.void
    )
  })

const make = Effect.scoped(
  Effect.gen(function* () {
    const bucket = yield* createBucket
    const index = yield* createIndex
    return yield* createEntry(bucket, index)
  })
)

然后我们创建简单的服务实现来测试我们的工作空间代码的行为。 为了实现这一点，我们将利用层来构建测试。 这些层将能够处理各种场景，包括错误，我们可以使用 FailureCase 类型来控制这些错误。

import { Effect, Context, Exit, Data, Layer, Console } from "effect"

class S3Error extends Data.TaggedError("S3Error")<{}> {}

interface Bucket {
  readonly name: string
}

class S3 extends Context.Tag("S3")<
  S3,
  {
    readonly createBucket: Effect.Effect<Bucket, S3Error>
    readonly deleteBucket: (bucket: Bucket) => Effect.Effect<void>
  }
>() {}

class ElasticSearchError extends Data.TaggedError(
  "ElasticSearchError"
)<{}> {}

interface Index {
  readonly id: string
}

class ElasticSearch extends Context.Tag("ElasticSearch")<
  ElasticSearch,
  {
    readonly createIndex: Effect.Effect<Index, ElasticSearchError>
    readonly deleteIndex: (index: Index) => Effect.Effect<void>
  }
>() {}

class DatabaseError extends Data.TaggedError("DatabaseError")<{}> {}

interface Entry {
  readonly id: string
}

class Database extends Context.Tag("Database")<
  Database,
  {
    readonly createEntry: (
      bucket: Bucket,
      index: Index
    ) => Effect.Effect<Entry, DatabaseError>
    readonly deleteEntry: (entry: Entry) => Effect.Effect<void>
  }
>() {}

// Create a bucket, and define the release function that deletes the
// bucket if the operation fails.
const createBucket = Effect.gen(function* () {
  const { createBucket, deleteBucket } = yield* S3
  return yield* Effect.acquireRelease(createBucket, (bucket, exit) =>
    // The release function for the Effect.acquireRelease operation is
    // responsible for handling the acquired resource (bucket) after the
    // main effect has completed. It is called regardless of whether the
    // main effect succeeded or failed. If the main effect failed,
    // Exit.isFailure(exit) will be true, and the function will perform
    // a rollback by calling deleteBucket(bucket). If the main effect
    // succeeded, Exit.isFailure(exit) will be false, and the function
    // will return Effect.void, representing a successful, but
    // do-nothing effect.
    Exit.isFailure(exit) ? deleteBucket(bucket) : Effect.void
  )
})

// Create an index, and define the release function that deletes the
// index if the operation fails.
const createIndex = Effect.gen(function* () {
  const { createIndex, deleteIndex } = yield* ElasticSearch
  return yield* Effect.acquireRelease(createIndex, (index, exit) =>
    Exit.isFailure(exit) ? deleteIndex(index) : Effect.void
  )
})

// Create an entry in the database, and define the release function that
// deletes the entry if the operation fails.
const createEntry = (bucket: Bucket, index: Index) =>
  Effect.gen(function* () {
    const { createEntry, deleteEntry } = yield* Database
    return yield* Effect.acquireRelease(
      createEntry(bucket, index),
      (entry, exit) =>
        Exit.isFailure(exit) ? deleteEntry(entry) : Effect.void
    )
  })

const make = Effect.scoped(
  Effect.gen(function* () {
    const bucket = yield* createBucket
    const index = yield* createIndex
    return yield* createEntry(bucket, index)
  })
)

// The `FailureCaseLiterals` type allows us to provide different error
// scenarios while testing our
//
// For example, by providing the value "S3", we can simulate an error
// scenario specific to the S3 service. This helps us ensure that our
// program handles errors correctly and behaves as expected in various
// situations.
//
// Similarly, we can provide other values like "ElasticSearch" or
// "Database" to simulate error scenarios for those  In cases
// where we want to test the absence of errors, we can provide
// `undefined`. By using this parameter, we can thoroughly test our
// services and verify their behavior under different error conditions.
type FailureCaseLiterals = "S3" | "ElasticSearch" | "Database" | undefined

class FailureCase extends Context.Tag("FailureCase")<
  FailureCase,
  FailureCaseLiterals
>() {}

// Create a test layer for the S3 service

const S3Test = Layer.effect(
  S3,
  Effect.gen(function* () {
    const failureCase = yield* FailureCase
    return {
      createBucket: Effect.gen(function* () {
        console.log("[S3] creating bucket")
        if (failureCase === "S3") {
          return yield* Effect.fail(new S3Error())
        } else {
          return { name: "<bucket.name>" }
        }
      }),
      deleteBucket: (bucket) =>
        Console.log(`[S3] delete bucket ${bucket.name}`)
    }
  })
)

// Create a test layer for the ElasticSearch service

const ElasticSearchTest = Layer.effect(
  ElasticSearch,
  Effect.gen(function* () {
    const failureCase = yield* FailureCase
    return {
      createIndex: Effect.gen(function* () {
        console.log("[ElasticSearch] creating index")
        if (failureCase === "ElasticSearch") {
          return yield* Effect.fail(new ElasticSearchError())
        } else {
          return { id: "<index.id>" }
        }
      }),
      deleteIndex: (index) =>
        Console.log(`[ElasticSearch] delete index ${index.id}`)
    }
  })
)

// Create a test layer for the Database service

const DatabaseTest = Layer.effect(
  Database,
  Effect.gen(function* () {
    const failureCase = yield* FailureCase
    return {
      createEntry: (bucket, index) =>
        Effect.gen(function* () {
          console.log(
            "[Database] creating entry for bucket" +
              `${bucket.name} and index ${index.id}`
          )
          if (failureCase === "Database") {
            return yield* Effect.fail(new DatabaseError())
          } else {
            return { id: "<entry.id>" }
          }
        }),
      deleteEntry: (entry) =>
        Console.log(`[Database] delete entry ${entry.id}`)
    }
  })
)

// Merge all the test layers for S3, ElasticSearch, and Database
// services into a single layer
const layer = Layer.mergeAll(S3Test, ElasticSearchTest, DatabaseTest)

// Create a runnable effect to test the Workspace code. The effect is
// provided with the test layer and a FailureCase service with undefined
// value (no failure case).
const runnable = make.pipe(
  Effect.provide(layer),
  Effect.provideService(FailureCase, undefined)
)

Effect.runPromise(Effect.either(runnable)).then(console.log)

Let’s examine the test results for the scenario where FailureCase is set to undefined (happy path):

[S3] creating bucket
[ElasticSearch] creating index
[Database] creating entry for bucket <bucket.name> and index <index.id>
{ _id: 'Either', _tag: 'Right', right: { id: '<entry.id>' } }

In this case, all operations succeed, and we see a successful result with right({ id: '<entry.id>' }).

Now, let’s simulate a failure in the Database:

const runnable = make.pipe(
  Effect.provide(layer),
  Effect.provideService(FailureCase, "Database")
)

The console output will be:

[S3] creating bucket
[ElasticSearch] creating index
[Database] creating entry for bucket <bucket.name> and index <index.id>
[ElasticSearch] delete index <index.id>
[S3] delete bucket <bucket.name>
{ _id: 'Either', _tag: 'Left', left: { _tag: 'DatabaseError' } }

You can observe that once the Database error occurs, there is a complete rollback that deletes the ElasticSearch index first and then the associated S3 bucket. The result is a failure with left(new DatabaseError()).

Let’s now make the index creation fail instead:

const runnable = make.pipe(
  Effect.provide(layer),
  Effect.provideService(FailureCase, "ElasticSearch")
)

In this case, the console output will be:

[S3] creating bucket
[ElasticSearch] creating index
[S3] delete bucket <bucket.name>
{ _id: 'Either', _tag: 'Left', left: { _tag: 'ElasticSearchError' } }

As expected, once the ElasticSearch index creation fails, there is a rollback that deletes the S3 bucket. The result is a failure with left(new ElasticSearchError()).