nuxt-studio 1.3.3 → 1.4.0

package/dist/module/runtime/host.js

@@ -5,7 +5,7 @@ import { applyCollectionSchema, isDocumentMatchingContent, generateDocumentFromC
 import { getHostStyles, getSidebarWidth, adjustFixedElements } from "./utils/sidebar.js";
 import { clearError, getAppManifest, queryCollection, queryCollectionItemSurroundings, queryCollectionNavigation, queryCollectionSearchSections, useRuntimeConfig } from "#imports";
 import { collections } from "#content/preview";
-import { publicAssetsStorage } from "#build/studio-public-assets";
+import { publicAssetsStorage, externalAssetsStorage } from "#build/studio-assets";
 import { useHostMeta } from "./composables/useMeta.js";
 import { generateIdFromFsPath as generateMediaIdFromFsPath } from "./utils/media.js";
 import { getCollectionSourceById } from "./utils/source.js";
@@ -52,11 +52,13 @@ export function useStudioHost(user, repository) {
   function useContentCollectionQuery(collection) {
     return useContent().queryCollection(collection);
   }
-  const runtimeConfig = useRuntimeConfig();
-  const aiConfig = runtimeConfig.public.studio.ai;
+  const studioConfig = useRuntimeConfig().public.studio;
+  const aiConfig = studioConfig.ai;
+  const mediaConfig = studioConfig.media;
   const host = {
     meta: {
       dev: false,
+      media: mediaConfig,
       ai: {
         enabled: aiConfig?.enabled ?? false,
         experimental: {
@@ -68,7 +70,7 @@ export function useStudioHost(user, repository) {
         }
       },
       getComponents: () => meta.components.value,
-      defaultLocale: runtimeConfig.public.studio.i18n?.defaultLocale || "en",
+      defaultLocale: studioConfig.i18n?.defaultLocale || "en",
       getHighlightTheme: () => meta.highlightTheme.value
     },
     on: {
@@ -235,21 +237,30 @@ export function useStudioHost(user, repository) {
         contentFromDocument: async (document2) => generateContentFromDocument(document2)
       }
     },
-    media: {
-      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 (fsPath, media) => {
-        const id = generateMediaIdFromFsPath(fsPath);
-        await publicAssetsStorage.setItem(generateMediaIdFromFsPath(fsPath), { ...media, id });
-      },
-      delete: async (fsPath) => {
-        await publicAssetsStorage.removeItem(generateMediaIdFromFsPath(fsPath));
-      }
-    },
+    media: /* @__PURE__ */ (() => {
+      const getStorage = () => host.meta.media?.external ? externalAssetsStorage : publicAssetsStorage;
+      return {
+        get: async (fsPath) => {
+          return await getStorage().getItem(generateMediaIdFromFsPath(fsPath));
+        },
+        list: async () => {
+          const storage = getStorage();
+          return await Promise.all(
+            await storage.getKeys().then(
+              (keys) => keys.map((key) => storage.getItem(key))
+            )
+          );
+        },
+        upsert: async (fsPath, media) => {
+          const id = generateMediaIdFromFsPath(fsPath);
+          await getStorage().setItem(id, { ...media, id });
+        },
+        delete: async (fsPath) => {
+          const id = generateMediaIdFromFsPath(fsPath);
+          await getStorage().removeItem(id);
+        }
+      };
+    })(),
     app: {
       getManifestId: async () => {
         const manifest = await getAppManifest();

package/dist/module/runtime/server/routes/ai/analyze.post.js

@@ -1,8 +1,9 @@
 import { streamText } from "ai";
 import { createGateway } from "@ai-sdk/gateway";
-import { eventHandler, createError, useSession, getRequestProtocol, readBody } from "h3";
+import { eventHandler, createError, readBody } from "h3";
 import { consola } from "consola";
 import { useRuntimeConfig } from "#imports";
+import { requireStudioAuth } from "../../utils/auth.js";
 import { queryCollection } from "@nuxt/content/server";
 import {
   detectContentType,
@@ -14,6 +15,7 @@ import {
 import { ContentType } from "../../types/ai.js";
 const logger = consola.withTag("Nuxt Studio");
 export default eventHandler(async (event) => {
+  await requireStudioAuth(event);
   const config = useRuntimeConfig(event);
   const body = await readBody(event).catch(() => ({}));
   const collection = body.collection;
@@ -29,22 +31,6 @@ export default eventHandler(async (event) => {
       statusMessage: "Invalid collection: name and type are required"
     });
   }
-  if (!config.public.studio.dev) {
-    const session = await useSession(event, {
-      name: "studio-session",
-      password: config.studio?.auth?.sessionSecret,
-      cookie: {
-        secure: getRequestProtocol(event) === "https",
-        path: "/"
-      }
-    });
-    if (!session.data || Object.keys(session.data).length === 0) {
-      throw createError({
-        statusCode: 401,
-        statusMessage: "Unauthorized. Please log in to use AI features."
-      });
-    }
-  }
   const aiConfig = config.studio?.ai;
   const apiKey = aiConfig?.apiKey;
   if (!apiKey) {

package/dist/module/runtime/server/routes/ai/generate.post.js

@@ -1,30 +1,16 @@
 import { streamText } from "ai";
 import { createGateway } from "@ai-sdk/gateway";
-import { eventHandler, readBody, createError, useSession, getRequestProtocol } from "h3";
+import { eventHandler, readBody, createError } from "h3";
 import { useRuntimeConfig } from "#imports";
 import {
   buildAIContext,
   calculateMaxTokens,
   getSystem
 } from "../../utils/ai/generate.js";
+import { requireStudioAuth } from "../../utils/auth.js";
 export default eventHandler(async (event) => {
+  await requireStudioAuth(event);
   const config = useRuntimeConfig(event);
-  if (!config.public.studio.dev) {
-    const session = await useSession(event, {
-      name: "studio-session",
-      password: config.studio?.auth?.sessionSecret,
-      cookie: {
-        secure: getRequestProtocol(event) === "https",
-        path: "/"
-      }
-    });
-    if (!session.data || Object.keys(session.data).length === 0) {
-      throw createError({
-        statusCode: 401,
-        statusMessage: "Unauthorized. Please log in to use AI features."
-      });
-    }
-  }
   const aiConfig = config.studio?.ai;
   const apiKey = aiConfig?.apiKey;
   if (!apiKey) {

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

@@ -21,19 +21,26 @@ export interface OAuthGitHubConfig {
      * @default false
      */
     emailRequired?: boolean;
+    /**
+     * GitHub instance base web URL (for GitHub Enterprise Server).
+     * Must be the web origin without a trailing slash and without `/api/v3`,
+     * for example: `https://github.com` or `https://ghe.example.com`.
+     * @default 'https://github.com'
+     */
+    instanceUrl?: string;
     /**
      * GitHub OAuth Authorization URL
-     * @default 'https://github.com/login/oauth/authorize'
+     * @default '{instanceUrl}/login/oauth/authorize'
      */
     authorizationURL?: string;
     /**
      * GitHub OAuth Token URL
-     * @default 'https://github.com/login/oauth/access_token'
+     * @default '{instanceUrl}/login/oauth/access_token'
      */
     tokenURL?: string;
     /**
      * GitHub API URL
-     * @default 'https://api.github.com'
+     * @default 'https://api.github.com' (or '{instanceUrl}/api/v3' for GitHub Enterprise Server)
      */
     apiURL?: string;
     /**

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

@@ -1,18 +1,21 @@
 import { useRuntimeConfig } from "#imports";
 import { createError, deleteCookie, eventHandler, getCookie, getQuery, getRequestURL, sendRedirect } from "h3";
-import { withQuery } from "ufo";
+import { withQuery, withoutTrailingSlash } from "ufo";
 import { generateOAuthState, requestAccessToken, validateOAuthState } from "../../utils/auth.js";
 import { setInternalStudioUserSession } from "../../utils/session.js";
 import { mergeConfig } from "../../utils/object.js";
 export default eventHandler(async (event) => {
   const studioConfig = useRuntimeConfig(event).studio;
+  const instanceUrl = withoutTrailingSlash(studioConfig?.auth?.github?.instanceUrl || studioConfig?.repository?.instanceUrl || "https://github.com");
+  const isEnterprise = new URL(instanceUrl).hostname !== "github.com";
   const config = mergeConfig(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",
+    instanceUrl,
+    authorizationURL: `${instanceUrl}/login/oauth/authorize`,
+    tokenURL: `${instanceUrl}/login/oauth/access_token`,
+    apiURL: isEnterprise ? `${instanceUrl}/api/v3` : "https://api.github.com",
     authorizationParams: {},
     emailRequired: true
   });

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

@@ -1,13 +1,13 @@
 import { useRuntimeConfig } from "#imports";
 import { createError, deleteCookie, eventHandler, getCookie, getQuery, getRequestURL, sendRedirect } from "h3";
 import { FetchError } from "ofetch";
-import { withQuery } from "ufo";
+import { withQuery, withoutTrailingSlash } from "ufo";
 import { generateOAuthState, validateOAuthState } from "../../utils/auth.js";
 import { setInternalStudioUserSession } from "../../utils/session.js";
 import { mergeConfig } from "../../utils/object.js";
 export default eventHandler(async (event) => {
   const studioConfig = useRuntimeConfig(event).studio;
-  const instanceUrl = studioConfig?.auth?.gitlab?.instanceUrl || "https://gitlab.com";
+  const instanceUrl = withoutTrailingSlash(studioConfig?.auth?.gitlab?.instanceUrl || studioConfig?.repository?.instanceUrl || "https://gitlab.com");
   const config = mergeConfig(studioConfig?.auth?.gitlab, {
     applicationId: process.env.STUDIO_GITLAB_APPLICATION_ID,
     applicationSecret: process.env.STUDIO_GITLAB_APPLICATION_SECRET,

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

@@ -1,9 +1,10 @@
 import { createError, eventHandler, getRequestHeader, readRawBody, setResponseHeader } from "h3";
 import { withLeadingSlash } from "ufo";
 import { useStorage } from "#imports";
+import { VIRTUAL_MEDIA_COLLECTION_NAME } from "../../../../utils/constants.js";
 export default eventHandler(async (event) => {
   const path = event.path.replace("/__nuxt_studio/dev/public/", "");
-  const key = path.replace(/\//g, ":").replace(/^public-assets:/, "");
+  const key = path.replace(/\//g, ":").replace(new RegExp(`^${VIRTUAL_MEDIA_COLLECTION_NAME}:`), "");
   const storage = useStorage("nuxt_studio_public_assets");
   if (event.method === "GET") {
     const lastChar = key[key.length - 1];
@@ -20,7 +21,7 @@ export default eventHandler(async (event) => {
       });
     }
     return {
-      id: `public-assets/${key.replace(/:/g, "/")}`,
+      id: `${VIRTUAL_MEDIA_COLLECTION_NAME}/${key.replace(/:/g, "/")}`,
       extension: key.split(".").pop(),
       stem: key.split(".").join("."),
       path: "/" + key.replace(/:/g, "/"),

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

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

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

@@ -0,0 +1,71 @@
+import { joinURL, withLeadingSlash } from "ufo";
+import { createError, eventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { VIRTUAL_MEDIA_COLLECTION_NAME } from "../../../utils/constants.js";
+import { requireStudioAuth } from "../../utils/auth.js";
+import { blob } from "hub:blob";
+export default eventHandler(async (event) => {
+  await requireStudioAuth(event);
+  const { prefix, publicUrl, maxFileSize, allowedTypes } = useRuntimeConfig(event).public.studio.media;
+  const path = event.path.replace("/__nuxt_studio/medias/", "");
+  const key = path.replace(/\//g, ":").replace(new RegExp(`^${VIRTUAL_MEDIA_COLLECTION_NAME}:`), "");
+  if (event.method === "GET") {
+    const isBaseKey = key.endsWith("/") || key.endsWith(":");
+    if (isBaseKey) {
+      const subPath = key.slice(0, -1).replace(/:/g, "/");
+      const effectivePrefix = prefix ? subPath ? `${prefix}/${subPath}` : prefix : subPath;
+      const { blobs } = await blob.list(effectivePrefix ? { prefix: `${effectivePrefix}/` } : {});
+      return blobs.map((b) => {
+        return prefix ? b.pathname.slice(`${prefix}/`.length) : b.pathname;
+      });
+    }
+    const blobPath = key.replace(/:/g, "/");
+    const pathname = prefix ? `${prefix}/${blobPath}` : blobPath;
+    const meta = await blob.head(pathname);
+    if (!meta) {
+      throw createError({ statusCode: 404, message: "Item not found" });
+    }
+    const fsPath = withLeadingSlash(blobPath);
+    const resolvedPath = meta.url ?? joinURL(publicUrl, prefix, fsPath);
+    return {
+      id: path,
+      fsPath,
+      extension: fsPath.split(".").pop(),
+      stem: fsPath.split(".").slice(0, -1).join("."),
+      path: resolvedPath
+    };
+  }
+  if (event.method === "PUT") {
+    const body = await readBody(event);
+    const blobPath = key.replace(/:/g, "/");
+    const pathname = prefix ? `${prefix}/${blobPath}` : blobPath;
+    if (!body.raw) {
+      await blob.put(pathname, JSON.stringify(body), { contentType: "application/json" });
+    } else {
+      const raw = body.raw;
+      const [meta, data] = raw.split(";base64,");
+      const mimeType = meta.replace("data:", "");
+      const approximateSize = data.length * 3 / 4;
+      if (approximateSize > maxFileSize) {
+        throw createError({ statusCode: 413, message: `File size exceeds maximum of ${maxFileSize / 1024 / 1024}MB` });
+      }
+      if (!allowedTypes.some((t) => mimeType.startsWith(t.replace("*", "")))) {
+        throw createError({ statusCode: 415, message: `File type "${mimeType}" is not allowed` });
+      }
+      const binaryString = atob(data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      await blob.put(pathname, bytes, { contentType: mimeType });
+    }
+    return "OK";
+  }
+  if (event.method === "DELETE") {
+    const blobPath = key.replace(/:/g, "/");
+    const pathname = prefix ? `${prefix}/${blobPath}` : blobPath;
+    await blob.del(pathname);
+    return "OK";
+  }
+  throw createError({ statusCode: 405, message: "Method not allowed" });
+});

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

@@ -1,27 +1,12 @@
-import { eventHandler, useSession, getRequestProtocol } from "h3";
-import { useRuntimeConfig, createError } from "#imports";
+import { eventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
 import components from "#nuxt-component-meta/nitro";
 import { highlight } from "#mdc-imports";
 import { filterComponents } from "../utils/meta.js";
+import { requireStudioAuth } from "../utils/auth.js";
 export default eventHandler(async (event) => {
+  await requireStudioAuth(event);
   const config = useRuntimeConfig();
-  if (!import.meta.dev) {
-    const session = await useSession(event, {
-      name: "studio-session",
-      password: config.studio?.auth?.sessionSecret,
-      cookie: {
-        // Use secure cookies over HTTPS, required for locally testing purposes
-        secure: getRequestProtocol(event) === "https",
-        path: "/"
-      }
-    });
-    if (!session?.data?.user) {
-      throw createError({
-        statusCode: 404,
-        message: "Not found"
-      });
-    }
-  }
   const mappedComponents = Object.values(components).map(({ pascalName, filePath, meta }) => {
     return {
       name: pascalName,

package/dist/module/runtime/server/utils/auth.d.ts

@@ -1,4 +1,5 @@
 import { type H3Event } from 'h3';
+export declare function requireStudioAuth(event: H3Event): Promise<void>;
 export interface RequestAccessTokenResponse {
     access_token?: string;
     scope?: string;

package/dist/module/runtime/server/utils/auth.js

@@ -1,6 +1,24 @@
-import { createError, deleteCookie, getCookie, getRequestProtocol, setCookie } from "h3";
-import { FetchError } from "ofetch";
 import { getRandomValues } from "uncrypto";
+import { getCookie, deleteCookie, setCookie, useSession, getRequestProtocol, createError } from "h3";
+import { FetchError } from "ofetch";
+import { useRuntimeConfig } from "#imports";
+export async function requireStudioAuth(event) {
+  if (import.meta.dev) {
+    return;
+  }
+  const config = useRuntimeConfig(event);
+  const session = await useSession(event, {
+    name: "studio-session",
+    password: config.studio?.auth?.sessionSecret,
+    cookie: {
+      secure: getRequestProtocol(event) === "https",
+      path: "/"
+    }
+  });
+  if (!session?.data?.user) {
+    throw createError({ statusCode: 404, message: "Not found" });
+  }
+}
 export async function requestAccessToken(url, options) {
   const headers = {
     "Content-Type": "application/x-www-form-urlencoded",

package/dist/module/runtime/utils/collection.js

@@ -74,16 +74,14 @@ function computeValuesBasedOnCollectionSchema(collection, data) {
     const defaultValue = value?.default !== void 0 ? value.default : "NULL";
     const valueToInsert = typeof data[key] !== "undefined" ? data[key] : defaultValue;
     fields.push(key);
-    if (type === "json") {
+    if (valueToInsert === null || valueToInsert === "NULL" || valueToInsert === "") {
+      values.push("NULL");
+    } else if (type === "json") {
       values.push(`'${JSON.stringify(valueToInsert).replace(/'/g, "''")}'`);
     } else if (type === "string" || ["string", "enum"].includes(value.type)) {
-      if (["data", "datetime"].includes(value.format)) {
-        values.push(valueToInsert !== "NULL" ? `'${new Date(valueToInsert).toISOString()}'` : defaultValue);
-      } else {
-        values.push(`'${String(valueToInsert).replace(/\n/g, "\\n").replace(/'/g, "''")}'`);
-      }
+      values.push(`'${String(valueToInsert).replace(/\n/g, "\\n").replace(/'/g, "''")}'`);
     } else if (type === "boolean") {
-      values.push(valueToInsert !== "NULL" ? !!valueToInsert : valueToInsert);
+      values.push(!!valueToInsert);
     } else {
       values.push(valueToInsert);
     }

package/dist/module/runtime/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const VIRTUAL_MEDIA_COLLECTION_NAME: "public-assets";

package/dist/module/runtime/utils/constants.js

@@ -0,0 +1 @@
+export const VIRTUAL_MEDIA_COLLECTION_NAME = "public-assets";

package/dist/module/runtime/utils/media.js

@@ -1,5 +1,5 @@
 import { join } from "pathe";
-import { VirtualMediaCollectionName } from "nuxt-studio/app/utils";
+import { VIRTUAL_MEDIA_COLLECTION_NAME } from "./constants.js";
 export function generateIdFromFsPath(fsPath) {
-  return join(VirtualMediaCollectionName, fsPath);
+  return join(VIRTUAL_MEDIA_COLLECTION_NAME, fsPath);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-studio",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "description": "Nuxt Studio for Nuxt Content",
   "private": false,
   "repository": {
@@ -48,59 +48,61 @@
     "clean": "rm -rf dist .nuxt .output node_modules docs/node_modules docs/.output docs/.data docs/.nuxt playground/docus/node_modules playground/docus/.output playground/docus/.data playground/docus/.nuxt playground/minimal/node_modules playground/minimal/.output playground/minimal/.data playground/minimal/.nuxt pnpm-lock.yaml"
   },
   "dependencies": {
-    "@ai-sdk/gateway": "^3.0.42",
-    "@ai-sdk/vue": "^3.0.82",
-    "@iconify-json/lucide": "^1.2.90",
+    "@ai-sdk/gateway": "^3.0.55",
+    "@ai-sdk/vue": "^3.0.101",
+    "@iconify-json/lucide": "^1.2.94",
     "@nuxtjs/mdc": "^0.20.1",
     "@vueuse/core": "^14.2.1",
-    "ai": "^6.0.82",
+    "ai": "^6.0.101",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
     "js-yaml": "^4.1.1",
-    "minimatch": "^10.1.2",
+    "minimatch": "^10.2.4",
     "nuxt-component-meta": "^0.17.2",
     "remark-mdc": "^3.10.0",
-    "shiki": "^3.22.0",
+    "shiki": "^3.23.0",
     "unstorage": "1.17.4",
     "zod": "^4.3.6",
     "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {
     "@gitbeaker/core": "^43.8.0",
-    "@iconify-json/simple-icons": "^1.2.70",
-    "@nuxt/content": "^3.11.2",
-    "@nuxt/eslint-config": "^1.15.1",
+    "@iconify-json/simple-icons": "^1.2.71",
+    "@nuxt/content": "^3.12.0",
+    "@nuxt/eslint-config": "^1.15.2",
     "@nuxt/kit": "^4.3.1",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/ui": "^4.4.0",
+    "@nuxt/ui": "^4.5.0",
     "@octokit/types": "^16.0.0",
     "@release-it/conventional-changelog": "^10.0.5",
     "@tailwindcss/typography": "^0.5.19",
-    "@tiptap/extension-emoji": "^3.19.0",
+    "@tiptap/extension-emoji": "^3.20.0",
     "@types/js-yaml": "^4.0.9",
-    "@unhead/vue": "^2.1.4",
+    "@unhead/vue": "^2.1.9",
     "@unpic/vue": "^1.0.0",
     "@vitejs/plugin-vue": "^6.0.4",
-    "eslint": "^10.0.0",
+    "eslint": "^10.0.2",
     "idb-keyval": "^6.2.2",
     "minimark": "^0.2.0",
-    "modern-monaco": "^0.3.7",
+    "modern-monaco": "^0.3.8",
     "nuxt-studio": "workspace:*",
     "ofetch": "^1.5.1",
     "release-it": "^19.2.4",
-    "tailwindcss": "^4.1.18",
+    "tailwindcss": "^4.2.1",
     "vite": "^7.3.1",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-libcss": "^1.1.2",
     "vitest": "^4.0.18",
-    "vue": "^3.5.28",
-    "vue-router": "^5.0.2",
-    "vue-tsc": "^3.2.4"
+    "vue": "^3.5.29",
+    "vue-router": "^5.0.3",
+    "vue-tsc": "^3.2.5"
   },
   "resolutions": {
-    "minimark": "^0.2.0"
+    "minimark": "^0.2.0",
+    "@nuxt/content": "^3.12.0",
+    "unimport": "5.6.0"
   },
-  "packageManager": "pnpm@10.29.3",
+  "packageManager": "pnpm@10.30.3",
   "keywords": [
     "nuxt",
     "content",