@platformatic/generators 1.31.1 → 1.33.0

package/lib/base-generator.d.ts

@@ -93,7 +93,7 @@ export namespace BaseGenerator {
     getEnvVar (envVarName: string): EnvVarValue
     setEnvVars(env?: Env): void
 
-    getDefaultConfig(): JSONValue
+    getDefaultConfig(): { [x: string]: JSONValue }
     getDefaultEnv(): Env
 
     getFastifyVersion(): Promise<string>
@@ -106,19 +106,19 @@ export namespace BaseGenerator {
     run(): Promise<GeneratorMetadata>
     addQuestion(question: any, where?: WhereClause): Promise<void>
     removeQuestion(variableName: string): void
-    getTSConfig(): JSONValue
+    getTSConfig(): { [x: string]: JSONValue }
 
     getConfigFieldsDefinitions(): ConfigFieldDefinition[]
     setConfigFields(fields: ConfigField[]): void
 
     generateConfigFile(): Promise<void>
     readPackageJsonFile(): Promise<JSONValue>
-    generatePackageJson(): Promise<JSONValue>
+    generatePackageJson(): Promise<{ [x: string]: JSONValue }>
     getConfigFileName(): string
     checkEnvVariablesInConfigFile(): boolean
     _beforePrepare(): Promise<void>
     _afterPrepare(): Promise<void | JSONValue>
-    _getConfigFileContents(): Promise<JSONValue>
+    _getConfigFileContents(): Promise<{ [x: string]: BaseGenerator.JSONValue }>
     _generateEnv(): Promise<void>
     appendConfigEnv(): Promise<void>
 

package/lib/create-stackable-cli.js

@@ -89,7 +89,7 @@ async function execute (): Promise<void> {
         type: 'string',
         default: join(process.cwd(), '${kebabCase(stackableName + '-app')}')
       },
-      port: { type: 'string', default: '3042' },
+      port: { type: 'string' },
       hostname: { type: 'string', default: '0.0.0.0' },
       plugin: { type: 'boolean', default: true },
       tests: { type: 'boolean', default: true },
@@ -102,7 +102,7 @@ async function execute (): Promise<void> {
   const generator = new Generator()
 
   generator.setConfig({
-    port: parseInt(args.values.port as string),
+    port: parseInt(args.values.port || '3042'),
     hostname: args.values.hostname,
     plugin: args.values.plugin,
     tests: args.values.tests,

package/lib/create-stackable-files.js

@@ -36,8 +36,6 @@ stackable.configManagerConfig = {
 stackable[Symbol.for('skip-override')] = true
 
 module.exports = stackable
-module.exports.schema = schema
-module.exports.Generator = Generator
 `
 }
 
@@ -266,7 +264,7 @@ type PackageJson = {
 class ${stackableGeneratorType} extends ServiceGenerator {
   private _packageJson: PackageJson | null = null
 
-  getDefaultConfig (): BaseGenerator.JSONValue {
+  getDefaultConfig (): { [x: string]: BaseGenerator.JSONValue } {
     const defaultBaseConfig = super.getDefaultConfig()
     const defaultConfig = {
       greeting: 'Hello world!'
@@ -287,7 +285,7 @@ class ${stackableGeneratorType} extends ServiceGenerator {
     ]
   }
 
-  async _getConfigFileContents (): Promise<BaseGenerator.JSONValue> {
+  async _getConfigFileContents (): Promise<{ [x: string]: BaseGenerator.JSONValue }> {
     const baseConfig = await super._getConfigFileContents()
     const packageJson = await this.getStackablePackageJson()
     const config = {
@@ -402,6 +400,9 @@ function getTsStackableSchemaFile (stackableName) {
 
   return `\
 import { schema } from '@platformatic/service'
+import { readFileSync } from 'node:fs'
+
+const { version } = JSON.parse(readFileSync('package.json', 'utf8'))
 
 const ${schemaVarName} = {
   ...schema.schema,

package/lib/create-stackable-tests.js

@@ -0,0 +1,395 @@
+'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, rm } = require('node:fs/promises')
+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(() => rm(testDir, { recursive: true, force: true }))
+
+  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, rm } from 'node:fs/promises'
+import { readFileSync } from 'node:fs'
+import { Generator } from '../index'
+
+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(() => rm(testDir, { recursive: true, force: true }))
+
+  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

@@ -10,6 +10,7 @@ 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 = {
@@ -109,6 +110,7 @@ class StackableGenerator extends FileGenerator {
       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()
@@ -209,6 +211,7 @@ class StackableGenerator extends FileGenerator {
     }
 
     const devDependencies = {
+      borp: '^0.10.0',
       fastify: `^${this.fastifyVersion}`
     }
 
@@ -233,7 +236,8 @@ class StackableGenerator extends FileGenerator {
           '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'
+          clean: 'rm -fr ./dist',
+          test: 'borp'
         },
         engines: {
           node: '^18.8.0 || >=20.6.0'
@@ -247,9 +251,6 @@ class StackableGenerator extends FileGenerator {
           ...dependencies,
           '@platformatic/generators': `^${this.platformaticVersion}`,
           ...this.config.dependencies
-        },
-        overrides: {
-          minimatch: '^5.0.0'
         }
       }
     }
@@ -267,7 +268,8 @@ class StackableGenerator extends FileGenerator {
         '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'
+        lint: 'standard',
+        test: 'borp'
       },
       engines: {
         node: '^18.8.0 || >=20.6.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/generators",
-  "version": "1.31.1",
+  "version": "1.33.0",
   "description": "Main classes and utils for generators.",
   "main": "index.js",
   "keywords": [],
@@ -20,7 +20,7 @@
     "c8": "^9.1.0",
     "snazzy": "^9.0.0",
     "standard": "^17.1.0",
-    "tsd": "^0.30.7",
+    "tsd": "^0.31.0",
     "typescript": "^5.4.2"
   },
   "scripts": {

package/test/stackable-generator.test.js

@@ -53,6 +53,15 @@ test('should create a stackable project without typescript', async (t) => {
 
   const gitignore = await readFile(join(dir, '.gitignore'), 'utf8')
   assert.ok(gitignore.length > 0)
+
+  const testIndexFile = await readFile(join(dir, 'test', 'index.test.js'), 'utf8')
+  assert.ok(testIndexFile.length > 0)
+
+  const testSchemaFile = await readFile(join(dir, 'test', 'schema.test.js'), 'utf8')
+  assert.ok(testSchemaFile.length > 0)
+
+  const testGeneratorFile = await readFile(join(dir, 'test', 'generator.test.js'), 'utf8')
+  assert.ok(testGeneratorFile.length > 0)
 })
 
 test('should create a stackable project with typescript', async (t) => {
@@ -93,4 +102,13 @@ test('should create a stackable project with typescript', async (t) => {
 
   const gitignore = await readFile(join(dir, '.gitignore'), 'utf8')
   assert.ok(gitignore.length > 0)
+
+  const testIndexFile = await readFile(join(dir, 'test', 'index.test.ts'), 'utf8')
+  assert.ok(testIndexFile.length > 0)
+
+  const testSchemaFile = await readFile(join(dir, 'test', 'schema.test.ts'), 'utf8')
+  assert.ok(testSchemaFile.length > 0)
+
+  const testGeneratorFile = await readFile(join(dir, 'test', 'generator.test.ts'), 'utf8')
+  assert.ok(testGeneratorFile.length > 0)
 })