@platformatic/service 0.45.1 → 0.46.2

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

@@ -1,310 +0,0 @@
-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/gen-schema.test.mjs

@@ -1,44 +0,0 @@
-import { test } from 'tap'
-import fs from 'fs/promises'
-import { mkdtempSync } from 'fs'
-import { tmpdir } from 'os'
-import { generateJsonSchemaConfig } from '../../lib/gen-schema.js'
-import { join } from 'path'
-import jsonLanguageService from 'vscode-json-languageservice'
-
-const pkg = JSON.parse(await fs.readFile('../../package.json', 'utf8'))
-
-test('generateJsonSchemaConfig generates the file', async (t) => {
-  const tmpDir = await mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
-  process.chdir(tmpDir)
-  await generateJsonSchemaConfig()
-
-  const configSchema = await fs.readFile('platformatic.service.schema.json', 'utf8')
-  const schema = JSON.parse(configSchema)
-  const { required } = schema
-  t.has(required, ['server'])
-  const { $id, type } = schema
-  t.equal($id, `https://platformatic.dev/schemas/v${pkg.version}/service`)
-  t.equal(type, 'object')
-
-  const languageservice = jsonLanguageService.getLanguageService({
-    async schemaRequestService (uri) {
-      return configSchema
-    }
-  })
-
-  languageservice.configure({ allowComments: false, schemas: [{ fileMatch: ['*.data.json'], uri: $id }] })
-
-  const jsonContent = `{
-    "$schema": "https://platformatic.dev/schemas/v${pkg.version}/service",
-    "server": {
-      "hostname": "127.0.0.1",
-      "port": 3000
-    }
-  }`
-  const jsonContentUri = 'foo://server/example.data.json'
-  const textDocument = jsonLanguageService.TextDocument.create(jsonContentUri, 'json', 1, jsonContent)
-  const jsonDocument = languageservice.parseJSONDocument(textDocument)
-  const diagnostics = await languageservice.doValidation(textDocument, jsonDocument)
-  t.equal(diagnostics.length, 0)
-})

package/test/cli/gen-types.test.mjs

@@ -1,30 +0,0 @@
-import { cliPath } from './helper.mjs'
-import { test } from 'tap'
-import { join } from 'desm'
-import { execa } from 'execa'
-import { readFile, unlink } from 'fs/promises'
-
-const GLOBAL_TYPES_TEMPLATE = `
-import { FastifyInstance } from 'fastify'
-import { PlatformaticApp, PlatformaticServiceConfig } from '@platformatic/service'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApp<PlatformaticServiceConfig>
-  }
-}
-`
-
-test('generate global.d.ts', async ({ equal }) => {
-  const fileNameOrThen = join(import.meta.url, '..', '..', 'fixtures', 'hello', 'global.d.ts')
-  try {
-    await unlink(fileNameOrThen)
-  } catch {}
-
-  await execa('node', [cliPath, 'types', '-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json')])
-
-  const data = await readFile(fileNameOrThen, 'utf-8')
-  await unlink(fileNameOrThen)
-
-  equal(data, GLOBAL_TYPES_TEMPLATE)
-})

package/test/cli/helper.mjs

@@ -1,67 +0,0 @@
-import { Agent, setGlobalDispatcher } from 'undici'
-import { on } from 'events'
-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,
-  keepAliveMaxTimeout: 10,
-  tls: {
-    rejectUnauthorized: false
-  }
-}))
-
-// This should not be needed, but a weird combination
-// of node-tap, Windows, c8 and ESM makes this necessary.
-tap.teardown(() => {
-  process.exit(0)
-})
-
-export const cliPath = join(import.meta.url, '..', '..', 'service.mjs')
-
-export async function start (commandOpts, exacaOpts = {}) {
-  const child = execa('node', [cliPath, 'start', ...commandOpts], exacaOpts)
-  child.stderr.pipe(process.stdout)
-
-  const output = child.stdout.pipe(split(function (line) {
-    try {
-      const obj = JSON.parse(line)
-      return obj
-    } catch (err) {
-      console.log(line)
-    }
-  }))
-  child.ndj = output
-
-  const errorTimeout = setTimeout(() => {
-    throw new Error('Couldn\'t start server')
-  }, 30000)
-
-  for await (const messages of on(output, 'data')) {
-    for (const message of messages) {
-      const text = message.msg
-      if (text && text.includes('Server listening at')) {
-        const url = text.match(/Server listening at (.*)/)[1]
-        clearTimeout(errorTimeout)
-        return { child, url, output }
-      }
-    }
-  }
-}
-
-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/cli/start.test.mjs

