@platformatic/service 2.74.3 → 3.0.0-alpha.2

package/lib/generator.js

@@ -0,0 +1,424 @@
+import { BaseGenerator } from '@platformatic/generators'
+import { join } from 'node:path'
+
+const JS_PLUGIN_WITH_TYPES_SUPPORT = `\
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.decorate('example', 'foobar')
+}
+`
+
+const TS_PLUGIN_WITH_TYPES_SUPPORT = `\
+import { type FastifyInstance, type FastifyPluginOptions } from 'fastify'
+
+export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
+  fastify.decorate('example', 'foobar')
+}
+`
+
+const JS_ROUTES_WITH_TYPES_SUPPORT = `\
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.get('/example', async (request, reply) => {
+    return { hello: fastify.example }
+  })
+}
+`
+
+const TS_ROUTES_WITH_TYPES_SUPPORT = `\
+import { type FastifyInstance, type FastifyPluginOptions } from 'fastify'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    example: string
+  }
+}
+
+export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
+  fastify.get('/example', async (request, reply) => {
+    return { hello: fastify.example }
+  })
+}
+`
+
+const TEST_ROUTES_JS = `\
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { getServer } = require('../helper')
+
+test('example', async (t) => {
+  const server = await getServer(t)
+  const res = await server.inject({
+    method: 'GET',
+    url: '/example'
+  })
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(res.json(), {
+    hello: 'foobar'
+  })
+})
+`
+
+const TEST_PLUGIN_JS = `\
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { getServer } = require('../helper')
+
+test('example decorator', async (t) => {
+  const server = await getServer(t)
+
+  assert.strictEqual(server.example, 'foobar')
+})
+`
+
+const TEST_ROUTES_TS = `\
+import test from 'node:test'
+import assert from 'node:assert'
+import { getServer } from '../helper'
+
+test('root', async (t) => {
+  const server = await getServer(t)
+  const res = await server.inject({
+    method: 'GET',
+    url: '/example'
+  })
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(res.json(), {
+    hello: 'foobar'
+  })
+})
+`
+
+const TEST_PLUGIN_TS = `\
+import test from 'node:test'
+import assert from 'node:assert'
+import { getServer } from '../helper'
+
+test('example decorator', async (t) => {
+  const server = await getServer(t)
+
+  assert.strictEqual(server.example, 'foobar')
+})
+`
+
+const TEST_HELPER_JS = `
+'use strict'
+
+const { join } = require('node:path')
+const { readFile } = require('node:fs/promises')
+const { buildServer } = require('$__MOD__')
+$__REQUIRES__
+
+async function getServer (t) {
+$__PRE__
+  const config = JSON.parse(await readFile(join(__dirname, '..', 'watt.json'), 'utf8'))
+  // Add your config customizations here. For example you want to set
+  // all things that are set in the config file to read from an env variable
+  config.server ||= {}
+  config.server.logger ||= {}
+  config.watch = false
+$__CONFIG__
+  // Add your config customizations here
+  const server = await buildServer(config)
+  t.after(() => server.close())
+$__POST__
+  return server
+}
+
+module.exports.getServer = getServer
+`
+
+const TEST_HELPER_TS = `
+import { join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+import { buildServer } from '$__MOD__'
+import { test } from 'node:test'
+$__REQUIRES__
+
+type testfn = Parameters<typeof test>[0]
+type TestContext = Parameters<Exclude<testfn, undefined>>[0]
+
+export async function getServer (t: TestContext) {
+$__PRE__
+  // We go up two folder because this files executes in the dist folder
+  const config = JSON.parse(await readFile(join(__dirname, '..', '..', 'watt.json'), 'utf8'))
+  // Add your config customizations here. For example you want to set
+  // all things that are set in the config file to read from an env variable
+  config.server ||= {}
+  config.server.logger ||= {}
+  config.server.logger.level = 'warn'
+  config.watch = false
+$__CONFIG__
+  // Add your config customizations here
+  const server = await buildServer(config)
+  t.after(() => server.close())
+$__POST__
+  return server
+}
+  `
+
+const TS_CONFIG = `
+{
+  compilerOptions: {
+    module: 'commonjs',
+    esModuleInterop: true,
+    target: 'es2020',
+    sourceMap: true,
+    pretty: true,
+    noEmitOnError: true,
+    incremental: true,
+    strict: true,
+    outDir: 'dist',
+    skipLibCheck: true
+  },
+  watchOptions: {
+    watchFile: 'fixedPollingInterval',
+    watchDirectory: 'fixedPollingInterval',
+    fallbackPolling: 'dynamicPriority',
+    synchronousWatchDirectory: true,
+    excludeDirectories: ['**/node_modules', 'dist']
+  }
+}
+`
+
+const PLT_ENVIRONMENT_TEMPLATE = `
+import { type FastifyInstance } from 'fastify'
+import { PlatformaticApplication, PlatformaticServiceConfig } from '@platformatic/service'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    platformatic: PlatformaticApplication<PlatformaticServiceConfig>
+  }
+}
+`
+
+const README = `
+# Platformatic Service API
+
+This is a generated [Platformatic Service](https://docs.platformatic.dev/docs/service/overview) application.
+
+## Requirements
+
+Platformatic supports macOS, Linux and Windows ([WSL](https://docs.microsoft.com/windows/wsl/) recommended).
+You'll need to have [Node.js](https://nodejs.org/) >= v18.8.0 or >= v20.6.0
+
+## Setup
+
+Install dependencies:
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Usage
+
+Run the API with:
+
+\`\`\`bash
+npm start
+\`\`\`
+
+### Explore
+- ⚡ The Platformatic DB server is running at http://localhost:3042/
+- 📔 View the REST API's Swagger documentation at http://localhost:3042/documentation/
+- 🔍 Try out the GraphiQL web UI at http://localhost:3042/graphiql
+`
+
+export function applyTestHelperCustomizations (testHelper, mod, customizations) {
+  return testHelper
+    .replaceAll('$__MOD__', mod || '@platformatic/service')
+    .replaceAll('$__REQUIRES__', customizations.requires || '')
+    .replaceAll('$__PRE__', customizations.pre || '')
+    .replaceAll('$__CONFIG__', customizations.config || '')
+    .replaceAll('$__POST__', customizations.post || '')
+}
+
+export class Generator extends BaseGenerator {
+  constructor (opts = {}) {
+    super({
+      module: '@platformatic/service',
+      ...opts
+    })
+  }
+
+  getConfigFieldsDefinitions () {
+    if (this.config.isRuntimeContext) {
+      return []
+    }
+
+    return [
+      {
+        var: 'PLT_SERVER_HOSTNAME',
+        label: 'What is the hostname?',
+        default: '0.0.0.0',
+        type: 'string',
+        configValue: 'hostname'
+      },
+      {
+        var: 'PLT_SERVER_LOGGER_LEVEL',
+        label: 'What is the logger level?',
+        default: 'info',
+        type: 'string',
+        configValue: ''
+      },
+      {
+        label: 'Which port do you want to use?',
+        var: 'PORT',
+        default: 3042,
+        type: 'number',
+        configValue: 'port'
+      }
+    ]
+  }
+
+  getDefaultConfig () {
+    const defaultBaseConfig = super.getDefaultConfig()
+
+    return {
+      ...defaultBaseConfig,
+      plugin: true,
+      tests: true
+    }
+  }
+
+  async prepareQuestions () {
+    await super.prepareQuestions()
+
+    if (!this.config.skipTypescript) {
+      this.questions.push({
+        type: 'list',
+        name: 'typescript',
+        message: 'Do you want to use TypeScript?',
+        default: false,
+        choices: [
+          { name: 'yes', value: true },
+          { name: 'no', value: false }
+        ]
+      })
+    }
+  }
+
+  async _beforePrepare () {
+    if (this.config.isUpdating) {
+      return
+    }
+
+    if (!this.config.isRuntimeContext) {
+      this.addEnvVars(
+        {
+          PLT_SERVER_HOSTNAME: this.config.hostname,
+          PLT_SERVER_LOGGER_LEVEL: 'info',
+          PORT: 3042
+        },
+        { overwrite: false }
+      )
+    }
+
+    this.config.dependencies = {
+      '@platformatic/service': `^${this.platformaticVersion}`
+    }
+  }
+
+  async _afterPrepare () {
+    // if we are NOT updating, create env and files, otherwise leave as it is
+    if (this.config.isUpdating) {
+      return
+    }
+
+    if (this.config.typescript) {
+      this.addFile({ path: '', file: 'tsconfig.json', contents: TS_CONFIG })
+    }
+
+    this.addFile({ path: '', file: 'plt-env.d.ts', contents: PLT_ENVIRONMENT_TEMPLATE })
+    this.addFile({ path: '', file: 'README.md', contents: README })
+
+    if (this.config.plugin) {
+      // create plugin
+      this.files.push({
+        path: 'plugins',
+        file: this.config.typescript ? 'example.ts' : 'example.js',
+        contents: this.config.typescript ? TS_PLUGIN_WITH_TYPES_SUPPORT : JS_PLUGIN_WITH_TYPES_SUPPORT
+      })
+
+      this.files.push({
+        path: 'routes',
+        file: this.config.typescript ? 'root.ts' : 'root.js',
+        contents: this.config.typescript ? TS_ROUTES_WITH_TYPES_SUPPORT : JS_ROUTES_WITH_TYPES_SUPPORT
+      })
+
+      if (this.config.tests) {
+        if (this.config.typescript) {
+          this.files.push({
+            path: 'test',
+            file: 'helper.ts',
+            contents: applyTestHelperCustomizations(TEST_HELPER_TS, this.module, this.testHelperCustomizations ?? {})
+          })
+          this.files.push({
+            path: join('test', 'plugins'),
+            file: 'example.test.ts',
+            contents: TEST_PLUGIN_TS
+          })
+          this.files.push({
+            path: join('test', 'routes'),
+            file: 'root.test.ts',
+            contents: TEST_ROUTES_TS
+          })
+        } else {
+          this.files.push({
+            path: 'test',
+            file: 'helper.js',
+            contents: applyTestHelperCustomizations(TEST_HELPER_JS, this.module, this.testHelperCustomizations ?? {})
+          })
+          this.files.push({
+            path: join('test', 'plugins'),
+            file: 'example.test.js',
+            contents: TEST_PLUGIN_JS
+          })
+          this.files.push({
+            path: join('test', 'routes'),
+            file: 'root.test.js',
+            contents: TEST_ROUTES_JS
+          })
+        }
+      }
+    }
+  }
+
+  async _getConfigFileContents () {
+    const config = {
+      $schema: `https://schemas.platformatic.dev/@platformatic/service/${this.platformaticVersion}.json`,
+      service: {
+        openapi: true
+      },
+      watch: true
+    }
+
+    if (this.config.plugin) {
+      config.plugins = {
+        paths: [{ path: './plugins', encapsulate: false }, './routes']
+      }
+    }
+
+    if (!this.config.isRuntimeContext) {
+      config.server = {
+        hostname: '{PLT_SERVER_HOSTNAME}',
+        port: '{PORT}',
+        logger: {
+          level: '{PLT_SERVER_LOGGER_LEVEL}'
+        }
+      }
+    }
+
+    return config
+  }
+}

