create-platformatic 0.45.1 → 0.46.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "0.45.1",
+  "version": "0.46.1",
   "description": "Create platformatic-db interactive tool",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
     "semver": "^7.5.1",
     "undici": "^5.22.1",
     "which": "^3.0.1",
-    "@platformatic/config": "0.45.1"
+    "@platformatic/config": "0.46.1"
   },
   "devDependencies": {
     "ajv": "^8.12.0",
@@ -47,8 +47,8 @@
     "tap": "^16.3.6",
     "typescript": "~5.2.0",
     "yaml": "^2.3.1",
-    "@platformatic/db": "0.45.1",
-    "@platformatic/service": "0.45.1"
+    "@platformatic/db": "0.46.1",
+    "@platformatic/service": "0.46.1"
   },
   "scripts": {
     "test": "standard | snazzy && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" c8 tap --no-coverage test/*test.mjs test/*/*test.mjs",

package/src/composer/create-composer-cli.mjs

@@ -93,8 +93,8 @@ const createPlatformaticComposer = async (_args, opts) => {
   }
 
   if (!opts.skipGitHubActions) {
-    await askDynamicWorkspaceCreateGHAction(logger, env, 'composer', false, projectDir)
     await askStaticWorkspaceGHAction(logger, env, 'composer', false, projectDir)
+    await askDynamicWorkspaceCreateGHAction(logger, env, 'composer', false, projectDir)
   }
 }
 

package/src/create-plugins.mjs

