@studiocms/cfetch 0.2.0 → 0.3.0

package/dist/cache.js

@@ -1,89 +0,0 @@
-import { Clock, Context, Duration, Effect } from "effect";
-import { defaultConfigLive } from "./consts";
-class CacheMaps extends Context.Tag("@studiocms/cfetch/CacheMaps")() {
-}
-class ConfigFetchError {
-  _tag = "ConfigFetchError";
-}
-const getConfig = async () => {
-  try {
-    const config = await import("virtual:cfetch/config");
-    return config.default;
-  } catch (error) {
-    console.warn("Could not load virtual:cfetch/config, using default config.");
-    return defaultConfigLive;
-  }
-};
-class CacheService extends Effect.Service()("@studiocms/cfetch/CacheService", {
-  effect: Effect.gen(function* () {
-    const { store, tagIndex } = yield* CacheMaps;
-    const config = yield* Effect.tryPromise({
-      try: () => getConfig(),
-      catch: () => new ConfigFetchError()
-    }).pipe(Effect.catchTag("ConfigFetchError", () => Effect.succeed(defaultConfigLive)));
-    const get = (key) => Effect.gen(function* () {
-      const now = yield* Clock.currentTimeMillis;
-      const entry = store.get(key);
-      if (!entry) return null;
-      if (entry.expiresAt < now) {
-        yield* deleteKey(key);
-        return null;
-      }
-      return entry.value;
-    });
-    const set = (key, value, options) => Effect.gen(function* () {
-      const now = yield* Clock.currentTimeMillis;
-      const ttl = options?.ttl ?? Duration.millis(config.lifetime);
-      const tags = new Set(options?.tags ?? []);
-      const expiresAt = now + Duration.toMillis(ttl);
-      store.set(key, { value, expiresAt, lastUpdatedAt: now, tags });
-      for (const tag of tags) {
-        if (!tagIndex.has(tag)) {
-          tagIndex.set(tag, /* @__PURE__ */ new Set());
-        }
-        tagIndex.get(tag)?.add(key);
-      }
-    });
-    const deleteKey = (key) => Effect.sync(() => {
-      const entry = store.get(key);
-      if (entry) {
-        for (const tag of entry.tags) {
-          const keys = tagIndex.get(tag);
-          if (keys) {
-            keys.delete(key);
-            if (keys.size === 0) {
-              tagIndex.delete(tag);
-            }
-          }
-        }
-        store.delete(key);
-      }
-    });
-    const invalidateTags = (tags) => Effect.gen(function* () {
-      for (const tag of tags) {
-        const keys = tagIndex.get(tag);
-        if (keys) {
-          for (const key of [...keys]) {
-            yield* deleteKey(key);
-          }
-        }
-      }
-    });
-    const clear = () => Effect.sync(() => {
-      store.clear();
-      tagIndex.clear();
-    });
-    return {
-      get,
-      set,
-      delete: deleteKey,
-      invalidateTags,
-      clear
-    };
-  })
-}) {
-}
-export {
-  CacheMaps,
-  CacheService
-};

package/dist/consts.d.ts

@@ -1,8 +0,0 @@
-/**
- * @module cfetch/consts
- *
- * Constant values used throughout the cfetch package.
- */
-import type { CacheConfig, CacheConfigLive } from './types.js';
-export declare const defaultConfig: CacheConfig;
-export declare const defaultConfigLive: CacheConfigLive;

package/dist/consts.js

@@ -1,11 +0,0 @@
-import { Duration } from "effect";
-const defaultConfig = {
-  lifetime: Duration.hours(1)
-};
-const defaultConfigLive = {
-  lifetime: Duration.toMillis(Duration.hours(1))
-};
-export {
-  defaultConfig,
-  defaultConfigLive
-};

package/dist/index.d.ts

