@platformatic/vite 2.0.0-alpha.7 → 2.0.0-alpha.8

package/config.d.ts

@@ -152,20 +152,27 @@ export interface PlatformaticViteStackable {
     | string;
   application?: {
     basePath?: string;
+    outputDirectory?: string;
+    include?: string[];
+    commands?: {
+      install?: string;
+      build?: string;
+      development?: string;
+      production?: string;
+    };
   };
   vite?: {
     configFile?: string | boolean;
+    devServer?: {
+      strict?: boolean;
+    };
     ssr?:
       | {
+          enabled?: boolean;
           entrypoint: string;
+          clientDirectory?: string;
+          serverDirectory?: string;
         }
       | boolean;
   };
-  deploy?: {
-    include?: string[];
-    buildCommand?: string;
-    installCommand?: string;
-    startCommand?: string;
-    [k: string]: unknown;
-  };
 }

package/eslint.config.js

@@ -1,5 +1,5 @@
 import neostandard from 'neostandard'
 
 export default neostandard({
-  ignores: ['test/tmp/version.js', '**/.vite'],
+  ignores: ['**/.vite', '**/dist', '**/tmp']
 })

package/index.js

@@ -1,16 +1,21 @@
+import fastifyStatic from '@fastify/static'
 import {
   BaseStackable,
   transformConfig as basicTransformConfig,
+  cleanBasePath,
   createServerListener,
+  ensureTrailingSlash,
   errors,
   getServerUrl,
   importFile,
+  resolvePackage,
   schemaOptions
 } from '@platformatic/basic'
 import { ConfigManager } from '@platformatic/config'
 import { NodeStackable } from '@platformatic/node'
