fix: inline schema + strip NUXT_ prefix + multiline

Author: onmax

src/wizard/shelve-setup.ts

@@ -5,7 +5,7 @@ import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 import process from 'node:process'
 import { consola } from 'consola'
-import { loadFile, writeFile } from 'magicast'
+import { builders, loadFile, writeFile } from 'magicast'
 import { getDefaultExportOptions } from 'magicast/helpers'
 import { $fetch } from 'ofetch'
 import { getPrefix, toCamelCase } from '../utils/transform'
@@ -96,41 +96,54 @@ function countPrefixes(keys: string[]): Map<string, number> {
   return counts
 }
 
+/** Strip Nuxt-specific prefixes from env var keys */
+function stripNuxtPrefix(key: string): { key: string, isPublic: boolean } {
+  if (key.startsWith('NUXT_PUBLIC_'))
+    return { key: key.slice(12), isPublic: true }
+  if (key.startsWith('PUBLIC_'))
+    return { key: key.slice(7), isPublic: true }
+  if (key.startsWith('NUXT_'))
+    return { key: key.slice(5), isPublic: false }
+  return { key, isPublic: false }
+}
+
 /** Transform env var keys into nested runtimeConfig structure */
 function transformKeysToStructure(keys: string[]): Record<string, Record<string, true> | true> {
-  const prefixCounts = countPrefixes(keys)
+  // First, normalize keys by stripping NUXT_ prefixes
+  const normalizedKeys = keys.map((k) => {
+    const { key, isPublic } = stripNuxtPrefix(k)
+    return { original: k, normalized: key, isPublic }
+  })
+
+  // Count prefixes on normalized keys
+  const prefixCounts = countPrefixes(normalizedKeys.map(k => k.normalized))
   const result: Record<string, Record<string, true> | true> = {}
 
-  for (const key of keys) {
-    if (key.startsWith('PUBLIC_')) {
-      result.public ??= {}
-      assignNestedKey(result.public as Record<string, true>, key.slice(7), prefixCounts, 'PUBLIC_')
-      continue
-    }
-    if (key.startsWith('NUXT_PUBLIC_')) {
+  for (const { normalized, isPublic } of normalizedKeys) {
+    if (isPublic) {
       result.public ??= {}
-      assignNestedKey(result.public as Record<string, true>, key.slice(12), prefixCounts, 'NUXT_PUBLIC_')
+      assignNestedKey(result.public as Record<string, true>, normalized, prefixCounts)
       continue
     }
 
-    const prefix = getPrefix(key)
+    const prefix = getPrefix(normalized)
     if (prefix && (prefixCounts.get(prefix) || 0) >= 2) {
       const groupKey = toCamelCase(prefix)
       result[groupKey] ??= {}
-      const nestedKey = toCamelCase(key.slice(prefix.length + 1))
+      const nestedKey = toCamelCase(normalized.slice(prefix.length + 1))
       ;(result[groupKey] as Record<string, true>)[nestedKey] = true
     }
     else {
-      result[toCamelCase(key)] = true
+      result[toCamelCase(normalized)] = true
     }
   }
 
   return result
 }
 
-function assignNestedKey(obj: Record<string, true | Record<string, true>>, key: string, prefixCounts: Map<string, number>, publicPrefix: string): void {
+function assignNestedKey(obj: Record<string, true | Record<string, true>>, key: string, prefixCounts: Map<string, number>): void {
   const prefix = getPrefix(key)
-  if (prefix && (prefixCounts.get(`${publicPrefix}${prefix}`) || 0) >= 2) {
+  if (prefix && (prefixCounts.get(prefix) || 0) >= 2) {
     const groupKey = toCamelCase(prefix)
     obj[groupKey] ??= {}
     const rest = key.slice(prefix.length + 1)
@@ -142,42 +155,40 @@ function assignNestedKey(obj: Record<string, true | Record<string, true>>, key:
   }
 }
 
-function generateSchemaCode(keys: string[] | null, library: ValidationLibrary): { imports: string, schema: string } {
+function generateSchemaCode(keys: string[] | null, library: ValidationLibrary): { imports: string, schemaExpr: string } {
+  const s = library === 'valibot' ? 'v.string()' : 'z.string()'
+  const o = library === 'valibot' ? 'v.object' : 'z.object'
+  const imports = library === 'valibot' ? `import * as v from 'valibot'` : `import { z } from 'zod'`
+
   if (!keys || keys.length === 0) {
-    // Dummy schema
-    if (library === 'valibot') {
-      return {
-        imports: `import * as v from 'valibot'`,
-        schema: `const runtimeConfigSchema = v.object({\n  // Add your runtime config keys here\n  // example: apiKey: v.string(),\n})`,
-      }
-    }
-    return {
-      imports: `import { z } from 'zod'`,
-      schema: `const runtimeConfigSchema = z.object({\n  // Add your runtime config keys here\n  // example: apiKey: z.string(),\n})`,
-    }
+    // Placeholder schema
+    return { imports, schemaExpr: `${o}({})` }
   }
 
   const structure = transformKeysToStructure(keys)
-  const s = library === 'valibot' ? 'v.string()' : 'z.string()'
-  const o = library === 'valibot' ? 'v.object' : 'z.object'
 
   function renderObject(obj: Record<string, true | Record<string, true>>, indent = 2): string {
     const entries = Object.entries(obj)
     if (entries.length === 0)
       return '{}'
     const pad = ' '.repeat(indent)
+    const closePad = ' '.repeat(indent - 2)
     const lines = entries.map(([k, v]) => {
       if (v === true)
         return `${pad}${k}: ${s},`
-      return `${pad}${k}: ${o}({ ${Object.keys(v).map(nk => `${nk}: ${s}`).join(', ')} }),`
+      // Nested object - render inline if small, multiline if large
+      const nestedKeys = Object.keys(v)
+      if (nestedKeys.length <= 2) {
+        return `${pad}${k}: ${o}({ ${nestedKeys.map(nk => `${nk}: ${s}`).join(', ')} }),`
+      }
+      const nestedPad = ' '.repeat(indent + 2)
+      const nestedLines = nestedKeys.map(nk => `${nestedPad}${nk}: ${s},`)
+      return `${pad}${k}: ${o}({\n${nestedLines.join('\n')}\n${pad}}),`
     })
-    return `{\n${lines.join('\n')}\n${' '.repeat(indent - 2)}}`
+    return `{\n${lines.join('\n')}\n${closePad}}`
   }
 
-  const imports = library === 'valibot' ? `import * as v from 'valibot'` : `import { z } from 'zod'`
-  const schema = `const runtimeConfigSchema = ${o}(${renderObject(structure)})`
-
-  return { imports, schema }
+  return { imports, schemaExpr: `${o}(${renderObject(structure)})` }
 }
 
 function findNuxtConfig(rootDir: string): string | null {
@@ -191,7 +202,7 @@ function findNuxtConfig(rootDir: string): string | null {
 }
 
 interface UpdateNuxtConfigOptions {
-  schema: { imports: string, schema: string } | null
+  schema: { imports: string, schemaExpr: string } | null
   shelve: { project: string, slug: string } | null
   logger: ConsolaInstance
 }
@@ -205,7 +216,7 @@ async function updateNuxtConfig(rootDir: string, options: UpdateNuxtConfigOption
   }
 
   try {
-    // If we have a schema, we need to manually edit the file to add imports and the schema variable
+    // If we have a schema, add imports at the top of the file
     if (options.schema) {
       let content = readFileSync(configPath, 'utf-8')
 
@@ -214,30 +225,33 @@ async function updateNuxtConfig(rootDir: string, options: UpdateNuxtConfigOption
         logger.info('Schema already exists in nuxt.config, skipping schema generation')
       }
       else {
-        // Add imports at the top (after any existing imports)
-        const importMatch = content.match(/^(import[\s\S]*?(?:\n(?!import)|\n$))/m)
-        if (importMatch) {
-          const lastImportEnd = importMatch.index! + importMatch[0].length
-          content = `${content.slice(0, lastImportEnd)}\n${options.schema.imports}\n\n${options.schema.schema}\n${content.slice(lastImportEnd)}`
-        }
-        else {
-          // No imports, add at the very top
-          content = `${options.schema.imports}\n\n${options.schema.schema}\n\n${content}`
+        // Check if import already exists
+        const importStatement = options.schema.imports
+        if (!content.includes(importStatement)) {
+          // Add imports at the top (after any existing imports)
+          const importMatch = content.match(/^(import[\s\S]*?(?:\n(?!import)|\n$))/m)
+          if (importMatch) {
+            const lastImportEnd = importMatch.index! + importMatch[0].length
+            content = `${content.slice(0, lastImportEnd)}${importStatement}\n${content.slice(lastImportEnd)}`
+          }
+          else {
+            // No imports, add at the very top
+            content = `${importStatement}\n\n${content}`
+          }
+          writeFileSync(configPath, content)
         }
-
-        writeFileSync(configPath, content)
       }
     }
 
     // Use magicast to update the config object
     const mod = await loadFile(configPath)
     const config = getDefaultExportOptions(mod)
 
-    // Add $schema reference if we generated a schema
+    // Add $schema as inline expression
     if (options.schema && !config.safeRuntimeConfig?.$schema) {
       if (!config.safeRuntimeConfig)
         config.safeRuntimeConfig = {}
-      ;(config.safeRuntimeConfig as any).$schema = { $type: 'identifier', value: 'runtimeConfigSchema' }
+      ;(config.safeRuntimeConfig as any).$schema = builders.raw(options.schema.schemaExpr)
     }
 
     // Set shelve config if provided

test/wizard.test.ts

@@ -111,7 +111,8 @@ describe('shelve wizard', () => {
     expect(mockFetch).not.toHaveBeenCalled()
     const config = readFileSync(nuxtConfig, 'utf-8')
     expect(config).toContain('valibot') // schema import
-    expect(config).toContain('runtimeConfigSchema')
+    expect(config).toContain('$schema') // inline schema
+    expect(config).toContain('v.object') // valibot schema expression
     expect(config).not.toContain('shelve') // no shelve config
   })