nuxt-studio 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/module/runtime/host.js

@@ -1,12 +1,15 @@
 import { ref } from "vue";
 import { ensure } from "./utils/ensure.js";
-import { getCollectionByFilePath, generateIdFromFsPath, createCollectionDocument, generateRecordDeletion, generateRecordInsert, getCollectionInfo, normalizeDocument } from "./utils/collection.js";
+import { getCollectionByFilePath, generateIdFromFsPath, generateRecordDeletion, generateRecordInsert, generateFsPathFromId, getCollectionById } from "./utils/collection.js";
+import { normalizeDocument, isDocumentMatchingContent, generateDocumentFromContent, generateContentFromDocument, areDocumentsEqual, pickReservedKeysFromDocument, removeReservedKeysFromDocument } from "./utils/document.js";
 import { kebabCase } from "scule";
-import { generateDocumentFromContent } from "nuxt-studio/app/utils";
-import { clearError, getAppManifest, queryCollection, queryCollectionItemSurroundings, queryCollectionNavigation, queryCollectionSearchSections } from "#imports";
+import { clearError, getAppManifest, queryCollection, queryCollectionItemSurroundings, queryCollectionNavigation, queryCollectionSearchSections, useRuntimeConfig } from "#imports";
 import { collections } from "#content/preview";
 import { publicAssetsStorage } from "#build/studio-public-assets";
 import { useHostMeta } from "./composables/useMeta.js";