@@ -1,126 +0,0 @@
-import { start, cliPath } from './helper.mjs'
-import { test } from 'tap'
-import { join } from 'desm'
-import { request } from 'undici'
-import { execa } from 'execa'
-
-test('autostart', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json')])
-
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {
-    hello: 'world'
-  }, 'response')
-
-  child.kill('SIGINT')
-})
-
-test('start command', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json')])
-
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {
-    hello: 'world'
-  }, 'response')
-
-  child.kill('SIGINT')
-})
-
-test('allow custom env properties', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(
-    [
-      '-c', join(import.meta.url, '..', 'fixtures', 'custom-port-placeholder.json'),
-      '--allow-env', 'A_CUSTOM_PORT'
-    ],
-    {
-      env: {
-        A_CUSTOM_PORT: '11111'
-      }
-    }
-  )
-  equal(url, 'http://127.0.0.1:11111', 'A_CUSTOM_PORT env variable has been used')
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {}, 'response')
-
-  child.kill('SIGINT')
-  delete process.env.A_CUSTOM_PORT
-})
-
-test('use default env variables names', async ({ equal, match }) => {
-  const { child, url } = await start(
-    [
-      '-c', join(import.meta.url, '..', 'fixtures', 'default-env-var-names.json')
-    ],
-    {
-      env: {
-        PORT: '11111',
-        HOSTNAME: '127.0.0.1'
-      }
-    }
-  )
-
-  equal(url, 'http://127.0.0.1:11111', 'default env variable names has been used')
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {}, 'response')
-
-  child.kill('SIGINT')
-  delete process.env.A_CUSTOM_PORT
-})
-
-test('default logger', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'no-server-logger.json')])
-  match(url, /http:\/\/127.0.0.1:[0-9]+/)
-  child.kill('SIGINT')
-})
-
-test('plugin options', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'options', 'platformatic.service.yml')])
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {
-    something: 'else'
-  }, 'response')
-
-  child.kill('SIGINT')
-})
-
-test('https embedded pem', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'https', 'embedded-pem.json')])
-
-  match(url, /https:\/\//)
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {
-    hello: 'world'
-  }, 'response')
-
-  child.kill('SIGINT')
-})
-
-test('https pem path', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'https', 'pem-path.json')])
-
-  match(url, /https:\/\//)
-  const res = await request(`${url}`)
-  equal(res.statusCode, 200)
-  const body = await res.body.json()
-  match(body, {
-    hello: 'world'
-  }, 'response')
-
-  child.kill('SIGINT')
-})
-
-test('not load', async ({ rejects }) => {
-  await rejects(execa('node', [cliPath, 'start', '-c', join(import.meta.url, '..', 'fixtures', 'not-load.service.json')]))
-})

package/test/cli/validations.test.mjs

@@ -1,33 +0,0 @@
-import { cliPath } from './helper.mjs'
-import { test } from 'tap'
-import { join } from 'desm'
-import { readFile } from 'fs/promises'
-import { execa } from 'execa'
-import stripAnsi from 'strip-ansi'
-
-const version = JSON.parse(await readFile(join(import.meta.url, '..', '..', 'package.json'))).version
-
-test('version', async (t) => {
-  const { stdout } = await execa('node', [cliPath, '--version'])
-  t.ok(stdout.includes('v' + version))
-})
-
-test('missing config', async (t) => {
-  await t.rejects(execa('node', [cliPath, 'start']))
-})
-
-test('print validation errors', async ({ equal, plan }) => {
-  plan(2)
-  try {
-    await execa('node', [cliPath, 'start', '--config', join(import.meta.url, '..', 'fixtures', 'missing-property.config.json')])
-  } catch (err) {
-    equal(err.exitCode, 1)
-    equal(stripAnsi(err.stdout), `
-┌─────────┬──────┬─────────────────────────────────────────────────────────────────────┐
-│ (index) │ path │                               message                               │
-├─────────┼──────┼─────────────────────────────────────────────────────────────────────┤
-│    0    │ '/'  │ \`must have required property 'server' {"missingProperty":"server"}\` │
-└─────────┴──────┴─────────────────────────────────────────────────────────────────────┘
-`.trim())
-  }
-})