unplugin-https-reverse-proxy 2.0.3-beta.2 → 4.0.0

package/src/caddy/caddyfile.ts

@@ -3,11 +3,11 @@ import { Liquid } from 'liquidjs'
 
 export const ProxyType = type({
   target: 'string',
-  port_suffix: 'string',
+  portSuffix: 'string',
   tls: 'string',
   source: 'string',
   base: 'string',
-  health_check: 'boolean',
+  healthCheck: 'boolean',
 })
 
 const CaddyContext = type({
@@ -46,27 +46,36 @@ export const caddyTemplate = `{
   }
 }
 
-{% for p in proxies %}
-{{ p.target }}{{ p.port_suffix }} {
-  {{ p.tls }}
-  reverse_proxy http://{{ p.source }} {% if p.health_check %} {
-    health_uri {{ p.base }}
-    health_interval 2s
-    health_timeout 5s
-    fail_duration 2s
-    unhealthy_status 502 503 504 404
-    lb_try_duration 3s
-    lb_try_interval 300ms
-
-    @error status 502 503 504 404
-    handle_response @error {
-      respond * 503 {
-        body "Service Unavailable"
-        close
+{% for host in hosts %}
+{{ host.host }}{{ host.portSuffix }} {
+  {{ host.tls }}
+
+  {% for route in host.routes %}
+  handle {{ route.base }}* {
+    reverse_proxy http://{{ route.source }} {% if route.healthCheck %} {
+      health_uri {{ route.base }}
+      health_interval 2s
+      health_timeout 5s
+      health_headers {
+        User-Agent {http.request.header.User-Agent}
+        Accept text/html,application/json,*/*
+      }
+      fail_duration 2s
+      unhealthy_status 502 503 504 404
+      lb_try_duration 3s
+      lb_try_interval 300ms
+
+      @error status 502 503 504 404
+      handle_response @error {
+        respond * 503 {
+          body "Service Unavailable"
+          close
+        }
       }
     }
+    {% endif %}
   }
-  {% endif %}
+  {% endfor %}
 }
 {% endfor %}
 `
@@ -74,5 +83,35 @@ export const caddyTemplate = `{
 const liquid = new Liquid()
 
 export async function genCaddyfile(ctx: typeof CaddyContext.infer): Promise<string> {
-  return await liquid.parseAndRender(caddyTemplate, ctx)
+  const hostsMap = new Map<string, {
+    host: string
+    portSuffix: string
+    tls: string
+    routes: typeof ProxyType.infer[]
+  }>()
+
+  for (const proxy of ctx.proxies) {
+    const key = `${proxy.target}${proxy.portSuffix}`
+    if (!hostsMap.has(key)) {
+      hostsMap.set(key, {
+        host: proxy.target,
+        portSuffix: proxy.portSuffix,
+        tls: proxy.tls,
+        routes: [],
+      })
+    }
+    let base = proxy.base || '/'
+    if (!base.startsWith('/'))
+      base = `/${base}`
+    if (base !== '/' && !base.endsWith('/'))
+      base = `${base}/`
+    hostsMap.get(key)!.routes.push({ ...proxy, base })
+  }
+
+  for (const host of hostsMap.values())
+    host.routes.sort((a, b) => b.base.length - a.base.length)
+
+  const hosts = Array.from(hostsMap.values())
+
+  return await liquid.parseAndRender(caddyTemplate, { ...ctx, hosts })
 }

package/src/caddy/config.ts

@@ -44,8 +44,13 @@ export function useCaddyConfig(): {
     const proxies = configJsonRef() || {}
 
     _proxies.forEach((p) => {
-      const index = `${p.target}${p.port_suffix}`
-      proxies[index] = p
+      let base = p.base || '/'
+      if (!base.startsWith('/'))
+        base = `/${base}`
+      if (base !== '/' && !base.endsWith('/'))
+        base = `${base}/`
+      const index = `${p.target}${p.portSuffix}${base}`
+      proxies[index] = { ...p, base }
     })
 
     const content = JSON.stringify(proxies, null, 2)

package/src/caddy/index.ts

@@ -102,10 +102,17 @@ interface RunOptions {
   base: string
   showCaddyLog: boolean
   https: boolean
-  health_check?: boolean
+  healthCheck?: boolean
 }
 
-const { cleanUp, configJsonRef, writeCaddyConfig } = useCaddyConfig()
+let caddyConfig: ReturnType<typeof useCaddyConfig> | undefined
+
+function getCaddyConfig(): ReturnType<typeof useCaddyConfig> {
+  if (!caddyConfig) {
+    caddyConfig = useCaddyConfig()
+  }
+  return caddyConfig
+}
 
 export class CaddyInstant {
   private inited = false
@@ -178,7 +185,7 @@ export class CaddyInstant {
       base = '/',
       showCaddyLog = false,
       https = false,
-      health_check = true,
+      healthCheck = true,
     } = options || {}
 
     this._source = source
@@ -192,32 +199,41 @@ export class CaddyInstant {
     consola.success('update host success\n')
 
     const targetHost = target.split(':')[0]
+    const normalizeBase = (b: string): string => {
+      let out = b || '/'
+      if (!out.startsWith('/'))
+        out = `/${out}`
+      if (out !== '/' && !out.endsWith('/'))
+        out = `${out}/`
+      return out
+    }
+    const baseNormalized = normalizeBase(base)
 
     const proxies = [
       {
         target: targetHost,
-        port_suffix: https ? '' : ':80',
+        portSuffix: https ? '' : ':80',
         tls: https ? 'tls internal' : '',
         source,
-        base,
-        health_check,
+        base: baseNormalized,
+        healthCheck,
       },
     ]
 
+    const { writeCaddyConfig } = getCaddyConfig()
     writeCaddyConfig(proxies)
 
     this._stopEffects.push(
       effect(async () => {
+        const { configJsonRef } = getCaddyConfig()
         const proxies = Object.values(configJsonRef() || {})
-        if (!(this.caddyfile || '').includes(`${target.split(':')[0]}${https ? '' : ':80'}`)) {
-          const ctx = validateTemplateContext({
-            caddy_root: this.caddyRoot,
-            proxies,
-          })
-
-          this.caddyfile = await genCaddyfile(ctx)
-          await this.writeCaddyfile()
-        }
+        const ctx = validateTemplateContext({
+          caddy_root: this.caddyRoot,
+          proxies,
+        })
+
+        this.caddyfile = await genCaddyfile(ctx)
+        await this.writeCaddyfile()
       }),
     )
 
@@ -368,7 +384,9 @@ export class CaddyInstant {
         await lockfile.unlock(caddyLockFilePath).catch(() => { })
         await unlink(caddyFilePath).catch(() => { })
         await unlink(caddyLockFilePath).catch(() => { })
-        await cleanUp()
+        if (caddyConfig) {
+          await caddyConfig.cleanUp()
+        }
       }
       catch (e) {
         consola.error(e)

package/src/index.ts

@@ -160,6 +160,16 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
     if (caddy)
       return
 
+    let base = '/'
+    const publicPath = compiler.options.output?.publicPath as unknown
+    if (typeof publicPath === 'string' && publicPath) {
+      base = publicPath
+    }
+    if (!base.startsWith('/'))
+      base = `/${base}`
+    if (base !== '/' && !base.endsWith('/'))
+      base = `${base}/`
+
     // https://github.com/webpack/webpack-dev-server/blob/master/lib/Server.js#L1913
     const _close = compiler.close?.bind(compiler)
     if (_close) {
@@ -177,12 +187,13 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
     caddy = new CaddyInstant()
 
     caddy.run(source, target, {
+      base,
       ...options,
     }).then(() => {
       compiler.hooks.done.tap('unplugin-https-reverse-proxy', async () => {
         await printForwardProxy()
 
-        consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}`)}`)
+        consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}${base}`)}`)
       })
     }).catch((e) => {
       throw e
@@ -231,12 +242,23 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
 
     caddy = new CaddyInstant()
 
+    let base = '/'
+    const publicPath = compiler.options.output?.publicPath as unknown
+    if (typeof publicPath === 'string' && publicPath) {
+      base = publicPath
+    }
+    if (!base.startsWith('/'))
+      base = `/${base}`
+    if (base !== '/' && !base.endsWith('/'))
+      base = `${base}/`
+
     caddy.run(source, target, {
+      base,
       ...options,
     }).then(async () => {
       await printForwardProxy()
 
-      consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}`)}`)
+      consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}${base}`)}`)
     }).catch((e) => {
       throw e
     })

package/src/types.ts

@@ -5,5 +5,5 @@ export interface Options {
   showCaddyLog?: boolean
   /** default `false` */
   https?: boolean
-  health_check?: boolean
+  healthCheck?: boolean
 }