-import { readFile } from 'node:fs/promises'
-import { createRequire } from 'node:module'
+import fastify from 'fastify'
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
 import { dirname, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { satisfies } from 'semver'
@@ -29,7 +34,7 @@ export class ViteStackable extends BaseStackable {
   }
 
   async init () {
-    this.#vite = dirname(createRequire(this.root).resolve('vite'))
+    this.#vite = dirname(resolvePackage(this.root, 'vite'))
     const vitePackage = JSON.parse(await readFile(resolve(this.#vite, 'package.json'), 'utf-8'))
 
     /* c8 ignore next 3 */
@@ -38,20 +43,135 @@ export class ViteStackable extends BaseStackable {
     }
   }
 
-  async start () {
+  async start ({ listen }) {
     // Make this idempotent
     if (this.url) {
       return this.url
     }
 
+    if (this.isProduction) {
+      await this.#startProduction(listen)
+    } else {
+      await this.#startDevelopment(listen)
+    }
+  }
+
+  async stop () {
+    if (this.subprocess) {
+      return this.stopCommand()
+    }
+
+    return this.#app.close()
+  }
+
+  async build () {
     const config = this.configManager.current
+    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'))
+
+    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)
+          }
+        }
+      ]
+    })
+
+    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 () {
+    let composer = { prefix: this.servicePrefix, wantsAbsoluteUrls: true, needsRootRedirect: true }
+
+    if (this.isProduction) {
+      composer = {
+        tcp: typeof this.url !== 'undefined',
+        url: this.url,
+        prefix: (this.subprocessConfig?.base ?? this.#basePath).replace(/(^\/)|(\/$)/g, ''),
+        wantsAbsoluteUrls: true,
+        needsRootRedirect: true
+      }
+    } else if (this.url) {
+      if (!this.#basePath) {
+        const config = this.subprocessConfig ?? this.#app.config
+        this.#basePath = config.base.replace(/(^\/)|(\/$)/g, '')
+      }
+
+      composer = {
+        tcp: true,
+        url: this.url,
+        prefix: this.#basePath.replace(/(^\/)|(\/$)/g, ''),
+        wantsAbsoluteUrls: true,
+        needsRootRedirect: true
+      }
+    }
+
+    return { composer }
+  }
+
+  _getVite () {
+    return this.#app
+  }
+
+  async #startDevelopment () {
+    const config = this.configManager.current
+    const command = this.configManager.current.application.commands.development
+
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    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 basePath = config.application?.basePath
-      ? `/${config.application?.basePath}`.replaceAll(/\/+/g, '/').replace(/\/$/, '')
-      : undefined
+    const configFile = config.vite.configFile ? resolve(this.root, config.vite.configFile) : undefined
 
     const serverOptions = {
       host: hostname || '127.0.0.1',
@@ -60,17 +180,20 @@ export class ViteStackable extends BaseStackable {
       https,
       cors,
       origin: 'http://localhost',
-      hmr: true
+      hmr: true,
+      fs: {
+        strict: config.vite.devServer.strict
+      }
     }
 
     // Require Vite
-    const serverPromise = createServerListener()
+    const serverPromise = createServerListener((this.isEntrypoint ? serverOptions?.port : 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: basePath,
+      base: this.#basePath,
       mode: 'development',
       configFile,
       logLevel: this.logger.level,
@@ -84,47 +207,56 @@ export class ViteStackable extends BaseStackable {
     this.url = getServerUrl(this.#server)
   }
 
-  async stop () {
-    return this.#app.close()
-  }
+  async #startProduction (listen) {
+    const config = this.configManager.current
+    const command = this.configManager.current.application.commands.production
 
-  /* c8 ignore next 5 */
-  async getWatchConfig () {
-    return {
-      enabled: false
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    if (command) {
+      return this.startWithCommand(command)
     }
-  }
 
-  getMeta () {
-    const deploy = this.configManager.current.deploy
-    let composer
+    if (this.#app && listen) {
+      const serverOptions = this.serverConfig
+      await this.#app.listen({ host: serverOptions?.hostname || '127.0.0.1', port: serverOptions?.port || 0 })
+      this.url = getServerUrl(this.#app.server)
+      return this.url
+    }
 
-    if (this.url) {
-      if (!this.#basePath) {
-        this.#basePath = this.#app.config.base.replace(/(^\/)|(\/$)/g, '')
-      }
+    this.#app = fastify({ logger: { level: 'info' } })
 
-      composer = {
-        tcp: true,
-        url: this.url,
-        prefix: this.#basePath,
-        wantsAbsoluteUrls: true
+    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) {
+        console.log(e)
       }
     }
 
-    return { deploy, composer }
-  }
+    await this.#app.register(fastifyStatic, {
+      root: outputDirectory,
+      prefix: this.#basePath,
+      prefixAvoidTrailingSlash: true,
+      schemaHide: true
+    })
 
-  _getVite () {
-    return this.#app
+    await this.#app.ready()
   }
 }
 
 export class ViteSSRStackable extends NodeStackable {
   #basePath
 
-  constructor (options, root, configManager, entrypoint) {
-    super(options, root, configManager, entrypoint, true)
+  constructor (options, root, configManager) {
+    super(options, root, configManager)
 
     this.type = 'vite'
   }
@@ -133,14 +265,15 @@ export class ViteSSRStackable extends NodeStackable {
     const config = this.configManager.current
 
     this.#basePath = config.application?.basePath
-      ? `/${config.application?.basePath}`.replaceAll(/\/+/g, '/').replace(/\/$/, '')
-      : ''
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
 
     this.registerGlobals({
+      id: this.id,
       // Always use URL to avoid serialization problem in Windows
-      root: pathToFileURL(this.root),
+      root: pathToFileURL(this.root).toString(),
       basePath: this.#basePath,
-      logger: { id: this.id, level: this.logger.level }
+      logLevel: this.logger.level
     })
   }
 
@@ -151,33 +284,112 @@ export class ViteSSRStackable extends NodeStackable {
       return this.url
     }
 
+    const config = this.configManager.current
+    const command = config.application.commands[this.isProduction ? 'production' : 'development']
+
+    if (command) {
+      return this.startWithCommand(command)
+    }
+
+    if (this.isProduction) {
+      const clientDirectory = config.vite.ssr.clientDirectory
+      this.verifyOutputDirectory(
+        resolve(this.root, clientDirectory, config.application.outputDirectory, clientDirectory)
+      )
+    }
+
     await super.start({ listen })
     await super._listen()
   }
 
+  async build () {
+    const config = this.configManager.current
+    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()
+    const vite = dirname(resolvePackage(this.root, 'vite'))
+    const { build } = await importFile(resolve(vite, 'dist/node/index.js'))
+
+    // Build the client
+    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)
+          }
+        }
+      ]
+    })
+
+    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 deploy = this.configManager.current.deploy
-    let composer
+    let composer = { prefix: this.servicePrefix, wantsAbsoluteUrls: true, needsRootRedirect: true }
 
     if (this.url) {
       if (!this.#basePath) {
-        this.#basePath = this._getApplication().vite.devServer.config.base.replace(/(^\/)|(\/$)/g, '')
+        const application = this._getApplication()
+        const config = application.vite.devServer?.config ?? application.vite.config.vite
+        this.#basePath = (config.base ?? '').replace(/(^\/)|(\/$)/g, '')
       }
 
       composer = {
         tcp: true,
         url: this.url,
-        prefix: this.#basePath,
-        wantsAbsoluteUrls: true
+        prefix: this.#basePath ?? this.servicePrefix,
+        wantsAbsoluteUrls: true,
+        needsRootRedirect: true
       }
     }
 
-    return { deploy, composer }
+    return { composer }
+  }
+
+  _findEntrypoint () {
+    const config = this.configManager.current.vite ?? {}
+    return resolve(this.root, config.ssr.entrypoint)
   }
 }
 
 /* c8 ignore next 9 */
