@platformatic/generators 1.19.0 → 1.20.0

package/index.js

@@ -1,10 +1,12 @@
 'use strict'
 
 const { BaseGenerator } = require('./lib/base-generator')
+const { StackableGenerator } = require('./lib/stackable-generator')
 const { generateTests } = require('./lib/create-plugin')
 const { addPrefixToEnv } = require('./lib/utils')
 module.exports = {
   addPrefixToEnv,
   BaseGenerator,
+  StackableGenerator,
   generateTests
 }

package/lib/create-plugin.js

@@ -54,7 +54,7 @@ function testHelperJS (mod, customization = { pre: '', post: '', config: '' }) {
 
 const { join } = require('node:path')
 const { readFile } = require('node:fs/promises')
-const { buildServer } = require('@platformatic/${mod}')
+const { buildServer } = require('${mod}')
 ${customization.requires || ''}
 
 async function getServer (t) {

package/lib/create-stackable-cli.js

@@ -0,0 +1,167 @@
+'use strict'
+
+const { kebabCase } = require('change-case-all')
+
+function getJsStackableStartCli () {
+  return `\
+#!/usr/bin/env node
+'use strict'
+  
+const stackable = require('../index')
+const { start } = require('@platformatic/service')
+const { printAndExitLoadConfigError } = require('@platformatic/config')
+  
+start(stackable, process.argv.splice(2)).catch(printAndExitLoadConfigError)
+`
+}
+
+function getTsStackableStartCli () {
+  return `\
+#!/usr/bin/env node
+import stackable from '../index'
+import { start } from '@platformatic/service'
+import { printAndExitLoadConfigError } from '@platformatic/config'
+
+start(stackable, process.argv.splice(2)).catch(printAndExitLoadConfigError)
+`
+}
+
+function getJsStackableCreateCli (stackableName) {
+  return `\
+#!/usr/bin/env node
+'use strict'
+
+const { join } = require('node:path')
+const pino = require('pino')
+const pretty = require('pino-pretty')
+const minimist = require('minimist')
+const { Generator } = require('../lib/generator')
+  
+async function execute () {
+  const logger = pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+  
+  const args = minimist(process.argv.slice(2), {
+    string: ['dir', 'port', 'hostname'],
+    boolean: ['typescript', 'install', 'plugin', 'git'],
+    default: {
+      dir: join(process.cwd(), '${kebabCase(stackableName + '-app')}'),
+      port: 3042,
+      hostname: '0.0.0.0',
+      plugin: true,
+      typescript: false,
+      git: false,
+      install: true
+    }
+  })
+  
+  const generator = new Generator({ logger })
+  
+  generator.setConfig({
+    port: args.port,
+    hostname: args.hostname,
+    plugin: args.plugin,
+    tests: args.plugin,
+    typescript: args.typescript,
+    initGitRepository: args.git,
+    targetDirectory: args.dir
+  })
+  
+  await generator.run()
+  
+  logger.info('Application created successfully! Run \`npm run start\` to start an application.')
+}
+  
+execute()
+`
+}
+
+function getTsStackableCreateCli (stackableName) {
+  return `\
+#!/usr/bin/env node
+import { join } from 'node:path'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import minimist from 'minimist'
+import { Generator } from '../lib/generator'
+
+async function execute () {
+  const logger = pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+
+  const args = minimist(process.argv.slice(2), {
+    string: ['dir', 'port', 'hostname'],
+    boolean: ['typescript', 'install', 'plugin', 'git'],
+    default: {
+      dir: join(process.cwd(), '${kebabCase(stackableName + '-app')}'),
+      port: 3042,
+      hostname: '0.0.0.0',
+      plugin: true,
+      typescript: false,
+      git: false,
+      install: true
+    }
+  })
+
+  const generator = new Generator({ logger })
+
+  generator.setConfig({
+    port: args.port,
+    hostname: args.hostname,
+    plugin: args.plugin,
+    tests: args.plugin,
+    typescript: args.typescript,
+    initGitRepository: args.git,
+    targetDirectory: args.dir
+  })
+
+  await generator.run()
+
+  logger.info('Application created successfully! Run \`npm run start\` to start an application.')
+}
+
+execute()
+`
+}
+
+function generateStackableCli (typescript, stackableName) {
+  if (typescript) {
+    return [
+      {
+        path: 'cli',
+        file: 'start.ts',
+        contents: getTsStackableStartCli(),
+        options: { mode: 0o755 }
+      },
+      {
+        path: 'cli',
+        file: 'create.ts',
+        contents: getTsStackableCreateCli(stackableName),
+        options: { mode: 0o755 }
+      }
+    ]
+  }
+
+  return [
+    {
+      path: 'cli',
+      file: 'start.js',
+      contents: getJsStackableStartCli(),
+      options: { mode: 0o755 }
+    },
+    {
+      path: 'cli',
+      file: 'create.js',
+      contents: getJsStackableCreateCli(stackableName),
+      options: { mode: 0o755 }
+    }
+  ]
+}
+
+module.exports = {
+  generateStackableCli
+}

package/lib/create-stackable-files.js

@@ -0,0 +1,344 @@
+'use strict'
+
+const { pascalCase, camelCase, capitalCase, kebabCase } = require('change-case-all')
+
+function getJsStackableIndexFile (stackableName) {
+  return `\
+'use strict'
+
+const { platformaticService } = require('@platformatic/service')
+const { schema } = require('./lib/schema')
+const { Generator } = require('./lib/generator')
+
+async function stackable (fastify, opts) {
+  await fastify.register(platformaticService, opts)
+  await fastify.register(require('./plugins/example'), opts)
+}
+
+stackable.configType = '${kebabCase(stackableName + '-app')}'
+stackable.schema = schema
+stackable.Generator = Generator
+stackable.configManagerConfig = {
+  schema,
+  envWhitelist: ['PORT', 'HOSTNAME'],
+  allowToWatch: ['.env'],
+  schemaOptions: {
+    useDefaults: true,
+    coerceTypes: true,
+    allErrors: true,
+    strict: false
+  },
+  transformConfig: async () => {}
+}
+
+// break Fastify encapsulation
+stackable[Symbol.for('skip-override')] = true
+
+module.exports = stackable
+`
+}
+
+function getTsStackableIndexFile (stackableName) {
+  const stackableConfigType = pascalCase(stackableName + 'Config')
+
+  return `\
+import { platformaticService, Stackable } from '@platformatic/service'
+import { schema } from './lib/schema'
+import { Generator } from './lib/generator'
+import { ${stackableConfigType} } from './config'
+
+const stackable: Stackable<${stackableConfigType}> = async function (fastify, opts) {
+  await fastify.register(platformaticService, opts)
+  await fastify.register(require('./plugins/example'), opts)
+}
+
+stackable.configType = '${kebabCase(stackableName + '-app')}'
+stackable.schema = schema
+stackable.Generator = Generator
+stackable.configManagerConfig = {
+  schema,
+  envWhitelist: ['PORT', 'HOSTNAME'],
+  allowToWatch: ['.env'],
+  schemaOptions: {
+    useDefaults: true,
+    coerceTypes: true,
+    allErrors: true,
+    strict: false
+  },
+  transformConfig: async () => {}
+}
+
+// break Fastify encapsulation
+// @ts-ignore 
+stackable[Symbol.for('skip-override')] = true
+
+export default stackable
+`
+}
+
+function getStackableIndexTypesFile (stackableName) {
+  const stackableConfigType = pascalCase(stackableName + 'Config')
+
+  return `\
+import { FastifyInstance } from 'fastify'
+import { PlatformaticApp } from '@platformatic/service'
+import { ${stackableConfigType} } from './config'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    platformatic: PlatformaticApp<${stackableConfigType}>
+  }
+}
+`
+}
+
+function getJsStackableGeneratorFile (stackableName) {
+  const stackableGeneratorType = pascalCase(stackableName + 'Generator')
+
+  return `\
+'use strict'
+
+const { Generator: ServiceGenerator } = require('@platformatic/service')
+const { schema } = require('./schema')
+
+class ${stackableGeneratorType} extends ServiceGenerator {
+  getDefaultConfig () {
+    const defaultBaseConfig = super.getDefaultConfig()
+    const defaultConfig = {
+      greeting: 'Hello world!'
+    }
+    return Object.assign({}, defaultBaseConfig, defaultConfig)
+  }
+
+  async _getConfigFileContents () {
+    const baseConfig = await super._getConfigFileContents()
+    const config = {
+      $schema: './stackable.schema.json',
+      greeting: {
+        text: '{PLT_GREETING_TEXT}'
+      }
+    }
+    return Object.assign({}, baseConfig, config)
+  }
+
+  async _beforePrepare () {
+    super._beforePrepare()
+
+    this.config.env = {
+      PLT_GREETING_TEXT: this.config.greeting ?? 'Hello world!',
+      ...this.config.env
+    }
+  }
+
+  async _afterPrepare () {
+    this.addFile({
+      path: '',
+      file: 'stackable.schema.json',
+      contents: JSON.stringify(schema, null, 2)
+    })
+  }
+}
+
+module.exports = ${stackableGeneratorType}
+module.exports.Generator = ${stackableGeneratorType}
+`
+}
+
+function getTsStackableGeneratorFile (stackableName) {
+  const stackableGeneratorType = pascalCase(stackableName + 'Generator')
+
+  return `\
+import { Generator as ServiceGenerator } from '@platformatic/service'
+import { BaseGenerator } from '@platformatic/generators'
+import { schema } from './schema'
+
+class ${stackableGeneratorType} extends ServiceGenerator {
+  getDefaultConfig (): BaseGenerator.JSONValue {
+    const defaultBaseConfig = super.getDefaultConfig()
+    const defaultConfig = {
+      greeting: 'Hello world!'
+    }
+    return Object.assign({}, defaultBaseConfig, defaultConfig)
+  }
+
+  async _getConfigFileContents (): Promise<BaseGenerator.JSONValue> {
+    const baseConfig = await super._getConfigFileContents()
+    const config = {
+      $schema: './stackable.schema.json',
+      greeting: {
+        text: '{PLT_GREETING_TEXT}'
+      }
+    }
+    return Object.assign({}, baseConfig, config)
+  }
+
+  async _beforePrepare () {
+    super._beforePrepare()
+
+    this.config.env = {
+      PLT_GREETING_TEXT: this.config.greeting ?? 'Hello world!',
+      ...this.config.env
+    }
+  }
+
+  async _afterPrepare () {
+    this.addFile({
+      path: '',
+      file: 'stackable.schema.json',
+      contents: JSON.stringify(schema, null, 2)
+    })
+  }
+}
+
+export default ${stackableGeneratorType}
+export { ${stackableGeneratorType} as Generator }
+`
+}
+
+function getJsStackableSchemaFile (stackableName) {
+  const schemaId = kebabCase(stackableName)
+  const schemaTitle = capitalCase(stackableName + 'Config')
+  const schemaVarName = camelCase(stackableName + 'Schema')
+
+  return `\
+'use strict'
+
+const { schema } = require('@platformatic/service')
+
+const ${schemaVarName} = {
+  ...schema.schema,
+  $id: '${schemaId}',
+  title: '${schemaTitle}',
+  properties: {
+    ...schema.schema.properties,
+    greeting: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string'
+        }
+      },
+      required: ['text'],
+      additionalProperties: false
+    }
+  }
+}
+
+module.exports.schema = ${schemaVarName}
+
+if (require.main === module) {
+  console.log(JSON.stringify(${schemaVarName}, null, 2))
+}
+`
+}
+
+function getTsStackableSchemaFile (stackableName) {
+  const schemaId = kebabCase(stackableName)
+  const schemaTitle = capitalCase(stackableName + 'Config')
+  const schemaVarName = camelCase(stackableName + 'Schema')
+
+  return `\
+import { schema } from '@platformatic/service'
+
+const ${schemaVarName} = {
+  ...schema.schema,
+  $id: '${schemaId}',
+  title: '${schemaTitle}',
+  properties: {
+    ...schema.schema.properties,
+    greeting: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string'
+        }
+      },
+      required: ['text'],
+      additionalProperties: false
+    }
+  }
+}
+
+export { ${schemaVarName} as schema }
+
+if (require.main === module) {
+  console.log(JSON.stringify(${schemaVarName}, null, 2))
+}
+`
+}
+
+function getStackableConfigTypesFile (stackableName) {
+  const stackableConfigType = pascalCase(stackableName + 'Config')
+
+  return `\
+// Use npm run build:config to generate this file from the Stackable schema
+export interface ${stackableConfigType} {
+  greeting?: {
+    text: string;
+  };
+}
+`
+}
+
+function generateStackableFiles (typescript, stackableName) {
+  if (typescript) {
+    return [
+      {
+        path: '',
+        file: 'index.ts',
+        contents: getTsStackableIndexFile(stackableName)
+      },
+      {
+        path: '',
+        file: 'index.d.ts',
+        contents: getStackableIndexTypesFile(stackableName)
+      },
+      {
+        path: '',
+        file: 'config.d.ts',
+        contents: getStackableConfigTypesFile(stackableName)
+      },
+      {
+        path: 'lib',
+        file: 'generator.ts',
+        contents: getTsStackableGeneratorFile(stackableName)
+      },
+      {
+        path: 'lib',
+        file: 'schema.ts',
+        contents: getTsStackableSchemaFile(stackableName)
+      }
+    ]
+  }
+  return [
+    {
+      path: '',
+      file: 'index.js',
+      contents: getJsStackableIndexFile(stackableName)
+    },
+    {
+      path: '',
+      file: 'index.d.ts',
+      contents: getStackableIndexTypesFile(stackableName)
+    },
+    {
+      path: '',
+      file: 'config.d.ts',
+      contents: getStackableConfigTypesFile(stackableName)
+    },
+    {
+      path: 'lib',
+      file: 'generator.js',
+      contents: getJsStackableGeneratorFile(stackableName)
+    },
+    {
+      path: 'lib',
+      file: 'schema.js',
+      contents: getJsStackableSchemaFile(stackableName)
+    }
+  ]
+}
+
+module.exports = {
+  generateStackableFiles
+}

package/lib/create-stackable-plugin.js

@@ -0,0 +1,48 @@
+'use strict'
+
+function getJsStackablePluginFile () {
+  return `\
+/// <reference path="../index.d.ts" />
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  const config = fastify.platformatic.config
+  const greeting = config.greeting
+  fastify.log.info({ greeting }, 'Loading stackable greeting plugin.')
+  fastify.decorate('greeting', greeting)
+}
+`
+}
+
+function getTsStackablePluginFile () {
+  return `\
+/// <reference path="../index.d.ts" />
+import { FastifyInstance, FastifyPluginOptions } from 'fastify'
+
+export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
+  const config = fastify.platformatic.config
+  const greeting = config.greeting
+  fastify.log.info({ greeting }, 'Loading stackable greeting plugin.')
+  fastify.decorate('greeting', greeting)
+}
+`
+}
+
+function generateStackablePlugins (typescript) {
+  if (typescript) {
+    return [{
+      path: 'plugins',
+      file: 'example.ts',
+      contents: getTsStackablePluginFile()
+    }]
+  }
+  return [{
+    path: 'plugins',
+    file: 'example.js',
+    contents: getJsStackablePluginFile()
+  }]
+}
+
+module.exports = {
+  generateStackablePlugins
+}

package/lib/file-generator.js

@@ -24,7 +24,7 @@ class FileGenerator {
     this.targetDirectory = dir
   }
 
-  addFile ({ path, file, contents }) {
+  addFile ({ path, file, contents, options = {} }) {
     const fileObject = this.getFileObject(file, path)
     if (path.startsWith('/')) {
       path = path.substring(1)
@@ -32,7 +32,7 @@ class FileGenerator {
     if (fileObject) {
       fileObject.contents = contents
     } else {
-      this.files.push({ path, file, contents })
+      this.files.push({ path, file, contents, options })
     }
   }
 
@@ -62,7 +62,7 @@ class FileGenerator {
         await safeMkdir(baseDir)
       }
       const fullFilePath = join(baseDir, fileToWrite.file)
-      await writeFile(fullFilePath, fileToWrite.contents)
+      await writeFile(fullFilePath, fileToWrite.contents, fileToWrite.options)
       this.logger.info(`${fullFilePath} written!`)
     }
   }

package/lib/stackable-generator.js

@@ -0,0 +1,309 @@
+'use strict'
+
+const { join } = require('node:path')
+const { readFile } = require('node:fs/promises')
+const { kebabCase } = require('change-case-all')
+const { stripVersion, getLatestNpmVersion } = require('./utils')
+const { FileGenerator } = require('./file-generator')
+const { PrepareError } = require('./errors')
+const { generateGitignore } = require('./create-gitignore')
+const { generateStackableCli } = require('./create-stackable-cli')
+const { generateStackableFiles } = require('./create-stackable-files')
+const { generateStackablePlugins } = require('./create-stackable-plugin')
+
+/* c8 ignore start */
+const fakeLogger = {
+  info: () => {},
+  warn: () => {},
+  debug: () => {},
+  trace: () => {},
+  error: () => {}
+}
+/* c8 ignore start */
+
+class StackableGenerator extends FileGenerator {
+  constructor (opts = {}) {
+    super(opts)
+    this.files = []
+    this.logger = opts.logger || fakeLogger
+    this.questions = []
+    this.pkgData = null
+    this.inquirer = opts.inquirer || null
+    this.targetDirectory = opts.targetDirectory || null
+    this.config = this.getDefaultConfig()
+    this.packages = []
+  }
+
+  getDefaultConfig () {
+    return {
+      stackableName: 'my-stackable',
+      typescript: false,
+      initGitRepository: false,
+      dependencies: {},
+      devDependencies: {}
+    }
+  }
+
+  setConfigFields (fields) {
+    for (const field of fields) {
+      this.config[field.configValue] = field.value
+    }
+  }
+
+  setConfig (config) {
+    if (!config) {
+      this.config = this.getDefaultConfig()
+    }
+    const oldConfig = this.config
+    this.config = {
+      ...this.getDefaultConfig(),
+      ...oldConfig,
+      ...config
+    }
+
+    if (this.config.targetDirectory) {
+      this.targetDirectory = this.config.targetDirectory
+    }
+  }
+
+  /* c8 ignore start */
+  async ask () {
+    if (this.inquirer) {
+      await this.prepareQuestions()
+      const newConfig = await this.inquirer.prompt(this.questions)
+      this.setConfig({
+        ...this.config,
+        ...newConfig
+      })
+    }
+  }
+
+  async prepare () {
+    try {
+      this.reset()
+      await this.getFastifyVersion()
+      await this.getPlatformaticVersion()
+
+      await this._beforePrepare()
+
+      // generate package.json
+      const template = await this.generatePackageJson()
+      this.addFile({
+        path: '',
+        file: 'package.json',
+        contents: JSON.stringify(template, null, 2)
+      })
+
+      if (this.config.typescript) {
+        // create tsconfig.json
+        this.addFile({
+          path: '',
+          file: 'tsconfig.json',
+          contents: JSON.stringify(this.getTsConfig(), null, 2)
+        })
+      }
+
+      const typescript = this.config.typescript
+      const stackableName = this.config.stackableName
+
+      this.files.push(...generateStackableFiles(typescript, stackableName))
+      this.files.push(...generateStackableCli(typescript, stackableName))
+      this.files.push(...generateStackablePlugins(typescript))
+      this.files.push(generateGitignore())
+
+      await this._afterPrepare()
+
+      return {
+        targetDirectory: this.targetDirectory
+      }
+    } catch (err) {
+      if (err.code?.startsWith('PLT_GEN')) {
+        // throw the same error
+        throw err
+      }
+      const _err = new PrepareError(err.message)
+      _err.cause = err
+      throw _err
+    }
+  }
+
+  getTsConfig () {
+    return {
+      compilerOptions: {
+        module: 'commonjs',
+        esModuleInterop: true,
+        target: 'es2020',
+        sourceMap: true,
+        pretty: true,
+        noEmitOnError: true,
+        incremental: true,
+        strict: true,
+        outDir: 'dist'
+      },
+      watchOptions: {
+        watchFile: 'fixedPollingInterval',
+        watchDirectory: 'fixedPollingInterval',
+        fallbackPolling: 'dynamicPriority',
+        synchronousWatchDirectory: true,
+        excludeDirectories: ['**/node_modules', 'dist']
+      }
+    }
+  }
+
+  async prepareQuestions () {
+    if (!this.config.targetDirectory) {
+      // directory
+      this.questions.push({
+        type: 'input',
+        name: 'targetDirectory',
+        message: 'Where would you like to create your project?',
+        default: 'platformatic'
+      })
+    }
+
+    this.questions.push({
+      type: 'input',
+      name: 'stackableName',
+      message: 'What is the name of the stackable?',
+      default: 'my-stackable'
+    })
+
+    // typescript
+    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 }]
+    })
+  }
+
+  /**
+   * Reads the content of package.json and returns it as an object
+   * @returns Object
+   */
+  async readPackageJsonFile () {
+    if (this.pkgData) {
+      return this.pkgData
+    }
+    const currentPackageJsonPath = join(__dirname, '..', 'package.json')
+    this.pkgData = JSON.parse(await readFile(currentPackageJsonPath, 'utf8'))
+    return this.pkgData
+  }
+
+  async getFastifyVersion () {
+    const pkgData = await this.readPackageJsonFile()
+    this.fastifyVersion = stripVersion(pkgData.dependencies.fastify)
+  }
+
+  async getPlatformaticVersion () {
+    const pkgData = await this.readPackageJsonFile()
+    this.platformaticVersion = stripVersion(pkgData.version)
+  }
+
+  async generatePackageJson () {
+    const dependencies = {
+      '@platformatic/config': `^${this.platformaticVersion}`,
+      '@platformatic/service': `^${this.platformaticVersion}`,
+      'json-schema-to-typescript': '^13.0.0',
+      pino: '^8.0.0',
+      'pino-pretty': '^10.0.0',
+      minimist: '^1.2.0',
+      platformatic: `^${this.platformaticVersion}`
+    }
+
+    const devDependencies = {
+      fastify: `^${this.fastifyVersion}`
+    }
+
+    const npmPackageName = kebabCase(this.config.stackableName)
+    const createStackableCommand = kebabCase('create-' + this.config.stackableName)
+    const startStackableCommand = kebabCase('start-' + this.config.stackableName)
+
+    if (this.config.typescript) {
+      const packageJsonFile = await readFile(join(__dirname, '..', 'package.json'), 'utf-8')
+      const typescriptVersion = JSON.parse(packageJsonFile).devDependencies.typescript
+
+      return {
+        name: npmPackageName,
+        main: 'dist/index.js',
+        bin: {
+          [createStackableCommand]: './dist/cli/create.js',
+          [startStackableCommand]: './dist/cli/start.js'
+        },
+        scripts: {
+          build: 'tsc --build',
+          'build:config': 'node ./dist/lib/schema.js | json2ts > config.d.ts',
+          clean: 'rm -fr ./dist'
+        },
+        devDependencies: {
+          ...devDependencies,
+          '@types/minimist': '^1.2.5',
+          typescript: typescriptVersion,
+          ...this.config.devDependencies
+        },
+        dependencies: {
+          ...dependencies,
+          '@platformatic/generators': `^${this.platformaticVersion}`,
+          ...this.config.dependencies
+        },
+        engines: {
+          node: '^18.8.0 || >=20.6.0'
+        }
+      }
+    }
+
+    return {
+      name: npmPackageName,
+      main: 'index.js',
+      bin: {
+        [createStackableCommand]: './cli/create.js',
+        [startStackableCommand]: './cli/start.js'
+      },
+      scripts: {
+        'build:config': 'node lib/schema.js | json2ts > config.d.ts'
+      },
+      devDependencies: {
+        ...devDependencies,
+        ...this.config.devDependencies
+      },
+      dependencies: {
+        ...dependencies,
+        ...this.config.dependencies
+      },
+      engines: {
+        node: '^18.8.0 || >=20.6.0'
+      }
+    }
+  }
+
+  async run () {
+    const metadata = await this.prepare()
+    await this.writeFiles()
+    return metadata
+  }
+
+  async addPackage (pkg) {
+    this.config.dependencies[pkg.name] = 'latest'
+    try {
+      const version = await getLatestNpmVersion(pkg.name)
+      if (version) {
+        this.config.dependencies[pkg.name] = version
+      }
+    } catch (err) {
+      this.logger.warn(`Could not get latest version for ${pkg.name}, setting it to latest`)
+    }
+    this.packages.push(pkg)
+  }
+
+  // implement in the subclass
+  /* c8 ignore next 1 */
+  async postInstallActions () {}
+  async _beforePrepare () {}
+  async _afterPrepare () {}
+  async _getConfigFileContents () { return {} }
+  async _generateEnv () {}
+}
+
+module.exports = StackableGenerator
+module.exports.StackableGenerator = StackableGenerator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/generators",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "Main classes and utils for generators.",
   "main": "index.js",
   "keywords": [],