@@ -1,66 +0,0 @@
-/**
- * @module @studiocms/cfetch
- *
- * An Astro integration that provides a caching fetch utility using Effect.
- *
- * This module exports the `cFetch` function, which can be used to create an Astro
- * integration that adds virtual modules for cached fetching capabilities. It also
- * exports the `Duration` type from Effect for specifying cache lifetimes.
- *
- * The `cFetch` integration injects virtual modules:
- * - `virtual:cfetch/config`: Exports the default cache configuration.
- * - `c:fetch`: Exports various cached fetch functions and types.
- *
- * Example usage:
- *
- * ```ts
- * import cFetch, { Duration } from '@studiocms/cfetch';
- * import { defineConfig } from 'astro/config';
- *
- * export default defineConfig({
- *   integrations: [
- *     cFetch({
- *       lifetime: Duration.minutes(5), // Set cache lifetime to 5 minutes (default is 1 hour)
- *     }),
- *   ],
- * });
- * ```
- *
- * You can then use the cached fetch functions in your Astro components or pages:
- *
- * ```ts
- * import { cFetch } from 'c:fetch';
- *
- * const response = await cFetch('https://api.example.com/data', (res) => res.json());
- * console.log(response.data);
- * ```
- */
-import type { AstroIntegration } from 'astro';
-import type { CacheConfig } from './types.js';
-export { Duration } from 'effect';
-/**
- * Creates a caching fetch integration for Astro.
- *
- * This integration provides a cached fetch implementation that can be configured
- * with custom cache lifetime and other options. It sets up virtual module imports
- * and injects TypeScript type definitions for the cached fetch functionality.
- *
- * @param opts - Optional cache configuration options to customize the caching behavior
- * @returns An Astro integration object with hooks for configuration setup and completion
- *
- * @example
- * ```typescript
- * // astro.config.mjs
- * import cFetch, { Duration } from '@studiocms/cfetch';
- *
- * export default defineConfig({
- *   integrations: [
- *     cFetch({
- *       lifetime: Duration.minutes(10), // Cache entries live for 10 minutes (default is 1 hour)
- *     })
- *   ]
- * });
- * ```
- */
-export declare function cFetch(opts?: CacheConfig): AstroIntegration;
-export default cFetch;

package/dist/index.js

@@ -1,42 +0,0 @@
-import { Duration } from "effect";
-import { defaultConfig } from "./consts.js";
-import stub from "./stub.js";
-import { addVirtualImports, createResolver } from "./utils/integration.js";
-import { Duration as Duration2 } from "effect";
-function cFetch(opts) {
-  const name = "@studiocms/cfetch";
-  const { resolve } = createResolver(import.meta.url);
-  const options = {
-    ...defaultConfig,
-    ...opts
-  };
-  return {
-    name,
-    hooks: {
-      "astro:config:setup": (params) => {
-        addVirtualImports(params, {
-          name,
-          imports: {
-            "virtual:cfetch/config": `export default ${JSON.stringify({
-              // Convert Duration.DurationInput to milliseconds number (required to preserve value through JSON.stringify)
-              lifetime: Duration.toMillis(options.lifetime)
-            })}`,
-            "c:fetch": `export * from '${resolve("./wrappers.js")}';`
-          }
-        });
-      },
-      "astro:config:done": ({ injectTypes }) => {
-        injectTypes({
-          filename: "cfetch.d.ts",
-          content: stub
-        });
-      }
-    }
-  };
-}
-var index_default = cFetch;
-export {
-  Duration2 as Duration,
-  cFetch,
-  index_default as default
-};

package/dist/stub.d.ts

@@ -1,6 +0,0 @@
-/**
- * This module contains a stub file for type generation
- * @module
- */
-declare const stub: string;
-export default stub;

package/dist/utils/integration.js

