fix!: do not augment nuxt options inside module entry (#295)

Author: danielroe

.gitignore

@@ -10,3 +10,4 @@ package-lock.json
 .output
 .idea/
 example/playground/.nuxtrc
+.temp*

package.json

@@ -40,8 +40,7 @@
     "pathe": "^1.1.2",
     "pkg-types": "^1.1.1",
     "tsconfck": "^3.1.0",
-    "unbuild": "^2.0.0",
-    "untyped": "^1.4.2"
+    "unbuild": "^2.0.0"
   },
   "peerDependencies": {
     "@nuxt/kit": "^3.12.2",

pnpm-lock.yaml

@@ -8,12 +8,9 @@ import type { TSConfig } from 'pkg-types'
 import { defu } from 'defu'
 import { anyOf, createRegExp } from 'magic-regexp'
 import { consola } from 'consola'
-import type { ModuleMeta, NuxtModule } from '@nuxt/schema'
+import type { NuxtModule } from '@nuxt/schema'
 import { findExports, resolvePath } from 'mlly'
-import { resolveSchema, generateTypes } from 'untyped'
-import type { InputObject } from 'untyped'
 import { defineCommand } from 'citty'
-import { loadNuxt } from '@nuxt/kit'
 
 import { name, version } from '../../package.json'
 
@@ -172,24 +169,14 @@ export default defineCommand({
           await fsp.writeFile(metaFile, JSON.stringify(moduleMeta, null, 2), 'utf8')
 
           // Generate types
-          await writeTypes(ctx.options.outDir, moduleMeta, async () => {
-            const nuxt = await loadNuxt({
-              cwd,
-              overrides: {
-                modules: [resolve(cwd, './src/module')],
-              },
-            })
-            const moduleOptions = await moduleFn.getOptions?.({}, nuxt) || {}
-            await nuxt.close()
-            return moduleOptions
-          })
+          await writeTypes(ctx.options.outDir)
         },
       },
     })
   },
 })
 
