@useairfoil/effect-vcr 0.4.0 → 0.4.2

package/README.md

@@ -1,79 +1,237 @@
 # @useairfoil/effect-vcr
 
-An HttpClient for Effect that records all HTTP interactions and stores them on tape, ready to be replayed for future test runs.
+An `HttpClient` for Effect that records HTTP interactions to cassette files and replays them for future test runs.
 
-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 tests will replay the response from the cassette, making no HTTP requests.
+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.
 
 ```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");
+  const response = yield* client.get("https://httpbin.org/robots.txt");
   return yield* response.text;
 });
 
 // my-program.test.ts
-import { VcrHttpClient, FileSystemCassetteStore } from "@useairfoil/effect-vcr";
+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", () =>
-    Effect.gen(function* () {
-      yield* program;
-    }),
-  ).pipe(
-    // Wrap the HttpClient with the VCR
-    Effect.provide(VcrHttpClient.layer()),
-    // Store cassettes on the file system
-    Effect.provide(FileSystemCassetteStore.layer()),
-    // HttpClient based on fetch
-    Effect.provide(FetchHttpClient.layer),
-    // Node is used to access the file system
-    Effect.provide(NodeServices.layer),
-  );
+  it.effect("works", () => program.pipe(Effect.provide(vcrLayer)));
 });
 ```
 
-The main use case for the VCR is to allow open source projects to run tests against a real API endpoint without exposing secrets to forks.
+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
 
-- Project owners generate cassettes locally by interacting with the upstream API
-- External contributors run their tests using the cassettes
-- CI runs using cassettes
-- Optionally, CI runs against the upstream API periodically, to catch any schema 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 the VcrHttpClient and FileSystemCassetteStore layers to the Effect being tested.
+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:
 
-- VcrHttpClient: this HttpClient wraps another HttpClient, adding support for recording and replaying HTTP interactions.
-- FileSystemCassetteStore: stores cassettes on the file system.
+- 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
 
-- `vcrName?: string`: the VCR name. Used to selectively disable VCRs during test runs (more on this in the runtime configuration section).
-- `cassetteName?: string`: the cassette name. If not set, defaults to the current vitest file name.
-- `mode: "record" | "replay" | "auto"`: controls the VCR behaviour. Defaults to `auto`.
-  - `record`: always call the live client and write a cassette.
-  - `replay`: only serve from cassette; missing entries fail.
-  - `auto`: replay if cassette exists, otherwise record. If `CI=true`, missing cassette fails.
-- `redact`: control which sensitive headers and JSON body keys to remove from requests and responses.
-  - `.requestHeaders?: string[]`: redact the specified request headers.
-  - `.responseHeaders?: string[]`: redact the specified response headers.
-  - `.requestBodyKeys?: string[]`: redact the specified request JSON keys.
-  - `.responseBodyKeys?: string[]`: redact the specified response JSON keys.
-- `matchIgnore`: control which fields are ignored when matching requests.
-  - `.requestHeaders?: string[]`: ignore the specified request headers.
-  - `.requestBodyKeys?: string[]`: ignore the specified request JSON keys.
-- `match: (request: VcrRequest, entry: VcrEntry) => boolean`: custom request to entry matcher.
+```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 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 body keys before writing to disk
+- `matchIgnore`
+  - ignore request headers or JSON 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`: change the location of the cassette. By default, the VCR stores cassettes in the `__cassettes__` folder next to the test.
+- `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",
+  matchIgnore: {
+    requestHeaders: ["x-shopify-access-token", "authorization"],
+  },
+  redact: {
+    requestHeaders: ["x-shopify-access-token", "authorization"],
+  },
+});
+```
+
+Use `matchIgnore` when a request field should not affect cassette identity.
+
+Use `redact` when a field should never be written to disk.
 
 ## Runtime configuration
 
 The VCR is controlled by the following environment variables:
 
