@studiocms/cfetch 0.1.6 → 0.2.0

package/dist/wrappers.js

@@ -1,47 +1,87 @@
-import { defaultConfig as _config } from "./consts.js";
-import isOlderThan from "./utils/isOlderThan.js";
-const defaultConfig = await import("virtual:cfetch/config").then((mod) => {
-  return mod.default;
-}).catch(() => {
-  return _config;
+import { Data, Effect, Layer } from "effect";
+import { CacheMaps, CacheService } from "./cache.js";
+import { Duration } from "effect";
+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));
+class FetchError extends Data.TaggedError("FetchError") {
+}
+const runEffect = (effect) => Effect.runPromise(effect);
+const cacheableMethods = ["GET", "HEAD"];
+const noOpParser = (_) => Promise.resolve(void 0);
+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 })
+  });
+  const data = yield* Effect.tryPromise({
+    try: () => parser(response),
+    catch: (cause) => new FetchError({ message: "Failed to parse response", cause })
+  });
+  return {
+    data,
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries())
+  };
 });
-const cachedData = /* @__PURE__ */ new Map();
-async function cFetch(input, init = {}, cacheConfig = defaultConfig, type = "json", metadata = false) {
-  if (init?.method && init.method !== "GET") {
+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(
-      "Warning: cFetch is designed for GET requests. Using it with other methods will not cache the response."
+      `[c:fetch] Non-serializable request body detected for ${urlString}. Consider providing an explicit cache key via cacheConfig.key to avoid collisions.`
     );
-    const response = await fetch(input, init);
-    const data = type === "json" ? await response.clone().json() : await response.clone().text();
-    const result = new Response(type === "json" ? JSON.stringify(data) : data, response);
-    return metadata ? { lastCheck: /* @__PURE__ */ new Date(), data: result } : result;
   }
-  const { lifetime } = { ...defaultConfig, ...cacheConfig };
-  const key = input.toString();
-  const storedData = cachedData.get(key);
-  if (!storedData || isOlderThan(storedData.lastCheck, lifetime)) {
-    const response = await fetch(input, init);
-    if (!response.ok) {
-      if (!storedData) {
-        throw new Error("Failed to retrieve cached data, and failed to fetch new data");
-      }
-      const fallback = new Response(
-        type === "json" ? JSON.stringify(storedData.data) : storedData.data
-      );
-      return metadata ? { ...storedData, data: fallback } : fallback;
-    }
-    const data = type === "json" ? await response.clone().json() : await response.clone().text();
-    const newCachedData = { lastCheck: /* @__PURE__ */ new Date(), data };
-    cachedData.set(key, newCachedData);
-    const result = new Response(type === "json" ? JSON.stringify(data) : data, response);
-    return metadata ? { ...newCachedData, data: result } : result;
+  const cacheKey = key ?? `${urlString}-${JSON.stringify(cacheRelevantOptions)}`;
+  const cached = yield* cache.get(cacheKey);
+  if (cached) {
+    if (verbose) console.log(`[c:fetch] Cache hit for: ${cacheKey}, returning cached response.`);
+    return cached;
   }
-  const cachedResponse = new Response(
-    type === "json" ? JSON.stringify(storedData.data) : storedData.data
-  );
-  return metadata ? { ...storedData, data: cachedResponse } : cachedResponse;
-}
+  if (verbose) console.log(`[c:fetch] Cache miss for: ${cacheKey}, fetching from network.`);
+  const effectiveParser = method === "HEAD" ? noOpParser : parser;
+  const cachedResponse = yield* fetchAndParse(url, effectiveParser, 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));
+const cFetchEffectJson = (url, options, cacheConfig) => cFetchEffect(url, (res) => res.json(), options, cacheConfig);
+const cFetchEffectText = (url, options, cacheConfig) => cFetchEffect(url, (res) => res.text(), options, cacheConfig);
+const cFetchEffectBlob = (url, options, cacheConfig) => cFetchEffect(url, (res) => res.blob(), options, cacheConfig);
+const cFetch = (url, parser, options, cacheConfig) => runEffect(cFetchEffect(url, parser, options, cacheConfig));
+const cFetchJson = (url, options, cacheConfig) => runEffect(cFetchEffectJson(url, options, cacheConfig));
+const cFetchText = (url, options, cacheConfig) => runEffect(cFetchEffectText(url, options, cacheConfig));
+const cFetchBlob = (url, options, cacheConfig) => runEffect(cFetchEffectBlob(url, options, cacheConfig));
 export {
+  Duration,
+  FetchError,
   cFetch,
-  cachedData
+  cFetchBlob,
+  cFetchEffect,
+  cFetchEffectBlob,
+  cFetchEffectJson,
+  cFetchEffectText,
+  cFetchJson,
+  cFetchText,
+  noOpParser
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studiocms/cfetch",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Astro integration that allows you to have a cached fetch function in your Astro SSR project.",
   "license": "MIT",
   "homepage": "https://studiocms.dev",
@@ -50,14 +50,16 @@
     }
   },
   "devDependencies": {
-    "@inox-tools/astro-tests": "^0.5.1",
+    "@inox-tools/astro-tests": "^0.8.0",
     "@types/node": "^22.0.0",
-    "jest-extended": "^4.0.2",
-    "astro": "^5.5"
+    "jest-extended": "^7.0.0",
+    "astro": "^5.16.6",
+    "effect": "^3.19.14"
   },
   "peerDependencies": {
-    "astro": "^5.5",
-    "vite": "^6.2.0"
+    "astro": "^5.16.6",
+    "effect": "^3.19.13",
+    "vite": "^6.4.1"
   },
   "scripts": {
     "build": "buildkit build 'src/**/*.{ts,astro,css,js}'",

package/dist/utils/isOlderThan.d.ts

@@ -1,13 +0,0 @@
-/**
- * This module contains helper functions for cFetch
- * @module
- */
-/**
- * Determines whether a given date is older than a specified lifetime.
- *
- * @param date - The date to compare against the current time.
- * @param lifetime - The lifetime duration in the format of `${number}m` for minutes
- *                   or `${number}h` for hours (e.g., "30m" or "2h").
- * @returns `true` if the given date is older than the specified lifetime, otherwise `false`.
- */
-export default function isOlderThan(date: Date, lifetime: `${number}m` | `${number}h`): boolean;

package/dist/utils/isOlderThan.js

@@ -1,13 +0,0 @@
-function isOlderThan(date, lifetime) {
-  const now = /* @__PURE__ */ new Date();
-  let milliseconds = 0;
-  if (lifetime.endsWith("m")) {
-    milliseconds = Number.parseInt(lifetime) * 60 * 1e3;
-  } else if (lifetime.endsWith("h")) {
-    milliseconds = Number.parseInt(lifetime) * 60 * 60 * 1e3;
-  }
-  return date < new Date(now.getTime() - milliseconds);
-}
-export {
-  isOlderThan as default
-};