refactor(http-recorder): use Schema.TaggedErrorClass for cassette errors (#26729)

packages/http-recorder/src/cassette.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, FileSystem, Layer } from "effect"
+import { Context, Effect, FileSystem, Layer, Schema } from "effect"
 import * as fs from "node:fs"
 import * as path from "node:path"
 import { secretFindings, type SecretFinding } from "./redaction"
@@ -6,9 +6,10 @@ import { decodeCassette, encodeCassette, type Cassette, type CassetteMetadata, t
 
 const DEFAULT_RECORDINGS_DIR = path.resolve(process.cwd(), "test", "fixtures", "recordings")
 
-export class CassetteNotFoundError extends Data.TaggedError("CassetteNotFoundError")<{
+export class CassetteNotFoundError extends Schema.TaggedErrorClass<CassetteNotFoundError>()(
-  readonly cassetteName: string
+  "CassetteNotFoundError",
-}> {
+  { cassetteName: Schema.String },
+) {
   override get message() {
     return `Cassette "${this.cassetteName}" not found`
   }

packages/http-recorder/src/recorder.ts

@@ -1,13 +1,13 @@
-import { Data, Effect, Ref, Scope } from "effect"
+import { Effect, Ref, Schema, Scope } from "effect"
 import type * as CassetteService from "./cassette"
 import type { CassetteNotFoundError } from "./cassette"
-import type { SecretFinding } from "./redaction"
+import { SecretFindingSchema } from "./redaction"
 import type { CassetteMetadata, Interaction } from "./schema"
 
-export class UnsafeCassetteError extends Data.TaggedError("UnsafeCassetteError")<{
+export class UnsafeCassetteError extends Schema.TaggedErrorClass<UnsafeCassetteError>()("UnsafeCassetteError", {
-  readonly cassetteName: string
+  cassetteName: Schema.String,
-  readonly findings: ReadonlyArray<SecretFinding>
+  findings: Schema.Array(SecretFindingSchema),
-}> {
+}) {
   override get message() {
     return `Refusing to write cassette "${this.cassetteName}" because it contains possible secrets: ${this.findings
       .map((finding) => `${finding.path} (${finding.reason})`)

packages/http-recorder/src/redaction.ts

@@ -95,10 +95,13 @@ export const redactHeaders = (
   )
 }
 
-export type SecretFinding = {
+import { Schema } from "effect"
-  readonly path: string
+
-  readonly reason: string
+export const SecretFindingSchema = Schema.Struct({
-}
+  path: Schema.String,
+  reason: Schema.String,
+})
+export type SecretFinding = Schema.Schema.Type<typeof SecretFindingSchema>
 
 export const secretFindings = (value: unknown): ReadonlyArray<SecretFinding> =>
   stringEntries(value).flatMap((entry) => [