feat!: add support for nuxt 3/nuxt bridge (#52)

* refactor: add support for nuxt 3/nuxt bridge

* test: disabled for now

* docs: typo

* refactor: update module

* test: enable

* chore: remove .ts

* chore: update script

* ci: update

* refactor: use config file to write rules

* feat: add `rules` option

* refactor: use `nitro.prerender`

* refactor: remove robots hooks

* test: update

* chore: update test command

* test: update

.github/workflows/ci.yml

@@ -14,9 +14,8 @@ jobs:
 
     strategy:
       matrix:
-        # os: [ubuntu-latest, macos-latest, windows-latest]
-        os: [ubuntu-latest]
-        node: [12]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        node: [14, 16, 18]
 
     steps:
       - uses: actions/setup-node@v3
@@ -33,9 +32,11 @@ jobs:
           key: ${{ matrix.os }}-node-v${{ matrix.node }}-deps-${{ hashFiles(format('{0}{1}', github.workspace, '/yarn.lock')) }}
 
       - name: Install dependencies
-        if: steps.cache.outputs.cache-hit != 'true'
         run: yarn
 
+      - name: Prepare TypeScript environment
+        run: yarn dev:prepare
+
       - name: Lint
         run: yarn lint
 

.gitignore

@@ -9,3 +9,4 @@ coverage
 dist
 sw.*
 .env
+.output

README.md

@@ -8,7 +8,13 @@
 
 > A Nuxt.js module that injects a middleware to generate a robots.txt file
 
-[📖 **Release Notes**](./CHANGELOG.md)
+- [📖 **Release Notes**](./CHANGELOG.md)
+
+## Features
+
+- Nuxt 3 and Nuxt Bridge support
+- Generate `robots.txt` for static mode
+- Add middleware for `robots.txt`
 
 ## Setup
 
@@ -47,45 +53,33 @@ export default {
 
 ## Options
 
-The module option parameter can be:
+### configPath
 
-### `Object`
-
-```js
-export default {
-  robots: {
-    UserAgent: '*',
-    Disallow: '/'
-  }
-}
-```
+- Type: `String`
+- Default: `robots.config`
 
-### `Array`
+### rules
 
+- Type: `Object|Array`
+- Default: 
 ```js
-export default {
-  robots: [
-    {
-      UserAgent: 'Googlebot',
-      Disallow: () => '/users' // accepts function
-    }
-  ]
+{
+  UserAgent: '*',
+  Disallow: ''
 }
 ```
 
-### `Function`
+## Robots config
+
+If you need to use function in any rule, you need to create a config file through the `configPath` option
 
 ```js
 export default {
-  robots: () => {
-    return {
-      UserAgent: '*',
-      Disallow: '/',
+  UserAgent: '*',
+  Disallow: '/',
 
-      // Be aware that this will NOT work on target: 'static' mode
-      Sitemap: (req) => `https://${req.headers.host}/sitemap.xml`
-    }
-  }
+  // Be aware that this will NOT work on target: 'static' mode
+  Sitemap: (req) => `https://${req.headers.host}/sitemap.xml`
 }
 ```
 
@@ -110,15 +104,6 @@ Disallow: /admin
 
 **Note:** Don't worry, keys are parsed with case insensitivity and special characters.
 
-## Hooks
-
-Hooks are listeners to Nuxt events. [Learn more](https://nuxtjs.org/docs/configuration-glossary/configuration-hooks/)
-
-| Hook                   | Arguments             | When                               |
-| ---------------------- | --------------------- | ---------------------------------- |
-| robots:generate:before | (nuxt, robotsOptions) | Hook on before site generation     |
-| robots:generate:done   | (nuxt, robotsContent) | Hook on robots generation finished |
-
 ## License
 
 [MIT License](./LICENSE)

package.json

@@ -9,32 +9,40 @@
     "Robert Reinhard",
     "William DA SILVA <[email protected]>"
   ],
-  "main": "./dist/module.js",
-  "types": "./dist/module.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "require": "./dist/module.cjs",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "siroc build",
-    "prepublishOnly": "yarn build",
-    "dev": "nuxt dev test/fixture/basic",
-    "lint": "eslint --ext .js,.ts,.vue .",
-    "release": "yarn test && yarn build && standard-version && git push --follow-tags && npm publish",
-    "test": "yarn lint && yarn jest"
+    "build": "nuxt-module-build",
+    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "dev": "nuxt dev playground",
+    "lint": "eslint --ext .js,.ts,.vue",
+    "prepack": "yarn build",
+    "release": "yarn test && standard-version && git push --follow-tags && npm publish",
+    "test": "yarn lint && nuxi test --coverage"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^3.0.0-rc.6"
   },
   "devDependencies": {
-    "@babel/preset-typescript": "latest",
-    "@nuxt/test-utils": "latest",
-    "@nuxt/types": "latest",
+    "@nuxt/module-builder": "latest",
+    "@nuxt/test-utils": "^3.0.0-rc.6",
     "@nuxtjs/eslint-config-typescript": "latest",
-    "@types/jest": "latest",
-    "@types/node": "latest",
-    "del": "latest",
+    "c8": "latest",
     "eslint": "latest",
-    "jest": "latest",
-    "nuxt": "latest",
-    "siroc": "latest",
-    "standard-version": "latest"
+    "nuxt": "^3.0.0-rc.6",
+    "standard-version": "latest",
+    "vitest": "latest"
   },
   "publishConfig": {
     "access": "public"

playground/app.vue

@@ -0,0 +1,3 @@
+<template>
+  <NuxtWelcome />
+</template>

playground/nuxt.config.ts

@@ -0,0 +1,9 @@
+
+import { defineNuxtConfig } from 'nuxt'
+import RobotsModule from '..'
+
+export default defineNuxtConfig({
+  modules: [
+    RobotsModule
+  ]
+})

playground/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "@nuxtjs/robots-playground"
+}

src/module.ts

@@ -1,56 +1,60 @@
-import type { Module } from '@nuxt/types'
+import { existsSync } from 'node:fs'
+import { defineNuxtModule, addServerHandler, createResolver, useLogger, isNuxt2, findPath, addTemplate } from '@nuxt/kit'
 import { name, version } from '../package.json'
-import { build } from './build'
-import { generate } from './generate'
-import { middleware } from './middleware'
 import { Rule } from './types'
 
-const CONFIG_KEY = 'robots'
-
-export type { Rule }
-
-export type ModuleOptions = Rule | Rule[] | (() => Rule | Rule[])
-
-async function getOptions (moduleOptions: ModuleOptions): Promise<Rule[]> {
-  if (typeof moduleOptions === 'function') {
-    moduleOptions = await moduleOptions.call(this)
-  }
-
-  if (Array.isArray(moduleOptions)) {
-    return moduleOptions
-  }
-
-  let { robots } = this.options
-
-  if (typeof robots === 'function') {
-    robots = await robots.call(this)
-  }
-
-  if (Array.isArray(robots)) {
-    return robots
-  }
-
-  return [{
-    UserAgent: '*',
-    Disallow: '',
-    ...robots,
-    ...moduleOptions
-  }]
-}
-
-const nuxtModule: Module<ModuleOptions> = async function (moduleOptions) {
-  const options: Rule[] = await getOptions.call(this, moduleOptions)
-
-  build.bind(this)()
-  generate.bind(this)(options)
-  middleware.bind(this)(options)
+export type ModuleOptions = {
+  configPath: string,
+  rules: Rule | Rule[]
 }
 
-;(nuxtModule as any).meta = { name, version }
-
-declare module '@nuxt/types' {
-  interface NuxtConfig { [CONFIG_KEY]?: ModuleOptions } // Nuxt 2.14+
-  interface Configuration { [CONFIG_KEY]?: ModuleOptions } // Nuxt 2.9 - 2.13
-}
-
-export default nuxtModule
+const ROBOTS_FILENAME = 'robots.txt'
+const logger = useLogger('nuxt:robots')
+
+export default defineNuxtModule<ModuleOptions>({
+  meta: {
+    name,
+    version,
+    configKey: 'robots'
+  },
+  defaults: {
+    configPath: 'robots.config',
+    rules: {
+      UserAgent: '*',
+      Disallow: ''
+    }
+  },
+  async setup (options, nuxt) {
+    const { resolve } = createResolver(import.meta.url)
+
+    const staticFilePath = resolve(
+      nuxt.options.srcDir,
+      isNuxt2() ? nuxt.options.dir.static : nuxt.options.dir.public,
+      ROBOTS_FILENAME
+    )
+
+    if (existsSync(staticFilePath)) {
+      logger.warn('To use `' + name + '` module, please remove public `robots.txt`')
+      return
+    }
+
+    nuxt.options.alias['#robots-config'] = await findPath(options.configPath) ?? resolve('./robots.config')
+    nuxt.options.alias['#robots-rules'] = addTemplate({
+      filename: 'robots-rules.mjs',
+      write: true,
+      getContents: () => `export const rules = ${JSON.stringify(options.rules, null, 2)}`
+    }).dst
+
+    nuxt.hook('nitro:build:before', (nitro) => {
+      nitro.options.prerender.routes.push(`/${ROBOTS_FILENAME}`)
+    })
+
+    const runtimeDir = resolve('./runtime')
+    nuxt.options.build.transpile.push(runtimeDir)
+
+    addServerHandler({
+      route: `/${ROBOTS_FILENAME}`,
+      handler: resolve(runtimeDir, 'server/middleware')
+    })
+  }
+})

src/robots.config.ts

@@ -0,0 +1,3 @@
+import { rules } from '#robots-rules'
+
+export default rules

src/runtime/server/middleware.ts

@@ -0,0 +1,8 @@
+import { defineHandler } from 'h3'
+import { getRules, render } from '../../utils'
+import config from '#robots-config'
+
+export default defineHandler(async ({ req, res }) => {
+  res.setHeader('Content-Type', 'text/plain')
+  res.end(render(await getRules(config, req)))
+})