@platformatic/vite 3.4.1 → 3.5.1

package/lib/capability.js

@@ -0,0 +1,422 @@
+import fastifyStatic from '@fastify/static'
+import {
+  BaseCapability,
+  cleanBasePath,
+  createServerListener,
+  ensureTrailingSlash,
+  errors,
+  getServerUrl,
+  importFile,
+  resolvePackage
+} from '@platformatic/basic'
+import { ensureLoggableError, features } from '@platformatic/foundation'
+import { NodeCapability } from '@platformatic/node'
+import fastify from 'fastify'
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { parse, satisfies } from 'semver'
+import { version } from './schema.js'
+
+const supportedVersions = ['^5.0.0', '^6.0.0', '^7.0.0']
+
+export class ViteCapability extends BaseCapability {
+  #vite
+  #viteVersion
+  #app
+  #server
+  #basePath
+
+  constructor (root, config, context) {
+    super('vite', version, root, config, context)
+  }
+
+  async init () {
+    await super.init()
+
+    if (this.isProduction) {
+      return
+    }
+
+    this.#vite = dirname(resolvePackage(this.root, 'vite'))
+
+    // In Vite 6, module resolving changed, adjust it
+    if (!existsSync(resolve(this.#vite, 'dist/node/index.js'))) {
+      this.#vite = resolve(this.#vite, '../..')
+    }
+
+    const vitePackage = JSON.parse(await readFile(resolve(this.#vite, 'package.json'), 'utf-8'))
+    this.#viteVersion = parse(vitePackage.version)
+
+    if (!supportedVersions.some(v => satisfies(vitePackage.version, v))) {
+      throw new errors.UnsupportedVersion('vite', vitePackage.version, supportedVersions)
+    }
+  }
+
+  async start ({ listen }) {
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    if (this.isProduction) {
+      await this.#startProduction(listen)
+    } else {
+      await this.#startDevelopment(listen)
+    }
+
+    await this._collectMetrics()
+  }
+
+  async stop () {
+    await super.stop()
+
+    if (this.childManager) {
+      return this.stopCommand()
+    } else if (this.#app) {
+      // This is needed if the capability was subclassed
+      return this.#app.close()
+    }
+  }
+
+  async build () {
+    const config = this.config
+    const command = config.application.commands.build
+    const configFile = config.vite.configFile ? resolve(this.root, config.vite.configFile) : undefined
+    let basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+    let outDir
+
+    if (command) {
+      return this.buildWithCommand(command, basePath)
+    }
+
+    await this.init()
+    const { build } = await importFile(resolve(this.#vite, 'dist/node/index.js'))
+
+    try {
+      globalThis.platformatic.isBuilding = true
+
+      await build({
+        root: this.root,
+        base: basePath,
+        mode: 'production',
+        configFile,
+        logLevel: this.logger.level,
+        build: {
+          outDir: config.application.outputDirectory
+        },
+        plugins: [
+          {
+            name: 'platformatic-build',
+            configResolved: config => {
+              basePath = ensureTrailingSlash(cleanBasePath(config.base))
+              outDir = resolve(this.root, config.build.outDir)
+            }
+          }
+        ]
+      })
+    } finally {
+      globalThis.platformatic.isBuilding = false
+    }
+
+    await writeFile(resolve(outDir, '.platformatic-build.json'), JSON.stringify({ basePath }), 'utf-8')
+  }
+
+  /* c8 ignore next 5 */
+  async getWatchConfig () {
+    return {
+      enabled: false
+    }
+  }
+
+  // This is only used in production mode
+  async inject (injectParams, onInject) {
+    const res = await this.#app.inject(injectParams, onInject)
+
+    /* c8 ignore next 3 */
+    if (onInject) {
+      return
+    }
+
+    // Since inject might be called from the main thread directly via ITC, let's clean it up
+    const { statusCode, headers, body, payload, rawPayload } = res
+    return { statusCode, headers, body, payload, rawPayload }
+  }
+
+  getMeta () {
+    const config = this.subprocessConfig ?? this.#app?.config
+
+    const gateway = {
+      tcp: typeof this.url !== 'undefined',
+      url: this.url,
+      prefix: this.basePath ?? config?.base ?? this.#basePath,
+      wantsAbsoluteUrls: true,
+      needsRootTrailingSlash: true
+    }
+
+    return { gateway }
+  }
+
+  _getVite () {
+    return this.#app
+  }
+
+  async #startDevelopment () {
+    const config = this.config
+    const command = this.config.application.commands.development
+
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    this.registerGlobals({ basePath: this.#basePath })
+
+    if (command) {
+      return this.startWithCommand(command)
+    }
+
+    // Prepare options
+    const { hostname, port, https, cors } = this.serverConfig ?? {}
+    const configFile = config.vite.configFile ? resolve(this.root, config.vite.configFile) : undefined
+
+    const serverOptions = {
+      host: hostname || '127.0.0.1',
+      port: port || 0,
+      strictPort: false,
+      https,
+      cors,
+      hmr: true,
+      allowedHosts: ['.plt.local'],
+      fs: {
+        strict: config.vite.devServer.strict
+      }
+    }
+
+    // Require Vite
+    const serverPromise = createServerListener(
+      (this.isEntrypoint ? serverOptions?.port : undefined) ?? true,
+      (this.isEntrypoint ? serverOptions?.hostname : undefined) ?? true
+    )
+    const { createServer } = await importFile(resolve(this.#vite, 'dist/node/index.js'))
+
+    // Create the server and listen
+    this.#app = await createServer({
+      root: this.root,
+      base: this.#basePath,
+      mode: 'development',
+      configFile,
+      logLevel: this.logger.level,
+      clearScreen: false,
+      optimizeDeps: { force: false },
+      server: serverOptions
+    })
+
+    await this.#app.listen()
+    this.#server = await serverPromise
+    this.url = getServerUrl(this.#server)
+  }
+
+  async #startProduction (listen) {
+    const config = this.config
+    const command = this.config.application.commands.production
+
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    this.registerGlobals({ basePath: this.#basePath })
+
+    if (command) {
+      return this.startWithCommand(command)
+    }
+
+    if (this.#app && listen) {
+      const serverOptions = this.serverConfig
+      const listenOptions = { host: serverOptions?.hostname || '127.0.0.1', port: serverOptions?.port || 0 }
+
+      if (this.isProduction && features.node.reusePort) {
+        listenOptions.reusePort = true
+      }
+
+      await this.#app.listen(listenOptions)
+      this.url = getServerUrl(this.#app.server)
+      return this.url
+    }
+
+    this.#app = fastify({ loggerInstance: this.logger })
+
+    const outputDirectory = resolve(this.root, config.application.outputDirectory)
+    this.verifyOutputDirectory(outputDirectory)
+    const buildInfoPath = resolve(outputDirectory, '.platformatic-build.json')
+
+    if (!this.#basePath && existsSync(buildInfoPath)) {
+      try {
+        const buildInfo = JSON.parse(await readFile(buildInfoPath, 'utf-8'))
+        this.#basePath = buildInfo.basePath
+      } catch (e) {
+        globalThis.platformatic.logger.error({ err: ensureLoggableError(e) }, 'Reading build info failed.')
+      }
+    }
+
+    await this.#app.register(fastifyStatic, {
+      root: outputDirectory,
+      prefix: this.#basePath,
+      prefixAvoidTrailingSlash: true,
+      schemaHide: true
+    })
+
+    await this.#app.ready()
+  }
+}
+
+export class ViteSSRCapability extends NodeCapability {
+  #basePath
+
+  constructor (root, config, context) {
+    super(root, config, context)
+    this.type = 'vite'
+  }
+
+  _getWantsAbsoluteUrls () {
+    return true
+  }
+
+  async init () {
+    await super.init()
+
+    const config = this.config
+
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    this.registerGlobals({ basePath: this.#basePath })
+  }
+
+  async start ({ listen }) {
+    // Make this idempotent
+    /* c8 ignore next 3 */
+    if (this.url) {
+      return this.url
+    }
+
+    const config = this.config
+    const command = config.application.commands[this.isProduction ? 'production' : 'development']
+
+    if (command) {
+      return this.startWithCommand(command)
+    }
+
+    if (this.isProduction) {
+      const clientDirectory = config.vite.ssr.clientDirectory
+      const clientOutDir = resolve(this.root, clientDirectory, config.application.outputDirectory, clientDirectory)
+
+      this.verifyOutputDirectory(clientOutDir)
+
+      const buildInfoPath = resolve(clientOutDir, '.platformatic-build.json')
+      if (!this.#basePath && existsSync(buildInfoPath)) {
+        try {
+          const buildInfo = JSON.parse(await readFile(buildInfoPath, 'utf-8'))
+          this.#basePath = buildInfo.basePath
+        } catch (e) {
+          globalThis.platformatic.logger.error({ err: ensureLoggableError(e) }, 'Reading build info failed.')
+        }
+      }
+    }
+
+    await super.start({ listen })
+    await super._listen()
+  }
+
+  async build () {
+    const config = this.config
+    const command = config.application.commands.build
+    const configFile = config.vite.configFile ? resolve(this.root, config.vite.configFile) : undefined
+    let basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    if (command) {
+      return this.buildWithCommand(command, basePath)
+    }
+
+    const clientDirectory = config.vite.ssr.clientDirectory
+    const serverDirectory = config.vite.ssr.serverDirectory
+    let clientOutDir = resolve(this.root, clientDirectory, config.application.outputDirectory, clientDirectory)
+
+    await this.init()
+
+    let vite = dirname(resolvePackage(this.root, 'vite'))
+    // In Vite 6, module resolving changed, adjust it
+    if (!existsSync(resolve(vite, 'dist/node/index.js'))) {
+      vite = resolve(vite, '../..')
+    }
+
+    const { build } = await importFile(resolve(vite, 'dist/node/index.js'))
+
+    // Build the client
+    try {
+      globalThis.platformatic.isBuilding = true
+
+      await build({
+        root: resolve(this.root, clientDirectory),
+        base: basePath,
+        mode: 'production',
+        configFile,
+        logLevel: this.logger.level,
+        build: {
+          outDir: clientOutDir,
+          ssrManifest: true
+        },
+        plugins: [
+          {
+            name: 'platformatic-build',
+            configResolved: config => {
+              basePath = ensureTrailingSlash(cleanBasePath(config.base))
+              clientOutDir = resolve(this.root, clientDirectory, config.build.outDir)
+            }
+          }
+        ]
+      })
+    } finally {
+      globalThis.platformatic.isBuilding = false
+    }
+
+    await writeFile(resolve(clientOutDir, '.platformatic-build.json'), JSON.stringify({ basePath }), 'utf-8')
+
+    // Build the server
+    await build({
+      root: this.root,
+      base: basePath,
+      mode: 'production',
+      configFile,
+      logLevel: this.logger.level,
+      build: {
+        outDir: resolve(this.root, clientDirectory, config.application.outputDirectory, serverDirectory),
+        ssr: resolve(this.root, clientDirectory, 'index.js')
+      }
+    })
+  }
+
+  getMeta () {
+    const vite = this._getApplication()?.vite
+    const applicationBasePath = vite?.config?.base
+
+    const gateway = {
+      tcp: typeof this.url !== 'undefined',
+      url: this.url,
+      prefix: this.basePath ?? applicationBasePath ?? this.#basePath,
+      wantsAbsoluteUrls: true,
+      needsRootTrailingSlash: true
+    }
+
+    return { gateway }
+  }
+
+  _findEntrypoint () {
+    const config = this.config.vite ?? {}
+    return resolve(this.root, config.ssr.entrypoint)
+  }
+}

package/lib/schema.js

@@ -1,8 +1,10 @@
 import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
-import { schemaComponents as utilsSchemaComponents } from '@platformatic/utils'
+import { schemaComponents as utilsSchemaComponents } from '@platformatic/foundation'
 import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 
-export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
 
 const vite = {
   type: 'object',
@@ -50,7 +52,7 @@ export const schemaComponents = { vite }
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/vite/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic Vite Stackable',
+  title: 'Platformatic Vite Config',
   type: 'object',
   properties: {
     $schema: {
@@ -59,7 +61,8 @@ export const schema = {
     logger: utilsSchemaComponents.logger,
     server: utilsSchemaComponents.server,
     watch: basicSchemaComponents.watch,
-    application: basicSchemaComponents.application,
+    application: basicSchemaComponents.buildableApplication,
+    runtime: utilsSchemaComponents.wrappedRuntime,
     vite
   },
   additionalProperties: false

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@platformatic/vite",
-  "version": "3.4.1",
-  "description": "Platformatic Vite Stackable",
+  "version": "3.5.1",
+  "description": "Platformatic Vite Capability",
   "main": "index.js",
   "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
   },
-  "author": "Paolo Insogna <paolo@cowtech.it>",
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/platformatic/platformatic/issues"
@@ -18,31 +18,31 @@
     "@fastify/static": "^8.0.0",
     "fastify": "^5.0.0",
     "semver": "^7.6.3",
-    "@platformatic/basic": "3.4.1",
-    "@platformatic/config": "3.4.1",
-    "@platformatic/node": "3.4.1",
-    "@platformatic/utils": "3.4.1"
+    "@platformatic/basic": "3.5.1",
+    "@platformatic/foundation": "3.5.1",
+    "@platformatic/node": "3.5.1"
   },
   "devDependencies": {
-    "@fastify/vite": "^7.0.1",
-    "borp": "^0.17.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
     "json-schema-to-typescript": "^15.0.1",
-    "neostandard": "^0.11.1",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
+    "neostandard": "^0.12.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
     "typescript": "^5.5.4",
-    "vite": "^5.4.0",
+    "vite": "^7.1.4",
     "ws": "^8.18.0",
-    "@platformatic/composer": "3.4.1",
-    "@platformatic/service": "3.4.1"
+    "@platformatic/gateway": "3.5.1",
+    "@platformatic/service": "3.5.1"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --no-timeout",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --no-timeout",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
-    "build": "pnpm run gen-schema && pnpm run gen-types",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }