@platformatic/nest 2.72.0 → 3.0.0-alpha.1

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticNestJSStackable {
+export interface PlatformaticNestJSConfig {
   $schema?: string;
   logger?: {
     level: (

package/index.js

@@ -1,312 +1,31 @@
-import {
-  BaseStackable,
-  cleanBasePath,
-  ensureTrailingSlash,
-  errors,
-  getServerUrl,
-  importFile,
-  resolvePackage,
-  schemaOptions,
-  transformConfig
-} from '@platformatic/basic'
-import { ConfigManager } from '@platformatic/config'
-import { features } from '@platformatic/utils'
-import getPort from 'get-port'
-import inject from 'light-my-request'
-import { readFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import { pinoHttp } from 'pino-http'
-import { satisfies } from 'semver'
-import { packageJson, schema } from './lib/schema.js'
-
-const supportedVersions = '^11.0.0'
-
-export class NestStackable extends BaseStackable {
-  #basePath
-  #nestjsCore
-  #nestjsCli
-  #isFastify
-  #app
-  #server
-  #dispatcher
-
-  constructor (options, root, configManager) {
-    super('nest', packageJson.version, options, root, configManager)
-  }
-
-  async init () {
-    const config = this.configManager.current
-
-    this.#isFastify = config.nest.adapter === 'fastify'
-    this.#nestjsCore = resolve(resolvePackage(this.root, '@nestjs/core'))
-    // As @nest/cli is not exporting any file, we assume it's in the same folder of @nestjs/core.
-    this.#nestjsCli = resolve(this.#nestjsCore, '../../cli/bin/nest.js')
-
-    const nestPackage = JSON.parse(await readFile(resolve(dirname(this.#nestjsCore), 'package.json'), 'utf-8'))
-
-    if (!this.isProduction && !satisfies(nestPackage.version, supportedVersions)) {
-      throw new errors.UnsupportedVersion('@nestjs/core', nestPackage.version, supportedVersions)
-    }
-
-    this.#basePath = config.application?.basePath
-      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
-      : undefined
-
-    this.registerGlobals({ basePath: this.#basePath })
-
-    this.subprocessForceClose = true
-  }
-
-  async start ({ listen }) {
-    // Make this idempotent
-    if (this.url) {
-      return this.url
-    }
-
-    const config = this.configManager.current
-    const command = config.application.commands[this.isProduction ? 'production' : 'development']
-
-    // In development mode, we use the Nest CLI in a children thread - Using build then start would result in a bad DX
-    this.on('config', config => {
-      this.#basePath = config.basePath
-    })
-
-    if (command || !this.isProduction) {
-      await this.startWithCommand(command || `node ${this.#nestjsCli} start --watch --preserveWatchOutput`)
-    } else {
-      return this.#startProduction(listen)
-    }
-  }
-
-  async stop () {
-    if (this.childManager) {
-      return this.stopCommand()
-    }
-
-    if (this.#isFastify) {
-      return this.#server.close()
-    }
-
-    /* c8 ignore next 3 */
-    if (!this.#server?.listening) {
-      return
-    }
-
-    return new Promise((resolve, reject) => {
-      this.#server.close(error => {
-        /* c8 ignore next 3 */
-        if (error) {
-          return reject(error)
-        }
-
-        resolve()
-      })
-    })
-  }
-
-  async build () {
-    if (!this.#nestjsCore) {
-      await this.init()
-    }
-
-    const config = this.configManager.current
-    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
-
-    return this.buildWithCommand(config.application.commands.build ?? `node ${this.#nestjsCli} build`, this.#basePath)
-  }
-
-  async inject (injectParams, onInject) {
-    let res
-
-    if (this.#isFastify) {
-      res = await this.#server.inject(injectParams, onInject)
-    } else {
-      res = await inject(this.#dispatcher, 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 hasBasePath = this.basePath || this.#basePath
-
-    return {
-      composer: {
-        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 getChildManagerContext (basePath) {
-    const context = await super.getChildManagerContext(basePath)
-
-    // In development mode we need to choose the random port in advance as the Nest CLI will start a new process
-    // every time the code changes and thus we need to ensure that the port is always the same.
-    if (!this.isProduction && (context.port === true || context.port === 0)) {
-      context.port = await getPort()
-    }
-
-    return context
-  }
-
-  async #startProduction (listen) {
-    // Listen if entrypoint
-    if (this.#app && listen) {
-      await this.#listen()
-      return this.url
-    }
-
-    const outputDirectory = this.configManager.current.application.outputDirectory
-    const { path, name } = this.configManager.current.nest.appModule
-    this.verifyOutputDirectory(resolve(this.root, outputDirectory))
-
-    // Import all the necessary modules
-    const { NestFactory } = await importFile(this.#nestjsCore)
-    const Adapter = await this.#importAdapter()
-    const appModuleExport = await importFile(resolve(this.root, `${outputDirectory}/${path}.js`))
-    const appModule = appModuleExport[name]
-    const setup = await this.#importSetup()
-
-    // Create the server
-    if (this.#isFastify) {
-      this.#app = await NestFactory.create(appModule, new Adapter({ loggerInstance: this.logger }))
-
-      setup?.(this.#app)
-      await this.#app.init()
-
-      this.#server = this.#app.getInstance()
-    } else {
-      this.#app = await NestFactory.create(appModule, new Adapter())
-
-      const instance = this.#app.getInstance()
-      instance.disable('x-powered-by')
-      instance.use(pinoHttp({ logger: this.logger }))
-
-      setup?.(this.#app)
-      await this.#app.init()
-
-      this.#server = this.#app.getHttpServer()
-      this.#dispatcher = this.#server.listeners('request')[0]
-    }
-
-    if (listen) {
-      await this.#listen()
-    }
-
-    await this._collectMetrics()
-    return this.url
-  }
-
-  async #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.#isFastify ? this.#server.server : this.#server)
-
-    return this.url
-  }
-
-  async #importAdapter () {
-    let adapter
-    const toImport = `@nestjs/platform-${this.configManager.current.nest.adapter}`
-
-    this.logger.debug(`Using NestJS adapter ${toImport}.`)
-
-    try {
-      adapter = await importFile(resolvePackage(this.root, toImport))
-      return adapter[this.#isFastify ? 'FastifyAdapter' : 'ExpressAdapter']
-    } catch (e) {
-      throw new Error(`Cannot import the NestJS adapter. Please add ${toImport} to the dependencies and try again.`)
-    }
-  }
-
-  async #importSetup () {
-    const config = this.configManager.current
-
-    if (!config.nest.setup.path) {
-      return undefined
-    }
-
-    let setupModule
-    let setup
-
-    try {
-      setupModule = await importFile(
-        resolve(this.root, `${config.application.outputDirectory}/${config.nest.setup.path}.js`)
-      )
-    } catch (e) {
-      throw new Error(`Cannot import the NestJS setup file: ${e.message}.`)
-    }
-
-    // This is for improved compatibility
-    if (config.nest.setup.name) {
-      setup = setupModule[config.setup.name]
-    } else {
-      setup = setupModule.default
-
-      if (setup && typeof setup !== 'function' && typeof setup.default === 'function') {
-        setup = setup.default
-      }
-    }
-
-    if (typeof setup !== 'function') {
-      const name = config.setup.name ? ` named ${config.setup.name}` : ''
-      throw new Error(`The NestJS setup file must export a function named ${name}, but got ${typeof setup}.`)
-    }
-
-    return setup
-  }
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/utils'
+import { schema } from './lib/schema.js'
+import { NestStackable } from './lib/stackable.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 buildStackable (opts) {
-  const root = opts.context.directory
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
 
-  const configManager = new ConfigManager({
-    schema,
-    source: opts.config ?? {},
-    schemaOptions,
-    transformConfig,
-    dirname: root,
-    context: opts.context
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    replaceEnv: true,
+    root,
+    ...context
   })
-  await configManager.parseAndValidate()
-
-  return new NestStackable(opts, root, configManager)
 }
 
-export { schema, schemaComponents } from './lib/schema.js'
-
-export default {
-  configType: 'nest',
-  configManagerConfig: {
-    schemaOptions,
-    transformConfig
-  },
-  buildStackable,
-  schema,
-  version: packageJson.version,
-  modulesToLoad: []
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new NestStackable(config[kMetadata].root, config, context)
 }
+
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'
+export * from './lib/stackable.js'

package/lib/schema.js

@@ -1,9 +1,9 @@
 import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
 import { schemaComponents as utilsSchemaComponents } from '@platformatic/utils'
 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 nest = {
@@ -49,12 +49,12 @@ const nest = {
   additionalProperties: false
 }
 
-export const schemaComponents = { node: nest }
+export const schemaComponents = { nest }
 
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/nest/${version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic NestJS Stackable',
+  title: 'Platformatic NestJS Config',
   type: 'object',
   properties: {
     $schema: {

package/lib/stackable.js

@@ -0,0 +1,281 @@
+import {
+  BaseStackable,
+  cleanBasePath,
+  ensureTrailingSlash,
+  errors,
+  getServerUrl,
+  importFile,
+  resolvePackage
+} from '@platformatic/basic'
+import { features } from '@platformatic/utils'
+import getPort from 'get-port'
+import inject from 'light-my-request'
+import { readFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { pinoHttp } from 'pino-http'
+import { satisfies } from 'semver'
+import { version } from './schema.js'
+
+const supportedVersions = '^11.0.0'
+
+export class NestStackable extends BaseStackable {
+  #basePath
+  #nestjsCore
+  #nestjsCli
+  #isFastify
+  #app
+  #server
+  #dispatcher
+
+  constructor (root, config, context) {
+    super('nest', version, root, config, context)
+  }
+
+  async init () {
+    await super.init()
+
+    const config = this.config
+
+    this.#isFastify = config.nest.adapter === 'fastify'
+    this.#nestjsCore = resolve(resolvePackage(this.root, '@nestjs/core'))
+    // As @nest/cli is not exporting any file, we assume it's in the same folder of @nestjs/core.
+    this.#nestjsCli = resolve(this.#nestjsCore, '../../cli/bin/nest.js')
+
+    const nestPackage = JSON.parse(await readFile(resolve(dirname(this.#nestjsCore), 'package.json'), 'utf-8'))
+
+    if (!this.isProduction && !satisfies(nestPackage.version, supportedVersions)) {
+      throw new errors.UnsupportedVersion('@nestjs/core', nestPackage.version, supportedVersions)
+    }
+
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    this.registerGlobals({ basePath: this.#basePath })
+
+    this.subprocessForceClose = true
+  }
+
+  async start ({ listen }) {
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    const config = this.config
+    const command = config.application.commands[this.isProduction ? 'production' : 'development']
+
+    // In development mode, we use the Nest CLI in a children thread - Using build then start would result in a bad DX
+    this.on('config', config => {
+      this.#basePath = config.basePath
+    })
+
+    if (command || !this.isProduction) {
+      await this.startWithCommand(command || `node ${this.#nestjsCli} start --watch --preserveWatchOutput`)
+    } else {
+      return this.#startProduction(listen)
+    }
+  }
+
+  async stop () {
+    if (this.childManager) {
+      return this.stopCommand()
+    }
+
+    if (this.#isFastify) {
+      return this.#server.close()
+    }
+
+    /* c8 ignore next 3 */
+    if (!this.#server?.listening) {
+      return
+    }
+
+    return new Promise((resolve, reject) => {
+      this.#server.close(error => {
+        /* c8 ignore next 3 */
+        if (error) {
+          return reject(error)
+        }
+
+        resolve()
+      })
+    })
+  }
+
+  async build () {
+    if (!this.#nestjsCore) {
+      await this.init()
+    }
+
+    const config = this.config
+    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+
+    return this.buildWithCommand(config.application.commands.build ?? `node ${this.#nestjsCli} build`, this.#basePath)
+  }
+
+  async inject (injectParams, onInject) {
+    let res
+
+    if (this.#isFastify) {
+      res = await this.#server.inject(injectParams, onInject)
+    } else {
+      res = await inject(this.#dispatcher, 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 hasBasePath = this.basePath || this.#basePath
+
+    return {
+      composer: {
+        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 getChildManagerContext (basePath) {
+    const context = await super.getChildManagerContext(basePath)
+
+    // In development mode we need to choose the random port in advance as the Nest CLI will start a new process
+    // every time the code changes and thus we need to ensure that the port is always the same.
+    if (!this.isProduction && (context.port === true || context.port === 0)) {
+      context.port = await getPort()
+    }
+
+    return context
+  }
+
+  async #startProduction (listen) {
+    // Listen if entrypoint
+    if (this.#app && listen) {
+      await this.#listen()
+      return this.url
+    }
+
+    const outputDirectory = this.config.application.outputDirectory
+    const { path, name } = this.config.nest.appModule
+    this.verifyOutputDirectory(resolve(this.root, outputDirectory))
+
+    // Import all the necessary modules
+    const { NestFactory } = await importFile(this.#nestjsCore)
+    const Adapter = await this.#importAdapter()
+    const appModuleExport = await importFile(resolve(this.root, `${outputDirectory}/${path}.js`))
+    const appModule = appModuleExport[name]
+    const setup = await this.#importSetup()
+
+    // Create the server
+    if (this.#isFastify) {
+      this.#app = await NestFactory.create(appModule, new Adapter({ loggerInstance: this.logger }))
+
+      setup?.(this.#app)
+      await this.#app.init()
+
+      this.#server = this.#app.getInstance()
+    } else {
+      this.#app = await NestFactory.create(appModule, new Adapter())
+
+      const instance = this.#app.getInstance()
+      instance.disable('x-powered-by')
+      instance.use(pinoHttp({ logger: this.logger }))
+
+      setup?.(this.#app)
+      await this.#app.init()
+
+      this.#server = this.#app.getHttpServer()
+      this.#dispatcher = this.#server.listeners('request')[0]
+    }
+
+    if (listen) {
+      await this.#listen()
+    }
+
+    await this._collectMetrics()
+    return this.url
+  }
+
+  async #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.#isFastify ? this.#server.server : this.#server)
+
+    return this.url
+  }
+
+  async #importAdapter () {
+    let adapter
+    const toImport = `@nestjs/platform-${this.config.nest.adapter}`
+
+    this.logger.debug(`Using NestJS adapter ${toImport}.`)
+
+    try {
+      adapter = await importFile(resolvePackage(this.root, toImport))
+      return adapter[this.#isFastify ? 'FastifyAdapter' : 'ExpressAdapter']
+    } catch (e) {
+      throw new Error(`Cannot import the NestJS adapter. Please add ${toImport} to the dependencies and try again.`)
+    }
+  }
+
+  async #importSetup () {
+    const config = this.config
+
+    if (!config.nest.setup.path) {
+      return undefined
+    }
+
+    let setupModule
+    let setup
+
+    try {
+      setupModule = await importFile(
+        resolve(this.root, `${config.application.outputDirectory}/${config.nest.setup.path}.js`)
+      )
+    } catch (e) {
+      throw new Error(`Cannot import the NestJS setup file: ${e.message}.`)
+    }
+
+    // This is for improved compatibility
+    if (config.nest.setup.name) {
+      setup = setupModule[config.setup.name]
+    } else {
+      setup = setupModule.default
+
+      if (setup && typeof setup !== 'function' && typeof setup.default === 'function') {
+        setup = setup.default
+      }
+    }
+
+    if (typeof setup !== 'function') {
+      const name = config.setup.name ? ` named ${config.setup.name}` : ''
+      throw new Error(`The NestJS setup file must export a function named ${name}, but got ${typeof setup}.`)
+    }
+
+    return setup
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/nest",
-  "version": "2.72.0",
+  "version": "3.0.0-alpha.1",
   "description": "Platformatic Nest.js Stackable",
   "main": "index.js",
   "type": "module",
@@ -18,10 +18,9 @@
     "get-port": "^7.1.0",
     "light-my-request": "^6.0.0",
     "pino-http": "^10.2.0",
-    "@platformatic/basic": "2.72.0",
-    "@platformatic/config": "2.72.0",
-    "@platformatic/generators": "2.72.0",
-    "@platformatic/utils": "2.72.0"
+    "@platformatic/basic": "3.0.0-alpha.1",
+    "@platformatic/utils": "3.0.0-alpha.1",
+    "@platformatic/generators": "3.0.0-alpha.1"
   },
   "devDependencies": {
     "@nestjs/cli": "^11.0.7",
@@ -34,12 +33,12 @@
     "neostandard": "^0.12.0",
     "tsx": "^4.19.0",
     "typescript": "^5.5.4",
-    "@platformatic/service": "2.72.0",
-    "@platformatic/composer": "2.72.0"
+    "@platformatic/composer": "3.0.0-alpha.1",
+    "@platformatic/service": "3.0.0-alpha.1"
   },
   "scripts": {
-    "test": "pnpm run lint && borp --concurrency=1 --no-timeout",
-    "coverage": "pnpm run lint && borp -C -X test -X test/fixtures --concurrency=1 --no-timeout",
+    "test": "pnpm run lint && borp --concurrency=1 --timeout 1200000",
+    "coverage": "pnpm run lint && borp -C -X test -X test/fixtures --concurrency=1 --timeout 1200000",
     "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",

package/schema.json

@@ -1,7 +1,7 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/nest/2.72.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/nest/3.0.0-alpha.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Platformatic NestJS Stackable",
+  "title": "Platformatic NestJS Config",
   "type": "object",
   "properties": {
     "$schema": {