@platformatic/nuxt 0.0.1 → 3.58.1

package/eslint.config.js

@@ -0,0 +1,3 @@
+import neostandard from 'neostandard'
+
+export default neostandard()

package/index.d.ts

@@ -0,0 +1,35 @@
+import { BaseCapability, BaseContext, BaseOptions } from '@platformatic/basic'
+import { Configuration, ConfigurationOptions } from '@platformatic/foundation'
+import { JSONSchemaType } from 'ajv'
+import type { PlatformaticNuxtConfig } from './config.d.ts'
+
+export type { PlatformaticNuxtConfig } from './config.d.ts'
+
+export interface NuxtContext extends BaseContext {}
+
+export type NuxtConfiguration = Configuration<PlatformaticNuxtConfig>
+
+export declare function loadConfiguration (
+  root: string | PlatformaticNuxtConfig,
+  source?: string | PlatformaticNuxtConfig,
+  context?: ConfigurationOptions
+): Promise<NuxtConfiguration>
+
+export declare function create (
+  configOrRoot: string | PlatformaticNuxtConfig,
+  sourceOrConfig?: string | PlatformaticNuxtConfig,
+  context?: ConfigurationOptions
+): Promise<NuxtCapability>
+
+export declare class NuxtCapability extends BaseCapability<
+  PlatformaticNuxtConfig,
+  BaseOptions<NuxtContext>
+> {
+  constructor (root: string, config: PlatformaticNuxtConfig, context?: object)
+}
+
+export declare const packageJson: Record<string, unknown>
+export declare const schema: JSONSchemaType<PlatformaticNuxtConfig>
+export declare const schemaComponents: { nuxt: unknown }
+export declare const version: string
+export declare const supportedVersions: string

package/index.js

@@ -0,0 +1,31 @@
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { NuxtCapability } from './lib/capability.js'
+import { schema } from './lib/schema.js'
+
+/* c8 ignore next 5 */
+export async function transform (config, schema, options) {
+  config = await basicTransform(config, schema, options)
+  config.watch = { enabled: false }
+  return config
+}
+
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
+
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    replaceEnv: true,
+    root,
+    ...context
+  })
+}
+
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new NuxtCapability(config[kMetadata].root, config, context)
+}
+
+export * from './lib/capability.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'

package/lib/capability.js

