@useairfoil/effect-vcr 0.4.5 → 0.4.7

package/README.md

@@ -1,247 +1,49 @@
-# @useairfoil/effect-vcr
+# Effect VCR
 
-An `HttpClient` for Effect that records HTTP interactions to cassette files and replays them for future test runs.
+This package records Effect HTTP requests into cassette files. Tests can replay
+the same requests later.
 
-The first time the following test is run, it sends the HTTP request to `httpbin.org` and stores the request/response pair to a cassette. All subsequent test runs replay the stored response and make no live HTTP requests.
+## Install
 
-```ts
-// my-program.ts
-import { Effect } from "effect";
-import { HttpClient } from "effect/unstable/http";
-
-export const program = Effect.gen(function* () {
-  const client = yield* HttpClient.HttpClient;
-  const response = yield* client.get("https://httpbin.org/robots.txt");
-  return yield* response.text;
-});
-
-// my-program.test.ts
-import { NodeServices } from "@effect/platform-node";
-import { FileSystemCassetteStore, VcrHttpClient } from "@useairfoil/effect-vcr";
-import { describe, it } from "@effect/vitest";
-import { Effect, Layer } from "effect";
-import { FetchHttpClient } from "effect/unstable/http";
-
-const cassetteStoreLayer = FileSystemCassetteStore.layer().pipe(Layer.provide(NodeServices.layer));
-
-const vcrRuntimeLayer = Layer.mergeAll(
-  FetchHttpClient.layer,
-  NodeServices.layer,
-  cassetteStoreLayer,
-);
-
-const vcrLayer = VcrHttpClient.layer({
-  vcrName: "httpbin",
-  mode: "auto",
-}).pipe(Layer.provide(vcrRuntimeLayer));
-
-describe("my awesome program", () => {
-  it.effect("works", () => program.pipe(Effect.provide(vcrLayer)));
-});
+```bash
+pnpm add -D @useairfoil/effect-vcr @effect/platform-node@^4 effect@^4
 ```
 
-The main use case for the VCR is to let open source projects run tests against a real upstream API without exposing secrets to forks.
-
-- project owners generate cassettes locally by talking to the real API
-- external contributors run tests against committed cassettes
-- CI runs deterministically from cassettes
-- scheduled or manual runs can still hit the live API to catch upstream drift
-
-## Package shape
-
-Root exports:
-
-- `CassetteStore`
-- `FileSystemCassetteStore`
-- `VcrHttpClient`
-- `VcrConfig`
-- `VcrMode`
-- `VcrRequest`
-- `VcrResponse`
-- `VcrEntry`
-- `Cassette`
-- `CassetteFile`
-
-Focused subpath exports are also available:
-
-- `@useairfoil/effect-vcr/cassette-store`
-- `@useairfoil/effect-vcr/file-system-cassette-store`
-- `@useairfoil/effect-vcr/types`
-- `@useairfoil/effect-vcr/vcr-http-client`
-
 ## Usage
 
-Use the VCR by providing `VcrHttpClient.layer(...)` to the Effect being tested.
-
-- `VcrHttpClient` wraps an existing `HttpClient` and adds record/replay behavior
-- `FileSystemCassetteStore` persists cassette files to disk
-
-`VcrHttpClient.layer(...)` depends on:
-
-- a live `HttpClient` implementation such as `FetchHttpClient.layer`
-- `Path.Path` for cassette name resolution
-- `CassetteStore.CassetteStore` for persistence
-
-`FileSystemCassetteStore.layer(...)` depends on:
-
-- `FileSystem.FileSystem`
-- `Path.Path`
-
-In Node tests, `NodeServices.layer` satisfies those platform services.
-
-## Configuration and defaults
-
-### VcrHttpClient
-
-```ts
-type VcrConfig = {
-  readonly vcrName?: string;
-  readonly cassetteName?: string;
-  readonly mode?: "record" | "replay" | "auto";
-  readonly redact?: {
-    readonly requestHeaders?: ReadonlyArray<string>;
-    readonly responseHeaders?: ReadonlyArray<string>;
-    readonly requestBodyKeys?: ReadonlyArray<string>;
-    readonly responseBodyKeys?: ReadonlyArray<string>;
-    readonly requestBodyReplacements?: Readonly<Record<string, string | number | boolean | null>>;
-    readonly responseBodyReplacements?: Readonly<Record<string, string | number | boolean | null>>;
-  };
-  readonly matchIgnore?: {
-    readonly requestHeaders?: ReadonlyArray<string>;
-    readonly requestBodyKeys?: ReadonlyArray<string>;
-  };
-  readonly match?: (request: VcrRequest, entry: VcrEntry) => boolean;
-};
-```
-
-- `vcrName?: string`
-  - logical VCR name used by `ACK_DISABLE_VCR`
-- `cassetteName?: string`
-  - cassette file basename or full file name
-  - `users` resolves to `users.cassette`
-  - `users.cassette` is preserved as-is
-  - when omitted in Vitest, the cassette file defaults to `<test-file>.cassette` and the current test name becomes the export key inside that file
-- `mode?: "record" | "replay" | "auto"`
-  - `record`: always call the live client and write a cassette
-  - `replay`: only serve from cassette; missing entries fail
-  - `auto`: replay if the cassette exists, otherwise record; when `CI=true`, missing cassettes fail instead of recording
-- `redact`
-  - remove sensitive headers or JSON and URL-encoded body keys before writing to disk
-  - replace body values with safe placeholders when the field must remain available during replay
-  - request fields redacted here are also ignored when building cassette keys
-- `matchIgnore`
-  - ignore request headers or JSON and URL-encoded body keys when computing the request lookup key
-- `match`
-  - custom request matcher for advanced lookup behavior
-
-Defaults:
-
-- `mode` defaults to `"auto"`
-- `authorization` is ignored for matching by default
-- `authorization` is redacted from recorded request headers by default
-
-### FileSystemCassetteStore
-
-- `cassetteDir?: string`
-  - changes the cassette root directory
-  - when omitted in Vitest, cassettes are written to the `__cassettes__` directory beside the test file
-  - outside Vitest, provide `cassetteDir` explicitly
-
-## Matching and redaction
-
-`matchIgnore` and `redact` solve different problems.
-
-- `matchIgnore` changes how requests are matched to cassette entries
-- `redact` changes what is persisted to disk
-
-Typical usage:
-
-```ts
-const vcrLayer = VcrHttpClient.layer({
-  vcrName: "shopify-products",
-  mode: "auto",
-  redact: {
-    requestHeaders: ["x-shopify-access-token", "authorization"],
-    requestBodyReplacements: {
-      client_secret: "client-secret-placeholder",
-    },
-    responseBodyReplacements: {
-      access_token: "access-token-placeholder",
-    },
-  },
-});
-```
-
-Use `matchIgnore` when a request field should not affect cassette identity.
-
-Use `redact` when a field should never be written to disk.
-Replacement values are useful for fields such as access tokens that a replayed
-response must still contain. If body redaction changes the encoded length, the VCR
-also removes and ignores the stale `content-length` header.
-
-## Runtime configuration
-
-The VCR is controlled by the following environment variables:
-
-- `CI=true`
-  - if the VCR mode is `auto`, tests with a missing cassette fail instead of recording
-- `ACK_DISABLE_VCR=<...>`
-  - disables the VCR and falls back to the wrapped live client
-  - `*` disables all configured VCRs
-  - a comma-separated list disables only matching `vcrName` values
-
-When the VCR is disabled, cassette files are not updated.
-
-## Common patterns
-
-### Build the VCR runtime once
+Use `VcrHttpClient.layer(...)` around the live Effect HTTP client and
+`FileSystemCassetteStore.layer(...)` for cassette files.
 
 ```ts
