@studiocms/cfetch 0.2.1 → 0.3.1

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

@@ -1,42 +1,41 @@
-/**
- * @module cfetch/wrappers
- *
- * Provides cached fetch wrappers using Effect for caching capabilities.
- *
- * This module exports functions to perform HTTP requests with built-in caching logic.
- * It defines types for cached responses and errors, and implements functions to fetch
- * data with various parsing options (JSON, text, Blob) while leveraging an in-memory
- * cache layer.
- */
-import { type Duration, Effect } from 'effect';
-export type { CacheConfig } from './types.js';
-export { Duration } from 'effect';
-declare const FetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "FetchError";
+import { CacheConfig } from "./types.mjs";
+import { Duration, Duration as Duration$1, Effect } from "effect";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/wrappers.d.ts
+declare const FetchError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "FetchError";
 } & Readonly<A>;
 /**
  * Custom error type for fetch-related errors.
  */
-export declare class FetchError extends FetchError_base<{
-    message: string;
-    cause?: unknown;
-}> {
-}
-export interface CachedResponse<T> {
-    data: T;
-    ok: boolean;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
+declare class FetchError extends FetchError_base<{
+  message: string;
+  cause?: unknown;
+}> {}
+interface CachedResponse<T> {
+  data: T;
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
 }
 /**
  * Configuration options for cached fetch requests.
  */
-export interface CFetchConfig {
-    ttl?: Duration.DurationInput;
-    tags?: string[];
-    key?: string;
-    verbose?: boolean;
+interface CFetchConfig {
+  ttl?: Duration$1.DurationInput;
+  tags?: string[];
+  key?: string;
+  verbose?: boolean;
+}
+/**
+ * Options for cache invalidation.
+ */
+interface InvalidateCacheOptions {
+  keys?: string[];
+  tags?: string[];
 }
 /**
  * No-op parser for HEAD requests.
@@ -45,7 +44,7 @@ export interface CFetchConfig {
  * @param _ - The Response object (ignored)
  * @returns A Promise that resolves to undefined
  */
-export declare const noOpParser: <U>(_: Response) => Promise<U>;
+declare const noOpParser: <U>(_: Response) => Promise<U>;
 /**
  * Fetches data from a URL with caching capabilities using Effect.
  *
@@ -87,7 +86,25 @@ export declare const noOpParser: <U>(_: Response) => Promise<U>;
  * );
  * ```
  */
-export declare const cFetchEffect: <T>(url: string | URL, parser: (response: Response) => Promise<T>, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<T>, FetchError, never>;
+declare const cFetchEffect: <T>(url: string | URL, parser: (response: Response) => Promise<T>, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<T>, FetchError, never>;
+/**
+ * Invalidates cache entries based on specified keys or tags.
+ *
+ * @param opts - An object containing optional keys and tags for cache invalidation
+ * @param opts.keys - An array of specific cache keys to invalidate
+ * @param opts.tags - An array of tags; all cache entries associated with these tags will be invalidated
+ *
+ * @returns An Effect that performs the cache invalidation when executed
+ *
+ * @example
+ * ```typescript
+ * yield* invalidateCacheEffect({
+ *   tags: ['user'],
+ *   keys: ['user:123', 'user:456']
+ * });
+ * ```
+ */
+declare const invalidateCacheEffect: (opts: InvalidateCacheOptions) => Effect.Effect<void, never, never>;
 /**
  * Creates an Effect that fetches JSON data from a URL with caching support.
  *
@@ -109,7 +126,7 @@ export declare const cFetchEffect: <T>(url: string | URL, parser: (response: Res
  * );
  * ```
  */
-export declare const cFetchEffectJson: <T>(url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<T>, FetchError, never>;
+declare const cFetchEffectJson: <T>(url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<T>, FetchError, never>;
 /**
  * Fetches a resource from the specified URL and returns the response body as text.
  *
@@ -132,7 +149,7 @@ export declare const cFetchEffectJson: <T>(url: string | URL, options?: RequestI
  * );
  * ```
  */
-export declare const cFetchEffectText: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<string>, FetchError, never>;
+declare const cFetchEffectText: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<string>, FetchError, never>;
 /**
  * Fetches a resource and returns it as a Blob with caching support.
  *
@@ -154,7 +171,7 @@ export declare const cFetchEffectText: (url: string | URL, options?: RequestInit
  * );
  * ```
  */
-export declare const cFetchEffectBlob: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<Blob>, FetchError, never>;
+declare const cFetchEffectBlob: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<Blob>, FetchError, never>;
 /**
  * Executes a cached fetch request with configurable caching behavior.
  *
@@ -178,7 +195,7 @@ export declare const cFetchEffectBlob: (url: string | URL, options?: RequestInit
  * );
  * ```
  */
-export declare const cFetch: <T>(url: string | URL, parser: (response: Response) => Promise<T>, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<T>>;
+declare const cFetch: <T>(url: string | URL, parser: (response: Response) => Promise<T>, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<T>>;
 /**
  * Fetches and parses JSON data from the specified URL with caching support.
  *
@@ -202,7 +219,7 @@ export declare const cFetch: <T>(url: string | URL, parser: (response: Response)
  * });
  * ```
  */
-export declare const cFetchJson: <T>(url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<T>>;
+declare const cFetchJson: <T>(url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<T>>;
 /**
  * Fetches a URL and returns the response as text with caching support.
  *
@@ -224,7 +241,7 @@ export declare const cFetchJson: <T>(url: string | URL, options?: RequestInit, c
  * });
  * ```
  */
-export declare const cFetchText: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<string>>;
+declare const cFetchText: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<string>>;
 /**
  * Fetches a Blob resource from the specified URL with optional caching configuration.
  *
@@ -242,4 +259,24 @@ export declare const cFetchText: (url: string | URL, options?: RequestInit, cach
  * const blob = response.data;
  * ```
  */
-export declare const cFetchBlob: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<Blob>>;
+declare const cFetchBlob: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<Blob>>;
+/**
+ * Invalidates cache entries based on specified keys or tags.
+ *
+ * @param opts - An object containing optional keys and tags for cache invalidation
+ * @param opts.keys - An array of specific cache keys to invalidate
+ * @param opts.tags - An array of tags; all cache entries associated with these tags will be invalidated
+ *
+ * @returns A Promise that resolves when the cache invalidation is complete
+ *
+ * @example
+ * ```typescript
+ * await invalidateCache({
+ *   tags: ['user'],
+ *   keys: ['user:123', 'user:456']
+ * });
+ * ```
+ */
+declare const invalidateCache: (opts: InvalidateCacheOptions) => Promise<void>;
+//#endregion
+export { CFetchConfig, type CacheConfig, CachedResponse, Duration, FetchError, InvalidateCacheOptions, cFetch, cFetchBlob, cFetchEffect, cFetchEffectBlob, cFetchEffectJson, cFetchEffectText, cFetchJson, cFetchText, invalidateCache, invalidateCacheEffect, noOpParser };

package/dist/wrappers.mjs

@@ -0,0 +1,364 @@
+import { CacheMaps, CacheService } from "./cache.mjs";
+import { Data, Duration, Effect, Layer, Pretty, Schema } from "effect";
+
+//#region src/wrappers.ts
+/**
+* @module cfetch/wrappers
+*
+* Provides cached fetch wrappers using Effect for caching capabilities.
+*
+* This module exports functions to perform HTTP requests with built-in caching logic.
+* It defines types for cached responses and errors, and implements functions to fetch
+* data with various parsing options (JSON, text, Blob) while leveraging an in-memory
+* cache layer.
+*/
+const store = /* @__PURE__ */ new Map();
+const tagIndex = /* @__PURE__ */ new Map();
+const CacheMapLayer = Layer.succeed(CacheMaps, {
+	store,
+	tagIndex
+});
+const CacheLive = CacheService.Default.pipe(Layer.provide(CacheMapLayer));
+/**
+* Custom error type for fetch-related errors.
+*/
+var FetchError = class extends Data.TaggedError("FetchError") {};
+/**
+* Schema for validating cache-relevant fetch options.
+*
+* This schema is used to ensure that only serializable and relevant options are considered
+* when generating cache keys. It includes the HTTP method, headers (as a record of key-value pairs),
+* and body (only if it's a string). Non-serializable options are excluded to prevent cache key collisions.
+*/
+const CacheRelevantOptionsSchema = Schema.Struct({
+	method: Schema.optional(Schema.Union(Schema.String, Schema.Undefined)),
+	headers: Schema.optional(Schema.Union(Schema.Record({
+		key: Schema.String,
+		value: Schema.Any
+	}), Schema.Undefined)),
+	body: Schema.optional(Schema.Union(Schema.String, Schema.Undefined))
+});
+/**
+* Utility to stringify cache-relevant options for generating cache keys.
+*/
+const stringifyRelevantOptions = Pretty.make(CacheRelevantOptionsSchema);
+/**
+* Helper to run an Effect and return a Promise.
+*/
+const runEffect = (effect) => Effect.runPromise(effect);
+const cacheableMethods = ["GET", "HEAD"];
+/**
+* No-op parser for HEAD requests.
+*
+* @template U - The type of the parsed data
+* @param _ - The Response object (ignored)
+* @returns A Promise that resolves to undefined
+*/
+const noOpParser = (_) => Promise.resolve(void 0);
+/**
+* Fetches data from a URL and parses the response using a provided parser function.
+*
+* @template T - The type of the parsed data
+* @param url - The URL to fetch from, either as a string or URL object
+* @param parser - An async function that takes a Response and returns the parsed data of type T
+* @param options - Optional fetch configuration options (headers, method, body, etc.)
+* @returns An Effect that yields a CachedResponse containing the parsed data, response status, headers, and metadata
+* @throws {FetchError} When the fetch operation fails or when response parsing fails
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   fetchAndParse('https://api.example.com/data', (res) => res.json())
+* );
+* ```
+*/
+const fetchAndParse = (url, parser, options) => Effect.gen(function* () {
+	const response = yield* Effect.tryPromise({
+		try: () => fetch(url, options),
+		catch: (cause) => new FetchError({
+			message: "Failed to fetch",
+			cause
+		})
+	});
+	return {
+		data: yield* Effect.tryPromise({
+			try: () => parser(response),
+			catch: (cause) => new FetchError({
+				message: "Failed to parse response",
+				cause
+			})
+		}),
+		ok: response.ok,
+		status: response.status,
+		statusText: response.statusText,
+		headers: Object.fromEntries(response.headers.entries())
+	};
+});
+/**
+* Fetches data from a URL with caching capabilities using Effect.
+*
+* This function performs an HTTP request with built-in caching logic. It first checks
+* the cache for existing data, and if not found, fetches from the network, parses the
+* response, and caches successful responses for future use.
+*
+* @template T - The type of the parsed response data
+*
+* @param url - The URL to fetch data from
+* @param parser - A function that parses the Response object into type T
+* @param options - Optional RequestInit configuration for the fetch request
+* @param cacheConfig - Optional cache configuration object
+* @param cacheConfig.ttl - Time-to-live duration for the cached entry
+* @param cacheConfig.tags - Tags to associate with the cached entry for invalidation
+* @param cacheConfig.key - Custom cache key (defaults to URL and options hash)
+*
+* @returns An Effect that yields a CachedResponse containing the parsed data and response metadata
+*
+* @throws {FetchError} When the network request fails or response parsing fails
+*
+* @remarks
+* - Cache keys are automatically generated from the URL and options if not provided
+* - Only successful responses (response.ok === true) are cached
+* - Only 2xx responses are cached
+* - Users needing negative caching should implement custom logic
+* - The effect is provided with CacheLive layer automatically
+* - Non-cacheable HTTP methods (e.g. POST, PUT) bypass the cache entirely
+* - The parser function is bypassed for HEAD requests, returning undefined data
+* - Verbose logging can be enabled via cacheConfig.verbose
+*
+* @example
+* ```typescript
+* const effect = cFetchEffect(
+*   'https://api.example.com/data',
+*   (res) => res.json(),
+*   { method: 'GET' },
+*   { ttl: Duration.minutes(5), tags: ['api-data'] }
+* );
+* ```
+*/
+const cFetchEffect = (url, parser, options, cacheConfig) => Effect.gen(function* () {
+	const cache = yield* CacheService;
+	const { key, verbose = false, ...cacheOpts } = cacheConfig || {};
+	const method = options?.method?.toUpperCase() || "GET";
+	if (!cacheableMethods.includes(method)) {
+		if (verbose) console.log(`[c:fetch] Bypassing cache for non-cacheable method: ${method}`);
+		return yield* fetchAndParse(url, parser, options);
+	}
+	const urlString = typeof url === "string" ? url : url.href;
+	const cacheRelevantOptions = options ? {
+		method: options.method,
+		headers: options.headers instanceof Headers ? Object.fromEntries([...options.headers.entries()].sort(([a], [b]) => a.localeCompare(b))) : options.headers ? Object.fromEntries(Object.entries(options.headers).sort(([a], [b]) => a.localeCompare(b))) : void 0,
+		body: typeof options.body === "string" ? options.body : void 0
+	} : {};
+	if (options?.body && typeof options.body !== "string" && !key && verbose) console.warn(`[c:fetch] Non-serializable request body detected for ${urlString}. Consider providing an explicit cache key via cacheConfig.key to avoid collisions.`);
+	const cacheKey = key ?? `${urlString}-${stringifyRelevantOptions(cacheRelevantOptions)}`;
+	const cached = yield* cache.get(cacheKey);
+	if (cached) {
+		if (verbose) console.log(`[c:fetch] Cache hit for: ${cacheKey}, returning cached response.`);
+		return cached;
+	}
+	if (verbose) console.log(`[c:fetch] Cache miss for: ${cacheKey}, fetching from network.`);
+	const cachedResponse = yield* fetchAndParse(url, method === "HEAD" ? noOpParser : parser, options);
+	if (cachedResponse.ok) {
+		yield* cache.set(cacheKey, cachedResponse, cacheOpts);
+		if (verbose) console.log(`[c:fetch] Cached response for: ${cacheKey}`);
+	}
+	return cachedResponse;
+}).pipe(Effect.provide(CacheLive));
+/**
+* Invalidates cache entries based on specified keys or tags.
+*
+* @param opts - An object containing optional keys and tags for cache invalidation
+* @param opts.keys - An array of specific cache keys to invalidate
+* @param opts.tags - An array of tags; all cache entries associated with these tags will be invalidated
+*
+* @returns An Effect that performs the cache invalidation when executed
+*
+* @example
+* ```typescript
+* yield* invalidateCacheEffect({
+*   tags: ['user'],
+*   keys: ['user:123', 'user:456']
+* });
+* ```
+*/
+const invalidateCacheEffect = (opts) => Effect.gen(function* () {
+	const cache = yield* CacheService;
+	if (opts.keys) for (const key of opts.keys) yield* cache.delete(key);
+	if (opts.tags) yield* cache.invalidateTags(opts.tags);
+}).pipe(Effect.provide(CacheLive));
+/**
+* Creates an Effect that fetches JSON data from a URL with caching support.
+*
+* @template T - The expected type of the JSON response data
+* @param url - The URL to fetch data from
+* @param options - Optional fetch configuration options (headers, method, etc.)
+* @param cacheConfig - Optional cache configuration
+* @param cacheConfig.ttl - Time-to-live duration for the cached response
+* @param cacheConfig.tags - Tags to associate with the cached entry for invalidation
+* @param cacheConfig.key - Custom cache key to use instead of the default URL-based key
+* @returns An Effect that yields a CachedResponse containing the parsed JSON data, or fails with a FetchError
+*
+* @example
+* ```typescript
+* const effect = cFetchEffectJson<User>(
+*   'https://api.example.com/user/123',
+*   { method: 'GET' },
+*   { ttl: Duration.minutes(5), tags: ['user'] }
+* );
+* ```
+*/
+const cFetchEffectJson = (url, options, cacheConfig) => cFetchEffect(url, (res) => res.json(), options, cacheConfig);
+/**
+* Fetches a resource from the specified URL and returns the response body as text.
+*
+* @param url - The URL to fetch the resource from.
+* @param options - Optional fetch configuration including method, headers, body, etc.
+* @param cacheConfig - Optional cache configuration.
+* @param cacheConfig.ttl - Time-to-live duration for the cached response.
+* @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes.
+* @param cacheConfig.key - Custom cache key. If not provided, the URL will be used as the key.
+*
+* @returns An Effect that resolves to a CachedResponse containing the response text,
+*          or fails with a FetchError if the request fails.
+*
+* @example
+* ```typescript
+* const textEffect = cFetchEffectText(
+*   'https://api.example.com/data',
+*   { method: 'GET' },
+*   { ttl: Duration.minutes(5), tags: ['api', 'data'] }
+* );
+* ```
+*/
+const cFetchEffectText = (url, options, cacheConfig) => cFetchEffect(url, (res) => res.text(), options, cacheConfig);
+/**
+* Fetches a resource and returns it as a Blob with caching support.
+*
+* @param url - The URL of the resource to fetch
+* @param options - Optional fetch request configuration (headers, method, etc.)
+* @param cacheConfig - Optional cache configuration object
+* @param cacheConfig.ttl - Time-to-live duration for the cached response
+* @param cacheConfig.tags - Array of tags to associate with the cached entry
+* @param cacheConfig.key - Custom cache key to use instead of the default
+*
+* @returns An Effect that resolves to a CachedResponse containing a Blob, or fails with a FetchError
+*
+* @example
+* ```typescript
+* const imageEffect = cFetchEffectBlob(
+*   'https://example.com/image.png',
+*   { method: 'GET' },
+*   { ttl: Duration.hours(1), tags: ['images'] }
+* );
+* ```
+*/
+const cFetchEffectBlob = (url, options, cacheConfig) => cFetchEffect(url, (res) => res.blob(), options, cacheConfig);
+/**
+* Executes a cached fetch request with configurable caching behavior.
+*
+* @template T - The type of data returned after parsing the response
+* @param url - The URL to fetch from
+* @param parser - A function that parses the Response object into the desired type T
+* @param options - Optional fetch request configuration (headers, method, body, etc.)
+* @param cacheConfig - Optional cache configuration object
+* @param cacheConfig.ttl - Time-to-live duration for the cached response
+* @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes
+* @param cacheConfig.key - Custom cache key; if not provided, a key will be generated from the URL and options
+* @returns A Promise that resolves to a CachedResponse containing the parsed data
+*
+* @example
+* ```typescript
+* const result = await cFetch(
+*   'https://api.example.com/data',
+*   (res) => res.json(),
+*   { method: 'GET' },
+*   { ttl: Duration.minutes(5), tags: ['api-data'] }
+* );
+* ```
+*/
+const cFetch = (url, parser, options, cacheConfig) => runEffect(cFetchEffect(url, parser, options, cacheConfig));
+/**
+* Fetches and parses JSON data from the specified URL with caching support.
+*
+* @template T - The expected type of the parsed JSON response data
+* @param url - The URL to fetch data from
+* @param options - Optional fetch configuration options (headers, method, body, etc.)
+* @param cacheConfig - Optional cache configuration object
+* @param cacheConfig.ttl - Time-to-live duration for the cached response
+* @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes
+* @param cacheConfig.key - Custom cache key to use instead of the default
+* @returns A Promise that resolves to a CachedResponse containing the parsed JSON data of type T
+*
+* @example
+* ```typescript
+* const result = await cFetchJson<User>('https://api.example.com/user/123', {
+*   method: 'GET',
+*   headers: { 'Authorization': 'Bearer token' }
+* }, {
+*   ttl: Duration.minutes(5),
+*   tags: ['user-data']
+* });
+* ```
+*/
+const cFetchJson = (url, options, cacheConfig) => runEffect(cFetchEffectJson(url, options, cacheConfig));
+/**
+* Fetches a URL and returns the response as text with caching support.
+*
+* @param url - The URL to fetch
+* @param options - Optional fetch configuration options (headers, method, etc.)
+* @param cacheConfig - Optional cache configuration
+* @param cacheConfig.ttl - Time-to-live duration for the cached response
+* @param cacheConfig.tags - Tags to associate with the cached response for invalidation
+* @param cacheConfig.key - Custom cache key (defaults to URL if not provided)
+* @returns A promise that resolves to a CachedResponse containing the response text
+*
+* @example
+* ```typescript
+* const result = await cFetchText('https://api.example.com/data', {
+*   method: 'GET'
+* }, {
+*   ttl: Duration.hours(1),
+*   tags: ['api', 'data']
+* });
+* ```
+*/
+const cFetchText = (url, options, cacheConfig) => runEffect(cFetchEffectText(url, options, cacheConfig));
+/**
+* Fetches a Blob resource from the specified URL with optional caching configuration.
+*
+* @param url - The URL to fetch the Blob resource from
+* @param options - Optional fetch request configuration (headers, method, etc.)
+* @param cacheConfig - Optional cache configuration object
+* @param cacheConfig.ttl - Time-to-live duration for the cached response
+* @param cacheConfig.tags - Array of cache tags for cache invalidation
+* @param cacheConfig.key - Custom cache key for storing the response
+* @returns A Promise that resolves to a CachedResponse containing a Blob
+*
+* @example
+* ```typescript
+* const response = await cFetchBlob('https://example.com/image.png', {}, { ttl: Duration.minutes(5) });
+* const blob = response.data;
+* ```
+*/
+const cFetchBlob = (url, options, cacheConfig) => runEffect(cFetchEffectBlob(url, options, cacheConfig));
+/**
+* Invalidates cache entries based on specified keys or tags.
+*
+* @param opts - An object containing optional keys and tags for cache invalidation
+* @param opts.keys - An array of specific cache keys to invalidate
+* @param opts.tags - An array of tags; all cache entries associated with these tags will be invalidated
+*
+* @returns A Promise that resolves when the cache invalidation is complete
+*
+* @example
+* ```typescript
+* await invalidateCache({
+*   tags: ['user'],
+*   keys: ['user:123', 'user:456']
+* });
+* ```
+*/
+const invalidateCache = (opts) => runEffect(invalidateCacheEffect(opts));
+
+//#endregion
+export { Duration, FetchError, cFetch, cFetchBlob, cFetchEffect, cFetchEffectBlob, cFetchEffectJson, cFetchEffectText, cFetchJson, cFetchText, invalidateCache, invalidateCacheEffect, noOpParser };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studiocms/cfetch",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Astro integration that allows you to have a cached fetch function in your Astro SSR project.",
   "license": "MIT",
   "homepage": "https://studiocms.dev",
@@ -41,29 +41,32 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     },
     "./types": {
-      "types": "./dist/types.d.ts",
-      "default": "./dist/types.js"
+      "types": "./dist/types.d.mts",
+      "default": "./dist/types.mjs"
     }
   },
   "devDependencies": {
     "@inox-tools/astro-tests": "^0.8.1",
     "@types/node": "^22.0.0",
     "jest-extended": "^7.0.0",
-    "astro": "^5.16.16",
-    "effect": "^3.19.15"
+    "astro": "^5.17.1",
+    "effect": "^3.19.16"
   },
   "peerDependencies": {
-    "astro": "^5.16.6",
+    "astro": ">=5.16.6",
     "effect": "^3.19.13",
     "vite": "^6.4.1"
   },
   "scripts": {
-    "build": "buildkit build 'src/**/*.{ts,astro,css,js}'",
-    "dev": "buildkit dev 'src/**/*.{ts,astro,css,js}'",
-    "jsr": "jsr publish"
+    "build": "tsdown --config ./tsdown.config.ts --clean",
+    "dev": "tsdown --config ./tsdown.config.ts --watch",
+    "effect-check": "pnpm effect-language-service diagnostics --project tsconfig.tspc.json",
+    "typecheck": "tspc -p tsconfig.tspc.json",
+    "jsr": "jsr publish",
+    "ci:effect-check": "pnpm effect-check --format github-actions"
   }
 }