@@ -9,20 +9,22 @@
   "dependencies": {
     "@fastify/error": "^3.4.1",
     "boring-name-generator": "^1.0.3",
-    "fastify": "^4.24.3",
-    "pino": "^8.16.1",
-    "undici": "^6.3.0"
+    "change-case-all": "^2.1.0",
+    "fastify": "^4.26.0",
+    "pino": "^8.17.2",
+    "undici": "^6.6.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",
-    "c8": "^9.0.0",
+    "borp": "^0.9.0",
+    "c8": "^9.1.0",
     "glob": "^10.3.10",
     "snazzy": "^9.0.0",
     "standard": "^17.1.0",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.3"
   },
   "scripts": {
     "lint": "standard | snazzy",
-    "test": "pnpm run lint && c8 --100 -x fixtures -x test node ./test/runner.js"
+    "test": "pnpm run lint && borp -C -X fixtures -X test --concurrency=1"
   }
 }

package/test/base-generator.test.js

@@ -74,7 +74,8 @@ test('extended class should generate config', async (t) => {
   assert.deepEqual(configFile, {
     path: '',
     file: 'platformatic.json',
-    contents: JSON.stringify({ foo: 'bar' }, null, 2)
+    contents: JSON.stringify({ foo: 'bar' }, null, 2),
+    options: {}
   })
 })
 