+import { generateIdFromFsPath as generateMediaIdFromFsPath } from "./utils/media.js";
+import { getCollectionSourceById } from "./utils/source.js";
+const serviceWorkerVersion = "v0.0.2";
 function getSidebarWidth() {
   let sidebarWidth = 440;
   if (typeof window !== "undefined" && window.localStorage) {
@@ -83,7 +86,8 @@ export function useStudioHost(user, repository) {
   const host = {
     meta: {
       dev: false,
-      components: () => meta.componentsMeta.value
+      components: () => meta.componentsMeta.value,
+      defaultLocale: useRuntimeConfig().public.studio.i18n?.defaultLocale || "en"
     },
     on: {
       routeChange: (fn) => {
@@ -115,6 +119,9 @@ export function useStudioHost(user, repository) {
       documentUpdate: (_fn) => {
       },
       mediaUpdate: (_fn) => {
+      },
+      requestDocumentEdit: (fn) => {
+        useNuxtApp().hooks.hook("studio:document:edit", fn);
       }
     },
     ui: {
@@ -152,77 +159,116 @@ export function useStudioHost(user, repository) {
       }
     },
     repository,
-    // New API
     user: {
       get: () => user
     },
     document: {
-      get: async (id) => {
-        const item = await useContentCollectionQuery(id.split("/")[0]).where("id", "=", id).first();
-        return normalizeDocument(item);
-      },
-      getFileSystemPath: (id) => {
-        return getCollectionInfo(id, useContentCollections()).fsPath;
-      },
-      list: async () => {
-        const collections2 = Object.keys(useContentCollections()).filter((c) => c !== "info");
-        const contents = await Promise.all(collections2.map(async (collection) => {
-          return await useContentCollectionQuery(collection).all();
-        }));
-        return contents.flat();
-      },
-      create: async (fsPath, content) => {
-        const collections2 = useContentCollections();
-        const collectionInfo = getCollectionByFilePath(fsPath, collections2);
-        const id = generateIdFromFsPath(fsPath, collectionInfo);
-        const existingDocument = await host.document.get(id);
-        if (existingDocument) {
-          throw new Error(`Cannot create document with id "${id}": document already exists.`);
+      db: {
+        get: async (fsPath) => {
+          const collectionInfo = getCollectionByFilePath(fsPath, useContentCollections());
+          if (!collectionInfo) {
+            throw new Error(`Collection not found for fsPath: ${fsPath}`);
+          }
+          const id = generateIdFromFsPath(fsPath, collectionInfo);
+          const item = await useContentCollectionQuery(collectionInfo.name).where("id", "=", id).first();
+          if (!item) {
+            return void 0;
+          }
+          return {
+            ...item,
+            fsPath
+          };
+        },
+        list: async () => {
+          const collections2 = Object.values(useContentCollections()).filter((collection) => collection.name !== "info");
+          const documentsByCollection = await Promise.all(collections2.map(async (collection) => {
+            const documents = await useContentCollectionQuery(collection.name).all();
+            return documents.map((document2) => {
+              const source = getCollectionSourceById(document2.id, collection.source);
+              const fsPath = generateFsPathFromId(document2.id, source);
+              return {
+                ...document2,
+                fsPath
+              };
+            });
+          }));
+          return documentsByCollection.flat();
+        },
+        create: async (fsPath, content) => {
+          const existingDocument = await host.document.db.get(fsPath);
+          if (existingDocument) {
+            throw new Error(`Cannot create document with fsPath "${fsPath}": document already exists.`);
+          }
+          const collectionInfo = getCollectionByFilePath(fsPath, useContentCollections());
+          if (!collectionInfo) {
+            throw new Error(`Collection not found for fsPath: ${fsPath}`);
+          }
+          const id = generateIdFromFsPath(fsPath, collectionInfo);
+          const document2 = await generateDocumentFromContent(id, content);
+          const normalizedDocument = normalizeDocument(id, collectionInfo, document2);
+          await host.document.db.upsert(fsPath, normalizedDocument);
+          return {
+            ...normalizedDocument,
+            fsPath
+          };
+        },
+        upsert: async (fsPath, document2) => {
+          const collectionInfo = getCollectionByFilePath(fsPath, useContentCollections());
+          if (!collectionInfo) {
+            throw new Error(`Collection not found for fsPath: ${fsPath}`);
+          }
+          const id = generateIdFromFsPath(fsPath, collectionInfo);
+          const normalizedDocument = normalizeDocument(id, collectionInfo, document2);
+          await useContentDatabaseAdapter(collectionInfo.name).exec(generateRecordDeletion(collectionInfo, id));
+          await useContentDatabaseAdapter(collectionInfo.name).exec(generateRecordInsert(collectionInfo, normalizedDocument));
+        },
+        delete: async (fsPath) => {
+          const collection = getCollectionByFilePath(fsPath, useContentCollections());
+          if (!collection) {
+            throw new Error(`Collection not found for fsPath: ${fsPath}`);
+          }
+          const id = generateIdFromFsPath(fsPath, collection);
+          await useContentDatabaseAdapter(collection.name).exec(generateRecordDeletion(collection, id));
         }
-        const document2 = await generateDocumentFromContent(id, content);
-        const collectionDocument = createCollectionDocument(collectionInfo, id, document2);
-        await host.document.upsert(id, collectionDocument);
-        return collectionDocument;
-      },
-      upsert: async (id, document2) => {
-        id = id.replace(/:/g, "/");
-        const collection = getCollectionInfo(id, useContentCollections()).collection;
-        const doc = createCollectionDocument(collection, id, document2);
-        await useContentDatabaseAdapter(collection.name).exec(generateRecordDeletion(collection, id));
-        await useContentDatabaseAdapter(collection.name).exec(generateRecordInsert(collection, doc));
       },
-      delete: async (id) => {
-        id = id.replace(/:/g, "/");
-        const collection = getCollectionInfo(id, useContentCollections()).collection;
-        await useContentDatabaseAdapter(collection.name).exec(generateRecordDeletion(collection, id));
+      utils: {
+        areEqual: (document1, document2) => areDocumentsEqual(document1, document2),
+        isMatchingContent: async (content, document2) => isDocumentMatchingContent(content, document2),
+        pickReservedKeys: (document2) => pickReservedKeysFromDocument(document2),
+        removeReservedKeys: (document2) => removeReservedKeysFromDocument(document2),
+        detectActives: () => {
+          const wrappers = document.querySelectorAll("[data-content-id]");
+          return Array.from(wrappers).map((wrapper) => {
+            const id = wrapper.getAttribute("data-content-id");
+            const title = id.split(/[/:]/).pop() || id;
+            const collection = getCollectionById(id, useContentCollections());
+            const source = getCollectionSourceById(id, collection.source);
+            const fsPath = generateFsPathFromId(id, source);
+            return {
+              fsPath,
+              title
+            };
+          });
+        }
       },
-      detectActives: () => {
-        const wrappers = document.querySelectorAll("[data-content-id]");
-        return Array.from(wrappers).map((wrapper) => {
-          const id = wrapper.getAttribute("data-content-id");
-          const title = id.split(/[/:]/).pop() || id;
-          return {
-            id,
-            title
-          };
-        });
+      generate: {
+        documentFromContent: async (id, content) => generateDocumentFromContent(id, content),
+        contentFromDocument: async (document2) => generateContentFromDocument(document2)
       }
     },
     media: {
-      get: async (id) => {
-        return await publicAssetsStorage.getItem(id);
-      },
-      getFileSystemPath: (id) => {
-        return id.split("/").slice(1).join("/");
+      get: async (fsPath) => {
+        return await publicAssetsStorage.getItem(generateMediaIdFromFsPath(fsPath));
       },
       list: async () => {
         return await Promise.all(await publicAssetsStorage.getKeys().then((keys) => keys.map((key) => publicAssetsStorage.getItem(key))));
       },
-      upsert: async (id, media) => {
-        await publicAssetsStorage.setItem(id, media);
+      upsert: async (fsPath, media) => {
+        const id = generateMediaIdFromFsPath(fsPath);
+        await publicAssetsStorage.setItem(generateMediaIdFromFsPath(fsPath), { ...media, id });
       },
-      delete: async (id) => {
-        await publicAssetsStorage.removeItem(id);
+      delete: async (fsPath) => {
+        await publicAssetsStorage.removeItem(generateMediaIdFromFsPath(fsPath));
       }
     },
     app: {
@@ -248,10 +294,27 @@ export function useStudioHost(user, repository) {
       isMounted.value = true;
     }).then(() => {
       if ("serviceWorker" in navigator) {
-        navigator.serviceWorker.register("/sw.js");
+        navigator.serviceWorker.register(`/sw.js?${serviceWorkerVersion}`);
       }
       return meta.fetch();
     });
+    document.body.addEventListener("dblclick", (event) => {
+      let element = event.target;
+      while (element) {
+        if (element.getAttribute("data-content-id")) {
+          break;
+        }
+        element = element.parentElement;
+      }
+      if (element) {
+        const id = element.getAttribute("data-content-id");
+        const collection = getCollectionById(id, useContentCollections());
+        const source = getCollectionSourceById(id, collection.source);
+        const fsPath = generateFsPathFromId(id, source);
+        useNuxtApp().hooks.callHook("studio:document:edit", fsPath);
+      }
+    });
+    host.ui.updateStyles();
   })();
   return host;
 }

package/dist/module/runtime/plugins/studio.client.js

@@ -3,7 +3,7 @@ import { defineStudioActivationPlugin } from "../utils/activation.js";
 export default defineNuxtPlugin(() => {
   defineStudioActivationPlugin(async (user) => {
     const config = useRuntimeConfig();
-    const host = await import("../host.js").then((m) => m.useStudioHost);
+    const host = await (config.public.studio.dev ? import("../host.dev") : import("../host")).then((m) => m.useStudioHost);
     window.useStudioHost = () => host(user, config.public.studio.repository);
     await import("nuxt-studio/app");
     document.body.appendChild(document.createElement("nuxt-studio"));

package/dist/module/runtime/server/routes/admin.js

@@ -1,6 +1,15 @@
-import { eventHandler, sendRedirect } from "h3";
+import { eventHandler, getQuery, sendRedirect, setCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
 export default eventHandler((event) => {
-  return sendRedirect(event, "/__nuxt_studio/auth/github");
+  const { redirect } = getQuery(event);
+  if (redirect) {
+    setCookie(event, "studio-redirect", String(redirect), {
+      httpOnly: true
+    });
+  }
+  const config = useRuntimeConfig(event);
+  const provider = config.public.studio?.repository?.provider || "github";
+  return sendRedirect(event, `/__nuxt_studio/auth/${provider}`);
   return `<!DOCTYPE html>
 <html lang="en">
 <head>

package/dist/module/runtime/server/routes/auth/github.get.d.ts

@@ -1,12 +1,12 @@
 export interface OAuthGitHubConfig {
     /**
      * GitHub OAuth Client ID
-     * @default process.env.NUXT_OAUTH_GITHUB_CLIENT_ID
+     * @default process.env.STUDIO_GITHUB_CLIENT_ID
      */
     clientId?: string;
     /**
      * GitHub OAuth Client Secret
-     * @default process.env.NUXT_OAUTH_GITHUB_CLIENT_SECRET
+     * @default process.env.STUDIO_GITHUB_CLIENT_SECRET
      */
     clientSecret?: string;
     /**
@@ -44,8 +44,8 @@ export interface OAuthGitHubConfig {
     authorizationParams?: Record<string, string>;
     /**
      * Redirect URL to to allow overriding for situations like prod failing to determine public hostname
-     * @default process.env.NUXT_OAUTH_GITHUB_REDIRECT_URL
-     * @see https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/differences-between-github-apps-and-oauth-apps
+     * Use `process.env.STUDIO_GITHUB_REDIRECT_URL` to overwrite the default redirect URL.
+     * @default is ${hostname}/__nuxt_studio/auth/github
      */
     redirectURL?: string;
 }

package/dist/module/runtime/server/routes/auth/github.get.js

@@ -5,9 +5,11 @@ import { withQuery } from "ufo";
 import { defu } from "defu";
 import { useRuntimeConfig } from "#imports";
 export default eventHandler(async (event) => {
-  const config = defu(useRuntimeConfig(event).studio?.auth?.github, {
+  const studioConfig = useRuntimeConfig(event).studio;
+  const config = defu(studioConfig?.auth?.github, {
     clientId: process.env.STUDIO_GITHUB_CLIENT_ID,
     clientSecret: process.env.STUDIO_GITHUB_CLIENT_SECRET,
+    redirectURL: process.env.STUDIO_GITHUB_REDIRECT_URL,
     authorizationURL: "https://github.com/login/oauth/authorize",
     tokenURL: "https://github.com/login/oauth/access_token",
     apiURL: "https://api.github.com",
@@ -30,21 +32,21 @@ export default eventHandler(async (event) => {
     });
   }
   const requestURL = getRequestURL(event);
-  const redirectURL = `${requestURL.protocol}//${requestURL.host}${requestURL.pathname}`;
+  config.redirectURL = config.redirectURL || `${requestURL.protocol}//${requestURL.host}${requestURL.pathname}`;
   const state = await handleState(event);
   if (!query.code) {
     config.scope = config.scope || [];
     if (config.emailRequired && !config.scope.includes("user:email")) {
       config.scope.push("user:email");
     }
-    if (config.emailRequired && !config.scope.includes("repo")) {
-      config.scope.push("repo");
+    if (config.emailRequired && !config.scope.includes("repo") && !config.scope.includes("public_repo")) {
+      config.scope.push(studioConfig.repository.private ? "repo" : "public_repo");
     }
     return sendRedirect(
       event,
       withQuery(config.authorizationURL, {
         client_id: config.clientId,
-        redirect_uri: redirectURL,
+        redirect_uri: config.redirectURL,
         scope: config.scope.join(" "),
         state,
         ...config.authorizationParams
@@ -66,7 +68,7 @@ export default eventHandler(async (event) => {
       grant_type: "authorization_code",
       client_id: config.clientId,
       client_secret: config.clientSecret,
-      redirect_uri: redirectURL,
+      redirect_uri: config.redirectURL,
       code: query.code
     }
   });
@@ -108,14 +110,20 @@ export default eventHandler(async (event) => {
   await session.update(defu({
     user: {
       contentUser: true,
-      githubId: user.id,
-      githubToken: token.access_token,
-      name: user.name,
+      providerId: user.id.toString(),
+      accessToken: token.access_token,
+      name: user.name || user.login,
       avatar: user.avatar_url,
       email: user.email,
       provider: "github"
     }
   }, session.data));
+  const redirect = decodeURIComponent(getCookie(event, "studio-redirect") || "");
+  deleteCookie(event, "studio-redirect");
+  setCookie(event, "studio-session-check", "true", { httpOnly: false });
+  if (redirect && redirect.startsWith("/") && !redirect.startsWith("//")) {
+    return sendRedirect(event, redirect);
+  }
   return sendRedirect(event, "/");
 });
 async function requestAccessToken(url, options) {

package/dist/module/runtime/server/routes/auth/gitlab.get.d.ts

@@ -0,0 +1,55 @@
+export interface OAuthGitLabConfig {
+    /**
+     * GitLab OAuth Application ID
+     * @default process.env.STUDIO_GITLAB_APPLICATION_ID
+     */
+    applicationId?: string;
+    /**
+     * GitLab OAuth Application Secret
+     * @default process.env.STUDIO_GITLAB_APPLICATION_SECRET
+     */
+    applicationSecret?: string;
+    /**
+     * GitLab OAuth Scope
+     * @default []
+     * @see https://docs.gitlab.com/ee/integration/oauth_provider.html#authorized-applications
+     */
+    scope?: string[];
+    /**
+     * Require email from user
+     * @default false
+     */
+    emailRequired?: boolean;
+    /**
+     * GitLab instance URL
+     * @default 'https://gitlab.com'
+     */
+    instanceUrl?: string;
+    /**
+     * GitLab OAuth Authorization URL
+     * @default '{instanceUrl}/oauth/authorize'
+     */
+    authorizationURL?: string;
+    /**
+     * GitLab OAuth Token URL
+     * @default '{instanceUrl}/oauth/token'
+     */
+    tokenURL?: string;
+    /**
+     * GitLab API URL
+     * @default '{instanceUrl}/api/v4'
+     */
+    apiURL?: string;
+    /**
+     * Extra authorization parameters to provide to the authorization URL
+     */
+    authorizationParams?: Record<string, string>;
+    /**
+     * Redirect URL to allow overriding for situations like prod failing to determine public hostname
+     * Use `process.env.STUDIO_GITLAB_REDIRECT_URL` to overwrite the default redirect URL.
+     * @default is ${hostname}/__nuxt_studio/auth/gitlab
+     */
+    redirectURL?: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/module/runtime/server/routes/auth/gitlab.get.js

@@ -0,0 +1,157 @@
+import { FetchError } from "ofetch";
+import { getRandomValues } from "uncrypto";
+import { eventHandler, getQuery, sendRedirect, createError, getRequestURL, setCookie, deleteCookie, getCookie, useSession } from "h3";
+import { withQuery } from "ufo";
+import { defu } from "defu";
+import { useRuntimeConfig } from "#imports";
+export default eventHandler(async (event) => {
+  const studioConfig = useRuntimeConfig(event).studio;
+  const instanceUrl = studioConfig?.auth?.gitlab?.instanceUrl || "https://gitlab.com";
+  const config = defu(studioConfig?.auth?.gitlab, {
+    applicationId: process.env.STUDIO_GITLAB_APPLICATION_ID,
+    applicationSecret: process.env.STUDIO_GITLAB_APPLICATION_SECRET,
+    redirectURL: process.env.STUDIO_GITLAB_REDIRECT_URL,
+    instanceUrl,
+    authorizationURL: `${instanceUrl}/oauth/authorize`,
+    tokenURL: `${instanceUrl}/oauth/token`,
+    apiURL: `${instanceUrl}/api/v4`,
+    authorizationParams: {},
+    emailRequired: true
+  });
+  const query = getQuery(event);
+  if (query.error) {
+    throw createError({
+      statusCode: 401,
+      message: `GitLab login failed: ${query.error || "Unknown error"}`,
+      data: query
+    });
+  }
+  if (!config.applicationId || !config.applicationSecret) {
+    throw createError({
+      statusCode: 500,
+      message: "Missing GitLab application ID or secret",
+      data: config
+    });
+  }
+  const requestURL = getRequestURL(event);
+  config.redirectURL = config.redirectURL || `${requestURL.protocol}//${requestURL.host}${requestURL.pathname}`;
+  if (!query.code) {
+    const state = await generateState(event);
+    config.scope = config.scope || [];
+    if (!config.scope.includes("api")) {
+      config.scope.push("api");
+    }
+    return sendRedirect(
+      event,
+      withQuery(config.authorizationURL, {
+        client_id: config.applicationId,
+        redirect_uri: config.redirectURL,
+        response_type: "code",
+        scope: config.scope.join(" "),
+        state,
+        ...config.authorizationParams
+      })
+    );
+  }
+  const storedState = getCookie(event, "studio-oauth-state");
+  if (!storedState) {
+    throw createError({
+      statusCode: 400,
+      message: "OAuth state cookie not found. Please try logging in again.",
+      data: {
+        hint: "State cookie may have expired or been cleared"
+      }
+    });
+  }
+  if (query.state !== storedState) {
+    throw createError({
+      statusCode: 400,
+      message: "Invalid state - OAuth state mismatch",
+      data: {
+        hint: "This may be caused by browser refresh, navigation, or expired session"
+      }
+    });
+  }
+  deleteCookie(event, "studio-oauth-state");
+  const token = await requestAccessToken(config.tokenURL, {
+    body: {
+      grant_type: "authorization_code",
+      client_id: config.applicationId,
+      client_secret: config.applicationSecret,
+      redirect_uri: config.redirectURL,
+      code: query.code
+    }
+  });
+  if (token.error || !token.access_token) {
+    throw createError({
+      statusCode: 500,
+      message: "Failed to get access token",
+      data: token
+    });
+  }
+  const accessToken = token.access_token;
+  const user = await $fetch(`${config.apiURL}/user`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`
+    }
+  });
+  if (!user.email && config.emailRequired) {
+    throw createError({
+      statusCode: 500,
+      message: "Could not get GitLab user email",
+      data: token
+    });
+  }
+  const session = await useSession(event, {
+    name: "studio-session",
+    password: useRuntimeConfig(event).studio?.auth?.sessionSecret
+  });
+  await session.update(defu({
+    user: {
+      contentUser: true,
+      providerId: user.id.toString(),
+      accessToken: token.access_token,
+      name: user.name || user.username,
+      avatar: user.avatar_url,
+      email: user.email,
+      provider: "gitlab"
+    }
+  }, session.data));
+  const redirect = decodeURIComponent(getCookie(event, "studio-redirect") || "/");
+  deleteCookie(event, "studio-redirect");
+  setCookie(event, "studio-session-check", "true", { httpOnly: false });
+  if (redirect && redirect.startsWith("/") && !redirect.startsWith("//")) {
+    return sendRedirect(event, redirect);
+  }
+  return sendRedirect(event, "/");
+});
+async function requestAccessToken(url, options) {
+  try {
+    return await $fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: options.body,
+      params: options.params
+    });
+  } catch (error) {
+    if (error instanceof FetchError) {
+      return error.data || { error: error.message };
+    }
+    return { error: "Unknown error" };
+  }
+}
+async function generateState(event) {
+  const newState = Array.from(getRandomValues(new Uint8Array(32))).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const requestURL = getRequestURL(event);
+  const isSecure = requestURL.protocol === "https:";
+  setCookie(event, "studio-oauth-state", newState, {
+    httpOnly: true,
+    secure: isSecure,
+    sameSite: "lax",
+    maxAge: 60 * 15
+    // 15 minutes
+  });
+  return newState;
+}

package/dist/module/runtime/server/routes/auth/session.delete.js

@@ -1,4 +1,4 @@
-import { eventHandler, useSession } from "h3";
+import { eventHandler, useSession, deleteCookie } from "h3";
 import { useRuntimeConfig } from "#imports";
 export default eventHandler(async (event) => {
   const session = await useSession(event, {
@@ -6,5 +6,6 @@ export default eventHandler(async (event) => {
     password: useRuntimeConfig(event).studio?.auth?.sessionSecret
   });
   await session.clear();
+  deleteCookie(event, "studio-session-check");
   return { loggedOut: true };
 });

package/dist/module/runtime/server/routes/auth/session.get.js

@@ -1,10 +1,13 @@
-import { eventHandler, useSession } from "h3";
+import { eventHandler, useSession, deleteCookie } from "h3";
 import { useRuntimeConfig } from "#imports";
 export default eventHandler(async (event) => {
   const session = await useSession(event, {
     name: "studio-session",
     password: useRuntimeConfig(event).studio?.auth?.sessionSecret
   });
+  if (!session.data || Object.keys(session.data).length === 0) {
+    deleteCookie(event, "studio-session-check");
+  }
   return {
     ...session.data,
     id: session.id

package/dist/module/runtime/server/routes/dev/content/[...path].js

@@ -1,7 +1,4 @@
 import { createError, eventHandler, getRequestHeader, readRawBody, setResponseHeader } from "h3";
-import { stringifyMarkdown } from "@nuxtjs/mdc/runtime";
-import { decompressTree } from "@nuxt/content/runtime";
-import { removeReservedKeysFromDocument } from "nuxt-studio/app/utils";
 import { useStorage } from "#imports";
 export default eventHandler(async (event) => {
   const path = event.path.replace("/__nuxt_studio/dev/content/", "");
@@ -26,14 +23,6 @@ export default eventHandler(async (event) => {
     } else if (getRequestHeader(event, "content-type") === "text/plain") {
       const value = await readRawBody(event, "utf8");
       await storage.setItem(key, value);
-    } else {
-      const value = await readRawBody(event, "utf8");
-      const json = JSON.parse(value || "{}");
-      const content = await stringifyMarkdown(
-        json.body.type === "minimark" ? decompressTree(json.body) : json.body,
-        removeReservedKeysFromDocument(json)
-      );
-      await storage.setItem(key, content);
     }
     return "OK";
   }

package/dist/module/runtime/server/routes/dev/public/[...path].d.ts

@@ -3,6 +3,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     extension: string | undefined;
     stem: string;
     path: string;
+    fsPath: string;
     version: number;
 } | undefined>>;
 export default _default;

package/dist/module/runtime/server/routes/dev/public/[...path].js

@@ -1,4 +1,5 @@
 import { createError, eventHandler, getRequestHeader, readRawBody, setResponseHeader } from "h3";
+import { withLeadingSlash } from "ufo";
 import { useStorage } from "#imports";
 export default eventHandler(async (event) => {
   const path = event.path.replace("/__nuxt_studio/dev/public/", "");
@@ -23,6 +24,7 @@ export default eventHandler(async (event) => {
       extension: key.split(".").pop(),
       stem: key.split(".").join("."),
       path: "/" + key.replace(/:/g, "/"),
+      fsPath: withLeadingSlash(key.replace(/:/g, "/")),
       version: new Date(item.mtime || /* @__PURE__ */ new Date()).getTime()
     };
   }

package/dist/module/runtime/types/content.d.ts

@@ -0,0 +1,6 @@
+export declare enum ContentFileExtension {
+    Markdown = "md",
+    YAML = "yaml",
+    YML = "yml",
+    JSON = "json"
+}