@@ -0,0 +1,255 @@
+import {
+  BaseCapability,
+  buildAdditionalServerOptions,
+  cleanBasePath,
+  createServerListener,
+  ensureTrailingSlash,
+  errors,
+  getServerUrl,
+  importFile,
+  injectViaRequest,
+  resolvePackageViaESM,
+} from '@platformatic/basic'
+import {
+  sanitizeHTTPSArgument,
+  sanitizeHTTPSOptions,
+} from '@platformatic/foundation'
+import inject from 'light-my-request'
+import { readFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { satisfies } from 'semver'
+import { version } from './schema.js'
+
+export const supportedVersions = '^4.0.0'
+
+export class NuxtCapability extends BaseCapability {
+  #nuxt
+  #basePath
+  #server
+  #dispatcher
+
+  constructor (root, config, context) {
+    super('nuxt', version, root, config, context)
+    this.exitOnUnhandledErrors = false
+    this.subprocessTerminationSignal = 'SIGKILL'
+  }
+
+  async init () {
+    await super.init()
+
+    if (!this.isProduction) {
+      this.#nuxt = resolve(
+        dirname(await resolvePackageViaESM(this.root, 'nuxt')),
+        '..'
+      )
+      const nuxtPackage = JSON.parse(
+        await readFile(resolve(this.#nuxt, 'package.json'), 'utf-8')
+      )
+
+      if (!satisfies(nuxtPackage.version, supportedVersions)) {
+        throw new errors.UnsupportedVersion(
+          'nuxt',
+          nuxtPackage.version,
+          supportedVersions
+        )
+      }
+    }
+
+    this.#basePath = this.config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(this.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
+    }
+
+    await super._start({ listen })
+
+    const command =
+      this.config.application.commands[
+        this.isProduction ? 'production' : 'development'
+      ]
+
+    if (command) {
+      return this.startWithCommand(command)
+    }
+
+    // In development mode we use Nuxt CLI
+    if (!this.isProduction) {
+      await this.#startDevelopment()
+    } else {
+      await this.#startProduction()
+    }
+
+    await this._collectMetrics()
+  }
+
+  async stop () {
+    await super.stop()
+
+    if (this.childManager) {
+      return this.stopCommand()
+    }
+
+    /* c8 ignore next 3 */
+    if (!this.#server?.listening) {
+      return
+    }
+
+    return this._closeServer(this.#server)
+  }
+
+  async build () {
+    if (!this.#nuxt) {
+      await this.init()
+    }
+
+    const config = this.config
+    return this.buildWithCommand(
+      config.application.commands.build ??
+        `node ${resolve(this.#nuxt)}/bin/nuxt.mjs build`,
+      this.#basePath
+    )
+  }
+
+  async inject (injectParams, onInject) {
+    if (!this.isProduction) {
+      return injectViaRequest(this.url, injectParams, onInject)
+    }
+
+    const res = await inject(this.#dispatcher, injectParams, onInject)
+
+    if (onInject) {
+      return
+    }
+
+    const { statusCode, headers, body, payload, rawPayload } = res
+    return { statusCode, headers, body, payload, rawPayload }
+  }
+
+  getMeta () {
+    const hasBasePath = this.basePath || this.#basePath
+
+    return {
+      gateway: {
+        tcp: typeof this.url !== 'undefined',
+        url: this.url,
+        prefix: this.basePath ?? this.#basePath,
+        wantsAbsoluteUrls: !!hasBasePath,
+        needsRootTrailingSlash: false,
+      },
+    }
+  }
+
+  /* c8 ignore next 5 */
+  async getWatchConfig () {
+    return {
+      enabled: false,
+    }
+  }
+
+  async #startDevelopment () {
+    let { hostname, port, https } = this.serverConfig ?? {}
+    hostname ||= '127.0.0.1'
+    port ||= 0
+    let httpsArgs = ''
+
+    if (https) {
+      httpsArgs = ' --https'
+
+      const key = await sanitizeHTTPSArgument(https.key, true)
+      const cert = await sanitizeHTTPSArgument(https.cert, true)
+
+      if (https.key) {
+        httpsArgs += ` --https.key ${resolve(this.root, key)}`
+      }
+
+      if (https.cert) {
+        httpsArgs += ` --https.cert ${resolve(this.root, cert)}`
+      }
+    }
+
+    await this.startWithCommand(
+      `node ${resolve(this.#nuxt)}/bin/nuxt.mjs dev --host ${hostname} --port ${port} --no-open${httpsArgs}`
+    )
+
+    if (https) {
+      this.url = this.url.replace(/^http:/, 'https:')
+    }
+
+    return this.url
+  }
+
+  async #startProduction () {
+    const config = this.config
+    const outputDirectory = resolve(
+      this.root,
+      config.nuxt?.outputDirectory ?? '.output'
+    )
+    this.verifyOutputDirectory(outputDirectory)
+    // this.#basePath = await this._getBasePathFromBuildInfo()
+
+    const serverOptions = this.serverConfig
+    const serverPromise = createServerListener(
+      serverOptions?.port ?? true,
+      serverOptions?.hostname ?? true,
+      await buildAdditionalServerOptions(serverOptions)
+    )
+
+    const httpsOptions = await sanitizeHTTPSOptions(serverOptions?.https)
+
+    if (!httpsOptions?.cert && !httpsOptions?.key) {
+      await this.#importProductionNitro(outputDirectory)
+    } else {
+      const originalCert = process.env.NITRO_SSL_CERT
+      const originalKey = process.env.NITRO_SSL_KEY
+
+      process.env.NITRO_SSL_CERT = this.#serializeCertificateValue(
+        httpsOptions.cert
+      )
+      process.env.NITRO_SSL_KEY = this.#serializeCertificateValue(
+        httpsOptions.key
+      )
+
+      try {
+        await this.#importProductionNitro(outputDirectory)
+      } finally {
+        this.#restoreEnvironmentVariables('NITRO_SSL_CERT', originalCert)
+        this.#restoreEnvironmentVariables('NITRO_SSL_KEY', originalKey)
+      }
+    }
+
+    this.#server = await serverPromise
+    this.#dispatcher = this.#server.listeners('request')[0]
+    this.url = getServerUrl(this.#server)
+    await this._collectMetrics()
+
+    return this.url
+  }
+
+  #importProductionNitro (outputDirectory) {
+    return importFile(resolve(outputDirectory, 'server/index.mjs'))
+  }
+
+  #serializeCertificateValue (value) {
+    if (Array.isArray(value)) {
+      return value.map((item) => item.toString()).join('\n')
+    }
+
+    return value.toString()
+  }
+
+  #restoreEnvironmentVariables (key, originalValue) {
+    if (typeof originalValue === 'undefined') {
+      delete process.env[key]
+    } else {
+      process.env[key] = originalValue
+    }
+  }
+}