-const cassetteStoreLayer = FileSystemCassetteStore.layer().pipe(Layer.provide(NodeServices.layer));
+import { NodeServices } from "@effect/platform-node";
+import { FileSystemCassetteStore, VcrHttpClient } from "@useairfoil/effect-vcr";
+import { Layer } from "effect";
+import { FetchHttpClient } from "effect/http";
 
-const vcrRuntimeLayer = Layer.mergeAll(
-  FetchHttpClient.layer,
-  NodeServices.layer,
-  cassetteStoreLayer,
-);
+const store = FileSystemCassetteStore.layer().pipe(Layer.provide(NodeServices.layer));
 
-const vcrLayer = VcrHttpClient.layer({
-  vcrName: "example",
+const VcrLive = VcrHttpClient.layer({
+  vcrName: "provider-api",
   mode: "auto",
-}).pipe(Layer.provide(vcrRuntimeLayer));
+}).pipe(Layer.provide(Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer, store)));
 ```
 
-This keeps the dependency graph explicit:
+Auto mode replays a cassette if it is present. It records one if it is missing.
+On CI, a missing cassette fails. `ACK_DISABLE_VCR=*` skips VCR and uses live
+HTTP.
 
-- `FileSystemCassetteStore.layer(...)` gets its platform services from `NodeServices.layer`
-- `VcrHttpClient.layer(...)` gets its live client, `Path.Path`, and cassette store from `vcrRuntimeLayer`
+Requests match on method, URL with its query params, headers, and body.
+Authorization headers are ignored while matching and removed before a cassette
+is written. Add other secrets to `redact`. Query params listed in
+`redact.requestQueryParams` are removed from the cassette and ignored while
+matching, which also helps when a param comes from local config.
 
-### Override config in tests
-
-```ts
-import { ConfigProvider, Layer } from "effect";
+Requests can record at the same time. Cassette writes take turns, so no entry
+is lost.
 