-function transformConfig () {
+export function transformConfig () {
   if (this.current.watch === undefined) {
     this.current.watch = { enabled: false }
   }
@@ -186,8 +398,13 @@ function transformConfig () {
     this.current.watch = { enabled: this.current.watch || false }
   }
 
-  if (this.current.vite?.ssr === true) {
-    this.current.vite.ssr = { entrypoint: 'server.js' }
+  if (this.current.vite.ssr === true) {
+    this.current.vite.ssr = {
+      enabled: true,
+      entrypoint: 'server.js',
+      clientDirectory: 'client',
+      serverDirectory: 'server'
+    }
   }
 
   basicTransformConfig.call(this)
@@ -199,14 +416,18 @@ export async function buildStackable (opts) {
   const configManager = new ConfigManager({ schema, source: opts.config ?? {}, schemaOptions, transformConfig })
   await configManager.parseAndValidate()
 
-  // When in SSR mode, we use @platformatic/node
-  if (configManager.current.vite?.ssr) {
-    return new ViteSSRStackable(opts, root, configManager, configManager.current.vite.ssr.entrypoint)
+  // When in SSR mode, we use ViteSSRStackable, which is a subclass of @platformatic/node
+  const viteConfig = configManager.current.vite ?? {}
+
+  if (viteConfig.ssr?.enabled) {
+    return new ViteSSRStackable(opts, root, configManager)
   }
 
   return new ViteStackable(opts, root, configManager)
 }
 
+export { schema, schemaComponents } from './lib/schema.js'
+
 export default {
   configType: 'vite',
   configManagerConfig: {

package/lib/schema.js

@@ -1,9 +1,52 @@
-import { schemaComponents } from '@platformatic/basic'
-import { schemas as utilsSchema } from '@platformatic/utils'
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
+import { schemaComponents as utilsSchemaComponents } from '@platformatic/utils'
 import { readFileSync } from 'node:fs'
 
 export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
 
+const vite = {
+  type: 'object',
+  properties: {
+    configFile: {
+      oneOf: [{ type: 'string' }, { type: 'boolean' }]
+    },
+    devServer: {
+      type: 'object',
+      properties: {
+        strict: {
+          type: 'boolean',
+          // This required to avoid showing error users when the node_modules
+          // for vite or similar are in some nested parent folders
+          default: false
+        }
+      },
+      additionalProperties: false,
+      default: {}
+    },
+    ssr: {
+      oneOf: [
+        {
+          type: 'object',
+          properties: {
+            enabled: { type: 'boolean' },
+            entrypoint: { type: 'string', default: 'server.js' },
+            clientDirectory: { type: 'string', default: 'client' },
+            serverDirectory: { type: 'string', default: 'server' }
+          },
+          required: ['entrypoint'],
+          additionalProperties: false
+        },
+        { type: 'boolean' }
+      ],
+      default: false
+    }
+  },
+  default: {},
+  additionalProperties: false
+}
+
+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#',
@@ -13,30 +56,10 @@ export const schema = {
     $schema: {
       type: 'string'
     },
-    server: utilsSchema.server,
-    watch: schemaComponents.watch,
-    application: schemaComponents.application,
-    vite: {
-      type: 'object',
-      properties: {
-        configFile: {
-          oneOf: [{ type: 'string' }, { type: 'boolean' }]
-        },
-        ssr: {
-          oneOf: [
-            {
-              type: 'object',
-              properties: { entrypoint: { type: 'string' } },
-              required: ['entrypoint'],
-              additionalProperties: false
-            },
-            { type: 'boolean' }
-          ]
-        }
-      },
-      additionalProperties: false
-    },
-    deploy: schemaComponents.deploy
+    server: utilsSchemaComponents.server,
+    watch: basicSchemaComponents.watch,
+    application: basicSchemaComponents.application,
+    vite
   },
   additionalProperties: false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/vite",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.8",
   "description": "Platformatic Vite Stackable",
   "main": "index.js",
   "type": "module",
@@ -15,17 +15,18 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "dependencies": {
+    "@fastify/static": "^7.0.4",
+    "fastify": "^4.28.1",
     "semver": "^7.6.3",
-    "@platformatic/config": "2.0.0-alpha.7",
-    "@platformatic/node": "2.0.0-alpha.7",
-    "@platformatic/utils": "2.0.0-alpha.7",
-    "@platformatic/basic": "2.0.0-alpha.7"
+    "@platformatic/basic": "2.0.0-alpha.8",
+    "@platformatic/config": "2.0.0-alpha.8",
+    "@platformatic/utils": "2.0.0-alpha.8",
+    "@platformatic/node": "2.0.0-alpha.8"
   },
   "devDependencies": {
     "@fastify/vite": "^6.0.7",
     "borp": "^0.17.0",
     "eslint": "9",
-    "fastify": "^4.28.1",
     "json-schema-to-typescript": "^15.0.1",
     "neostandard": "^0.11.1",
     "react": "^18.3.1",
@@ -33,12 +34,12 @@
     "typescript": "^5.5.4",
     "vite": "^5.4.0",
     "ws": "^8.18.0",
-    "@platformatic/composer": "2.0.0-alpha.7",
-    "@platformatic/service": "2.0.0-alpha.7"
+    "@platformatic/composer": "2.0.0-alpha.8",
+    "@platformatic/service": "2.0.0-alpha.8"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --timeout=180000",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --timeout=180000",
+    "test": "npm run lint && borp --concurrency=1 --no-timeout",
+    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --no-timeout",
     "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",