@platformatic/service 0.29.0 → 0.30.1

package/fixtures/hello-client-ts/tsconfig.json

@@ -2,9 +2,10 @@
   "compilerOptions": {
     "module": "commonjs",
     "esModuleInterop": true,
-    "target": "es6",
+    "target": "es2020",
     "moduleResolution": "node",
-    "sourceMap": true,
+    "sourceMap": false,
+    "incremental": true,
     "pretty": true,
     "noEmitOnError": true,
     "outDir": "dist"

package/index.js

@@ -46,7 +46,15 @@ async function platformaticService (app, opts, toLoad = []) {
   }
 
   if (config.plugins) {
-    if (config.plugins.typescript) {
+    let registerTsCompiler = false
+    const typescript = config.plugins.typescript
+    if (typescript === true) {
+      registerTsCompiler = true
+    } else if (typeof typescript === 'object') {
+      registerTsCompiler = typescript.enabled === true || typescript.enabled === undefined
+    }
+
+    if (registerTsCompiler) {
       await app.register(setupTsCompiler)
     }
     await app.register(loadPlugins)

package/lib/compile.js

@@ -48,29 +48,30 @@ async function setup (cwd, config, logger) {
   /* c8 ignore next 4 */
   if (tscExecutablePath === undefined) {
     const msg = 'The tsc executable was not found.'
-    logger.error(msg)
+    logger.warn(msg)
   }
 
-  const tsconfigPath = resolve(cwd, 'tsconfig.json')
-  const tsconfigExists = await isFileAccessible(tsconfigPath)
+  const tsConfigPath = config?.plugins?.typescript?.tsConfig || resolve(cwd, 'tsconfig.json')
+  const tsConfigExists = await isFileAccessible(tsConfigPath)
 
-  if (!tsconfigExists) {
-    const msg = 'The tsconfig.json file was not found.'
-    logger.error(msg)
+  if (!tsConfigExists) {
+    const msg = 'No typescript configuration file was found.'
+    logger.warn(msg)
   }
 
-  return { execa, logger, tscExecutablePath }
+  return { execa, logger, tscExecutablePath, tsConfigPath, tsConfigExists }
 }
 
 async function compile (cwd, config, originalLogger) {
-  const { execa, logger, tscExecutablePath } = await setup(cwd, config, originalLogger)
+  const { execa, logger, tscExecutablePath, tsConfigPath, tsConfigExists } = await setup(cwd, config, originalLogger)
   /* c8 ignore next 3 */
-  if (!tscExecutablePath) {
+  if (!tscExecutablePath || !tsConfigExists) {
     return false
   }
 
   try {
-    await execa(tscExecutablePath, ['--project', 'tsconfig.json', '--rootDir', '.'], { cwd })
+    const tsFlags = config?.plugins?.typescript?.flags || ['--project', tsConfigPath, '--rootDir', '.']
+    await execa(tscExecutablePath, tsFlags, { cwd })
     logger.info('Typescript compilation completed successfully.')
     return true
   } catch (error) {
@@ -82,11 +83,13 @@ async function compile (cwd, config, originalLogger) {
 function buildCompileCmd (app) {
   return async function compileCmd (_args) {
     let fullPath = null
+    let config = null
     try {
       const { configManager } = await loadConfig({}, _args, app, {
         watch: false
       })
       await configManager.parseAndValidate()
+      config = configManager.current
       fullPath = dirname(configManager.fullPath)
       /* c8 ignore next 4 */
     } catch (err) {
@@ -94,7 +97,7 @@ function buildCompileCmd (app) {
       process.exit(1)
     }
 
-    if (!await compile(fullPath)) {
+    if (!await compile(fullPath, config)) {
       process.exit(1)
     }
   }

package/lib/plugins/plugins.js

@@ -12,26 +12,36 @@ async function loadPlugins (app) {
   const configManager = app.platformatic.configManager
   const config = configManager.current
 
+  let isOutDirAccessible = false
+  let outDir = null
+
   const workingDir = configManager.dirname
-  const tsConfigPath = join(workingDir, 'tsconfig.json')
+  const tsConfigPath = configManager.current.plugins.typescript?.tsConfig || join(workingDir, 'tsconfig.json')
 
   // If the tsconfig.json file exists, then we need to adjust the plugin paths
   // to point to the compiled JS files.
   const isTsConfigAccessible = await isFileAccessible(tsConfigPath)
   if (isTsConfigAccessible) {
     const tsConfig = JSON.parse(await readFile(tsConfigPath, 'utf8'))
-    const outDir = resolve(workingDir, tsConfig.compilerOptions.outDir)
-
-    const isOutDirAccessible = await isFileAccessible(outDir)
-
-    if (isOutDirAccessible) {
-      config.plugins.paths = config.plugins.paths.map((plugin) => {
-        /* c8 ignore next 3 */
-        return typeof plugin === 'string'
-          ? getJSPluginPath(workingDir, plugin, outDir)
-          : { ...plugin, path: getJSPluginPath(workingDir, plugin.path, outDir) }
-      })
-    }
+    outDir = resolve(workingDir, tsConfig.compilerOptions.outDir)
+  }
+
+  /* c8 ignore next 3 */
+  if (configManager.current.plugins.typescript?.outDir) {
+    outDir = configManager.current.plugins.typescript.outDir
+  }
+
+  if (outDir) {
+    isOutDirAccessible = await isFileAccessible(outDir)
+  }
+
+  if (isOutDirAccessible) {
+    config.plugins.paths = config.plugins.paths.map((plugin) => {
+      /* c8 ignore next 3 */
+      return typeof plugin === 'string'
+        ? getJSPluginPath(workingDir, plugin, outDir)
+        : { ...plugin, path: getJSPluginPath(workingDir, plugin.path, outDir) }
+    })
   }
 
   await app.register(require(wrapperPath), { paths: config.plugins.paths })

package/lib/schema.js

@@ -391,6 +391,31 @@ const plugins = {
     },
     typescript: {
       anyOf: [{
+        type: 'object',
+        properties: {
+          enabled: {
+            anyOf: [{
+              type: 'boolean'
+            }, {
+              type: 'string'
+            }]
+          },
+          tsConfig: {
+            type: 'string',
+            resolvePath: true
+          },
+          outDir: {
+            type: 'string',
+            resolvePath: true
+          },
+          flags: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          }
+        }
+      }, {
         type: 'boolean'
       }, {
         type: 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/service",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -64,11 +64,11 @@
     "pino-pretty": "^10.0.0",
     "rfdc": "^1.3.0",
     "ua-parser-js": "^1.0.35",
-    "@platformatic/client": "0.29.0",
-    "@platformatic/config": "0.29.0",
-    "@platformatic/swagger-ui-theme": "0.29.0",
-    "@platformatic/types": "0.29.0",
-    "@platformatic/utils": "0.29.0"
+    "@platformatic/client": "0.30.1",
+    "@platformatic/config": "0.30.1",
+    "@platformatic/swagger-ui-theme": "0.30.1",
+    "@platformatic/types": "0.30.1",
+    "@platformatic/utils": "0.30.1"
   },
   "standard": {
     "ignore": [

package/test/cli/{compile.test.mjs → compile-1.test.mjs}

@@ -1,34 +1,49 @@
 import path from 'path'
 import os from 'os'
-import { access, rename, cp } from 'fs/promises'
+import { access, rename, cp, rm, mkdir } from 'fs/promises'
 import t from 'tap'
 import { execa } from 'execa'
 import stripAnsi from 'strip-ansi'
 import split from 'split2'
-import { cliPath } from './helper.mjs'
+import { cliPath, safeKill } from './helper.mjs'
 import { fileURLToPath } from 'url'
 
+let count = 0
+
+if (os.platform() !== 'win32') {
+  t.jobs = 5
+}
+t.setTimeout(360000)
+
 function urlDirname (url) {
   return path.dirname(fileURLToPath(url))
 }
 
+async function getCWD (t) {
+  const dir = path.join(urlDirname(import.meta.url), '..', 'tmp', `typescript-plugin-clone-${count++}`)
+  try {
+    await rm(dir, { recursive: true })
+  } catch {}
+
+  await mkdir(dir, { recursive: true })
+
+  t.teardown(async () => {
+    try {
+      await rm(dir, { recursive: true })
+    } catch {}
+  })
+  return dir
+}
+
 function exitOnTeardown (child) {
   return async () => {
-    if (os.platform() === 'win32') {
-      try {
-        await execa('taskkill', ['/pid', child.pid, '/f', '/t'])
-      } catch (err) {
-        console.error(`Failed to kill process ${child.pid})`)
-      }
-    } else {
-      child.kill('SIGINT')
-    }
+    await safeKill(child)
   }
 }
 
 t.test('should compile typescript plugin', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-1')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -58,7 +73,7 @@ t.test('should compile typescript plugin', async (t) => {
 
 t.test('should compile typescript plugin even if typescript is `false`', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-2')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -88,7 +103,7 @@ t.test('should compile typescript plugin even if typescript is `false`', async (
 
 t.test('should compile typescript plugin with start command', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-3')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -108,7 +123,9 @@ t.test('should compile typescript plugin with start command', async (t) => {
 })
 
 t.test('should not compile bad typescript plugin', async (t) => {
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+  const cwd = await getCWD(t)
+  await cp(testDir, cwd, { recursive: true })
 
   try {
     await execa('node', [cliPath, 'compile'], { cwd })
@@ -130,7 +147,7 @@ t.test('should not compile bad typescript plugin', async (t) => {
 
 t.test('missing tsconfig file', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-4')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -145,20 +162,21 @@ t.test('missing tsconfig file', async (t) => {
   } catch (err) {
     t.comment(err.stdout)
     t.comment(err.stderr)
-    t.equal(err.stdout.includes('The tsconfig.json file was not found.'), true)
+    t.equal(err.stdout.includes('No typescript configuration file was found.'), true)
   }
 
   t.pass()
 })
 
 t.test('start command should not compile typescript plugin with errors', async (t) => {
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
 
   const childProcess = execa('node', [cliPath, 'start'], { cwd })
 
-  t.teardown(() => {
-    childProcess.kill('SIGINT')
-  })
+  t.teardown(exitOnTeardown(childProcess))
 
   try {
     await childProcess
@@ -167,9 +185,10 @@ t.test('start command should not compile typescript plugin with errors', async (
     if (!err.stdout.includes('Found 1 error')) {
       t.comment(err.stdout)
       t.comment(err.stderr)
+      console.error(err)
       t.fail('should throw one ts error')
     }
-    childProcess.kill('SIGINT')
+    await safeKill(childProcess)
   }
 
   const jsPluginPath = path.join(cwd, 'dist', 'plugin.js')
@@ -183,7 +202,7 @@ t.test('start command should not compile typescript plugin with errors', async (
 
 t.test('should not compile typescript plugin with start without tsconfig', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-5')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -194,17 +213,17 @@ t.test('should not compile typescript plugin with start without tsconfig', async
 
   try {
     const child = await execa('node', [cliPath, 'start'], { cwd })
-    t.teardown(() => child.kill('SIGINT'))
+    t.teardown(exitOnTeardown(child))
     t.fail('should not compile typescript plugin with start without tsconfig')
   } catch (err) {
     t.comment(err.stdout)
-    t.equal(err.stdout.includes('The tsconfig.json file was not found.'), true)
+    t.equal(err.stdout.includes('No typescript configuration file was found'), true)
   }
 })
 
 t.test('start command should not compile typescript if `typescript` is false', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-6')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -225,7 +244,7 @@ t.test('start command should not compile typescript if `typescript` is false', a
 
 t.test('should compile typescript plugin with start command with different cwd', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
-  const dest = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-4')
+  const dest = path.join(urlDirname(import.meta.url), '..', 'tmp', `typescript-plugin-clone-${count++}`)
 
   await cp(testDir, dest, { recursive: true })
 
@@ -249,7 +268,7 @@ t.test('should compile typescript plugin with start command with different cwd',
 
 t.test('valid tsconfig file inside an inner folder', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-7/inner-folder')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -264,7 +283,7 @@ t.test('valid tsconfig file inside an inner folder', async (t) => {
 
 t.test('should compile typescript plugin with start command from a folder', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-autoload')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-8')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -287,7 +306,7 @@ t.test('should compile typescript plugin with start command from a folder', asyn
 
 t.test('should start the service if it was precompiled and typescript is `false`', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-9')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -310,7 +329,7 @@ t.test('should start the service if it was precompiled and typescript is `false`
 
 t.test('should not start the service if it was not precompiled and typescript is `false`', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-10')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -332,7 +351,7 @@ t.test('should not start the service if it was not precompiled and typescript is
 
 t.test('should compile typescript plugin with string config', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-string')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-11')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -362,7 +381,7 @@ t.test('should compile typescript plugin with string config', async (t) => {
 
 t.test('should not start the service if it was not precompiled and typescript is `"false"`', async (t) => {
   const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'tmp', 'typescript-plugin-clone-12')
+  const cwd = await getCWD(t)
 
   await cp(testDir, cwd, { recursive: true })
 
@@ -381,3 +400,101 @@ t.test('should not start the service if it was not precompiled and typescript is
   }
   t.fail('should load the typescript plugin without compiling it')
 })
+
+t.test('should not compile bad typescript plugin', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+  const cwd = await getCWD(t)
+  await cp(testDir, cwd, { recursive: true })
+
+  try {
+    await execa('node', [cliPath, 'compile'], { cwd })
+    t.fail('should not compile bad typescript plugin')
+  } catch (err) {
+    t.comment(err.stdout)
+    t.comment(err.stderr)
+    t.equal(err.stdout.includes('Found 1 error in plugin.ts'), true)
+  }
+
+  const jsPluginPath = path.join(cwd, 'dist', 'plugin.js')
+  try {
+    await access(jsPluginPath)
+    t.fail('should not compile bad typescript plugin')
+  } catch (err) {
+    t.pass(err)
+  }
+})
+
+t.test('missing tsconfig file', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const pathToTSConfig = path.join(cwd, 'tsconfig.json')
+  const pathToTSConfigBackup = path.join(cwd, 'tsconfig.json.backup')
+
+  await rename(pathToTSConfig, pathToTSConfigBackup)
+
+  try {
+    await execa('node', [cliPath, 'compile'], { cwd })
+    t.fail('should not compile typescript plugin')
+  } catch (err) {
+    t.comment(err.stdout)
+    t.comment(err.stderr)
+    t.equal(err.stdout.includes('No typescript configuration file was found.'), true)
+  }
+
+  t.pass()
+})
+
+t.test('start command should not compile typescript plugin with errors', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+  const cwd = await getCWD(t)
+  await cp(testDir, cwd, { recursive: true })
+
+  const childProcess = execa('node', [cliPath, 'start'], { cwd })
+
+  t.teardown(exitOnTeardown(childProcess))
+
+  try {
+    await childProcess
+    t.fail('should not compile bad typescript plugin')
+  } catch (err) {
+    if (!err.stdout.includes('Found 1 error')) {
+      t.comment(err.stdout)
+      t.comment(err.stderr)
+      console.error(err)
+      t.fail('should throw one ts error')
+    }
+    safeKill(childProcess)
+  }
+
+  const jsPluginPath = path.join(cwd, 'dist', 'plugin.js')
+  try {
+    await access(jsPluginPath)
+    t.fail('should not compile bad typescript plugin')
+  } catch (err) {
+    t.pass(err)
+  }
+})
+
+t.test('should not compile typescript plugin with start without tsconfig', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const pathToTSConfig = path.join(cwd, 'tsconfig.json')
+  const pathToTSConfigBackup = path.join(cwd, 'tsconfig.json.backup')
+
+  await rename(pathToTSConfig, pathToTSConfigBackup)
+
+  try {
+    const child = await execa('node', [cliPath, 'start'], { cwd })
+    t.teardown(exitOnTeardown(child))
+    t.fail('should not compile typescript plugin with start without tsconfig')
+  } catch (err) {
+    t.comment(err.stdout)
+    t.equal(err.stdout.includes('No typescript configuration file was found.'), true)
+  }
+})

package/test/cli/compile-2.test.mjs

@@ -0,0 +1,310 @@
+import path from 'path'
+import os from 'os'
+import { access, cp, rm, mkdir } from 'fs/promises'
+import t from 'tap'
+import { execa } from 'execa'
+import stripAnsi from 'strip-ansi'
+import split from 'split2'
+import { cliPath, safeKill } from './helper.mjs'
+import { fileURLToPath } from 'url'
+
+let count = 0
+
+if (os.platform() !== 'win32') {
+  t.jobs = 5
+}
+t.setTimeout(360000)
+
+function urlDirname (url) {
+  return path.dirname(fileURLToPath(url))
+}
+
+async function getCWD (t) {
+  const dir = path.join(urlDirname(import.meta.url), '..', 'tmp', `typescript-plugin-clone2-${count++}`)
+  try {
+    await rm(dir, { recursive: true })
+  } catch {}
+
+  await mkdir(dir, { recursive: true })
+
+  t.teardown(async () => {
+    try {
+      await rm(dir, { recursive: true })
+    } catch {}
+  })
+  return dir
+}
+
+function exitOnTeardown (child) {
+  return async () => {
+    await safeKill(child)
+  }
+}
+
+t.test('start command should not compile typescript if `typescript` is false', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+  t.teardown(exitOnTeardown(child))
+
+  const jsPluginPath = path.join(cwd, 'dist', 'plugin.js')
+  try {
+    await access(jsPluginPath)
+    t.fail("should not have created 'dist/plugin.js'")
+  } catch (err) {
+    // cannot start because the plugin is not compiled
+    t.equal(err.code, 'ENOENT')
+    t.equal(err.path, jsPluginPath)
+    t.pass()
+  }
+})
+
+t.test('should compile typescript plugin with start command with different cwd', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
+  const dest = path.join(urlDirname(import.meta.url), '..', 'tmp', `typescript-plugin-clone-${count++}`)
+
+  await cp(testDir, dest, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start', '-c', path.join(dest, 'platformatic.service.json')])
+
+  t.teardown(exitOnTeardown(child))
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(process.stderr)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript plugin loaded')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should compile typescript plugin with start command')
+})
+
+t.test('valid tsconfig file inside an inner folder', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  try {
+    await execa('node', [cliPath, 'compile'], { cwd, stdio: 'inherit' })
+  } catch (err) {
+    t.fail('should not catch any error')
+  }
+
+  t.pass()
+})
+
+t.test('should compile typescript plugin with start command from a folder', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-autoload')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  t.teardown(exitOnTeardown(child))
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript plugin loaded')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should compile typescript plugin with start command')
+})
+
+t.test('should start the service if it was precompiled and typescript is `false`', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  await execa('node', [cliPath, 'compile'], { cwd })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript plugin loaded')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should load the typescript plugin without compiling it')
+})
+
+t.test('should not start the service if it was not precompiled and typescript is `false`', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Unknown file extension ".ts" for')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should load the typescript plugin without compiling it')
+})
+
+t.test('should compile typescript plugin with string config', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-string')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'compile'], { cwd })
+
+  t.teardown(exitOnTeardown(child))
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript compilation completed successfully.')) {
+      const jsPluginPath = path.join(cwd, 'dist', 'plugin.js')
+      try {
+        await access(jsPluginPath)
+      } catch (err) {
+        t.fail(err)
+      }
+
+      t.pass()
+      return
+    }
+  }
+  t.fail('should compile typescript plugin with a compile command')
+})
+
+t.test('should not start the service if it was not precompiled and typescript is `"false"`', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Unknown file extension ".ts" for')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should load the typescript plugin without compiling it')
+})
+
+t.test('should compile typescript plugin with start command with custom tsconfig', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-custom-tsconfig')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript plugin loaded')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should compile typescript plugin with start command')
+})
+
+t.test('should not start the service if it was not precompiled and typescript is `false`', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-nocompile-enabled')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Unknown file extension ".ts" for')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should load the typescript plugin without compiling it')
+})
+
+t.test('should start without a tsconfig but with a outDir configuration', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-compiled')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript plugin loaded')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should compile typescript plugin with start command')
+})
+
+t.test('should compile typescript plugin with start command with custom flags', async (t) => {
+  const testDir = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'typescript-plugin-custom-flags')
+  const cwd = await getCWD(t)
+
+  await cp(testDir, cwd, { recursive: true })
+
+  const child = execa('node', [cliPath, 'start'], { cwd })
+
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
+
+  for await (const data of splitter) {
+    const sanitized = stripAnsi(data)
+    if (sanitized.includes('Typescript plugin loaded')) {
+      t.pass()
+      return
+    }
+  }
+  t.fail('should compile typescript plugin with start command')
+})

package/test/cli/helper.mjs

@@ -4,6 +4,7 @@ import { execa } from 'execa'
 import split from 'split2'
 import { join } from 'desm'
 import tap from 'tap'
+import os from 'node:os'
 
 setGlobalDispatcher(new Agent({
   keepAliveTimeout: 10,
@@ -50,3 +51,17 @@ export async function start (commandOpts, exacaOpts = {}) {
     }
   }
 }
+
+export async function safeKill (child) {
+  child.kill('SIGINT')
+  if (os.platform() === 'win32') {
+    try {
+      await execa('taskkill', ['/pid', child.pid, '/f', '/t'])
+    } catch (err) {
+      if (err.stderr.indexOf('not found') === 0) {
+        console.error(`Failed to kill process ${child.pid}`)
+        console.error(err)
+      }
+    }
+  }
+}

package/test/clients.test.js

@@ -6,7 +6,7 @@ const { buildServer } = require('..')
 const { join } = require('path')
 const { request } = require('undici')
 const { compile } = require('../lib/compile')
-const { rmdir } = require('fs/promises')
+const { rm } = require('fs/promises')
 
 test('client is loaded', async ({ teardown, equal, same }) => {
   const app1 = await buildServer(join(__dirname, '..', 'fixtures', 'hello', 'warn-log.service.json'))
@@ -44,10 +44,12 @@ test('client is loaded (ts)', async ({ teardown, equal, pass, same }) => {
   const targetDir = join(__dirname, '..', 'fixtures', 'hello-client-ts')
 
   try {
-    await rmdir(join(targetDir, 'dist'))
+    await rm(join(targetDir, 'dist'), { recursive: true })
   } catch {}
 
+  console.time('compile')
   await compile(targetDir, { server: { logger: { level: 'warn' } } })
+  console.timeEnd('compile')
 
   const app2 = await buildServer(join(targetDir, 'platformatic.service.json'))
   teardown(async () => {
@@ -83,33 +85,3 @@ test('client is loaded dependencyless', async ({ teardown, equal, same }) => {
   const data = await res.body.json()
   same(data, { hello: 'world' })
 })
-
-test('client is loaded (ts) depencyless', async ({ teardown, equal, pass, same }) => {
-  const app1 = await buildServer(join(__dirname, '..', 'fixtures', 'hello', 'warn-log.service.json'))
-
-  teardown(async () => {
-    await app1.close()
-  })
-  await app1.start()
-
-  process.env.PLT_CLIENT_URL = app1.url
-
-  const targetDir = join(__dirname, '..', 'fixtures', 'hello-client-ts-without-deps')
-
-  try {
-    await rmdir(join(targetDir, 'dist'))
-  } catch {}
-
-  await compile(targetDir, { server: { logger: { level: 'warn' } } })
-
-  const app2 = await buildServer(join(targetDir, 'platformatic.service.json'))
-  teardown(async () => {
-    await app2.close()
-  })
-  await app2.start()
-
-  const res = await request(`${app2.url}/`)
-  equal(res.statusCode, 200, 'status code')
-  const data = await res.body.json()
-  same(data, { hello: 'world' })
-})

package/test/fixtures/bad-typescript-plugin/platformatic.service.json

@@ -5,7 +5,7 @@
     },
     "hostname": "127.0.0.1",
     "port": "3042",
-    "pluginTimeout": 30000,
+    "pluginTimeout": 60000,
     "keepAliveTimeout": 1
   },
   "plugins": {

package/test/fixtures/bad-typescript-plugin/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "module": "commonjs",
     "esModuleInterop": true,
-    "target": "es6",
+    "target": "es2020",
     "moduleResolution": "node",
     "sourceMap": true,
     "pretty": true,

package/test/fixtures/typescript-autoload/tsconfig.json

@@ -2,10 +2,10 @@
   "compilerOptions": {
     "module": "commonjs",
     "esModuleInterop": true,
-    "target": "es2019",
+    "target": "es2020",
     "moduleResolution": "node",
-    "sourceMap": true,
-    "pretty": true,
+    "sourceMap": false,
+    "pretty": false,
     "noEmitOnError": true,
     "outDir": "dist"
   },

package/test/fixtures/typescript-compiled/compiled/plugin.js

@@ -0,0 +1,6 @@
+'use strict'
+
+async function plugin (app) {
+  app.log.info('Typescript plugin loaded')
+}
+module.exports = plugin

package/test/fixtures/typescript-compiled/platformatic.service.json

@@ -0,0 +1,18 @@
+{
+  "server": {
+    "logger": {
+      "level": "info"
+    },
+    "hostname": "127.0.0.1",
+    "port": "0",
+    "pluginTimeout": 60000,
+    "keepAliveTimeout": 1
+  },
+  "plugins": {
+    "paths": ["plugin.ts"],
+    "typescript": {
+      "outDir": "compiled"
+    }
+  },
+  "watch": false
+}

package/test/fixtures/typescript-plugin-custom-flags/platformatic.service.json

@@ -0,0 +1,18 @@
+{
+  "server": {
+    "logger": {
+      "level": "info"
+    },
+    "hostname": "127.0.0.1",
+    "port": "0",
+    "pluginTimeout": 60000,
+    "keepAliveTimeout": 1
+  },
+  "plugins": {
+    "paths": ["plugin.ts"],
+    "typescript": {
+      "flags": ["-b"]
+    }
+  },
+  "watch": false
+}

package/test/fixtures/typescript-plugin-custom-flags/plugin.ts

@@ -0,0 +1,5 @@
+import { FastifyInstance } from 'fastify'
+
+export default async function (app: FastifyInstance) {
+  app.log.info('Typescript plugin loaded')
+}

package/test/fixtures/typescript-plugin-custom-flags/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es2020",
+    "moduleResolution": "node",
+    "sourceMap": false,
+    "pretty": false,
+    "noEmitOnError": true,
+    "outDir": "dist"
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": [
+      "**/node_modules",
+      "dist"
+    ]
+  }
+}

package/test/fixtures/typescript-plugin-custom-tsconfig/a-config-for-ts.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es6",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "pretty": true,
+    "noEmitOnError": true,
+    "outDir": "dist"
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": [
+      "**/node_modules",
+      "dist"
+    ]
+  }
+}

package/test/fixtures/typescript-plugin-custom-tsconfig/platformatic.service.json

@@ -0,0 +1,18 @@
+{
+  "server": {
+    "logger": {
+      "level": "info"
+    },
+    "hostname": "127.0.0.1",
+    "port": "0",
+    "pluginTimeout": 60000,
+    "keepAliveTimeout": 1
+  },
+  "plugins": {
+    "paths": ["plugin.ts"],
+    "typescript": {
+      "tsConfig": "./a-config-for-ts.json"
+    }
+  },
+  "watch": false
+}

package/test/fixtures/typescript-plugin-custom-tsconfig/plugin.ts

@@ -0,0 +1,5 @@
+import { FastifyInstance } from 'fastify'
+
+export default async function (app: FastifyInstance) {
+  app.log.info('Typescript plugin loaded')
+}

package/test/fixtures/typescript-plugin-nocompile/tsconfig.json

@@ -2,10 +2,10 @@
   "compilerOptions": {
     "module": "commonjs",
     "esModuleInterop": true,
-    "target": "es6",
+    "target": "es2020",
     "moduleResolution": "node",
-    "sourceMap": true,
-    "pretty": true,
+    "sourceMap": false,
+    "pretty": false,
     "noEmitOnError": true,
     "outDir": "dist"
   },

package/test/fixtures/typescript-plugin-nocompile-enabled/platformatic.service.json

@@ -0,0 +1,18 @@
+{
+  "server": {
+    "logger": {
+      "level": "info"
+    },
+    "hostname": "127.0.0.1",
+    "port": "0",
+    "pluginTimeout": 60000,
+    "keepAliveTimeout": 1
+  },
+  "plugins": {
+    "paths": ["plugin.ts"],
+    "typescript": {
+      "enabled": "false"
+    }
+  },
+  "watch": false
+}

package/test/fixtures/typescript-plugin-nocompile-enabled/plugin.ts

@@ -0,0 +1,5 @@
+import { FastifyInstance } from 'fastify'
+
+export default async function (app: FastifyInstance) {
+  app.log.info('Typescript plugin loaded')
+}

package/test/fixtures/typescript-plugin-nocompile-enabled/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es2020",
+    "moduleResolution": "node",
+    "sourceMap": false,
+    "pretty": false,
+    "noEmitOnError": true,
+    "outDir": "dist"
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": [
+      "**/node_modules",
+      "dist"
+    ]
+  }
+}

package/test/fixtures/typescript-plugin-string/tsconfig.json

@@ -2,10 +2,10 @@
   "compilerOptions": {
     "module": "commonjs",
     "esModuleInterop": true,
-    "target": "es6",
+    "target": "es2020",
     "moduleResolution": "node",
-    "sourceMap": true,
-    "pretty": true,
+    "sourceMap": false,
+    "pretty": false,
     "noEmitOnError": true,
     "outDir": "dist"
   },