@platformatic/generators 2.0.0-alpha.8 → 2.0.0

package/lib/create-stackable-tests.js

@@ -1,397 +0,0 @@
-'use strict'
-
-const { kebabCase } = require('change-case-all')
-
-function getJsStackableIndexTestFile (stackableName) {
-  const configType = kebabCase(stackableName + '-app')
-
-  return `\
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const stackable = require('../index')
-const { schema } = require('../lib/schema')
-const { Generator } = require('../lib/generator')
-
-test('should export stackable interface', async () => {
-  assert.strictEqual(typeof stackable, 'function')
-  assert.strictEqual(stackable.configType, '${configType}')
-  assert.deepStrictEqual(stackable.schema, schema)
-  assert.deepStrictEqual(stackable.Generator, Generator)
-  assert.ok(stackable.configManagerConfig)
-  assert.ok(typeof stackable.transformConfig, 'function')
-})
-`
-}
-
-function getTsStackableIndexTestFile (stackableName) {
-  const configType = kebabCase(stackableName + '-app')
-
-  return `\
-import test from 'node:test'
-import assert from 'node:assert'
-import stackable from '../index'
-import { schema } from '../lib/schema'
-import { Generator } from '../lib/generator'
-
-test('should export stackable interface', async () => {
-  assert.strictEqual(typeof stackable, 'function')
-  assert.strictEqual(stackable.configType, '${configType}')
-  assert.deepStrictEqual(stackable.schema, schema)
-  assert.deepStrictEqual(stackable.Generator, Generator)
-  assert.ok(stackable.configManagerConfig)
-  assert.ok(typeof stackable.transformConfig, 'function')
-})
-`
-}
-
-function getJsStackableSchemaTestFile (stackableName) {
-  const schemaId = kebabCase(stackableName)
-
-  return `\
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const { schema } = require('../index')
-
-test('should export stackable schema', async () => {
-  assert.strictEqual(schema.$id, '${schemaId}')
-  assert.strictEqual(typeof schema.version, 'string')
-
-  assert.deepStrictEqual(schema.properties.greeting, {
-    type: 'object',
-    properties: {
-      text: {
-        type: 'string'
-      }
-    },
-    required: ['text'],
-    additionalProperties: false
-  })
-})
-`
-}
-
-function getTsStackableSchemaTestFile (stackableName) {
-  const schemaId = kebabCase(stackableName)
-
-  return `\
-import test from 'node:test'
-import assert from 'node:assert'
-import { schema } from '../index'
-
-test('should export stackable schema', async () => {
-  assert.strictEqual(schema.$id, '${schemaId}')
-  assert.strictEqual(typeof schema.version, 'string')
-
-  assert.deepStrictEqual(schema.properties.greeting, {
-    type: 'object',
-    properties: {
-      text: {
-        type: 'string'
-      }
-    },
-    required: ['text'],
-    additionalProperties: false
-  })
-})
-`
-}
-
-function getJsStackableGeneratorTestFile () {
-  return `\
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const { tmpdir } = require('node:os')
-const { join } = require('node:path')
-const { readFile, readdir, mkdtemp } = require('node:fs/promises')
-const { safeRemove } = require('@platformatic/utils')
-const { Generator } = require('../index')
-const stackablePackageJson = require('../package.json')
-
-test('should return a default Generator config', async () => {
-  const generator = new Generator()
-  const defaultConfig = generator.getDefaultConfig()
-
-  assert.strictEqual(defaultConfig.hostname, '0.0.0.0')
-  assert.strictEqual(defaultConfig.port, 3042)
-  assert.strictEqual(defaultConfig.greeting, 'Hello world!')
-  assert.deepStrictEqual(defaultConfig.env, {})
-  assert.deepStrictEqual(defaultConfig.dependencies, {})
-  assert.deepStrictEqual(defaultConfig.devDependencies, {})
-})
-
-test('should return Generator config fields definitions', async () => {
-  const generator = new Generator()
-  const configFieldsDefs = generator.getConfigFieldsDefinitions()
-
-  const hostnameField = configFieldsDefs.find(
-    field => field.var === 'PLT_SERVER_HOSTNAME'
-  )
-  assert.deepStrictEqual(hostnameField, {
-    var: 'PLT_SERVER_HOSTNAME',
-    label: 'What is the hostname?',
-    default: '0.0.0.0',
-    type: 'string',
-    configValue: 'hostname'
-  })
-
-  const portField = configFieldsDefs.find(
-    field => field.var === 'PORT'
-  )
-  assert.deepStrictEqual(portField, {
-    var: 'PORT',
-    label: 'Which port do you want to use?',
-    default: 3042,
-    type: 'number',
-    configValue: 'port'
-  })
-
-  const greetingField = configFieldsDefs.find(
-    field => field.var === 'PLT_GREETING_TEXT'
-  )
-  assert.deepStrictEqual(greetingField, {
-    var: 'PLT_GREETING_TEXT',
-    label: 'What should the stackable greeting say?',
-    default: 'Hello world!',
-    type: 'string'
-  })
-})
-
-test('should generate a stackable app', async (t) => {
-  const testDir = await mkdtemp(join(tmpdir(), 'stackable-'))
-  t.after(() => safeRemove(testDir))
-
-  const generator = new Generator()
-
-  generator.setConfig({
-    serviceName: 'stackable-app',
-    targetDirectory: testDir
-  })
-
-  await generator.prepare()
-  await generator.writeFiles()
-
-  const files = await readdir(testDir)
-  assert.deepStrictEqual(files.sort(), [
-    '.env',
-    '.env.sample',
-    '.gitignore',
-    'global.d.ts',
-    'package.json',
-    'platformatic.json',
-    'stackable.schema.json'
-  ])
-
-  const packageJson = require(join(testDir, 'package.json'))
-  assert.strictEqual(packageJson.name, 'stackable-app')
-
-  const envFile = await readFile(join(testDir, '.env'), 'utf8')
-  const envVars = envFile.split('\\n').filter(Boolean)
-  assert.deepStrictEqual(envVars.sort(), [
-    'PLT_GREETING_TEXT=Hello world!',
-    'PLT_SERVER_HOSTNAME=0.0.0.0',
-    'PLT_SERVER_LOGGER_LEVEL=info',
-    'PLT_TYPESCRIPT=false',
-    'PORT=3042'
-  ])
-
-  const stackableConfig = require(join(testDir, 'platformatic.json'))
-  const stackableName = stackablePackageJson.name
-  const stackableVersion = stackablePackageJson.version
-
-  assert.deepStrictEqual(stackableConfig, {
-    $schema: './stackable.schema.json',
-    module: \`\${stackableName}@\${stackableVersion}\`,
-    server: {
-      hostname: '{PLT_SERVER_HOSTNAME}',
-      port: '{PORT}',
-      logger: {
-        level: '{PLT_SERVER_LOGGER_LEVEL}'
-      }
-    },
-    service: {
-      openapi: true
-    },
-    greeting: {
-      text: '{PLT_GREETING_TEXT}'
-    },
-    watch: true
-  })
-})
-`
-}
-
-function getTsStackableGeneratorTestFile () {
-  return `\
-import test from 'node:test'
-import assert from 'node:assert'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { readFile, readdir, mkdtemp } from 'node:fs/promises'
-import { readFileSync } from 'node:fs'
-import { Generator } from '../index'
-import { safeRemove } from '@platformatic/utils'
-
-const stackablePackageJsonPath = require.resolve('../../package.json')
-const stackablePackageJson = JSON.parse(readFileSync(stackablePackageJsonPath, 'utf8'))
-
-test('should return a default Generator config', async () => {
-  const generator = new Generator()
-  const defaultConfig = generator.getDefaultConfig()
-
-  assert.strictEqual(defaultConfig.hostname, '0.0.0.0')
-  assert.strictEqual(defaultConfig.port, 3042)
-  assert.strictEqual(defaultConfig.greeting, 'Hello world!')
-  assert.deepStrictEqual(defaultConfig.env, {})
-  assert.deepStrictEqual(defaultConfig.dependencies, {})
-  assert.deepStrictEqual(defaultConfig.devDependencies, {})
-})
-
-test('should return Generator config fields definitions', async () => {
-  const generator = new Generator()
-  const configFieldsDefs = generator.getConfigFieldsDefinitions()
-
-  const hostnameField = configFieldsDefs.find(
-    field => field.var === 'PLT_SERVER_HOSTNAME'
-  )
-  assert.deepStrictEqual(hostnameField, {
-    var: 'PLT_SERVER_HOSTNAME',
-    label: 'What is the hostname?',
-    default: '0.0.0.0',
-    type: 'string',
-    configValue: 'hostname'
-  })
-
-  const portField = configFieldsDefs.find(
-    field => field.var === 'PORT'
-  )
-  assert.deepStrictEqual(portField, {
-    var: 'PORT',
-    label: 'Which port do you want to use?',
-    default: 3042,
-    type: 'number',
-    configValue: 'port'
-  })
-
-  const greetingField = configFieldsDefs.find(
-    field => field.var === 'PLT_GREETING_TEXT'
-  )
-  assert.deepStrictEqual(greetingField, {
-    var: 'PLT_GREETING_TEXT',
-    label: 'What should the stackable greeting say?',
-    default: 'Hello world!',
-    type: 'string'
-  })
-})
-
-test('should generate a stackable app', async (t) => {
-  const testDir = await mkdtemp(join(tmpdir(), 'stackable-'))
-  t.after(() => safeRemove(testDir))
-
-  const generator = new Generator()
-
-  generator.setConfig({
-    serviceName: 'stackable-app',
-    targetDirectory: testDir
-  })
-
-  await generator.prepare()
-  await generator.writeFiles()
-
-  const files = await readdir(testDir)
-  assert.deepStrictEqual(files.sort(), [
-    '.env',
-    '.env.sample',
-    '.gitignore',
-    'global.d.ts',
-    'package.json',
-    'platformatic.json',
-    'stackable.schema.json'
-  ])
-
-  const packageJson = require(join(testDir, 'package.json'))
-  assert.strictEqual(packageJson.name, 'stackable-app')
-
-  const envFile = await readFile(join(testDir, '.env'), 'utf8')
-  const envVars = envFile.split('\\n').filter(Boolean)
-  assert.deepStrictEqual(envVars.sort(), [
-    'PLT_GREETING_TEXT=Hello world!',
-    'PLT_SERVER_HOSTNAME=0.0.0.0',
-    'PLT_SERVER_LOGGER_LEVEL=info',
-    'PLT_TYPESCRIPT=false',
-    'PORT=3042'
-  ])
-
-  const stackableConfig = require(join(testDir, 'platformatic.json'))
-  const stackableName = stackablePackageJson.name
-  const stackableVersion = stackablePackageJson.version
-
-  assert.deepStrictEqual(stackableConfig, {
-    $schema: './stackable.schema.json',
-    module: \`\${stackableName}@\${stackableVersion}\`,
-    server: {
-      hostname: '{PLT_SERVER_HOSTNAME}',
-      port: '{PORT}',
-      logger: {
-        level: '{PLT_SERVER_LOGGER_LEVEL}'
-      }
-    },
-    service: {
-      openapi: true
-    },
-    greeting: {
-      text: '{PLT_GREETING_TEXT}'
-    },
-    watch: true
-  })
-})
-`
-}
-
-function generateStackableTests (typescript, stackableName) {
-  if (typescript) {
-    return [
-      {
-        path: 'test',
-        file: 'index.test.ts',
-        contents: getTsStackableIndexTestFile(stackableName),
-      },
-      {
-        path: 'test',
-        file: 'schema.test.ts',
-        contents: getTsStackableSchemaTestFile(stackableName),
-      },
-      {
-        path: 'test',
-        file: 'generator.test.ts',
-        contents: getTsStackableGeneratorTestFile(),
-      },
-    ]
-  }
-  return [
-    {
-      path: 'test',
-      file: 'index.test.js',
-      contents: getJsStackableIndexTestFile(stackableName),
-    },
-    {
-      path: 'test',
-      file: 'schema.test.js',
-      contents: getJsStackableSchemaTestFile(stackableName),
-    },
-    {
-      path: 'test',
-      file: 'generator.test.js',
-      contents: getJsStackableGeneratorTestFile(),
-    },
-  ]
-}
-
-module.exports = {
-  generateStackableTests,
-}