-- `CI=true`: if set and the VCR mode is `auto`, tests with a missing cassette fail.
-- `ACK_DISABLE_VCR=<...>`: disable the VCR. If `'*'`, then all VCRs are disabled. To selectively disable VCRs, pass a comma separated list of VCRs to disable (based on their `vcrName` config). Use this to test against the upstream API. In this case, the cassettes are not updated.
+- `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
+
+```ts
+const cassetteStoreLayer = FileSystemCassetteStore.layer().pipe(Layer.provide(NodeServices.layer));
+
+const vcrRuntimeLayer = Layer.mergeAll(
+  FetchHttpClient.layer,
+  NodeServices.layer,
+  cassetteStoreLayer,
+);
+
+const vcrLayer = VcrHttpClient.layer({
+  vcrName: "example",
+  mode: "auto",
+}).pipe(Layer.provide(vcrRuntimeLayer));
+```
+
+This keeps the dependency graph explicit:
+
+- `FileSystemCassetteStore.layer(...)` gets its platform services from `NodeServices.layer`
+- `VcrHttpClient.layer(...)` gets its live client, `Path.Path`, and cassette store from `vcrRuntimeLayer`
+
+### Override config in tests
+
+```ts
+import { ConfigProvider, Layer } from "effect";
+
+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";
+```
+
+Use root imports for normal package consumption and subpath imports when you want a narrower surface.

package/dist/cassette-store-BunkvLoV.d.ts

@@ -0,0 +1,59 @@
+import { n as CassetteFile, t as Cassette } from "./types-DWwkMzxG.js";
+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";
+/**
+ * Storage contract for VCR cassettes.
+ *
+ */
+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. */
+  readonly load: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
+  /** Saves a cassette by name, overwriting any existing cassette with the same name. */
+  readonly save: (name: string, content: CassetteFile) => Effect.Effect<void, CassetteStoreError>;
+  /** Loads a cassette by name, initializing a new empty cassette if not found. */
+  readonly loadOrInit: (name: string) => Effect.Effect<CassetteFile, CassetteStoreError>;
+}
+declare const CassetteStore_base: Context.ServiceClass<CassetteStore, "@useairfoil/effect-vcr/CassetteStore", CassetteStoreService>;
+/**
+ * Effect service tag for the cassette store.
+ */
+declare class CassetteStore extends CassetteStore_base {}
+/**
+ * Creates a new empty cassette with a timestamp and format version.
+ */
+declare const createEmptyCassette: () => Effect.Effect<Cassette, 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 & {
+  readonly _tag: "CassetteStoreError";
+} & Readonly<A>;
+/**
+ * Structured error for cassette persistence operations.
+ *
+ * `operation` indicates which store function failed.
+ * `path` is the file or directory path that was targeted.
+ */
+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;
+/**
+ * Parses cassette JSON and maps invalid JSON to a store error.
+ */
+declare const parseCassette: (content: string, path: string) => Effect.Effect<CassetteFile, CassetteStoreError, never>;
+/** Creates a `CassetteStore` implementation that uses the given `impl` object. */
+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-BunkvLoV.d.ts.map

package/dist/cassette-store-CnXX5OLB.js

@@ -0,0 +1,60 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { Context, Data, DateTime, Effect } from "effect";
+
+//#region src/cassette-store.ts
+var cassette_store_exports = /* @__PURE__ */ __export({
+	CassetteStore: () => CassetteStore,
+	CassetteStoreError: () => CassetteStoreError,
+	createEmptyCassette: () => createEmptyCassette,
+	createEmptyCassetteFile: () => createEmptyCassetteFile,
+	make: () => make,
+	parseCassette: () => parseCassette,
+	toStoreError: () => toStoreError
+});
+/**
+* Effect service tag for the cassette store.
+*/
+var CassetteStore = class extends Context.Service()("@useairfoil/effect-vcr/CassetteStore") {};
+/**
+* Creates a new empty cassette with a timestamp and format version.
+*/
+const createEmptyCassette = Effect.fnUntraced(function* () {
+	const now = yield* DateTime.now;
+	return {
+		meta: {
+			createdAt: DateTime.formatIso(now),
+			version: "1"
+		},
+		entries: {}
+	};
+});
+const createEmptyCassetteFile = () => Effect.map(createEmptyCassette(), (cassette) => ({ exports: { default: cassette } }));
+/**
+* Structured error for cassette persistence operations.
+*
+* `operation` indicates which store function failed.
+* `path` is the file or directory path that was targeted.
+*/
+var CassetteStoreError = class extends Data.TaggedError("CassetteStoreError") {};
+const toStoreError = (operation, path, cause, message) => new CassetteStoreError({
+	operation,
+	path,
+	cause,
+	message
+});
+/**
+* Parses cassette JSON and maps invalid JSON to a store error.
+*/
+const parseCassette = (content, path) => Effect.try({
+	try: () => JSON.parse(content),
+	catch: (error) => toStoreError("load", path, error, "Invalid JSON")
+}).pipe(Effect.flatMap((parsed) => {
+	if (!parsed || typeof parsed !== "object" || !("exports" in parsed)) return Effect.fail(toStoreError("load", path, void 0, "Invalid cassette file format"));
+	return Effect.succeed(parsed);
+}));
+/** 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-CnXX5OLB.js.map

package/dist/cassette-store-CnXX5OLB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cassette-store-CnXX5OLB.js","names":[],"sources":["../src/cassette-store.ts"],"sourcesContent":["import { Context, Data, DateTime, Effect } from \"effect\";\n\nimport type { Cassette, 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 to a store error.\n */\nexport const parseCassette = (content: string, path: string) =>\n  Effect.try({\n    try: () => JSON.parse(content) as CassetteFile,\n    catch: (error) => toStoreError(\"load\", path, error, \"Invalid JSON\"),\n  }).pipe(\n    Effect.flatMap((parsed) => {\n      if (!parsed || typeof parsed !== \"object\" || !(\"exports\" in parsed)) {\n        return Effect.fail(toStoreError(\"load\", path, undefined, \"Invalid cassette file format\"));\n      }\n      return Effect.succeed(parsed);\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,SAA8C,CACvF,uCACD,CAAC;;;;AAKF,MAAa,sBAAsB,OAAO,WAAW,aAAyC;CAC5F,MAAM,MAAM,OAAO,SAAS;AAC5B,QAAO;EACL,MAAM;GACJ,WAAW,SAAS,UAAU,IAAI;GAClC,SAAS;GACV;EACD,SAAS,EAAE;EACZ;EACD;AAEF,MAAa,gCACX,OAAO,IAAI,qBAAqB,GAAG,cAAc,EAC/C,SAAS,EAAE,SAAS,UAAU,EAC/B,EAAE;;;;;;;AAQL,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAK3E;AAEH,MAAa,gBACX,WACA,MACA,OACA,YAEA,IAAI,mBAAmB;CACrB;CACA;CACA;CACA;CACD,CAAC;;;;AAKJ,MAAa,iBAAiB,SAAiB,SAC7C,OAAO,IAAI;CACT,WAAW,KAAK,MAAM,QAAQ;CAC9B,QAAQ,UAAU,aAAa,QAAQ,MAAM,OAAO,eAAe;CACpE,CAAC,CAAC,KACD,OAAO,SAAS,WAAW;AACzB,KAAI,CAAC,UAAU,OAAO,WAAW,YAAY,EAAE,aAAa,QAC1D,QAAO,OAAO,KAAK,aAAa,QAAQ,MAAM,QAAW,+BAA+B,CAAC;AAE3F,QAAO,OAAO,QAAQ,OAAO;EAC7B,CACH;;AAGH,MAAa,QAAQ,SACnB,cAAc,GAAG,EAAE,GAAG,MAAM,CAAC"}

package/dist/cassette-store.d.ts

@@ -0,0 +1,3 @@
+import "./types-DWwkMzxG.js";
+import { c as make, i as CassetteStoreService, l as parseCassette, n as CassetteStoreError, o as createEmptyCassette, r as CassetteStoreOperation, s as createEmptyCassetteFile, t as CassetteStore, u as toStoreError } from "./cassette-store-BunkvLoV.js";
+export { CassetteStore, CassetteStoreError, CassetteStoreOperation, CassetteStoreService, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, toStoreError };

package/dist/cassette-store.js

@@ -0,0 +1,3 @@
+import { a as createEmptyCassetteFile, c as toStoreError, i as createEmptyCassette, n as CassetteStoreError, o as make, s as parseCassette, t as CassetteStore } from "./cassette-store-CnXX5OLB.js";
+
+export { CassetteStore, CassetteStoreError, createEmptyCassette, createEmptyCassetteFile, make, parseCassette, toStoreError };

package/dist/file-system-cassette-store-LXpwwrw3.d.ts

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

package/dist/file-system-cassette-store-zWkrhhlO.js

@@ -0,0 +1,42 @@
+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-CnXX5OLB.js";
+import { t as getVitestState } from "./vitest-state-BOynp4Va.js";
+import { Effect, FileSystem, Layer, Path } from "effect";
+
+//#region src/file-system-cassette-store.ts
+var file_system_cassette_store_exports = /* @__PURE__ */ __export({ layer: () => layer });
+/**
+* FileSystem-backed cassette store.
+*
+* Requires a platform FileSystem layer (Node/Bun) to be provided by the user.
+*/
+const layer = (config = {}) => Layer.effect(CassetteStore)(Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	let rootDir;
+	if (config.cassetteDir) rootDir = config.cassetteDir;
+	else {
+		const { testPath } = getVitestState();
+		if (!testPath) return yield* Effect.fail(toStoreError("resolveRoot", "__cassettes__", void 0, "VCR cassette directory could not be inferred. Provide cassetteDir when not running in Vitest."));
+		const testFolder = path.dirname(testPath);
+		rootDir = path.join(testFolder, "__cassettes__");
+	}
+	const fullPath = (name) => path.join(rootDir, name);
+	const load = (name) => fs.readFileString(fullPath(name)).pipe(Effect.mapError((error) => toStoreError("load", name, error)), Effect.flatMap((content) => parseCassette(content, name)));
+	const save = (name, cassette) => {
+		const filePath = fullPath(name);
+		const dir = path.dirname(filePath);
+		return (dir === "" ? Effect.void : fs.makeDirectory(dir, { recursive: true }).pipe(Effect.mapError((error) => toStoreError("save", dir, error)))).pipe(Effect.andThen(fs.writeFileString(filePath, JSON.stringify(cassette, null, 2)).pipe(Effect.mapError((error) => toStoreError("save", name, error)))));
+	};
+	const loadOrInit = (name) => fs.exists(fullPath(name)).pipe(Effect.mapError((error) => toStoreError("loadOrInit", name, error)), Effect.flatMap((exists) => exists ? load(name) : createEmptyCassetteFile().pipe(Effect.tap((cassette) => save(name, cassette)))));
+	return make({
+		exists: (name) => fs.exists(fullPath(name)).pipe(Effect.mapError((error) => toStoreError("exists", name, error))),
+		load,
+		save,
+		loadOrInit
+	});
+}));
+
+//#endregion
+export { layer as n, file_system_cassette_store_exports as t };
+//# sourceMappingURL=file-system-cassette-store-zWkrhhlO.js.map

package/dist/file-system-cassette-store-zWkrhhlO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-system-cassette-store-zWkrhhlO.js","names":["CassetteStore.CassetteStore","rootDir: string","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,EAAE,KAC9D,MAAM,OAAOA,cAA4B,CACvC,OAAO,IAAI,aAAa;CACtB,MAAM,KAAK,OAAO,WAAW;CAC7B,MAAM,OAAO,OAAO,KAAK;CAEzB,IAAIC;AACJ,KAAI,OAAO,YACT,WAAU,OAAO;MACZ;EACL,MAAM,EAAE,aAAa,gBAAgB;AACrC,MAAI,CAAC,SACH,QAAO,OAAO,OAAO,KACnBC,aACE,eACA,iBACA,QACA,gGACD,CACF;EAEH,MAAM,aAAa,KAAK,QAAQ,SAAS;AACzC,YAAU,KAAK,KAAK,YAAY,gBAAgB;;CAGlD,MAAM,YAAY,SAAiB,KAAK,KAAK,SAAS,KAAK;CAE3D,MAAM,QAAQ,SACZ,GAAG,eAAe,SAAS,KAAK,CAAC,CAAC,KAChC,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,MAAM,CAAC,EAC3E,OAAO,SAAS,YAAYC,cAA4B,SAAS,KAAK,CAAC,CACxE;CAEH,MAAM,QAAQ,MAAc,aAA2B;EACrD,MAAM,WAAW,SAAS,KAAK;EAC/B,MAAM,MAAM,KAAK,QAAQ,SAAS;AAOlC,UALE,QAAQ,KACJ,OAAO,OACP,GACG,cAAc,KAAK,EAAE,WAAW,MAAM,CAAC,CACvC,KAAK,OAAO,UAAU,UAAUD,aAA2B,QAAQ,KAAK,MAAM,CAAC,CAAC,EACxE,KACf,OAAO,QACL,GACG,gBAAgB,UAAU,KAAK,UAAU,UAAU,MAAM,EAAE,CAAC,CAC5D,KAAK,OAAO,UAAU,UAAUA,aAA2B,QAAQ,MAAM,MAAM,CAAC,CAAC,CACrF,CACF;;CAGH,MAAM,cAAc,SAClB,GAAG,OAAO,SAAS,KAAK,CAAC,CAAC,KACxB,OAAO,UAAU,UAAUA,aAA2B,cAAc,MAAM,MAAM,CAAC,EACjF,OAAO,SAAS,WACd,SACI,KAAK,KAAK,GACVE,yBAAuC,CAAC,KACtC,OAAO,KAAK,aAAa,KAAK,MAAM,SAAS,CAAC,CAC/C,CACN,CACF;AAEH,QAAOC,KAAmB;EACxB,SAAS,SACP,GACG,OAAO,SAAS,KAAK,CAAC,CACtB,KAAK,OAAO,UAAU,UAAUH,aAA2B,UAAU,MAAM,MAAM,CAAC,CAAC;EACxF;EACA;EACA;EACD,CAAC;EACF,CACH"}

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

@@ -0,0 +1,4 @@
+import "./types-DWwkMzxG.js";
+import "./cassette-store-BunkvLoV.js";
+import { r as layer, t as FileSystemCassetteStoreConfig } from "./file-system-cassette-store-LXpwwrw3.js";
+export { FileSystemCassetteStoreConfig, layer };

package/dist/file-system-cassette-store.js

@@ -0,0 +1,5 @@
+import "./cassette-store-CnXX5OLB.js";
+import "./vitest-state-BOynp4Va.js";
+import { n as layer } from "./file-system-cassette-store-zWkrhhlO.js";
+
+export { layer };