package/lib/plugins/cors.js

@@ -1,6 +1,5 @@
-'use strict'
-
-const fp = require('fastify-plugin')
+import fastifyCors from '@fastify/cors'
+import fp from 'fastify-plugin'
 
 function originToRegexp (origin) {
   if (typeof origin === 'object') {
@@ -12,9 +11,7 @@ function originToRegexp (origin) {
   return origin
 }
 
-async function setupClients (app, opts) {
-  const cors = opts
-
+async function setupCorsPlugin (app, cors) {
   let origin = cors.origin
   if (Array.isArray(origin)) {
     origin = origin.map(originToRegexp)
@@ -23,7 +20,7 @@ async function setupClients (app, opts) {
   }
 
   cors.origin = origin
-  app.register(require('@fastify/cors'), cors)
+  app.register(fastifyCors, cors)
 }
 
-module.exports = fp(setupClients)
+export const setupCors = fp(setupCorsPlugin)

package/lib/plugins/graphql.js

@@ -1,24 +1,26 @@
-'use strict'
-
-const mercurius = require('mercurius')
-const deepmerge = require('@fastify/deepmerge')({ all: true })
-const fp = require('fastify-plugin')
+import { deepmerge } from '@platformatic/foundation'
+import fp from 'fastify-plugin'
+import mercurius from 'mercurius'
 
 // For some unknown reason, c8 is not detecting any of this
 // despite being covered by test/graphql.test.js
 /* c8 ignore next 12 */
-async function setupGraphQL (app, opts) {
-  if (typeof opts !== 'object') {
-    opts = {}
+async function setupGraphQLPlugin (app, options) {
+  if (typeof options !== 'object') {
+    options = {}
   }
-  const graphqlOptions = deepmerge({
-    graphiql: true,
-    additionalRouteOptions: {
-      schema: { hide: true },
+
+  const graphqlOptions = deepmerge(
+    {
+      graphiql: true,
+      additionalRouteOptions: {
+        schema: { hide: true }
+      }
     },
-  }, opts)
+    options
+  )
 
   app.register(mercurius, graphqlOptions)
 }
 
-module.exports = fp(setupGraphQL)
+export const setupGraphQL = fp(setupGraphQLPlugin)

package/lib/plugins/health-check.js

@@ -1,17 +1,15 @@
-'use strict'
+import underPressure from '@fastify/under-pressure'
+import fp from 'fastify-plugin'
 
-const underPressure = require('@fastify/under-pressure')
-const fp = require('fastify-plugin')
-
-async function setupClients (app, opts) {
-  const healthCheck = opts
+async function setupHealthCheckPlugin (app, options) {
+  const healthCheck = options
 
   app.register(underPressure, {
     exposeStatusRoute: '/status',
     healthCheckInterval: healthCheck.interval !== undefined ? healthCheck.interval : 5000,
     ...healthCheck,
-    healthCheck: healthCheck.fn,
+    healthCheck: healthCheck.fn
   })
 }
 
-module.exports = fp(setupClients)
+export const setupHealthCheck = fp(setupHealthCheckPlugin)

package/lib/plugins/openapi.js

@@ -1,43 +1,44 @@
-'use strict'
-
-const Swagger = require('@fastify/swagger')
-const deepmerge = require('@fastify/deepmerge')({ all: true })
-const fp = require('fastify-plugin')
+import Swagger from '@fastify/swagger'
+import { deepmerge } from '@platformatic/foundation'
+import fp from 'fastify-plugin'
 
 // For some unknown reason, c8 is not detecting any of this
 // pf
 // despite being covered by test/routes.test.js
 /* c8 ignore next 33 */
-async function setupOpenAPI (app, opts) {
-  const { openapi } = opts
-  const openapiConfig = deepmerge({
-    exposeRoute: true,
-    info: {
-      title: 'Platformatic',
-      description: 'This is a service built on top of Platformatic',
-      version: '1.0.0',
+async function setupOpenAPIPlugin (app, options) {
+  const { openapi } = options
+  const openapiConfig = deepmerge(
+    {
+      exposeRoute: true,
+      info: {
+        title: 'Platformatic',
+        description: 'This is a service built on top of Platformatic',
+        version: '1.0.0'
+      },
+      servers: [{ url: globalThis.platformatic?.runtimeBasePath ?? '/' }]
     },
-    servers: [{ url: globalThis.platformatic?.runtimeBasePath ?? '/' }],
-  }, typeof openapi === 'object' ? openapi : {})
+    typeof openapi === 'object' ? openapi : {}
+  )
   app.log.trace({ openapi: openapiConfig })
   const swaggerOptions = {
     exposeRoute: openapiConfig.exposeRoute,
     openapi: {
-      ...openapiConfig,
+      ...openapiConfig
     },
     refResolver: {
       buildLocalReference (json, baseUri, fragment, i) {
         // TODO figure out if we need def-${i}
         /* istanbul ignore next */
         return json.$id || `def-${i}`
-      },
-    },
+      }
+    }
   }
 
   if (openapi.path) {
     swaggerOptions.mode = 'static'
     swaggerOptions.specification = {
-      path: openapi.path,
+      path: openapi.path
     }
   }
 
@@ -49,24 +50,32 @@ async function setupOpenAPI (app, opts) {
   const routePrefix = openapi.swaggerPrefix || '/documentation'
 
   /** Serve spec file in yaml and json */
-  app.get(`${routePrefix}/json`, {
-    schema: { hide: true },
-    logLevel: 'warn',
-  }, async () => app.swagger())
-  app.get(`${routePrefix}/yaml`, {
-    schema: { hide: true },
-    logLevel: 'warn',
-  }, async () => app.swagger({ yaml: true }))
+  app.get(
+    `${routePrefix}/json`,
+    {
+      schema: { hide: true },
+      logLevel: 'warn'
+    },
+    async () => app.swagger()
+  )
+  app.get(
+    `${routePrefix}/yaml`,
+    {
+      schema: { hide: true },
+      logLevel: 'warn'
+    },
+    async () => app.swagger({ yaml: true })
+  )
 
   app.register(scalarApiReference, {
-    ...opts,
+    ...options,
     ...openapi,
     routePrefix,
     publicPath: './',
     configuration: {
-      customCss: scalarTheme.theme,
-    },
+      customCss: scalarTheme.theme
+    }
   })
 }
 
-module.exports = fp(setupOpenAPI)
+export const setupOpenAPI = fp(setupOpenAPIPlugin)

package/lib/plugins/plugins.js

@@ -1,57 +1,10 @@
-'use strict'
+import fp from 'fastify-plugin'
+import { sandboxWrapper } from './sandbox-wrapper.js'
 
-const { join, resolve } = require('path')
-const { readFile } = require('fs/promises')
-const fp = require('fastify-plugin')
-const wrapper = require('./sandbox-wrapper')
+async function loadPluginsPlugin (app, context) {
+  const config = app.platformatic.config
 
-const { getJSPluginPath, isFileAccessible } = require('../utils')
-
-async function loadPlugins (app, opts) {
-  const configManager = app.platformatic.configManager
-  const config = configManager.current
-
-  let isOutDirAccessible = false
-  let outDir = null
-
-  const workingDir = opts?.context?.directory ?? configManager.dirname
-  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'))
-    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 (opts.context?.isProduction && !isOutDirAccessible) {
-      throw new Error(
-        `Cannot access directory '${outDir}'. Please run the 'build' command before running in production mode.`
-      )
-    }
-  }
-
-  if (config.plugins.paths && isOutDirAccessible) {
-    config.plugins.paths = config.plugins.paths.map(plugin => {
-      /* c8 ignore next 3 */
-      const tmp =
-        typeof plugin === 'string'
-          ? getJSPluginPath(workingDir, plugin, outDir)
-          : { ...plugin, path: getJSPluginPath(workingDir, plugin.path, outDir) }
-      return tmp
-    })
-  }
-
-  await app.register(wrapper, { packages: config.plugins.packages, paths: config.plugins.paths })
+  await app.register(sandboxWrapper, { packages: config.plugins.packages, paths: config.plugins.paths })
 }
 
-module.exports = fp(loadPlugins)
+export const loadPlugins = fp(loadPluginsPlugin)