package/lib/schema.js

@@ -0,0 +1,50 @@
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
+import { schemaComponents as utilsSchemaComponents } from '@platformatic/foundation'
+import { schemaComponents as viteSchemaComponents } from '@platformatic/vite'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
+
+export const nuxt = {
+  type: 'object',
+  properties: {
+    outputDirectory: {
+      type: 'string',
+      default: '.output'
+    }
+  },
+  default: {},
+  additionalProperties: false
+}
+
+export const schemaComponents = { nuxt }
+
+export const schema = {
+  $id: `https://schemas.platformatic.dev/@platformatic/nuxt/${packageJson.version}.json`,
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'Platformatic Nuxt Config',
+  type: 'object',
+  properties: {
+    $schema: {
+      type: 'string'
+    },
+    module: {
+      type: 'string'
+    },
+    logger: utilsSchemaComponents.logger,
+    server: utilsSchemaComponents.server,
+    watch: basicSchemaComponents.watch,
+    application: basicSchemaComponents.buildableApplication,
+    runtime: utilsSchemaComponents.wrappedRuntime,
+    vite: viteSchemaComponents.vite,
+    nuxt
+  },
+  additionalProperties: false
+}
+
+/* c8 ignore next 3 */
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
+}

package/package.json

@@ -1,29 +1,50 @@
 {
   "name": "@platformatic/nuxt",
-  "version": "0.0.1",
-  "description": "",
-  "homepage": "https://github.com/platformatic/platformatic",
-  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
-  "license": "Apache-2.0",
+  "version": "3.58.1",
+  "description": "Platformatic Nuxt Capability",
+  "main": "index.js",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
   },
-  "keywords": [],
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
+  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/platformatic/platformatic/issues"
   },
-  "private": false,
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
-  "type": "module",
-  "exports": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "devDependencies": {},
+  "homepage": "https://github.com/platformatic/platformatic#readme",
+  "dependencies": {
+    "light-my-request": "^6.6.0",
+    "semver": "^7.6.3",
+    "@platformatic/basic": "3.58.1",
+    "@platformatic/vite": "3.58.1",
+    "@platformatic/foundation": "3.58.1"
+  },
+  "devDependencies": {
+    "@nuxt/cli": "^3.35.2",
+    "cleaner-spec-reporter": "^0.5.0",
+    "eslint": "9",
+    "json-schema-to-typescript": "^15.0.1",
+    "neostandard": "^0.12.0",
+    "nuxt": "^4.4.8",
+    "tstyche": "^6.2.0",
+    "typescript": "^5.5.4",
+    "vite": "^7.2.4",
+    "vue": "^3.5.22",
+    "ws": "^8.18.0",
+    "@platformatic/gateway": "3.58.1",
+    "@platformatic/service": "3.58.1"
+  },
   "engines": {
-    "node": ">= 22.19.0"
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "test": "npm run test:types && node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "test:types": "tstyche",
+    "gen-schema": "node lib/schema.js > schema.json",
+    "gen-types": "json2ts > config.d.ts < schema.json",
+    "build": "npm run gen-schema && npm run gen-types",
+    "lint": "eslint"
   }
-}
+}