package/test/stackable-generator.test.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const { readFile, rm } = require('node:fs/promises')
+const { test, afterEach } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+
+const { fakeLogger, getTempDir } = require('./helpers')
+const { StackableGenerator } = require('../lib/stackable-generator')
+
+afterEach(async () => {
+  try {
+    await rm(join(__dirname, 'tmp'), { recursive: true })
+  } catch (err) {
+    // do nothing
+  }
+})
+
+test('should create a stackable project without typescript', async (t) => {
+  const dir = await getTempDir()
+  const gen = new StackableGenerator({
+    logger: fakeLogger
+  })
+
+  gen.setConfig({
+    targetDirectory: dir
+  })
+
+  await gen.run()
+  // check files are created
+  const packageJson = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'))
+  assert.ok(packageJson.scripts)
+  assert.ok(packageJson.dependencies)
+  assert.ok(packageJson.engines)
+
+  const indexFile = await readFile(join(dir, 'index.js'), 'utf8')
+  assert.ok(indexFile.length > 0)
+
+  const indexTypesFile = await readFile(join(dir, 'index.d.ts'), 'utf8')
+  assert.ok(indexTypesFile.length > 0)
+
+  const schemaFile = await readFile(join(dir, 'lib', 'schema.js'), 'utf8')
+  assert.ok(schemaFile.length > 0)
+
+  const generatorFile = await readFile(join(dir, 'lib', 'generator.js'), 'utf8')
+  assert.ok(generatorFile.length > 0)
+
+  const startCommandFile = await readFile(join(dir, 'cli', 'start.js'), 'utf8')
+  assert.ok(startCommandFile.length > 0)
+
+  const createCommandFile = await readFile(join(dir, 'cli', 'create.js'), 'utf8')
+  assert.ok(createCommandFile.length > 0)
+
+  const gitignore = await readFile(join(dir, '.gitignore'), 'utf8')
+  assert.ok(gitignore.length > 0)
+})
+
+test('should create a stackable project with typescript', async (t) => {
+  const dir = await getTempDir()
+  const gen = new StackableGenerator({
+    logger: fakeLogger
+  })
+
+  gen.setConfig({
+    targetDirectory: dir,
+    typescript: true
+  })
+
+  await gen.run()
+  // check files are created
+  const packageJson = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'))
+  assert.ok(packageJson.scripts)
+  assert.ok(packageJson.dependencies)
+  assert.ok(packageJson.engines)
+
+  const indexFile = await readFile(join(dir, 'index.ts'), 'utf8')
+  assert.ok(indexFile.length > 0)
+
+  const indexTypesFile = await readFile(join(dir, 'index.d.ts'), 'utf8')
+  assert.ok(indexTypesFile.length > 0)
+
+  const schemaFile = await readFile(join(dir, 'lib', 'schema.ts'), 'utf8')
+  assert.ok(schemaFile.length > 0)
+
+  const generatorFile = await readFile(join(dir, 'lib', 'generator.ts'), 'utf8')
+  assert.ok(generatorFile.length > 0)
+
+  const startCommandFile = await readFile(join(dir, 'cli', 'start.ts'), 'utf8')
+  assert.ok(startCommandFile.length > 0)
+
+  const createCommandFile = await readFile(join(dir, 'cli', 'create.ts'), 'utf8')
+  assert.ok(createCommandFile.length > 0)
+
+  const gitignore = await readFile(join(dir, '.gitignore'), 'utf8')
+  assert.ok(gitignore.length > 0)
+})