@@ -1,266 +0,0 @@
-import { fileURLToPath } from "node:url";
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-const isAbsolute = (p) => _IS_ABSOLUTE_RE.test(p);
-const dirname = (p) => {
-  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
-    segments[0] += "/";
-  }
-  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-};
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) {
-      } else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-          if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-const resolve = (...arguments_) => {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-const createResolver = (_base) => {
-  let base = _base;
-  if (base.startsWith("file://")) {
-    base = dirname(fileURLToPath(base));
-  }
-  return {
-    resolve: (...path) => resolve(base, ...path)
-  };
-};
-const defineUtility = (_hook) => (
-  /**
-   * The function itself
-   * @param {Function} fn;
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  (fn) => fn
-);
-function getPluginNames(plugins) {
-  const names = [];
-  if (plugins) {
-    for (const plugin of plugins) {
-      if (!plugin) continue;
-      if (Array.isArray(plugin)) {
-        names.push(...getPluginNames(plugin));
-        continue;
-      }
-      if (plugin instanceof Promise) {
-        continue;
-      }
-      names.push(plugin.name);
-    }
-  }
-  return names;
-}
-const hasVitePlugin = defineUtility("astro:config:setup")(
-  ({ config }, {
-    plugin
-  }) => {
-    if (!plugin || plugin instanceof Promise) return false;
-    const currentPlugins = new Set(getPluginNames(config?.vite?.plugins));
-    const plugins = /* @__PURE__ */ new Set();
-    if (typeof plugin === "string") {
-      plugins.add(plugin);
-    }
-    if (typeof plugin === "object") {
-      if (Array.isArray(plugin)) {
-        const names = new Set(
-          getPluginNames(plugin)
-        );
-        for (const name of names) plugins.add(name);
-      } else {
-        plugins.add(plugin.name);
-      }
-    }
-    return [...plugins].some((name) => currentPlugins.has(name));
-  }
-);
-const addVitePlugin = defineUtility("astro:config:setup")(
-  (params, {
-    plugin,
-    warnDuplicated = true
-  }) => {
-    const { updateConfig, logger } = params;
-    if (warnDuplicated && hasVitePlugin(params, { plugin })) {
-      logger.warn(
-        `The Vite plugin "${plugin.name}" is already present in your Vite configuration, this plugin may not behave correctly.`
-      );
-    }
-    updateConfig({
-      vite: {
-        plugins: [plugin]
-      }
-    });
-  }
-);
-const incrementPluginName = (name) => {
-  let count = 1;
-  return `${name.replace(/-(\d+)$/, (_, c) => {
-    count = Number.parseInt(c) + 1;
-    return "";
-  })}-${count}`;
-};
-const resolveVirtualModuleId = (id) => {
-  return `\0${id}`;
-};
-const createVirtualModule = (name, _imports, bypassCoreValidation) => {
-  const imports = Array.isArray(_imports) ? _imports : Object.entries(_imports).map(([id, content]) => ({
-    id,
-    content,
-    context: void 0
-  }));
-  const duplicatedImports = {};
-  for (const { id, context } of imports) {
-    duplicatedImports[id] ??= [];
-    duplicatedImports[id]?.push(...context === void 0 ? ["server", "client"] : [context]);
-  }
-  for (const [id, contexts] of Object.entries(duplicatedImports)) {
-    if (contexts.length !== [...new Set(contexts)].length) {
-      throw new Error(
-        `Virtual import with id "${id}" has been registered several times with conflicting contexts.`
-      );
-    }
-  }
-  const resolutionMap = Object.fromEntries(
-    imports.map(({ id }) => {
-      if (!bypassCoreValidation && id.startsWith("astro:")) {
-        throw new Error(
-          `Virtual import name prefix can't be "astro:" (for "${id}") because it's reserved for Astro core.`
-        );
-      }
-      return [resolveVirtualModuleId(id), id];
-    })
-  );
-  return {
-    name,
-    resolveId(id) {
-      if (imports.find((_import) => _import.id === id)) {
-        return resolveVirtualModuleId(id);
-      }
-      return;
-    },
-    load(id, options) {
-      const resolution = resolutionMap[id];
-      if (resolution) {
-        const context = options?.ssr ? "server" : "client";
-        const data = imports.find(
-          (_import) => _import.id === resolution && (_import.context === void 0 || _import.context === context)
-        );
-        if (data) {
-          return data.content;
-        }
-      }
-      return;
-    }
-  };
-};
-const addVirtualImports = defineUtility("astro:config:setup")(
-  (params, {
-    name,
-    imports,
-    __enableCorePowerDoNotUseOrYouWillBeFired = false
-  }) => {
-    let pluginName = `vite-plugin-${name}`;
-    while (hasVitePlugin(params, { plugin: pluginName }))
-      pluginName = incrementPluginName(pluginName);
-    addVitePlugin(params, {
-      warnDuplicated: false,
-      plugin: createVirtualModule(pluginName, imports, __enableCorePowerDoNotUseOrYouWillBeFired)
-    });
-  }
-);
-export {
-  addVirtualImports,
-  addVitePlugin,
-  createResolver,
-  defineUtility,
-  dirname,
-  hasVitePlugin,
-  isAbsolute,
-  normalizeString,
-  normalizeWindowsPath,
-  resolve
-};

package/dist/wrappers.js

@@ -1,87 +0,0 @@
-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 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}-${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;
-  }
-  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,
-  cFetchBlob,
-  cFetchEffect,
-  cFetchEffectBlob,
-  cFetchEffectJson,
-  cFetchEffectText,
-  cFetchJson,
-  cFetchText,
-  noOpParser
-};