@platformatic/service 0.28.1 → 0.30.0

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

@@ -1,68 +1,113 @@
 import path from 'path'
 import os from 'os'
-import { access, rename, cp } from 'fs/promises'
+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 } 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-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 () => {
-    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')
+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, 'compile'], { cwd })
+  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 compilation completed successfully.')) {
-      const jsPluginPath = path.join(cwd, 'dist', 'plugin.js')
-      try {
-        await access(jsPluginPath)
-      } catch (err) {
-        t.fail(err)
-      }
-
+    if (sanitized.includes('Typescript plugin loaded')) {
       t.pass()
       return
     }
   }
-  t.fail('should compile typescript plugin with a compile command')
+  t.fail('should compile typescript plugin with start command')
 })
 
-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')
+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 })
 
-  const child = execa('node', [cliPath, 'compile'], { cwd })
+  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))
 
@@ -71,27 +116,22 @@ t.test('should compile typescript plugin even if typescript is `false`', async (
 
   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)
-      }
-
+    if (sanitized.includes('Typescript plugin loaded')) {
       t.pass()
       return
     }
   }
-  t.fail('should compile typescript plugin with a compile command')
+  t.fail('should compile typescript plugin with start command')
 })
 
-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')
+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()
@@ -104,176 +144,160 @@ t.test('should compile typescript plugin with start command', async (t) => {
       return
     }
   }
-  t.fail('should compile typescript plugin with start command')
+  t.fail('should load the typescript plugin without compiling it')
 })
 
-t.test('should not compile bad typescript plugin', async (t) => {
-  const cwd = path.join(urlDirname(import.meta.url), '..', 'fixtures', 'bad-typescript-plugin')
+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)
 
-  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)
-  }
+  await cp(testDir, cwd, { recursive: 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)
+  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('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')
+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 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('The tsconfig.json file was not found.'), true)
-  }
-
-  t.pass()
-})
+  const child = execa('node', [cliPath, 'compile'], { cwd })
 
-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')
+  t.teardown(exitOnTeardown(child))
 
-  const childProcess = execa('node', [cliPath, 'start'], { cwd })
+  const splitter = split()
+  child.stdout.pipe(splitter)
 
-  t.teardown(() => {
-    childProcess.kill('SIGINT')
-  })
+  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)
+      }
 
-  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)
-      t.fail('should throw one ts error')
+      t.pass()
+      return
     }
-    childProcess.kill('SIGINT')
-  }
-
-  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.fail('should compile typescript plugin with a compile command')
 })
 
-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')
+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 pathToTSConfig = path.join(cwd, 'tsconfig.json')
-  const pathToTSConfigBackup = path.join(cwd, 'tsconfig.json.backup')
+  const child = execa('node', [cliPath, 'start'], { cwd })
 
-  await rename(pathToTSConfig, pathToTSConfigBackup)
+  const splitter = split()
+  child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
 
-  try {
-    const child = await execa('node', [cliPath, 'start'], { cwd })
-    t.teardown(() => child.kill('SIGINT'))
-    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)
+  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('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')
+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 })
-  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()
+  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 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')
-
-  await cp(testDir, dest, { recursive: true })
+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)
 
-  const child = execa('node', [cliPath, 'start', '-c', path.join(dest, 'platformatic.service.json')])
+  await cp(testDir, cwd, { recursive: true })
 
-  t.teardown(exitOnTeardown(child))
+  const child = execa('node', [cliPath, 'start'], { cwd })
 
   const splitter = split()
   child.stdout.pipe(splitter)
-  child.stderr.pipe(process.stderr)
+  child.stderr.pipe(splitter)
 
   for await (const data of splitter) {
     const sanitized = stripAnsi(data)
-    if (sanitized.includes('Typescript plugin loaded')) {
+    if (sanitized.includes('Unknown file extension ".ts" for')) {
       t.pass()
       return
     }
   }
-  t.fail('should compile typescript plugin with start command')
+  t.fail('should load the typescript plugin without compiling it')
 })
 
-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')
+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 })
 
-  try {
-    await execa('node', [cliPath, 'compile'], { cwd, stdio: 'inherit' })
-  } catch (err) {
-    t.fail('should not catch any error')
-  }
+  const child = execa('node', [cliPath, 'start'], { cwd })
 
-  t.pass()
+  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 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')
+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 })
 
-  t.teardown(exitOnTeardown(child))
-
   const splitter = split()
   child.stdout.pipe(splitter)
+  child.stderr.pipe(splitter)
 
   for await (const data of splitter) {
     const sanitized = stripAnsi(data)

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 () => {
@@ -60,3 +62,26 @@ test('client is loaded (ts)', async ({ teardown, equal, pass, same }) => {
   const data = await res.body.json()
   same(data, { hello: 'world' })
 })
+
+test('client is loaded dependencyless', async ({ teardown, equal, 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 app2 = await buildServer(join(__dirname, '..', 'fixtures', 'hello-client-without-deps', '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"
+    ]
+  }
+}