-async function writeTypes(distDir: string, meta: ModuleMeta, getOptions: () => Promise<Record<string, unknown>>) {
+async function writeTypes(distDir: string) {
   const dtsFile = resolve(distDir, 'types.d.ts')
   const dtsFileMts = resolve(distDir, 'types.d.mts')
   if (existsSync(dtsFile)) {
@@ -211,21 +198,17 @@ async function writeTypes(distDir: string, meta: ModuleMeta, getOptions: () => P
   const appShims: string[] = []
   const schemaShims: string[] = []
   const moduleImports: string[] = []
-  const moduleDeclarations: string[] = []
+  const schemaImports: string[] = []
+  const moduleExports: string[] = []
 
   const hasTypeExport = (name: string) => isStub || typeExports.find(exp => exp.names.includes(name))
 
-  if (meta.configKey) {
-    schemaShims.push(`  interface NuxtConfig { ['${meta.configKey}']?: Partial<ModuleOptions> }`)
-    schemaShims.push(`  interface NuxtOptions { ['${meta.configKey}']?: ModuleOptions }`)
-
-    if (hasTypeExport('ModuleOptions')) {
-      moduleImports.push('ModuleOptions')
-    }
-    else {
-      moduleDeclarations.push(`  ${generateTypes(await resolveSchema(await getOptions() as InputObject), { interfaceName: 'ModuleOptions' })}`)
-    }
+  if (!hasTypeExport('ModuleOptions')) {
+    schemaImports.push('NuxtModule')
+    moduleImports.push('default as Module')
+    moduleExports.push(`export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>`)
   }
+
   if (hasTypeExport('ModuleHooks')) {
     moduleImports.push('ModuleHooks')
     schemaShims.push('  interface NuxtHooks extends ModuleHooks {}')
@@ -252,14 +235,16 @@ async function writeTypes(distDir: string, meta: ModuleMeta, getOptions: () => P
   }
 
   const dtsContents = `
+  ${schemaImports.length ? `import type { ${schemaImports.join(', ')} } from '@nuxt/schema'` : ''}
+
 import type { ${moduleImports.join(', ')} } from './module'
 
-${moduleDeclarations.join('\n')}
 ${appShims.length ? `declare module '#app' {\n${appShims.join('\n')}\n}\n` : ''}
 ${schemaShims.length ? `declare module '@nuxt/schema' {\n${schemaShims.join('\n')}\n}\n` : ''}
 ${schemaShims.length ? `declare module 'nuxt/schema' {\n${schemaShims.join('\n')}\n}\n` : ''}
+${moduleExports.length ? `\n${moduleExports.join('\n')}` : ''}
 ${typeExports[0] ? `\nexport type { ${typeExports[0].names.join(', ')} } from './module'` : ''}
-`
+`.trim().replace(/[\n\r]{3,}/g, '\n\n') + '\n'
 
   await fsp.writeFile(dtsFile, dtsContents, 'utf8')
   if (!existsSync(dtsFileMts)) {

src/commands/build.ts

@@ -1,20 +1,32 @@
 import { fileURLToPath } from 'node:url'
-import { readFile, readdir } from 'node:fs/promises'
+import { cp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
 import { beforeAll, describe, it, expect } from 'vitest'
 import { execaCommand } from 'execa'
 import { readPackageJSON } from 'pkg-types'
-import { join } from 'pathe'
+import { dirname, join } from 'pathe'
 import { findStaticImports } from 'mlly'
 import { version } from '../package.json'
 
 describe('module builder', () => {
   const rootDir = fileURLToPath(new URL('../example', import.meta.url))
+  const secondRootDir = rootDir.replace('example', '.temp-example-without-options')
   const distDir = join(rootDir, 'dist')
+  const secondDistDir = join(secondRootDir, 'dist')
   const runtimeDir = join(distDir, 'runtime')
 
   beforeAll(async () => {
-    await execaCommand('pnpm dev:prepare', { cwd: rootDir })
-    await execaCommand('pnpm prepack', { cwd: rootDir })
+    // Prepare second root directory without type export
+    await mkdir(dirname(secondRootDir), { recursive: true })
+    await rm(secondRootDir, { force: true, recursive: true })
+    await cp(rootDir, secondRootDir, { recursive: true })
+    const moduleSrc = join(secondRootDir, 'src/module.ts')
+    const contents = await readFile(moduleSrc, 'utf-8').then(r => r.replace('export interface ModuleOptions', 'interface ModuleOptions'))
+    await writeFile(moduleSrc, contents)
+
+    await Promise.all([
+      execaCommand('pnpm dev:prepare', { cwd: rootDir }).then(() => execaCommand('pnpm prepack', { cwd: rootDir })),
+      execaCommand('pnpm dev:prepare', { cwd: secondRootDir }).then(() => execaCommand('pnpm prepack', { cwd: secondRootDir })),
+    ])
   }, 120 * 1000)
 
   it('should generate all files', async () => {
@@ -47,32 +59,55 @@ describe('module builder', () => {
   it('should write types to output directory', async () => {
     const types = await readFile(join(distDir, 'types.d.ts'), 'utf-8')
     expect(types).toMatchInlineSnapshot(`
+      "import type { ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module'
+
+      declare module '#app' {
+        interface RuntimeNuxtHooks extends ModuleRuntimeHooks {}
+      }
+
+      declare module '@nuxt/schema' {
+        interface NuxtHooks extends ModuleHooks {}
+        interface RuntimeConfig extends ModuleRuntimeConfig {}
+        interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+      }
+
+      declare module 'nuxt/schema' {
+        interface NuxtHooks extends ModuleHooks {}
+        interface RuntimeConfig extends ModuleRuntimeConfig {}
+        interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+      }
+
+      export type { ModuleHooks, ModuleOptions, ModulePublicRuntimeConfig, ModuleRuntimeConfig, ModuleRuntimeHooks, default } from './module'
       "
-      import type { ModuleOptions, ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module'
+    `)
+  })
 
+  it('should generate types when no ModuleOptions are exported', async () => {
+    const types = await readFile(join(secondDistDir, 'types.d.ts'), 'utf-8')
+    expect(types).toMatchInlineSnapshot(`
+      "import type { NuxtModule } from '@nuxt/schema'
+
+      import type { default as Module, ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module'
 
       declare module '#app' {
         interface RuntimeNuxtHooks extends ModuleRuntimeHooks {}
       }
 
       declare module '@nuxt/schema' {
-        interface NuxtConfig { ['myModule']?: Partial<ModuleOptions> }
-        interface NuxtOptions { ['myModule']?: ModuleOptions }
         interface NuxtHooks extends ModuleHooks {}
         interface RuntimeConfig extends ModuleRuntimeConfig {}
         interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
       }
 
       declare module 'nuxt/schema' {
-        interface NuxtConfig { ['myModule']?: Partial<ModuleOptions> }
-        interface NuxtOptions { ['myModule']?: ModuleOptions }
         interface NuxtHooks extends ModuleHooks {}
         interface RuntimeConfig extends ModuleRuntimeConfig {}
         interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
       }
 
+      export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-      export type { ModuleHooks, ModuleOptions, ModulePublicRuntimeConfig, ModuleRuntimeConfig, ModuleRuntimeHooks, default } from './module'
+      export type { ModuleHooks, ModulePublicRuntimeConfig, ModuleRuntimeConfig, ModuleRuntimeHooks, default } from './module'
       "
     `)
   })