@@ -0,0 +1,232 @@
+import { join } from 'path'
+import { writeFile, mkdir } from 'fs/promises'
+import { isFileAccessible } from './utils.mjs'
+
+const JS_PLUGIN_WITH_TYPES_SUPPORT = `\
+/// <reference path="../global.d.ts" />
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.decorate('example', 'foobar')
+}
+`
+
+const TS_PLUGIN_WITH_TYPES_SUPPORT = `\
+/// <reference path="../global.d.ts" />
+import { FastifyInstance, FastifyPluginOptions } from 'fastify'
+
+export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
+  fastify.decorate('example', 'foobar')
+}
+`
+
+const JS_ROUTES_WITH_TYPES_SUPPORT = `\
+/// <reference path="../global.d.ts" />
+'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 = `\
+/// <reference path="../global.d.ts" />
+import { FastifyInstance, 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 }
+  })
+}
+`
+
+function testHelperJS (mod, customization = { pre: '', post: '', config: '' }) {
+  return `\
+'use strict'
+
+const { join } = require('node:path')
+const { readFile } = require('node:fs/promises')
+const { buildServer } = require('@platformatic/${mod}')
+${customization.requires || ''}
+
+async function getServer (t) {
+${customization.pre || ''}
+  const config = JSON.parse(await readFile(join(__dirname, '..', 'platformatic.${mod}.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.logger.level = 'warn'
+  config.watch = false
+${customization.config || ''}
+  // Add your config customizations here
+  const server = await buildServer(config)
+  t.after(() => server.close())
+${customization.post || ''}
+  return server
+}
+
+module.exports.getServer = getServer
+`
+}
+
+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')
+})
+`
+
+function testHelperTS (mod, customizations = { pre: '', post: '', config: '', requires: '' }) {
+  return `\
+import { join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+import { buildServer } from '@platformatic/${mod}'
+${customizations.requires}
+
+export async function getServer (t) {
+${customizations.pre}
+  // We go up two folder because this files executes in the dist folder
+  const config = JSON.parse(await readFile(join(__dirname, '..', '..', 'platformatic.${mod}.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.logger.level = 'warn'
+  config.watch = false
+${customizations.config}
+  // Add your config customizations here
+  const server = await buildServer(config)
+  t.after(() => server.close())
+${customizations.post}
+  return server
+}
+  `
+}
+
+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')
+})
+`
+
+export async function generatePluginWithTypesSupport (logger, currentDir, isTypescript) {
+  const accessible = await isFileAccessible('plugins', currentDir)
+  if (accessible) {
+    logger.info('Plugins folder "plugins" found, skipping creation of plugins folder.')
+    return
+  }
+  await mkdir(join(currentDir, 'plugins'))
+  const pluginTemplate = isTypescript
+    ? TS_PLUGIN_WITH_TYPES_SUPPORT
+    : JS_PLUGIN_WITH_TYPES_SUPPORT
+  const pluginName = isTypescript
+    ? 'example.ts'
+    : 'example.js'
+  await writeFile(join(currentDir, 'plugins', pluginName), pluginTemplate)
+  logger.info('Plugins folder "plugins" successfully created.')
+}
+
+export async function generateRouteWithTypesSupport (logger, currentDir, isTypescript) {
+  const accessible = await isFileAccessible('routes', currentDir)
+  if (accessible) {
+    logger.info('Routes folder "routes" found, skipping creation of routes folder.')
+    return
+  }
+  await mkdir(join(currentDir, 'routes'))
+  const routesTemplate = isTypescript
+    ? TS_ROUTES_WITH_TYPES_SUPPORT
+    : JS_ROUTES_WITH_TYPES_SUPPORT
+  const routesName = isTypescript
+    ? 'root.ts'
+    : 'root.js'
+  await writeFile(join(currentDir, 'routes', routesName), routesTemplate)
+  logger.info('Routes folder "routes" successfully created.')
+}
+
+export async function generateTests (logger, currentDir, isTypescript, mod, customizations) {
+  const accessible = await isFileAccessible('tests', currentDir)
+  if (accessible) {
+    logger.info('Test folder found, skipping creation of tests.')
+    return
+  }
+
+  await mkdir(join(currentDir, 'test'))
+  await mkdir(join(currentDir, 'test', 'plugins'))
+  await mkdir(join(currentDir, 'test', 'routes'))
+
+  if (isTypescript) {
+    await writeFile(join(currentDir, 'test', 'helper.ts'), testHelperTS(mod, customizations))
+    await writeFile(join(currentDir, 'test', 'plugins', 'example.test.ts'), TEST_PLUGIN_TS)
+    await writeFile(join(currentDir, 'test', 'routes', 'root.test.ts'), TEST_ROUTES_TS)
+  } else {
+    await writeFile(join(currentDir, 'test', 'helper.js'), testHelperJS(mod, customizations))
+    await writeFile(join(currentDir, 'test', 'plugins', 'example.test.js'), TEST_PLUGIN_JS)
+    await writeFile(join(currentDir, 'test', 'routes', 'root.test.js'), TEST_ROUTES_JS)
+  }
+
+  logger.info('Test folder "tests" successfully created.')
+}
+
+export async function generatePlugins (logger, currentDir, isTypescript, mod, helperCustomization) {
+  await generatePluginWithTypesSupport(logger, currentDir, isTypescript)
+  await generateRouteWithTypesSupport(logger, currentDir, isTypescript)
+  await generateTests(logger, currentDir, isTypescript, mod, helperCustomization)
+}

package/src/db/create-db-cli.mjs

@@ -166,7 +166,8 @@ const createPlatformaticDB = async (_args, opts) => {
   const fastifyVersion = await getDependencyVersion('fastify')
 
   const scripts = {
-    migrate: 'platformatic db migrations apply'
+    migrate: 'platformatic db migrations apply',
+    test: useTypescript ? 'tsc && node --test dist/test/*/*.test.js' : 'node --test test/*/*.test.js'
   }
 
   const dependencies = {
@@ -245,8 +246,8 @@ const createPlatformaticDB = async (_args, opts) => {
   }
 
   if (!opts.skipGitHubActions) {
-    await askDynamicWorkspaceCreateGHAction(logger, env, 'db', useTypescript, projectDir)
     await askStaticWorkspaceGHAction(logger, env, 'db', useTypescript, projectDir)
+    await askDynamicWorkspaceCreateGHAction(logger, env, 'db', useTypescript, projectDir)
   }
 }
 

package/src/db/create-db.mjs

@@ -1,7 +1,8 @@
 import { writeFile, mkdir, appendFile } from 'fs/promises'
-import { join, relative, resolve } from 'path'
+import { join } from 'path'
 import { findDBConfigFile, isFileAccessible } from '../utils.mjs'
 import { getTsConfig } from '../get-tsconfig.mjs'
+import { generatePlugins } from '../create-plugins.mjs'
 
 const connectionStrings = {
   postgres: 'postgres://postgres:postgres@127.0.0.1:5432/postgres',
@@ -32,9 +33,222 @@ const moviesMigrationUndo = `
 DROP TABLE movies;
 `
 
-const getPluginName = (isTypescript) => isTypescript === true ? 'plugin.ts' : 'plugin.js'
 const TS_OUT_DIR = 'dist'
 
+const jsHelperSqlite = {
+  requires: `
+const os = require('node:os')
+const path = require('node:path')
+const fs = require('node:fs/promises')
+
+let counter = 0
+`,
+  pre: `
+  const dbPath = join(os.tmpdir(), 'db-' + process.pid + '-' + counter++ + '.sqlite')
+  const connectionString = 'sqlite://' + dbPath
+`,
+  config: `
+  config.migrations.autoApply = true
+  config.types.autogenerate = false
+  config.db.connectionString = connectionString
+`,
+  post: `
+  t.after(async () => {
+    await fs.unlink(dbPath)
+  })
+`
+}
+
+function jsHelperPostgres (connectionString) {
+  return {
+    // TODO(mcollina): replace sql-mapper
+    requires: `
+const { createConnectionPool } = require('@platformatic/sql-mapper')
+const connectionString = '${connectionString}'
+let counter = 0
+`,
+    pre: `
+  const { db, sql } = await createConnectionPool({
+    log: {
+      debug: () => {},
+      info: () => {},
+      trace: () => {}
+    },
+    connectionString,
+    poolSize: 1
+  })
+
+  const newDB = \`t-\${process.pid}-\${counter++}\`
+  t.diagnostic('Creating database ' + newDB)
+
+  await db.query(sql\`
+    CREATE DATABASE \${sql.ident(newDB)}
+  \`)
+`,
+    config: `
+  config.migrations.autoApply = true
+  config.types.autogenerate = false
+  config.db.connectionString = connectionString.replace(/\\/[a-zA-Z0-9\\-_]+$/, '/' + newDB)
+  config.db.schemalock = false
+`,
+    post: `
+  t.after(async () => {
+    t.diagnostic('Disposing test database ' + newDB)
+    await db.query(sql\`
+      DROP DATABASE \${sql.ident(newDB)}
+    \`)
+    await db.dispose()
+  })
+`
+  }
+}
+
+function jsHelperMySQL (connectionString) {
+  return {
+    // TODO(mcollina): replace sql-mapper
+    requires: `
+const { createConnectionPool } = require('@platformatic/sql-mapper')
+const connectionString = '${connectionString}'
+let counter = 0
+`,
+    pre: `
+  const { db, sql } = await createConnectionPool({
+    log: {
+      debug: () => {},
+      info: () => {},
+      trace: () => {}
+    },
+    connectionString,
+    poolSize: 1
+  })
+
+  const newDB = \`t-\${process.pid}-\${counter++}\`
+  t.diagnostic('Creating database ' + newDB)
+
+  await db.query(sql\`
+    CREATE DATABASE \${sql.ident(newDB)}
+  \`)
+`,
+    config: `
+  config.migrations.autoApply = true
+  config.types.autogenerate = false
+  config.db.connectionString = connectionString.replace(/\\/[a-zA-Z0-9\\-_]+$/, '/' + newDB)
+  config.db.schemalock = false
+`,
+    post: `
+  t.after(async () => {
+    t.diagnostic('Disposing test database ' + newDB)
+    await db.query(sql\`
+      DROP DATABASE \${sql.ident(newDB)}
+    \`)
+    await db.dispose()
+  })
+`
+  }
+}
+
+const moviesTestJS = `\
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { getServer } = require('../helper')
+
+test('movies', async (t) => {
+  const server = await getServer(t)
+
+  {
+    const res = await server.inject({
+      method: 'GET',
+      url: '/movies'
+    })
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(res.json(), [])
+  }
+
+  let id
+  {
+    const res = await server.inject({
+      method: 'POST',
+      url: '/movies',
+      body: {
+        title: 'The Matrix'
+      }
+    })
+
+    assert.strictEqual(res.statusCode, 200)
+    const body = res.json()
+    assert.strictEqual(body.title, 'The Matrix')
+    assert.strictEqual(body.id !== undefined, true)
+    id = body.id
+  }
+
+  {
+    const res = await server.inject({
+      method: 'GET',
+      url: '/movies'
+    })
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(res.json(), [{
+      id,
+      title: 'The Matrix'
+    }])
+  }
+})
+`
+
+const moviesTestTS = `\
+import test from 'node:test'
+import assert from 'node:assert'
+import { getServer } from '../helper'
+
+test('movies', async (t) => {
+  const server = await getServer(t)
+
+  {
+    const res = await server.inject({
+      method: 'GET',
+      url: '/movies'
+    })
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(res.json(), [])
+  }
+
+  let id : Number
+  {
+    const res = await server.inject({
+      method: 'POST',
+      url: '/movies',
+      body: {
+        title: 'The Matrix'
+      }
+    })
+
+    assert.strictEqual(res.statusCode, 200)
+    const body = res.json()
+    assert.strictEqual(body.title, 'The Matrix')
+    assert.strictEqual(body.id !== undefined, true)
+    id = body.id as Number
+  }
+
+  {
+    const res = await server.inject({
+      method: 'GET',
+      url: '/movies'
+    })
+
+    assert.strictEqual(res.statusCode, 200)
+    assert.deepStrictEqual(res.json(), [{
+      id,
+      title: 'The Matrix'
+    }])
+  }
+})
+`
+
 function generateConfig (migrations, plugin, types, typescript, version) {
   const config = {
     $schema: `https://platformatic.dev/schemas/v${version}/db`,
@@ -64,7 +278,12 @@ function generateConfig (migrations, plugin, types, typescript, version) {
 
   if (plugin === true) {
     config.plugins = {
-      paths: [getPluginName(typescript)]
+      paths: [{
+        path: './plugins',
+        encapsulate: false
+      }, {
+        path: './routes'
+      }]
     }
   }
 
@@ -101,38 +320,6 @@ PLT_TYPESCRIPT=true
   return env
 }
 
-const JS_PLUGIN_WITH_TYPES_SUPPORT = `\
-/// <reference path="./global.d.ts" />
-'use strict'
-
-/** @param {import('fastify').FastifyInstance} app */
-module.exports = async function (app) {}
-`
-
-const TS_PLUGIN_WITH_TYPES_SUPPORT = `\
-/// <reference path="./global.d.ts" />
-import { FastifyInstance } from 'fastify'
-
-export default async function (app: FastifyInstance) {}
-`
-
-async function generatePluginWithTypesSupport (logger, currentDir, isTypescript) {
-  const pluginPath = resolve(currentDir, getPluginName(isTypescript))
-
-  const isPluginExists = await isFileAccessible(pluginPath)
-  if (isPluginExists) {
-    logger.info(`Plugin file ${pluginPath} found, skipping creation of plugin file.`)
-    return
-  }
-
-  const pluginTemplate = isTypescript
-    ? TS_PLUGIN_WITH_TYPES_SUPPORT
-    : JS_PLUGIN_WITH_TYPES_SUPPORT
-
-  await writeFile(pluginPath, pluginTemplate)
-  logger.info(`Plugin file created at ${relative(currentDir, pluginPath)}`)
-}
-
 export function getConnectionString (database) {
   return connectionStrings[database]
 }
@@ -201,7 +388,30 @@ export async function createDB ({ hostname, database = 'sqlite', port, migration
   }
 
   if (plugin) {
-    await generatePluginWithTypesSupport(logger, currentDir, typescript)
+    let jsHelper = { pre: '', config: '', post: '' }
+    switch (database) {
+      case 'sqlite':
+        jsHelper = jsHelperSqlite
+        break
+      case 'mysql':
+        jsHelper = jsHelperMySQL(connectionString)
+        break
+      case 'postgres':
+        jsHelper = jsHelperPostgres(connectionString)
+        break
+      case 'mariadb':
+        jsHelper = jsHelperMySQL(connectionString)
+        break
+    }
+    await generatePlugins(logger, currentDir, typescript, 'db', jsHelper)
+
+    if (createMigrations) {
+      if (typescript) {
+        await writeFile(join(currentDir, 'test', 'routes', 'movies.test.ts'), moviesTestTS)
+      } else {
+        await writeFile(join(currentDir, 'test', 'routes', 'movies.test.js'), moviesTestJS)
+      }
+    }
   }
 
   const output = {

package/src/ghaction.mjs

@@ -176,7 +176,7 @@ export const askStaticWorkspaceGHAction = async (logger, env, type, buildTS, pro
     {
       type: 'list',
       name: 'githubAction',
-      message: 'Do you want to create the github action to deploy this application to Platformatic Cloud static workspace?',
+      message: 'Do you want to create the github action to deploy this application to Platformatic Cloud?',
       default: true,
       choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
     }

package/src/runtime/create-runtime-cli.mjs

@@ -114,8 +114,8 @@ export async function createPlatformaticRuntime (_args) {
 
   const env = await createRuntime(logger, projectDir, version, servicesDir, entrypoint)
 
-  await askDynamicWorkspaceCreateGHAction(logger, env, 'service', false, projectDir)
   await askStaticWorkspaceGHAction(logger, env, 'service', false, projectDir)
+  await askDynamicWorkspaceCreateGHAction(logger, env, 'service', false, projectDir)
 }
 
 export async function createRuntimeService ({ servicesDir, names, logger }) {

package/src/service/create-service-cli.mjs

@@ -78,8 +78,11 @@ const createPlatformaticService = async (_args, opts = {}) => {
   const fastifyVersion = await getDependencyVersion('fastify')
 
   if (!opts.skipPackageJson) {
-    await createPackageJson(version, fastifyVersion, logger, projectDir, useTypescript, {}, {
-      '@platformatic/service': '^' + version
+    const test = useTypescript ? 'tsc && node --test dist/test/*/*.test.js' : 'node --test test/*/*.test.js'
+    await createPackageJson(version, fastifyVersion, logger, projectDir, useTypescript, {
+      test
+    }, {
+      '@platformatic/service': `^${version}`
     })
   }
   if (!opts.skipGitignore) {
@@ -103,8 +106,8 @@ const createPlatformaticService = async (_args, opts = {}) => {
   }
 
   if (!opts.skipGitHubActions) {
-    await askDynamicWorkspaceCreateGHAction(logger, env, 'service', useTypescript, projectDir)
     await askStaticWorkspaceGHAction(logger, env, 'service', useTypescript, projectDir)
+    await askDynamicWorkspaceCreateGHAction(logger, env, 'service', useTypescript, projectDir)
   }
 }
 

package/src/service/create-service.mjs

@@ -1,8 +1,9 @@
-import { writeFile, mkdir, readFile, appendFile } from 'fs/promises'
+import { writeFile, readFile, appendFile } from 'fs/promises'
 import { join } from 'path'
 import * as desm from 'desm'
 import { findServiceConfigFile, isFileAccessible } from '../utils.mjs'
 import { getTsConfig } from '../get-tsconfig.mjs'
+import { generatePlugins } from '../create-plugins.mjs'
 
 const TS_OUT_DIR = 'dist'
 
@@ -55,76 +56,6 @@ PLT_TYPESCRIPT=true
   return env
 }
 
-const JS_PLUGIN_WITH_TYPES_SUPPORT = `\
-/// <reference path="../global.d.ts" />
-'use strict'
-/** @param {import('fastify').FastifyInstance} fastify */
-module.exports = async function (fastify, opts) {
-  fastify.decorate('example', 'foobar')
-}
-`
-
-const TS_PLUGIN_WITH_TYPES_SUPPORT = `\
-/// <reference path="../global.d.ts" />
-import { FastifyInstance, FastifyPluginOptions } from 'fastify'
-
-export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
-  fastify.decorate('example', 'foobar')
-}
-`
-
-const JS_ROUTES_WITH_TYPES_SUPPORT = `\
-/// <reference path="../global.d.ts" />
-'use strict'
-/** @param {import('fastify').FastifyInstance} fastify */
-module.exports = async function (fastify, opts) {
-  fastify.get('/', async (request, reply) => {
-    return { hello: fastify.example }
-  })
-}
-`
-
-const TS_ROUTES_WITH_TYPES_SUPPORT = `\
-/// <reference path="../global.d.ts" />
-import { FastifyInstance, FastifyPluginOptions } from 'fastify'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    example: string
-  }
-}
-
-export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
-  fastify.get('/', async (request, reply) => {
-    return { hello: fastify.example }
-  })
-}
-`
-
-async function generatePluginWithTypesSupport (logger, currentDir, isTypescript) {
-  await mkdir(join(currentDir, 'plugins'))
-  const pluginTemplate = isTypescript
-    ? TS_PLUGIN_WITH_TYPES_SUPPORT
-    : JS_PLUGIN_WITH_TYPES_SUPPORT
-  const pluginName = isTypescript
-    ? 'example.ts'
-    : 'example.js'
-  await writeFile(join(currentDir, 'plugins', pluginName), pluginTemplate)
-  logger.info('Plugins folder "plugins" successfully created.')
-}
-
-async function generateRouteWithTypesSupport (logger, currentDir, isTypescript) {
-  await mkdir(join(currentDir, 'routes'))
-  const routesTemplate = isTypescript
-    ? TS_ROUTES_WITH_TYPES_SUPPORT
-    : JS_ROUTES_WITH_TYPES_SUPPORT
-  const routesName = isTypescript
-    ? 'root.ts'
-    : 'root.js'
-  await writeFile(join(currentDir, 'routes', routesName), routesTemplate)
-  logger.info('Routes folder "routes" successfully created.')
-}
-
 async function createService ({ hostname, port, typescript = false }, logger, currentDir = process.cwd(), version) {
   if (!version) {
     const pkg = await readFile(desm.join(import.meta.url, '..', '..', 'package.json'))
@@ -167,19 +98,7 @@ async function createService ({ hostname, port, typescript = false }, logger, cu
     }
   }
 
-  const pluginFolderExists = await isFileAccessible('plugins', currentDir)
-  if (!pluginFolderExists) {
-    await generatePluginWithTypesSupport(logger, currentDir, typescript)
-  } else {
-    logger.info('Plugins folder "plugins" found, skipping creation of plugins folder.')
-  }
-
-  const routeFolderExists = await isFileAccessible('routes', currentDir)
-  if (!routeFolderExists) {
-    await generateRouteWithTypesSupport(logger, currentDir, typescript)
-  } else {
-    logger.info('Routes folder "routes" found, skipping creation of routes folder.')
-  }
+  await generatePlugins(logger, currentDir, typescript, 'service')
 
   const output = {
     PLT_SERVER_LOGGER_LEVEL: 'info',

package/test/db/create-db.test.mjs

@@ -88,7 +88,8 @@ test('creates project with no typescript', async ({ equal }) => {
   const migrationFileUndo = readFileSync(pathToMigrationFileUndo, 'utf8')
   equal(migrationFileUndo, moviesMigrationUndo)
 
-  equal(await isFileAccessible(join(tmpDir, 'plugin.js')), true)
+  equal(await isFileAccessible(join(tmpDir, 'routes', 'root.js')), true)
+  equal(await isFileAccessible(join(tmpDir, 'plugins', 'example.js')), true)
 })
 
 test('creates project with no typescript and no plugin', async ({ equal }) => {
@@ -202,9 +203,15 @@ test('creates project with typescript', async ({ equal, same }) => {
   const migrationFileUndo = readFileSync(pathToMigrationFileUndo, 'utf8')
   equal(migrationFileUndo, moviesMigrationUndo)
 
-  same(plugins.paths, ['plugin.ts'])
+  same(plugins.paths, [{
+    path: './plugins',
+    encapsulate: false
+  }, {
+    path: './routes'
+  }])
   equal(plugins.typescript, '{PLT_TYPESCRIPT}')
-  equal(await isFileAccessible(join(tmpDir, 'plugin.ts')), true)
+  equal(await isFileAccessible(join(tmpDir, 'plugins', 'example.ts')), true)
+  equal(await isFileAccessible(join(tmpDir, 'routes', 'root.ts')), true)
   equal(await isFileAccessible(join(tmpDir, 'tsconfig.json')), true)
 })
 
@@ -256,7 +263,8 @@ test('creates project with tsconfig already present', async ({ ok }) => {
 })
 
 test('creates project with plugin already present', async ({ ok }) => {
-  const pathToPlugin = join(tmpDir, 'plugin.js')
+  const pathToPlugin = join(tmpDir, 'routes', 'root.js')
+  mkdirSync(join(tmpDir, 'routes'))
   writeFileSync(pathToPlugin, 'test')
   const params = {
     hostname: 'myhost',
@@ -265,7 +273,7 @@ test('creates project with plugin already present', async ({ ok }) => {
     types: true
   }
   await createDB(params, fakeLogger, tmpDir)
-  ok(log.includes(`Plugin file ${pathToPlugin} found, skipping creation of plugin file.`))
+  ok(log.includes('Routes folder "routes" found, skipping creation of routes folder.'))
 })
 
 test('creates project with no default migrations', async ({ notOk }) => {

package/test/service/create-service.test.mjs

@@ -68,6 +68,10 @@ test('creates service with typescript', async ({ equal, same, ok }) => {
   ok(await isFileAccessible(join(tmpDir, 'tsconfig.json')))
   ok(await isFileAccessible(join(tmpDir, 'plugins', 'example.ts')))
   ok(await isFileAccessible(join(tmpDir, 'routes', 'root.ts')))
+
+  ok(await isFileAccessible(join(tmpDir, 'test', 'plugins', 'example.test.ts')))
+  ok(await isFileAccessible(join(tmpDir, 'test', 'routes', 'root.test.ts')))
+  ok(await isFileAccessible(join(tmpDir, 'test', 'helper.ts')))
 })
 
 test('creates service with javascript', async ({ equal, same, ok }) => {
@@ -101,6 +105,10 @@ test('creates service with javascript', async ({ equal, same, ok }) => {
   same(plugins, { paths: [{ path: './plugins', encapsulate: false }, './routes'] })
   ok(await isFileAccessible(join(tmpDir, 'plugins', 'example.js')))
   ok(await isFileAccessible(join(tmpDir, 'routes', 'root.js')))
+
+  ok(await isFileAccessible(join(tmpDir, 'test', 'plugins', 'example.test.js')))
+  ok(await isFileAccessible(join(tmpDir, 'test', 'routes', 'root.test.js')))
+  ok(await isFileAccessible(join(tmpDir, 'test', 'helper.js')))
 })
 
 test('creates project with configuration already present', async ({ ok }) => {