-const vcrTestRuntimeLayer = Layer.mergeAll(
-  vcrRuntimeLayer,
-  ConfigProvider.layer(
-    ConfigProvider.fromUnknown({
-      CI: false,
-      ACK_DISABLE_VCR: "",
-    }),
-  ),
-);
-
-const vcrLayer = VcrHttpClient.layer({
-  vcrName: "example",
-  mode: "auto",
-}).pipe(Layer.provide(vcrTestRuntimeLayer));
-```
-
-### Use focused subpath imports
-
-```ts
-import * as VcrHttpClient from "@useairfoil/effect-vcr/vcr-http-client";
-import * as FileSystemCassetteStore from "@useairfoil/effect-vcr/file-system-cassette-store";
-```
+## Configuration
 
-Use root imports for normal package consumption and subpath imports when you want a narrower surface.
+| Variable          | Required | Default |
+| ----------------- | -------- | ------- |
+| `CI`              | no       | `false` |
+| `ACK_DISABLE_VCR` | no       | empty   |

package/dist/{cassette-store-BMtcjh5h.d.ts → cassette-store.d.mts}

@@ -1,18 +1,14 @@
-import { n as CassetteFile } from "./types-XZehMu_v.js";
+import { n as CassetteFile } from "./types-v6cSTgDp.mjs";
 import { Context, Effect } from "effect";
-import * as effect_Types0 from "effect/Types";
-import * as effect_Cause0 from "effect/Cause";
-
-//#region src/cassette-store.d.ts
 declare namespace cassette_store_d_exports {
   export { CassetteStore, CassetteStoreError, CassetteStoreOperation, CassetteStoreService, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, toStoreError };
 }
-type CassetteStoreOperation = "exists" | "load" | "save" | "loadOrInit" | "resolveRoot";
+export type CassetteStoreOperation = "exists" | "load" | "save" | "loadOrInit" | "resolveRoot";
 /**
  * Storage contract for VCR cassettes.
  *
  */
-interface CassetteStoreService {
+export interface CassetteStoreService {
   /** Returns true if a cassette with the given name exists. */
   readonly exists: (name: string) => Effect.Effect<boolean, CassetteStoreError>;
   /** Loads a cassette by name, returning a `CassetteFile` if found. */
@@ -26,11 +22,11 @@ declare const CassetteStore_base: Context.ServiceClass<CassetteStore, "@useairfo
 /**
  * Effect service tag for the cassette store.
  */
-declare class CassetteStore extends CassetteStore_base {}
+export declare class CassetteStore extends CassetteStore_base {}
 /**
  * Creates a new empty cassette with a timestamp and format version.
  */
-declare const createEmptyCassette: () => Effect.Effect<{
+export declare const createEmptyCassette: () => Effect.Effect<{
   readonly meta: {
     readonly createdAt: string;
     readonly version: string;
@@ -55,8 +51,8 @@ declare const createEmptyCassette: () => Effect.Effect<{
     };
   };
 }, never, never>;
-declare const createEmptyCassetteFile: () => Effect.Effect<CassetteFile>;
-declare const CassetteStoreError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+export declare const createEmptyCassetteFile: () => Effect.Effect<CassetteFile>;
+declare const CassetteStoreError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "CassetteStoreError";
 } & Readonly<A>;
 /**
@@ -65,19 +61,19 @@ declare const CassetteStoreError_base: new <A extends Record<string, any> = {}>(
  * `operation` indicates which store function failed.
  * `path` is the file or directory path that was targeted.
  */
-declare class CassetteStoreError extends CassetteStoreError_base<{
+export declare class CassetteStoreError extends CassetteStoreError_base<{
   readonly operation: CassetteStoreOperation;
   readonly path: string;
   readonly message?: string;
   readonly cause?: unknown;
 }> {}
-declare const toStoreError: (operation: CassetteStoreOperation, path: string, cause?: unknown, message?: string) => CassetteStoreError;
+export declare const toStoreError: (operation: CassetteStoreOperation, path: string, cause?: unknown, message?: string) => CassetteStoreError;
 /**
  * Parses cassette JSON and maps invalid JSON or an invalid cassette shape to a store error.
  */
-declare const parseCassette: (content: string, path: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
+export declare const parseCassette: (content: string, path: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
 /** Creates a `CassetteStore` implementation that uses the given `impl` object. */
-declare const make: (impl: CassetteStoreService) => CassetteStoreService;
+export declare const make: (impl: CassetteStoreService) => CassetteStoreService;
 //#endregion
-export { cassette_store_d_exports as a, make as c, CassetteStoreService as i, parseCassette as l, CassetteStoreError as n, createEmptyCassette as o, CassetteStoreOperation as r, createEmptyCassetteFile as s, CassetteStore as t, toStoreError as u };
-//# sourceMappingURL=cassette-store-BMtcjh5h.d.ts.map
+export { cassette_store_d_exports as t };
+//# sourceMappingURL=cassette-store.d.mts.map

package/dist/{cassette-store-BF9e0rz3.js → cassette-store.mjs}

@@ -1,9 +1,8 @@
-import { t as __export } from "./chunk-Bp6m_JJh.js";
-import { t as CassetteFileSchema } from "./types-DMuz_JGd.js";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { CassetteFileSchema } from "./types.mjs";
 import { Context, Data, DateTime, Effect, Schema } from "effect";
-
 //#region src/cassette-store.ts
-var cassette_store_exports = /* @__PURE__ */ __export({
+var cassette_store_exports = /* @__PURE__ */ __exportAll({
 	CassetteStore: () => CassetteStore,
 	CassetteStoreError: () => CassetteStoreError,
 	createEmptyCassette: () => createEmptyCassette,
@@ -52,7 +51,7 @@ const parseCassette = (content, path) => Effect.try({
 }).pipe(Effect.flatMap((parsed) => Schema.decodeUnknownEffect(CassetteFileSchema)(parsed).pipe(Effect.mapError((error) => toStoreError("load", path, error, "Invalid cassette file format")))));
 /** Creates a `CassetteStore` implementation that uses the given `impl` object. */
 const make = (impl) => CassetteStore.of({ ...impl });
-
 //#endregion
-export { createEmptyCassetteFile as a, toStoreError as c, createEmptyCassette as i, CassetteStoreError as n, make as o, cassette_store_exports as r, parseCassette as s, CassetteStore as t };
-//# sourceMappingURL=cassette-store-BF9e0rz3.js.map
+export { CassetteStore, CassetteStoreError, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, cassette_store_exports as t, toStoreError };
+
+//# sourceMappingURL=cassette-store.mjs.map

package/dist/cassette-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cassette-store.mjs","names":[],"sources":["../src/cassette-store.ts"],"sourcesContent":["import { Context, Data, DateTime, Effect, Schema } from \"effect\";\n\nimport { CassetteFileSchema, type Cassette, type CassetteFile } from \"./types\";\n\nexport type CassetteStoreOperation = \"exists\" | \"load\" | \"save\" | \"loadOrInit\" | \"resolveRoot\";\n\n/**\n * Storage contract for VCR cassettes.\n *\n */\nexport interface CassetteStoreService {\n  /** Returns true if a cassette with the given name exists. */\n  readonly exists: (name: string) => Effect.Effect<boolean, CassetteStoreError>;\n\n  /** Loads a cassette by name, returning a `CassetteFile` if found. */\n  readonly load: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;\n\n  /** Saves a cassette by name, overwriting any existing cassette with the same name. */\n  readonly save: (name: string, content: CassetteFile) => Effect.Effect<void, CassetteStoreError>;\n\n  /** Loads a cassette by name, initializing a new empty cassette if not found. */\n  readonly loadOrInit: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;\n}\n\n/**\n * Effect service tag for the cassette store.\n */\nexport class CassetteStore extends Context.Service<CassetteStore, CassetteStoreService>()(\n  \"@useairfoil/effect-vcr/CassetteStore\",\n) {}\n\n/**\n * Creates a new empty cassette with a timestamp and format version.\n */\nexport const createEmptyCassette = Effect.fnUntraced(function* (): Effect.fn.Return<Cassette> {\n  const now = yield* DateTime.now;\n  return {\n    meta: {\n      createdAt: DateTime.formatIso(now),\n      version: \"1\",\n    },\n    entries: {},\n  };\n});\n\nexport const createEmptyCassetteFile = (): Effect.Effect<CassetteFile> =>\n  Effect.map(createEmptyCassette(), (cassette) => ({\n    exports: { default: cassette },\n  }));\n\n/**\n * Structured error for cassette persistence operations.\n *\n * `operation` indicates which store function failed.\n * `path` is the file or directory path that was targeted.\n */\nexport class CassetteStoreError extends Data.TaggedError(\"CassetteStoreError\")<{\n  readonly operation: CassetteStoreOperation;\n  readonly path: string;\n  readonly message?: string;\n  readonly cause?: unknown;\n}> {}\n\nexport const toStoreError = (\n  operation: CassetteStoreOperation,\n  path: string,\n  cause?: unknown,\n  message?: string,\n) =>\n  new CassetteStoreError({\n    operation,\n    path,\n    cause,\n    message,\n  });\n\n/**\n * Parses cassette JSON and maps invalid JSON or an invalid cassette shape to a store error.\n */\nexport const parseCassette = (\n  content: string,\n  path: string,\n): Effect.Effect<CassetteFile, CassetteStoreError> =>\n  Effect.try({\n    try: () => JSON.parse(content) as unknown,\n    catch: (error) => toStoreError(\"load\", path, error, \"Invalid JSON\"),\n  }).pipe(\n    Effect.flatMap((parsed) =>\n      Schema.decodeUnknownEffect(CassetteFileSchema)(parsed).pipe(\n        Effect.mapError((error) =>\n          toStoreError(\"load\", path, error, \"Invalid cassette file format\"),\n        ),\n      ),\n    ),\n  );\n\n/** Creates a `CassetteStore` implementation that uses the given `impl` object. */\nexport const make = (impl: CassetteStoreService): CassetteStoreService =>\n  CassetteStore.of({ ...impl });\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,IAAa,gBAAb,cAAmC,QAAQ,QAA6C,CAAC,CACvF,sCACF,CAAC,CAAC,CAAC;;;;AAKH,MAAa,sBAAsB,OAAO,WAAW,aAAyC;CAC5F,MAAM,MAAM,OAAO,SAAS;CAC5B,OAAO;EACL,MAAM;GACJ,WAAW,SAAS,UAAU,GAAG;GACjC,SAAS;EACX;EACA,SAAS,CAAC;CACZ;AACF,CAAC;AAED,MAAa,gCACX,OAAO,IAAI,oBAAoB,IAAI,cAAc,EAC/C,SAAS,EAAE,SAAS,SAAS,EAC/B,EAAE;;;;;;;AAQJ,IAAa,qBAAb,cAAwC,KAAK,YAAY,oBAAoB,CAAC,CAK3E,CAAC;AAEJ,MAAa,gBACX,WACA,MACA,OACA,YAEA,IAAI,mBAAmB;CACrB;CACA;CACA;CACA;AACF,CAAC;;;;AAKH,MAAa,iBACX,SACA,SAEA,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,OAAO;CAC7B,QAAQ,UAAU,aAAa,QAAQ,MAAM,OAAO,cAAc;AACpE,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,WACd,OAAO,oBAAoB,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,KACrD,OAAO,UAAU,UACf,aAAa,QAAQ,MAAM,OAAO,8BAA8B,CAClE,CACF,CACF,CACF;;AAGF,MAAa,QAAQ,SACnB,cAAc,GAAG,EAAE,GAAG,KAAK,CAAC"}

package/dist/file-system-cassette-store.d.mts

@@ -0,0 +1,17 @@
+import { CassetteStore, CassetteStoreError, t as cassette_store_d_exports } from "./cassette-store.mjs";
+import { FileSystem, Layer, Path } from "effect";
+declare namespace file_system_cassette_store_d_exports {
+  export { FileSystemCassetteStoreConfig, layer };
+}
+export type FileSystemCassetteStoreConfig = {
+  readonly cassetteDir?: string;
+};
+/**
+ * FileSystem-backed cassette store.
+ *
+ * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.
+ */
+export declare const layer: (config?: FileSystemCassetteStoreConfig) => Layer.Layer<CassetteStore, CassetteStoreError, FileSystem.FileSystem | Path.Path>;
+//#endregion
+export { file_system_cassette_store_d_exports as t };
+//# sourceMappingURL=file-system-cassette-store.d.mts.map

package/dist/{file-system-cassette-store-CyOsu3z5.js → file-system-cassette-store.mjs}

@@ -1,10 +1,9 @@
-import { t as __export } from "./chunk-Bp6m_JJh.js";
-import { a as createEmptyCassetteFile, c as toStoreError, o as make, s as parseCassette, t as CassetteStore } from "./cassette-store-BF9e0rz3.js";
-import { t as getVitestState } from "./vitest-state-CiW5dzXZ.js";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { CassetteStore, createEmptyCassetteFile, make, parseCassette, toStoreError } from "./cassette-store.mjs";
+import { t as getVitestState } from "./vitest-state-rX5XIlH6.mjs";
 import { Effect, FileSystem, Layer, Path } from "effect";
-
 //#region src/file-system-cassette-store.ts
-var file_system_cassette_store_exports = /* @__PURE__ */ __export({ layer: () => layer });
+var file_system_cassette_store_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
 /**
 * FileSystem-backed cassette store.
 *
@@ -36,7 +35,7 @@ const layer = (config = {}) => Layer.effect(CassetteStore)(Effect.gen(function*
 		loadOrInit
 	});
 }));
-
 //#endregion
-export { layer as n, file_system_cassette_store_exports as t };
-//# sourceMappingURL=file-system-cassette-store-CyOsu3z5.js.map
+export { layer, file_system_cassette_store_exports as t };
+
+//# sourceMappingURL=file-system-cassette-store.mjs.map

package/dist/file-system-cassette-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-system-cassette-store.mjs","names":["CassetteStore.CassetteStore","CassetteStore.toStoreError","CassetteStore.parseCassette","CassetteStore.createEmptyCassetteFile","CassetteStore.make"],"sources":["../src/file-system-cassette-store.ts"],"sourcesContent":["import { Effect, Layer, FileSystem, Path } from \"effect\";\n\nimport type { CassetteFile } from \"./types\";\n\nimport * as CassetteStore from \"./cassette-store\";\nimport { getVitestState } from \"./vitest-state\";\n\nexport type FileSystemCassetteStoreConfig = {\n  readonly cassetteDir?: string;\n};\n\n/**\n * FileSystem-backed cassette store.\n *\n * Requires a platform FileSystem layer (Node/Bun) to be provided by the user.\n */\nexport const layer = (config: FileSystemCassetteStoreConfig = {}) =>\n  Layer.effect(CassetteStore.CassetteStore)(\n    Effect.gen(function* () {\n      const fs = yield* FileSystem.FileSystem;\n      const path = yield* Path.Path;\n\n      let rootDir: string;\n      if (config.cassetteDir) {\n        rootDir = config.cassetteDir;\n      } else {\n        const { testPath } = getVitestState();\n        if (!testPath) {\n          return yield* Effect.fail(\n            CassetteStore.toStoreError(\n              \"resolveRoot\",\n              \"__cassettes__\",\n              undefined,\n              \"VCR cassette directory could not be inferred. Provide cassetteDir when not running in Vitest.\",\n            ),\n          );\n        }\n        const testFolder = path.dirname(testPath);\n        rootDir = path.join(testFolder, \"__cassettes__\");\n      }\n\n      const fullPath = (name: string) => path.join(rootDir, name);\n\n      const load = (name: string) =>\n        fs.readFileString(fullPath(name)).pipe(\n          Effect.mapError((error) => CassetteStore.toStoreError(\"load\", name, error)),\n          Effect.flatMap((content) => CassetteStore.parseCassette(content, name)),\n        );\n\n      const save = (name: string, cassette: CassetteFile) => {\n        const filePath = fullPath(name);\n        const dir = path.dirname(filePath);\n        const ensureDir =\n          dir === \"\"\n            ? Effect.void\n            : fs\n                .makeDirectory(dir, { recursive: true })\n                .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"save\", dir, error)));\n        return ensureDir.pipe(\n          Effect.andThen(\n            fs\n              .writeFileString(filePath, JSON.stringify(cassette, null, 2))\n              .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"save\", name, error))),\n          ),\n        );\n      };\n\n      const loadOrInit = (name: string) =>\n        fs.exists(fullPath(name)).pipe(\n          Effect.mapError((error) => CassetteStore.toStoreError(\"loadOrInit\", name, error)),\n          Effect.flatMap((exists) =>\n            exists\n              ? load(name)\n              : CassetteStore.createEmptyCassetteFile().pipe(\n                  Effect.tap((cassette) => save(name, cassette)),\n                ),\n          ),\n        );\n\n      return CassetteStore.make({\n        exists: (name: string) =>\n          fs\n            .exists(fullPath(name))\n            .pipe(Effect.mapError((error) => CassetteStore.toStoreError(\"exists\", name, error))),\n        load,\n        save,\n        loadOrInit,\n      });\n    }),\n  );\n"],"mappings":";;;;;;;;;;;AAgBA,MAAa,SAAS,SAAwC,CAAC,MAC7D,MAAM,OAAOA,aAA2B,CAAC,CACvC,OAAO,IAAI,aAAa;CACtB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,OAAO,OAAO,KAAK;CAEzB,IAAI;CACJ,IAAI,OAAO,aACT,UAAU,OAAO;MACZ;EACL,MAAM,EAAE,aAAa,eAAe;EACpC,IAAI,CAAC,UACH,OAAO,OAAO,OAAO,KACnBC,aACE,eACA,iBACA,KAAA,GACA,+FACF,CACF;EAEF,MAAM,aAAa,KAAK,QAAQ,QAAQ;EACxC,UAAU,KAAK,KAAK,YAAY,eAAe;CACjD;CAEA,MAAM,YAAY,SAAiB,KAAK,KAAK,SAAS,IAAI;CAE1D,MAAM,QAAQ,SACZ,GAAG,eAAe,SAAS,IAAI,CAAC,CAAC,CAAC,KAChC,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,KAAK,CAAC,GAC1E,OAAO,SAAS,YAAYC,cAA4B,SAAS,IAAI,CAAC,CACxE;CAEF,MAAM,QAAQ,MAAc,aAA2B;EACrD,MAAM,WAAW,SAAS,IAAI;EAC9B,MAAM,MAAM,KAAK,QAAQ,QAAQ;EAOjC,QALE,QAAQ,KACJ,OAAO,OACP,GACG,cAAc,KAAK,EAAE,WAAW,KAAK,CAAC,CAAC,CACvC,KAAK,OAAO,UAAU,UAAUD,aAA2B,QAAQ,KAAK,KAAK,CAAC,CAAC,EAAA,CACvE,KACf,OAAO,QACL,GACG,gBAAgB,UAAU,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC,CAAC,CAC5D,KAAK,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,KAAK,CAAC,CAAC,CACrF,CACF;CACF;CAEA,MAAM,cAAc,SAClB,GAAG,OAAO,SAAS,IAAI,CAAC,CAAC,CAAC,KACxB,OAAO,UAAU,UAAUA,aAA2B,cAAc,MAAM,KAAK,CAAC,GAChF,OAAO,SAAS,WACd,SACI,KAAK,IAAI,IACTE,wBAAsC,CAAC,CAAC,KACtC,OAAO,KAAK,aAAa,KAAK,MAAM,QAAQ,CAAC,CAC/C,CACN,CACF;CAEF,OAAOC,KAAmB;EACxB,SAAS,SACP,GACG,OAAO,SAAS,IAAI,CAAC,CAAC,CACtB,KAAK,OAAO,UAAU,UAAUH,aAA2B,UAAU,MAAM,KAAK,CAAC,CAAC;EACvF;EACA;EACA;CACF,CAAC;AACH,CAAC,CACH"}

package/dist/{index.d.ts → index.d.mts}

@@ -1,5 +1,5 @@
-import { a as VcrConfig, c as VcrMode, d as VcrRequestSchema, f as VcrResponse, i as CassetteSchema, l as VcrRedactedValue, n as CassetteFile, o as VcrEntry, p as VcrResponseSchema, r as CassetteFileSchema, s as VcrEntrySchema, t as Cassette, u as VcrRequest } from "./types-XZehMu_v.js";
-import { a as cassette_store_d_exports } from "./cassette-store-BMtcjh5h.js";
-import { n as file_system_cassette_store_d_exports } from "./file-system-cassette-store-CYmQT7qj.js";
-import { r as vcr_http_client_d_exports } from "./vcr-http-client-zQZTK-ru.js";
+import { a as VcrConfig, c as VcrMode, d as VcrRequestSchema, f as VcrResponse, i as CassetteSchema, l as VcrRedactedValue, n as CassetteFile, o as VcrEntry, p as VcrResponseSchema, r as CassetteFileSchema, s as VcrEntrySchema, t as Cassette, u as VcrRequest } from "./types-v6cSTgDp.mjs";
+import { t as cassette_store_d_exports } from "./cassette-store.mjs";
+import { t as file_system_cassette_store_d_exports } from "./file-system-cassette-store.mjs";
+import { t as vcr_http_client_d_exports } from "./vcr-http-client.mjs";
 export { Cassette, CassetteFile, CassetteFileSchema, CassetteSchema, cassette_store_d_exports as CassetteStore, file_system_cassette_store_d_exports as FileSystemCassetteStore, VcrConfig, VcrEntry, VcrEntrySchema, vcr_http_client_d_exports as VcrHttpClient, VcrMode, VcrRedactedValue, VcrRequest, VcrRequestSchema, VcrResponse, VcrResponseSchema };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { CassetteFileSchema, CassetteSchema, VcrEntrySchema, VcrRequestSchema, VcrResponseSchema } from "./types.mjs";
+import { t as cassette_store_exports } from "./cassette-store.mjs";
+import { t as file_system_cassette_store_exports } from "./file-system-cassette-store.mjs";
+import { r as vcr_http_client_exports } from "./vcr-http-client-5K20k6US.mjs";
+export { CassetteFileSchema, CassetteSchema, cassette_store_exports as CassetteStore, file_system_cassette_store_exports as FileSystemCassetteStore, VcrEntrySchema, vcr_http_client_exports as VcrHttpClient, VcrRequestSchema, VcrResponseSchema };

package/dist/{chunk-Bp6m_JJh.js → rolldown-runtime-D7D4PA-g.mjs}

@@ -1,13 +1,13 @@
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
-var __export = (all) => {
+var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
 		get: all[name],
 		enumerable: true
 	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-
 //#endregion
-export { __export as t };
+export { __exportAll as t };

package/dist/{types-XZehMu_v.d.ts → types-v6cSTgDp.d.mts}

@@ -1,7 +1,5 @@
 import { Schema } from "effect";
-
 //#region src/types.d.ts
-
 /**
  * VCR operating mode.
  * - record: always call the live client and persist.
@@ -114,6 +112,8 @@ type VcrConfig = {
    * Remove or replace sensitive data before writing to disk.
    */
   readonly redact?: {
+    /** Removed from the recorded URL and ignored when matching. */
+    readonly requestQueryParams?: ReadonlyArray<string>;
     readonly requestHeaders?: ReadonlyArray<string>;
     readonly responseHeaders?: ReadonlyArray<string>;
     readonly requestBodyKeys?: ReadonlyArray<string>;
@@ -135,4 +135,4 @@ type VcrConfig = {
 };
 //#endregion
 export { VcrConfig as a, VcrMode as c, VcrRequestSchema as d, VcrResponse as f, CassetteSchema as i, VcrRedactedValue as l, CassetteFile as n, VcrEntry as o, VcrResponseSchema as p, CassetteFileSchema as r, VcrEntrySchema as s, Cassette as t, VcrRequest as u };
-//# sourceMappingURL=types-XZehMu_v.d.ts.map
+//# sourceMappingURL=types-v6cSTgDp.d.mts.map

package/dist/{types.d.ts → types.d.mts}

@@ -1,2 +1,2 @@
-import { a as VcrConfig, c as VcrMode, d as VcrRequestSchema, f as VcrResponse, i as CassetteSchema, l as VcrRedactedValue, n as CassetteFile, o as VcrEntry, p as VcrResponseSchema, r as CassetteFileSchema, s as VcrEntrySchema, t as Cassette, u as VcrRequest } from "./types-XZehMu_v.js";
+import { a as VcrConfig, c as VcrMode, d as VcrRequestSchema, f as VcrResponse, i as CassetteSchema, l as VcrRedactedValue, n as CassetteFile, o as VcrEntry, p as VcrResponseSchema, r as CassetteFileSchema, s as VcrEntrySchema, t as Cassette, u as VcrRequest } from "./types-v6cSTgDp.mjs";
 export { Cassette, CassetteFile, CassetteFileSchema, CassetteSchema, VcrConfig, VcrEntry, VcrEntrySchema, VcrMode, VcrRedactedValue, VcrRequest, VcrRequestSchema, VcrResponse, VcrResponseSchema };

package/dist/{types-DMuz_JGd.js → types.mjs}

@@ -1,5 +1,4 @@
 import { Schema } from "effect";
-
 //#region src/types.ts
 /**
 * Serialized request shape stored in a cassette.
@@ -39,7 +38,7 @@ const CassetteSchema = Schema.Struct({
 * Cassette file format with multiple exports.
 */
 const CassetteFileSchema = Schema.Struct({ exports: Schema.Record(Schema.String, CassetteSchema) });
-
 //#endregion
-export { VcrResponseSchema as a, VcrRequestSchema as i, CassetteSchema as n, VcrEntrySchema as r, CassetteFileSchema as t };
-//# sourceMappingURL=types-DMuz_JGd.js.map
+export { CassetteFileSchema, CassetteSchema, VcrEntrySchema, VcrRequestSchema, VcrResponseSchema };
+
+//# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/**\n * VCR operating mode.\n * - record: always call the live client and persist.\n * - replay: serve only from cassette, fail if missing.\n * - auto: replay if cassette exists, otherwise record (fail in CI).\n */\nexport type VcrMode = \"record\" | \"replay\" | \"auto\";\n\n/**\n * Safe scalar value written in place of a sensitive body field.\n */\nexport type VcrRedactedValue = string | number | boolean | null;\n\n/**\n * Serialized request shape stored in a cassette.\n */\nexport const VcrRequestSchema = Schema.Struct({\n  method: Schema.String,\n  url: Schema.String,\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n  body: Schema.optional(Schema.String),\n});\nexport type VcrRequest = Schema.Schema.Type<typeof VcrRequestSchema>;\n\n/**\n * Serialized response shape stored in a cassette.\n */\nexport const VcrResponseSchema = Schema.Struct({\n  status: Schema.Number,\n  body: Schema.String,\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n});\nexport type VcrResponse = Schema.Schema.Type<typeof VcrResponseSchema>;\n\n/**\n * A single request/response pair keyed in the cassette.\n */\nexport const VcrEntrySchema = Schema.Struct({\n  request: VcrRequestSchema,\n  response: VcrResponseSchema,\n});\nexport type VcrEntry = Schema.Schema.Type<typeof VcrEntrySchema>;\n\n/**\n * Cassette file format.\n */\nexport const CassetteSchema = Schema.Struct({\n  meta: Schema.Struct({\n    createdAt: Schema.String,\n    version: Schema.String,\n  }),\n  entries: Schema.Record(Schema.String, VcrEntrySchema),\n});\nexport type Cassette = Schema.Schema.Type<typeof CassetteSchema>;\n\n/**\n * Cassette file format with multiple exports.\n */\nexport const CassetteFileSchema = Schema.Struct({\n  exports: Schema.Record(Schema.String, CassetteSchema),\n});\nexport type CassetteFile = Schema.Schema.Type<typeof CassetteFileSchema>;\n\n/**\n * VCR configuration.\n */\nexport type VcrConfig = {\n  readonly vcrName?: string;\n  /**\n   * Cassette file name or basename.\n   *\n   * `users` resolves to `users.cassette`.\n   * `users.cassette` is preserved as-is.\n   */\n  readonly cassetteName?: string;\n  readonly mode?: VcrMode;\n  /**\n   * Remove or replace sensitive data before writing to disk.\n   */\n  readonly redact?: {\n    /** Removed from the recorded URL and ignored when matching. */\n    readonly requestQueryParams?: ReadonlyArray<string>;\n    readonly requestHeaders?: ReadonlyArray<string>;\n    readonly responseHeaders?: ReadonlyArray<string>;\n    readonly requestBodyKeys?: ReadonlyArray<string>;\n    readonly responseBodyKeys?: ReadonlyArray<string>;\n    readonly requestBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;\n    readonly responseBodyReplacements?: Readonly<Record<string, VcrRedactedValue>>;\n  };\n  /**\n   * Ignore fields when computing the request key for replay matching.\n   */\n  readonly matchIgnore?: {\n    readonly requestHeaders?: ReadonlyArray<string>;\n    readonly requestBodyKeys?: ReadonlyArray<string>;\n  };\n  /**\n   * Custom matcher to override key-based lookup.\n   */\n  readonly match?: (request: VcrRequest, entry: VcrEntry) => boolean;\n};\n"],"mappings":";;;;;AAkBA,MAAa,mBAAmB,OAAO,OAAO;CAC5C,QAAQ,OAAO;CACf,KAAK,OAAO;CACZ,SAAS,OAAO,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM,CAAC;CACpE,MAAM,OAAO,SAAS,OAAO,MAAM;AACrC,CAAC;;;;AAMD,MAAa,oBAAoB,OAAO,OAAO;CAC7C,QAAQ,OAAO;CACf,MAAM,OAAO;CACb,SAAS,OAAO,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM,CAAC;AACtE,CAAC;;;;AAMD,MAAa,iBAAiB,OAAO,OAAO;CAC1C,SAAS;CACT,UAAU;AACZ,CAAC;;;;AAMD,MAAa,iBAAiB,OAAO,OAAO;CAC1C,MAAM,OAAO,OAAO;EAClB,WAAW,OAAO;EAClB,SAAS,OAAO;CAClB,CAAC;CACD,SAAS,OAAO,OAAO,OAAO,QAAQ,cAAc;AACtD,CAAC;;;;AAMD,MAAa,qBAAqB,OAAO,OAAO,EAC9C,SAAS,OAAO,OAAO,OAAO,QAAQ,cAAc,EACtD,CAAC"}