@devite/nuxt-sanity 2.3.2 → 2.4.0

package/dist/module.d.mts

@@ -5,26 +5,33 @@ import { Slug, ImageAsset, PortableTextBlock } from '@sanity/types';
 
 type ModuleOptions = ClientConfig & {
     projectId: string;
-    /** @default 'production' */
+    /** @default "production" */
     dataset: string;
-    /** @default false */
-    minimalClient?: boolean;
+    /** @default { cachingEnabled: true, cacheBaseUrl: "http://localhost:3000", assetEndpoint: "/_sanity/cache/asset", queryEndpoint: "/_sanity/cache/query", webhookEndpoint: "/_sanity/cache/invalidate" } */
+    minimalClient?: boolean | {
+        cachingEnabled?: boolean;
+        cacheBaseUrl?: string;
+        assetEndpoint?: string;
+        queryEndpoint?: string;
+        webhookEndpoint?: string;
+        webhookSecret?: string;
+    };
     /** @default true */
     useCdn?: boolean;
-    /** @default '2024-08-08' */
+    /** @default "2024-08-08" */
     apiVersion?: string;
     visualEditing?: VisualEditingOptions;
 };
 interface VisualEditingOptions {
-    /** @default { enable: "/_sanity/preview/enable", disable: "/_sanity/preview/disable" } */
+    /** @default { enableEndpoint: "/_sanity/preview/enable", disableEndpoint: "/_sanity/preview/disable" } */
     previewMode?: boolean | {
-        enable?: string;
-        disable?: string;
+        enableEndpoint?: string;
+        disableEndpoint?: string;
     };
     previewModeId?: string;
-    /** @default 'live-visual-editing' */
-    mode?: 'live-visual-editing' | 'visual-editing' | 'custom';
-    /** @default '/_sanity/fetch' */
+    /** @default "live-visual-editing" */
+    mode?: SanityVisualEditingMode;
+    /** @default "/_sanity/fetch" */
     proxyEndpoint?: string;
     token?: string;
     studioUrl?: string;
@@ -35,6 +42,7 @@ interface VisualEditingOptions {
     /** @default 100 */
     zIndex?: VisualEditingOptions$1['zIndex'];
 }
+type SanityVisualEditingMode = 'live-visual-editing' | 'visual-editing' | 'custom';
 type SanityVisualEditingRefreshHandler = (payload: HistoryRefresh, refreshDefault: () => false | Promise<void>) => false | Promise<void>;
 
 interface Page {
@@ -99,4 +107,4 @@ type SanityArray<T> = Array<T & {
 
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, _default as default };
+export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingMode, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, _default as default };

package/dist/module.d.ts

@@ -5,26 +5,33 @@ import { Slug, ImageAsset, PortableTextBlock } from '@sanity/types';
 
 type ModuleOptions = ClientConfig & {
     projectId: string;
-    /** @default 'production' */
+    /** @default "production" */
     dataset: string;
-    /** @default false */
-    minimalClient?: boolean;
+    /** @default { cachingEnabled: true, cacheBaseUrl: "http://localhost:3000", assetEndpoint: "/_sanity/cache/asset", queryEndpoint: "/_sanity/cache/query", webhookEndpoint: "/_sanity/cache/invalidate" } */
+    minimalClient?: boolean | {
+        cachingEnabled?: boolean;
+        cacheBaseUrl?: string;
+        assetEndpoint?: string;
+        queryEndpoint?: string;
+        webhookEndpoint?: string;
+        webhookSecret?: string;
+    };
     /** @default true */
     useCdn?: boolean;
-    /** @default '2024-08-08' */
+    /** @default "2024-08-08" */
     apiVersion?: string;
     visualEditing?: VisualEditingOptions;
 };
 interface VisualEditingOptions {
-    /** @default { enable: "/_sanity/preview/enable", disable: "/_sanity/preview/disable" } */
+    /** @default { enableEndpoint: "/_sanity/preview/enable", disableEndpoint: "/_sanity/preview/disable" } */
     previewMode?: boolean | {
-        enable?: string;
-        disable?: string;
+        enableEndpoint?: string;
+        disableEndpoint?: string;
     };
     previewModeId?: string;
-    /** @default 'live-visual-editing' */
-    mode?: 'live-visual-editing' | 'visual-editing' | 'custom';
-    /** @default '/_sanity/fetch' */
+    /** @default "live-visual-editing" */
+    mode?: SanityVisualEditingMode;
+    /** @default "/_sanity/fetch" */
     proxyEndpoint?: string;
     token?: string;
     studioUrl?: string;
@@ -35,6 +42,7 @@ interface VisualEditingOptions {
     /** @default 100 */
     zIndex?: VisualEditingOptions$1['zIndex'];
 }
+type SanityVisualEditingMode = 'live-visual-editing' | 'visual-editing' | 'custom';
 type SanityVisualEditingRefreshHandler = (payload: HistoryRefresh, refreshDefault: () => false | Promise<void>) => false | Promise<void>;
 
 interface Page {
@@ -99,4 +107,4 @@ type SanityArray<T> = Array<T & {
 
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, _default as default };
+export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingMode, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, _default as default };

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@devite/nuxt-sanity",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "configKey": "sanity",
   "builder": {
     "@nuxt/module-builder": "0.8.4",

package/dist/module.mjs

@@ -1,41 +1,47 @@
 import crypto from 'node:crypto';
-import { defineNuxtModule, createResolver, addPlugin, addServerHandler, addImportsDir, addImports, addComponentsDir } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addPlugin, addServerHandler, addImportsDir, addImports, addComponentsDir, installModule } from '@nuxt/kit';
 import defu from 'defu';
 
 const name = "@devite/nuxt-sanity";
-const version = "2.3.2";
+const version = "2.4.0";
 
+const CONFIG_KEY = "sanity";
 const module = defineNuxtModule({
   meta: {
     name,
     version,
-    configKey: "sanity"
+    configKey: CONFIG_KEY
   },
   defaults: {},
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    const moduleConfig = defu(nuxt.options.runtimeConfig.public.sanity, {
+    const $config = nuxt.options.runtimeConfig;
+    const moduleConfig = {
       projectId: options.projectId,
       dataset: options.dataset || "production",
-      minimalClient: options.minimalClient || false,
+      minimalClient: options.minimalClient !== false ? defu(options.minimalClient, {
+        cachingEnabled: true,
+        cacheBaseUrl: "http://localhost:3000",
+        assetEndpoint: "/_sanity/cache/asset",
+        queryEndpoint: "/_sanity/cache/query",
+        webhookEndpoint: "/_sanity/cache/invalidate"
+      }) : false,
       useCdn: options.useCdn || true,
       apiVersion: options.apiVersion || "2024-08-08",
       visualEditing: options.visualEditing || null
-    });
+    };
     nuxt.options.build.transpile.push("@sanity/core-loader");
-    if (options.visualEditing) {
+    if (moduleConfig.visualEditing) {
       const previewMode = moduleConfig.visualEditing.previewMode !== false;
       const visualEditingConfig = defu(moduleConfig.visualEditing, {
         mode: "live-visual-editing",
         previewMode: previewMode ? defu(moduleConfig.visualEditing.previewMode, {
-          enable: "/_sanity/preview/enable",
-          disable: "/_sanity/preview/disable"
+          enableEndpoint: "/_sanity/preview/enable",
+          disableEndpoint: "/_sanity/preview/disable"
         }) : false,
-        previewModeId: previewMode ? crypto.randomBytes(16).toString("hex") : "",
         proxyEndpoint: "/_sanity/fetch",
         stega: true,
-        zIndex: 100,
-        token: ""
+        zIndex: 100
       });
       if (!moduleConfig.visualEditing.token?.length)
         console.warn('Visual editing requires a token with "read" access');
@@ -57,15 +63,15 @@ const module = defineNuxtModule({
         ]
       });
       addPlugin({ src: resolve("runtime/plugins/visual-editing") });
-      if (previewMode) {
+      if (typeof visualEditingConfig.previewMode === "object") {
         addServerHandler({
           method: "get",
-          route: visualEditingConfig.previewMode.enable,
+          route: visualEditingConfig.previewMode.enableEndpoint,
           handler: resolve("runtime/server/routes/preview/enable")
         });
         addServerHandler({
           method: "get",
-          route: visualEditingConfig.previewMode.disable,
+          route: visualEditingConfig.previewMode.disableEndpoint,
           handler: resolve("runtime/server/routes/preview/disable")
         });
       }
@@ -76,8 +82,45 @@ const module = defineNuxtModule({
       });
       moduleConfig.visualEditing = visualEditingConfig;
     }
-    nuxt.options.runtimeConfig.sanity = moduleConfig;
-    nuxt.options.runtimeConfig.public.sanity = defu(nuxt.options.runtimeConfig.public.sanity, {
+    if (typeof moduleConfig.minimalClient === "object" && moduleConfig.minimalClient.cachingEnabled) {
+      nuxt.options.nitro.storage ||= {};
+      nuxt.options.nitro.storage.sanityDocumentDeps = {
+        driver: "fsLite",
+        base: ".tmp/sanityDocumentDeps"
+      };
+      nuxt.options.nitro.storage.sanityData = {
+        driver: "fsLite",
+        base: ".tmp/sanityData"
+      };
+      addServerHandler({
+        method: "get",
+        route: moduleConfig.minimalClient.assetEndpoint,
+        handler: resolve("runtime/server/routes/cache/asset")
+      });
+      addServerHandler({
+        method: "get",
+        route: moduleConfig.minimalClient.queryEndpoint,
+        handler: resolve("runtime/server/routes/cache/query")
+      });
+      if (moduleConfig.minimalClient.webhookSecret) {
+        addServerHandler({
+          method: "delete",
+          route: moduleConfig.minimalClient.webhookEndpoint,
+          handler: resolve("runtime/server/routes/cache/webhook")
+        });
+      } else {
+        console.warn("Webhook secret is required for webhook-based cache invalidation");
+      }
+    }
+    $config.sanity = defu($config.sanity, {
+      visualEditing: moduleConfig.visualEditing && {
+        ...moduleConfig.visualEditing,
+        previewModeId: moduleConfig.visualEditing.previewMode ? crypto.randomBytes(16).toString("hex") : "",
+        token: moduleConfig.visualEditing.token || ""
+      },
+      webhookSecret: moduleConfig.minimalClient && moduleConfig.minimalClient.webhookSecret || void 0
+    });
+    $config.public.sanity = defu($config.public.sanity, {
       projectId: moduleConfig.projectId,
       dataset: moduleConfig.dataset,
       minimalClient: moduleConfig.minimalClient,
@@ -122,6 +165,13 @@ const module = defineNuxtModule({
       prefix: "Sanity",
       pathPrefix: false
     });
+    await installModule("@nuxt/image", {
+      providers: {
+        cachedSanity: {
+          provider: resolve("runtime/imageProviders/sanity")
+        }
+      }
+    }, nuxt);
   }
 });
 

package/dist/runtime/client/MinimalSanityClient.js

@@ -34,11 +34,13 @@ class MinimalSanityClient extends SanityClient {
   }
   async fetch(query, params, _options) {
     const perspectiveQueryString = `&perspective=${_options?.perspective || this.config.perspective}`;
-    const queryString = this.toQueryString(query, params || {}) + perspectiveQueryString;
+    const queryString = this.toQueryString(query, params || {}) + (this.config.useCdn ? "" : perspectiveQueryString);
     const byteLength = this.getByteLength(queryString);
     const isEligibleForGetRequest = byteLength <= 9e3;
-    const queryHost = this.config.useCdn && isEligibleForGetRequest ? API_CDN_HOST : API_HOST;
-    return (await $fetch(`https://${this.config.projectId}.${queryHost + this.queryPath}${queryString}`, {
+    const minimalClientConfig = typeof this.config.minimalClient === "object" ? this.config.minimalClient : {};
+    const useCache = minimalClientConfig.cachingEnabled && isEligibleForGetRequest;
+    const requestUrl = useCache && minimalClientConfig.cacheBaseUrl ? minimalClientConfig.cacheBaseUrl + minimalClientConfig.queryEndpoint : `https://${this.config.projectId}.${this.config.useCdn && isEligibleForGetRequest ? API_CDN_HOST : API_HOST}${this.queryPath}`;
+    return (await $fetch(requestUrl + queryString, {
       ...this.fetchOptions,
       method: isEligibleForGetRequest ? "GET" : "POST",
       body: !isEligibleForGetRequest ? { query, params } : void 0
@@ -52,7 +54,8 @@ class MinimalSanityClient extends SanityClient {
       apiVersion: this.config.apiVersion,
       withCredentials: this.config.withCredentials,
       token: this.config.token,
-      perspective: this.config.perspective
+      perspective: this.config.perspective,
+      minimalClient: this.config.minimalClient
     });
   }
 }

package/dist/runtime/components/SanityImageAsset.vue

@@ -1,16 +1,16 @@
 <template>
   <NuxtImg
     v-if="imageAsset?._id"
-    provider="sanity"
     densities="x1 x2"
     :src="imageAsset._id"
     :width="imageAsset.metadata.dimensions.width"
     :height="imageAsset.metadata.dimensions.height"
-    :alt="imageAsset.altText"
+    :alt="imageAsset.altText as (string | undefined)"
     :placeholder="loading === 'eager' ? undefined : imageAsset.metadata.lqip"
     :loading="loading || 'lazy'"
     :format="imageAsset.mimeType === 'image/svg+xml' ? undefined : 'webp'"
     draggable="false"
+    provider="cachedSanity"
   />
 </template>
 
@@ -41,5 +41,4 @@ async function resolveImageAsset() {
 }
 
 await resolveImageAsset()
-watch(() => props.asset, resolveImageAsset)
 </script>

package/dist/runtime/imageProviders/sanity.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderGetImage } from '@nuxt/image';
+export declare const getImage: ProviderGetImage;

package/dist/runtime/imageProviders/sanity.js

@@ -0,0 +1,16 @@
+import { joinURL } from "ufo";
+import { useSanityVisualEditingState } from "../composables/useSanityVisualEditingState.js";
+import { useRuntimeConfig } from "#imports";
+import { getImage as getSanityImage } from "#image/providers/sanity";
+export const getImage = (src, { modifiers = {} } = {}, ctx) => {
+  const sanityConfig = useRuntimeConfig().public.sanity;
+  const minimalClientConfig = sanityConfig.minimalClient;
+  const useCaching = typeof minimalClientConfig === "object" && minimalClientConfig.cachingEnabled;
+  if (useCaching && minimalClientConfig.cacheBaseUrl && !useSanityVisualEditingState().enabled) {
+    const params = new URLSearchParams();
+    params.set("src", src);
+    params.set("modifiers", JSON.stringify(modifiers));
+    return { url: joinURL(minimalClientConfig.cacheBaseUrl, minimalClientConfig.assetEndpoint + `?${params.toString()}`) };
+  }
+  return getSanityImage(src, { modifiers, projectId: sanityConfig.projectId, dataset: sanityConfig.dataset }, ctx);
+};

package/dist/runtime/plugins/visual-editing.js

@@ -11,11 +11,12 @@ export default defineNuxtPlugin(() => {
   const $config = useRuntimeConfig();
   const { visualEditing } = $config.public.sanity;
   if (import.meta.server) {
-    if (visualEditing?.previewMode) {
+    const previewModeId = $config.sanity.visualEditing.previewModeId;
+    if (visualEditing?.previewMode && previewModeId) {
       const previewModeCookie = useCookie("__sanity_preview");
-      visualEditingState.enabled = visualEditing.previewModeId === previewModeCookie.value;
+      visualEditingState.enabled = previewModeId === previewModeCookie.value;
     }
-  } else if (visualEditingState.enabled && visualEditing.mode !== "custom") {
+  } else if (visualEditingState.enabled && visualEditing?.mode !== "custom") {
     switch (visualEditing?.mode) {
       case "live-visual-editing":
       case "visual-editing":

package/dist/runtime/server/routes/cache/asset.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
+export default _default;

package/dist/runtime/server/routes/cache/asset.js

@@ -0,0 +1,60 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { hash } from "ohash";
+import resolveSanityImageUrl from "../../utils/resolveSanityImageUrl.js";
+import { useStorage } from "#imports";
+const TTL = 60 * 60 * 24 * 365;
+export default defineEventHandler(async (event) => {
+  const queryParams = getRequestURL(event).searchParams;
+  const src = queryParams.get("src");
+  if (!src) {
+    throw createError({ statusCode: 400, statusMessage: "Missing src parameter" });
+  }
+  const modifiers = JSON.parse(queryParams.get("modifiers") || "{}");
+  const hashedPath = hash(src + JSON.stringify(modifiers));
+  const dataCache = useStorage("sanityData");
+  const cachedAsset = await dataCache.getItemRaw(hashedPath);
+  if (cachedAsset) {
+    const meta = await dataCache.getMeta(hashedPath);
+    if (import.meta.dev) {
+      console.debug(`Cache hit for asset ${hashedPath}`);
+    }
+    return new Response(cachedAsset, {
+      headers: {
+        "Content-Type": meta.contentType || "application/octet-stream",
+        "Cache-Control": `public, max-age=${TTL}, immutable`
+      }
+    });
+  }
+  const imageUrl = resolveSanityImageUrl(src, modifiers);
+  return await new Promise((resolve, reject) => $fetch(imageUrl, {
+    headers: {
+      "Accept-Encoding": "gzip, deflate"
+    },
+    method: "GET",
+    responseType: "stream",
+    onResponseError: ({ response }) => reject(response),
+    async onResponse({ response }) {
+      if (response.status === 200) {
+        const assetBinaryData = Buffer.from(await response.arrayBuffer());
+        await dataCache.setItemRaw(hashedPath, assetBinaryData, { ttl: TTL });
+        await dataCache.setMeta(hashedPath, { contentType: response.headers.get("Content-Type") }, { ttl: TTL });
+        const assetId = src.split("/").pop();
+        if (assetId) {
+          const sanityDocumentDeps = useStorage("sanityDocumentDeps");
+          const documentDeps = await sanityDocumentDeps.getItem(assetId) || [];
+          documentDeps.push(hashedPath);
+          await sanityDocumentDeps.setItem(assetId, documentDeps);
+          if (import.meta.dev) {
+            console.debug(`Cache miss for asset ${hashedPath} (${assetId})`);
+          }
+        }
+        resolve(new Response(assetBinaryData, {
+          headers: {
+            "Content-Type": response.headers.get("Content-Type") || "application/octet-stream",
+            "Cache-Control": `public, max-age=${TTL}, immutable`
+          }
+        }));
+      }
+    }
+  }));
+});

package/dist/runtime/server/routes/cache/query.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    result: any;
+}>>;
+export default _default;

package/dist/runtime/server/routes/cache/query.js

@@ -0,0 +1,61 @@
+import {
+  createError,
+  defineEventHandler,
+  getRequestURL,
+  setResponseHeader
+} from "h3";
+import { hash } from "ohash";
+import useSanityClient from "../../utils/useSanityClient.js";
+import { useRuntimeConfig, useStorage } from "#imports";
+const TTL = 60 * 60 * 8;
+export default defineEventHandler(async (event) => {
+  const url = getRequestURL(event);
+  const queryParams = url.searchParams;
+  const query = queryParams.get("query");
+  if (!query)
+    throw createError({ statusCode: 400, statusMessage: "Missing query parameter" });
+  const params = Array.from(queryParams).filter(([key]) => key.startsWith("$"));
+  const perspective = queryParams.get("perspective") || useRuntimeConfig().public.sanity.perspective;
+  if (typeof perspective === "string" && !["previewDrafts", "published", "raw"].includes(perspective))
+    throw createError({ statusCode: 400, statusMessage: "Invalid perspective" });
+  const hashedQuery = hash(query + JSON.stringify(params) + (perspective || ""));
+  const dataCache = useStorage("sanityData");
+  const cachedResult = await dataCache.getItem(hashedQuery);
+  if (cachedResult) {
+    setResponseHeader(event, "X-Cache", "hit");
+    setResponseHeader(event, "Content-Type", "application/json");
+    if (import.meta.dev) {
+      console.debug(`Cache hit for query ${hashedQuery}`);
+    }
+    return { result: cachedResult };
+  }
+  const client = useSanityClient("minimal");
+  delete client.config.minimalClient;
+  client.config.useCdn = false;
+  const result = await client.fetch(
+    query,
+    Object.fromEntries(params.map(([key, value]) => [key.slice(1), JSON.parse(value)])),
+    { perspective }
+  );
+  if (!result)
+    throw createError({ statusCode: 400, statusMessage: "Invalid query" });
+  await dataCache.setItem(hashedQuery, result, { ttl: TTL });
+  const stringifiedResult = JSON.stringify(result);
+  const referencedIds = stringifiedResult.match(/"(_ref|_id)":\s*"(.*?)"/g) || [];
+  if (referencedIds.length > 0) {
+    const sanityDocumentDeps = useStorage("sanityDocumentDeps");
+    await Promise.all(referencedIds.map((ref) => new Promise((resolve) => {
+      const id = ref.split('"')[3];
+      sanityDocumentDeps.getItem(id).then((deps) => {
+        const documentDeps = deps || [];
+        documentDeps.push(hashedQuery);
+        sanityDocumentDeps.setItem(id, documentDeps).then(resolve);
+      });
+    })));
+  }
+  setResponseHeader(event, "Content-Type", "application/json");
+  if (import.meta.dev) {
+    console.debug(`Cache miss for query ${hashedQuery} (${referencedIds.join(", ")})`);
+  }
+  return { result };
+});

package/dist/runtime/server/routes/cache/webhook.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/routes/cache/webhook.js

@@ -0,0 +1,33 @@
+import { createHmac } from "node:crypto";
+import { defineEventHandler, readRawBody, setResponseStatus, getRequestHeader } from "h3";
+import { useRuntimeConfig, useStorage } from "#imports";
+export default defineEventHandler(async (event) => {
+  const body = await readRawBody(event);
+  const signatureHeader = getRequestHeader(event, "sanity-webhook-signature");
+  const signatureParts = signatureHeader?.split(",");
+  if (!signatureParts || signatureParts.length !== 2) {
+    return setResponseStatus(event, 400, "Invalid signature");
+  }
+  const timestamp = Number.parseInt(signatureParts[0].slice(2), 10);
+  const signature = signatureParts[1].slice(3);
+  const secret = useRuntimeConfig().sanity.webhookSecret;
+  const expectedSignature = createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("base64");
+  const expectedSignatureUrl = expectedSignature.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  if (signature !== expectedSignatureUrl) {
+    return setResponseStatus(event, 403);
+  }
+  const { _id } = JSON.parse(body || "{}");
+  const sanityDocumentDeps = useStorage("sanityDocumentDeps");
+  const documentDeps = await sanityDocumentDeps.getItem(_id);
+  if (documentDeps && documentDeps?.length > 0) {
+    const dataCache = useStorage("sanityData");
+    await Promise.all(documentDeps.map((key) => dataCache.removeItem(key)));
+    await dataCache.dispose();
+  }
+  await sanityDocumentDeps.removeItem(_id);
+  await sanityDocumentDeps.dispose();
+  if (import.meta.dev) {
+    console.debug(`Cleared cache for document ${_id} (${documentDeps?.length || 0} entries removed)`);
+  }
+  setResponseStatus(event, 204);
+});

package/dist/runtime/server/utils/resolveSanityImageUrl.d.ts

@@ -0,0 +1,2 @@
+import type { ImageModifiers } from '@nuxt/image';
+export default function resolveSanityImageUrl(src: string, modifiers: Partial<ImageModifiers>): string;

package/dist/runtime/server/utils/resolveSanityImageUrl.js

@@ -0,0 +1,74 @@
+import { joinURL } from "ufo";
+import { useRuntimeConfig } from "#imports";
+const transformationMap = {
+  "format": "fm",
+  "height": "h",
+  "quality": "q",
+  "width": "w",
+  "background": "bg",
+  "download": "dl",
+  "dpr": "dpr",
+  "sharpen": "sharp",
+  "orientation": "or",
+  "min-height": "min-h",
+  "max-height": "max-h",
+  "min-width": "min-w",
+  "max-width": "max-w",
+  "minHeight": "min-h",
+  "maxHeight": "max-h",
+  "minWidth": "min-w",
+  "maxWidth": "max-w",
+  "saturation": "sat"
+};
+export default function resolveSanityImageUrl(src, modifiers) {
+  const matchResult = src.match(/-(?<width>\d*)x(?<height>\d*)-(?<format>.*)$/);
+  if (!matchResult || !matchResult.groups) {
+    throw new Error("Invalid image URL");
+  }
+  const sourceWidth = Number.parseInt(matchResult.groups.width);
+  const sourceHeight = Number.parseInt(matchResult.groups.height);
+  if (modifiers.crop && typeof modifiers.crop !== "string" && sourceWidth && sourceHeight) {
+    const left = modifiers.crop.left * sourceWidth;
+    const top = modifiers.crop.top * sourceHeight;
+    const right = sourceWidth - modifiers.crop.right * sourceWidth;
+    const bottom = sourceHeight - modifiers.crop.bottom * sourceHeight;
+    modifiers.rect = [left, top, right - left, bottom - top].map((i) => i.toFixed(0)).join(",");
+    delete modifiers.crop;
+  }
+  if (modifiers.hotspot && typeof modifiers.hotspot !== "string") {
+    modifiers["fp-x"] = modifiers.hotspot.x;
+    modifiers["fp-y"] = modifiers.hotspot.y;
+    delete modifiers.hotspot;
+  }
+  if (!modifiers.format || modifiers.format === "auto") {
+    modifiers.auto = "format";
+  }
+  if (modifiers.fit === "contain" && !modifiers.bg)
+    modifiers.bg = "ffffff";
+  const operations = Object.keys(modifiers).map((key) => {
+    const operationKey = transformationMap[key] || key;
+    let value = modifiers[key];
+    if (operationKey === "fm" && value === "jpeg")
+      value = "jpg";
+    if (operationKey === "fit") {
+      if (value === "cover")
+        value = "crop";
+      else if (value === "contain")
+        value = "fill";
+      else if (value === "fill")
+        value = "scale";
+      else if (value === "inside")
+        value = "min";
+      else if (value === "outside")
+        value = "max";
+    }
+    if (value === true)
+      return operationKey;
+    return `${operationKey}=${value}`;
+  }).join("&");
+  const parts = src.split("-").slice(1);
+  const format = parts.pop();
+  const filenameAndQueries = parts.join("-") + "." + format + (operations ? "?" + operations : "");
+  const sanityConfig = useRuntimeConfig().public.sanity;
+  return joinURL("https://cdn.sanity.io/images", sanityConfig.projectId, sanityConfig.dataset, filenameAndQueries);
+}

package/dist/runtime/server/utils/useSanityClient.js

@@ -4,7 +4,7 @@ import { useRuntimeConfig } from "#imports";
 export default function useSanityClient(type) {
   const $config = useRuntimeConfig();
   const sanityConfig = defu($config.sanity, $config.public.sanity || {});
-  const visualEditingEnabled = sanityConfig.visualEditing && sanityConfig.visualEditing.previewMode !== false;
+  const visualEditingEnabled = type !== "minimal" && sanityConfig.visualEditing && sanityConfig.visualEditing.previewMode !== false;
   return getOrCreateSanityClient(
     visualEditingEnabled || false,
     visualEditingEnabled ? {

package/dist/types.d.mts

@@ -1 +1 @@
-export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, default } from './module.js'
+export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingMode, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, default } from './module.js'

package/dist/types.d.ts

@@ -1 +1 @@
-export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, default } from './module'
+export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingMode, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devite/nuxt-sanity",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "Advanced Sanity integration for Nuxt.js.",
   "repository": "devite-io/nuxt-sanity",
   "license": "MIT",
@@ -32,7 +32,8 @@
     "@sanity/visual-editing": "^2.11.0",
     "defu": "^6.1.4",
     "ofetch": "^1.4.1",
-    "ohash": "^1.1.4"
+    "ohash": "^1.1.4",
+    "unstorage": "^1.14.1"
   },
   "devDependencies": {
     "@nuxt/eslint-config": "^0.7.4",