package/lib/stackable-generator.js

@@ -1,317 +0,0 @@
-'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')
-const { generateStackableTests } = require('./create-stackable-tests')
-
-/* 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(...generateStackableTests(typescript, stackableName))
-      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',
-    }
-
-    const devDependencies = {
-      borp: '^0.10.0',
-      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,
-        version: '0.0.1',
-        main: 'dist/index.js',
-        bin: {
-          [createStackableCommand]: './dist/cli/create.js',
-          [startStackableCommand]: './dist/cli/start.js',
-        },
-        scripts: {
-          build: 'tsc --build',
-          'gen-schema': 'node lib/schema.js > schema.json',
-          'gen-types': 'json2ts > config.d.ts < schema.json',
-          'build:config': 'pnpm run gen-schema && pnpm run gen-types',
-          clean: 'rm -fr ./dist',
-          test: 'borp',
-        },
-        engines: {
-          node: '^18.8.0 || >=20.6.0',
-        },
-        devDependencies: {
-          ...devDependencies,
-          typescript: typescriptVersion,
-          ...this.config.devDependencies,
-        },
-        dependencies: {
-          ...dependencies,
-          '@platformatic/generators': `^${this.platformaticVersion}`,
-          ...this.config.dependencies,
-        },
-      }
-    }
-
-    return {
-      name: npmPackageName,
-      version: '0.0.1',
-      main: 'index.js',
-      bin: {
-        [createStackableCommand]: './cli/create.js',
-        [startStackableCommand]: './cli/start.js',
-      },
-      scripts: {
-        'gen-schema': 'node lib/schema.js > schema.json',
-        'gen-types': 'json2ts > config.d.ts < schema.json',
-        'build:config': 'pnpm run gen-schema && pnpm run gen-types',
-        prepublishOnly: 'pnpm run build:config',
-        lint: 'standard',
-        test: 'borp',
-      },
-      engines: {
-        node: '^18.8.0 || >=20.6.0',
-      },
-      devDependencies: {
-        ...devDependencies,
-        standard: '^17.0.0',
-        ...this.config.devDependencies,
-      },
-      dependencies: {
-        ...dependencies,
-        ...this.config.dependencies,
-      },
-    }
-  }
-
-  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 {} }
-}
-
-module.exports = StackableGenerator
-module.exports.StackableGenerator = StackableGenerator