@platformatic/generators 1.13.0 → 1.13.2

package/lib/base-generator.d.ts

@@ -1,9 +1,9 @@
 import { BaseLogger } from 'pino'
 import { FileGenerator } from './file-generator'
-
+import { PackageConfiguration } from './utils'
 export namespace BaseGenerator {
   export type BaseGeneratorOptions = FileGenerator.FileGeneratorOptions & {
-    type?: 'service' | 'db' | 'composer'
+    module: string
     inquirer?: object
   }
   
@@ -24,6 +24,11 @@ export namespace BaseGenerator {
   type Dependency = {
     [key: string]: string
   }
+
+  type PackageDefinition = {
+    name: string,
+    options: PackageConfiguration
+  }
   type BaseGeneratorConfig = Record<string, any> & {
     port?: number
     hostname?: string
@@ -37,7 +42,7 @@ export namespace BaseGenerator {
     env?: KeyValue,
     isRuntimeContext?: boolean,
     serviceName?: string,
-    envPrefix?: string 
+    envPrefix?: string
   }
   
   type WhereClause = {
@@ -71,6 +76,7 @@ export namespace BaseGenerator {
     config: BaseGeneratorConfig
     questions: Array<object>
   
+    packages: PackageConfiguration[]
     constructor(opts?: BaseGeneratorOptions)
   
     setConfig(config?: BaseGeneratorConfig): void
@@ -82,6 +88,8 @@ export namespace BaseGenerator {
     getFastifyVersion(): Promise<string>
     getPlatformaticVersion(): Promise<string>
   
+    addPackage(pkg: PackageDefinition): void
+
     prepare(): Promise<GeneratorMetadata>
     run(): Promise<GeneratorMetadata>
     addQuestion(question: any, where?: WhereClause): Promise<void>
@@ -101,5 +109,7 @@ export namespace BaseGenerator {
     _getConfigFileContents(): Promise<JSONValue>
     _generateEnv(): Promise<void>
     appendConfigEnv(): Promise<void>
+
+    postInstallActions(): Promise<void>
   }
-}
+}

package/lib/base-generator.js

@@ -5,8 +5,8 @@ const { stripVersion, convertServiceNameToPrefix, addPrefixToEnv, extractEnvVari
 const { join } = require('node:path')
 const { FileGenerator } = require('./file-generator')
 const { generateTests, generatePlugins } = require('./create-plugin')
+const { PrepareError, MissingEnvVariable, ModuleNeeded } = require('./errors')
 const { generateGitignore } = require('./create-gitignore')
-const { NoQuestionsError, PrepareError, MissingEnvVariable } = require('./errors')
 const generateName = require('boring-name-generator')
 /* c8 ignore start */
 const fakeLogger = {
@@ -21,14 +21,18 @@ const fakeLogger = {
 class BaseGenerator extends FileGenerator {
   constructor (opts = {}) {
     super(opts)
-    this.type = opts.type
     this.files = []
     this.logger = opts.logger || fakeLogger
     this.questions = []
     this.pkgData = null
-    this.inquirer = null
+    this.inquirer = opts.inquirer || null
     this.targetDirectory = opts.targetDirectory || null
     this.config = this.getDefaultConfig()
+    this.packages = []
+    this.module = opts.module
+    if (!this.module) {
+      throw ModuleNeeded()
+    }
   }
 
   getDefaultConfig () {
@@ -114,11 +118,13 @@ class BaseGenerator extends FileGenerator {
 
   /* c8 ignore start */
   async ask () {
-    if (!this.questions.length) {
-      throw new NoQuestionsError()
-    }
     if (this.inquirer) {
-      this.config = await this.inquirer.prompt(this.questions)
+      await this.prepareQuestions()
+      const newConfig = await this.inquirer.prompt(this.questions)
+      this.setConfig({
+        ...this.config,
+        ...newConfig
+      })
     }
   }
 
@@ -153,8 +159,6 @@ class BaseGenerator extends FileGenerator {
 
       await this.generateConfigFile()
 
-      await this.prepareQuestions()
-
       await this.generateEnv()
 
       if (this.config.typescript) {
@@ -171,12 +175,16 @@ class BaseGenerator extends FileGenerator {
         this.files.push(...generatePlugins(this.config.typescript))
         if (this.config.tests) {
           // create tests
-          this.files.push(...generateTests(this.config.typescript, this.type))
+          this.files.push(...generateTests(this.config.typescript, this.module))
         }
       }
+
       this.files.push(generateGitignore())
+
       await this._afterPrepare()
+
       this.checkEnvVariablesInConfigFile()
+
       return {
         targetDirectory: this.targetDirectory,
         env: this.config.env
@@ -186,12 +194,14 @@ class BaseGenerator extends FileGenerator {
         // throw the same error
         throw err
       }
-      throw new PrepareError(err.message)
+      const _err = new PrepareError(err.message)
+      _err.cause = err
+      throw _err
     }
   }
 
   checkEnvVariablesInConfigFile () {
-    const configFileName = this.getConfigFileName()
+    const configFileName = 'platformatic.json'
     const fileOjbect = this.getFileObject(configFileName)
     const envVars = extractEnvVariablesFromText(fileOjbect.contents)
     const envKeys = Object.keys(this.config.env)
@@ -230,113 +240,36 @@ class BaseGenerator extends FileGenerator {
   }
 
   async prepareQuestions () {
-    // directory
-    this.questions.push({
-      type: 'input',
-      name: 'targetDirectory',
-      message: 'Where would you like to create your project?'
-    })
-
-    // 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 }]
-    })
-
-    // init git repository
-    this.questions.push({
-      type: 'list',
-      name: 'initGitRepository',
-      message: 'Do you want to init the git repository?',
-      default: false,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    })
-
-    // port
-    this.questions.push({
-      type: 'input',
-      name: 'port',
-      message: 'What port do you want to use?'
-    })
-
-    // github actions
-    this.questions.push({
-      type: 'list',
-      name: 'staticWorkspaceGitHubAction',
-      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 }]
-    },
-    {
-      type: 'list',
-      name: 'dynamicWorkspaceGitHubAction',
-      message: 'Do you want to enable PR Previews in your application?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    })
-  }
-
-  async addQuestion (question, where) {
-    if (where) {
-      if (where.before) {
-        const position = this.questions.reduce((acc, element, idx) => {
-          if (acc === null) {
-            if (element.name === where.before) {
-              acc = idx
-            }
-          }
-          return acc
-        }, null)
-
-        if (position) {
-          this.questions.splice(position, 0, question)
-        }
-      } else if (where.after) {
-        const position = this.questions.reduce((acc, element, idx) => {
-          if (acc === null) {
-            if (element.name === where.after) {
-              acc = idx + 1
-            }
-          }
-          return acc
-        }, null)
-
-        if (position) {
-          this.questions.splice(position, 0, question)
-        }
+    if (!this.config.isRuntimeContext) {
+      if (!this.config.targetDirectory) {
+        // directory
+        this.questions.push({
+          type: 'input',
+          name: 'targetDirectory',
+          message: 'Where would you like to create your project?'
+        })
       }
-    } else {
-      this.questions.push(question)
-    }
-  }
 
-  removeQuestion (variableName) {
-    const position = this.questions.reduce((acc, element, idx) => {
-      if (acc === null) {
-        if (element.name === variableName) {
-          acc = idx
-        }
-      }
-      return acc
-    }, null)
-    if (position) {
-      this.questions.splice(position, 1)
-    }
-  }
+      // 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 }]
+      })
 
-  getConfigFileName () {
-    if (!this.type) {
-      return 'platformatic.json'
-    } else {
-      return `platformatic.${this.type}.json`
+      // port
+      this.questions.push({
+        type: 'input',
+        name: 'port',
+        message: 'What port do you want to use?'
+      })
     }
   }
 
   async generateConfigFile () {
-    const configFileName = this.getConfigFileName()
+    const configFileName = 'platformatic.json'
     const contents = await this._getConfigFileContents()
     this.addFile({
       path: '',
@@ -406,6 +339,13 @@ class BaseGenerator extends FileGenerator {
       })
       await this._generateEnv()
       this.appendConfigEnv()
+
+      const { contents } = this.getFileObject('.env')
+      this.addFile({
+        path: '',
+        file: '.env.sample',
+        contents
+      })
     }
   }
 
@@ -415,7 +355,13 @@ class BaseGenerator extends FileGenerator {
     return metadata
   }
 
+  addPackage (pkg) {
+    this.packages.push(pkg)
+  }
+
   // implement in the subclass
+  /* c8 ignore next 1 */
+  async postInstallActions () {}
   async _beforePrepare () {}
   async _afterPrepare () {}
   async _getConfigFileContents () { return {} }

package/lib/create-plugin.js

@@ -115,7 +115,7 @@ function testHelperTS (mod, customizations = { pre: '', post: '', config: '', re
   return `\
 import { join } from 'node:path'
 import { readFile } from 'node:fs/promises'
-import { buildServer } from '@platformatic/${mod}'
+import { buildServer } from '${mod}'
 import { test } from 'node:test'
 ${customizations.requires}
 
@@ -125,7 +125,7 @@ type TestContext = Parameters<Exclude<testfn, undefined>>[0]
 export async function getServer (t: TestContext) {
 ${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'))
+  const config = JSON.parse(await readFile(join(__dirname, '..', '..', 'platformatic'), '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'
@@ -199,13 +199,13 @@ function generateRouteWithTypesSupport (typescript) {
   }
 }
 
-function generateTests (typescript, type, customizations) {
+function generateTests (typescript, mod, customizations) {
   const output = []
   if (typescript) {
     output.push({
       path: 'test',
       file: 'helper.ts',
-      contents: testHelperTS(type, customizations)
+      contents: testHelperTS(mod, customizations)
     })
     output.push({
       path: join('test', 'plugins'),
@@ -221,7 +221,7 @@ function generateTests (typescript, type, customizations) {
     output.push({
       path: 'test',
       file: 'helper.js',
-      contents: testHelperJS(type, customizations)
+      contents: testHelperJS(mod, customizations)
     })
     output.push({
       path: join('test', 'plugins'),

package/lib/errors.js

@@ -5,7 +5,8 @@ const createError = require('@fastify/error')
 const ERROR_PREFIX = 'PLT_GEN'
 
 module.exports = {
-  NoQuestionsError: createError(`${ERROR_PREFIX}_NO_QUESTIONS_ERROR`, 'No questions added.'),
+  ModuleNeeded: createError(`${ERROR_PREFIX}_PREPARE_ERROR`, 'The module which the package will be published to must be specified'),
   PrepareError: createError(`${ERROR_PREFIX}_PREPARE_ERROR`, 'Error while generating the files: %s.'),
-  MissingEnvVariable: createError(`${ERROR_PREFIX}_MISSING_ENV_VAR`, 'Env variable %s is defined in config file %s, but not in config.env object.')
+  MissingEnvVariable: createError(`${ERROR_PREFIX}_MISSING_ENV_VAR`, 'Env variable %s is defined in config file %s, but not in config.env object.'),
+  WrongTypeError: createError(`${ERROR_PREFIX}_WRONG_TYPE`, 'Invalid value type. Accepted values are \'string\', \'number\' and \'boolean\', found \'%s\'.')
 }

package/lib/utils.d.ts

@@ -2,6 +2,12 @@ type Env = {
   [key: string]: string
 }
 
+export type PackageConfiguration = {
+  type: 'number' | 'string' | 'boolean'
+  path: string
+  value: number | string | boolean
+}
+
 export namespace GeneratorUtils {
   export function safeMkdir(dir: string): Promise<void>
   export function stripVersion(version: string): string
@@ -9,4 +15,5 @@ export namespace GeneratorUtils {
   export function addPrefixToEnv(env: Env, prefix: string): Env
   export function envObjectToString(env: Env): string
   export function extractEnvVariablesFromText(text: string): string[]
+  export function getPackageConfigurationObject(config: PackageConfiguration[]): object
 }

package/lib/utils.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { mkdir } = require('node:fs/promises')
+const { WrongTypeError } = require('./errors')
 
 async function safeMkdir (dir) {
   try {
@@ -58,10 +59,41 @@ function extractEnvVariablesFromText (text) {
   }
   return []
 }
-
+function getPackageConfigurationObject (config) {
+  const output = {}
+  let current = output
+  for (const param of config) {
+    const props = param.path.split('.')
+    props.forEach((prop, idx) => {
+      if (idx === props.length - 1) {
+        switch (param.type) {
+          case 'string' :
+            current[prop] = param.value.toString()
+            break
+          case 'number':
+            current[prop] = parseInt(param.value)
+            break
+          case 'boolean':
+            current[prop] = (param.value === 'true')
+            break
+          default:
+            throw new WrongTypeError(param.type)
+        }
+        current = output
+      } else {
+        if (!current[prop]) {
+          current[prop] = {}
+        }
+        current = current[prop]
+      }
+    })
+  }
+  return output
+}
 module.exports = {
   addPrefixToEnv,
   convertServiceNameToPrefix,
+  getPackageConfigurationObject,
   envObjectToString,
   extractEnvVariablesFromText,
   safeMkdir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/generators",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "Main classes and utils for generators.",
   "main": "index.js",
   "keywords": [],

package/test/base-generator.test.js

@@ -20,7 +20,8 @@ afterEach(async () => {
 test('should write file and dirs', async (t) => {
   const dir = await getTempDir()
   const gen = new BaseGenerator({
-    logger: fakeLogger
+    logger: fakeLogger,
+    module: '@platformatic/service'
   })
 
   gen.setConfig({
@@ -43,6 +44,13 @@ test('should write file and dirs', async (t) => {
 
 test('extended class should generate config', async (t) => {
   class ServiceClass extends BaseGenerator {
+    constructor (opts) {
+      super({
+        ...opts,
+        module: '@platformatic/service'
+      })
+    }
+
     async _getConfigFileContents () {
       // Implement when extending this class
       return {
@@ -52,7 +60,6 @@ test('extended class should generate config', async (t) => {
   }
 
   const svc = new ServiceClass({
-    type: 'service',
     logger: fakeLogger
   })
 
@@ -61,14 +68,14 @@ test('extended class should generate config', async (t) => {
   const configFile = svc.files[1]
   assert.deepEqual(configFile, {
     path: '',
-    file: 'platformatic.service.json',
+    file: 'platformatic.json',
     contents: JSON.stringify({ foo: 'bar' }, null, 2)
   })
 })
 
 test('setConfig', async (t) => {
   const bg = new BaseGenerator({
-    type: 'service'
+    module: '@platformatic/service'
   })
 
   // should init the default config
@@ -140,7 +147,7 @@ test('setConfig', async (t) => {
 
 test('should append env values', async (t) => {
   const bg = new BaseGenerator({
-    type: 'service'
+    module: '@platformatic/service'
   })
   // partial config with defaults
   bg.setConfig({
@@ -152,11 +159,85 @@ test('should append env values', async (t) => {
   await bg.prepare()
   const dotEnvFile = bg.getFileObject('.env')
   assert.equal(dotEnvFile.contents, 'FOO=bar\n')
+
+  const dotEnvSampleFile = bg.getFileObject('.env.sample')
+  assert.equal(dotEnvSampleFile.contents, 'FOO=bar\n')
+})
+
+test('should prepare the questions', async (t) => {
+  const bg = new BaseGenerator({
+    module: '@platformatic/service'
+  })
+  // partial config with defaults
+  bg.setConfig({
+    env: {
+      FOO: 'bar'
+    }
+  })
+
+  await bg.prepareQuestions()
+  assert.deepStrictEqual(bg.questions, [{
+    type: 'input',
+    name: 'targetDirectory',
+    message: 'Where would you like to create your project?'
+  }, {
+    type: 'list',
+    name: 'typescript',
+    message: 'Do you want to use TypeScript?',
+    default: false,
+    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
+  }, {
+    type: 'input',
+    name: 'port',
+    message: 'What port do you want to use?'
+  }])
+})
+
+test('should prepare the questions with a targetDirectory', async (t) => {
+  const bg = new BaseGenerator({
+    module: '@platformatic/service'
+  })
+  // partial config with defaults
+  bg.setConfig({
+    targetDirectory: './foo',
+    env: {
+      FOO: 'bar'
+    }
+  })
+
+  await bg.prepareQuestions()
+  assert.deepStrictEqual(bg.questions, [{
+    type: 'list',
+    name: 'typescript',
+    message: 'Do you want to use TypeScript?',
+    default: false,
+    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
+  }, {
+    type: 'input',
+    name: 'port',
+    message: 'What port do you want to use?'
+  }])
+})
+
+test('should prepare the questions in runtime context', async (t) => {
+  const bg = new BaseGenerator({
+    module: '@platformatic/service'
+  })
+  // partial config with defaults
+  bg.setConfig({
+    isRuntimeContext: true,
+    env: {
+      FOO: 'bar'
+    }
+  })
+
+  await bg.prepareQuestions()
+  assert.deepStrictEqual(bg.questions, [])
 })
 
 test('should return service metadata', async (t) => {
   const bg = new BaseGenerator({
-    type: 'service'
+    module: '@platformatic/service'
   })
   // partial config with defaults
   bg.setConfig({
@@ -177,7 +258,7 @@ test('should return service metadata', async (t) => {
 
 test('should generate javascript plugin, routes and tests', async (t) => {
   const bg = new BaseGenerator({
-    type: 'service'
+    module: '@platformatic/service'
   })
   bg.setConfig({
     plugin: true,
@@ -193,7 +274,7 @@ test('should generate javascript plugin, routes and tests', async (t) => {
 
 test('should generate tsConfig file and typescript files', async (t) => {
   const bg = new BaseGenerator({
-    type: 'service'
+    module: '@platformatic/service'
   })
   bg.setConfig({
     typescript: true,
@@ -231,98 +312,10 @@ test('should generate tsConfig file and typescript files', async (t) => {
   assert.ok(bg.getFileObject('example.test.ts', 'test/plugins'))
 })
 
-test('should generate platformatic.json file if no type is generated', async (t) => {
-  const bg = new BaseGenerator()
-  await bg.prepare()
-  const configFileObject = bg.getFileObject('platformatic.json')
-  assert.ok(configFileObject)
-})
-
-test('should add questions in the correct position (before)', async (t) => {
-  const question = {
-    type: 'input',
-    name: 'serviceName',
-    message: 'What is the name of the service?'
-  }
-
-  const bg = new BaseGenerator({
-    type: 'service'
-  })
-
-  await bg.prepare()
-  const originalQuestionsLength = bg.questions.length
-  bg.addQuestion(question, { before: 'typescript' }) // should add as second question
-
-  assert.equal(bg.questions.length, originalQuestionsLength + 1)
-  assert.deepEqual(bg.questions[1], {
-    type: 'input',
-    name: 'serviceName',
-    message: 'What is the name of the service?'
-  })
-})
-
-test('should add questions in the correct position (after)', async (t) => {
-  const question = {
-    type: 'input',
-    name: 'serviceName',
-    message: 'What is the name of the service?'
-  }
-
-  const bg = new BaseGenerator({
-    type: 'service'
-  })
-
-  await bg.prepare()
-  const originalQuestionsLength = bg.questions.length
-  bg.addQuestion(question, { after: 'typescript' }) // should add as third question
-
-  assert.equal(bg.questions.length, originalQuestionsLength + 1)
-  assert.deepEqual(bg.questions[2], {
-    type: 'input',
-    name: 'serviceName',
-    message: 'What is the name of the service?'
-  })
-})
-
-test('should add questions at the end', async (t) => {
-  const question = {
-    type: 'input',
-    name: 'serviceName',
-    message: 'What is the name of the service?'
-  }
-
+test('should throw if preapare fails', async (t) => {
   const bg = new BaseGenerator({
-    type: 'service'
-  })
-
-  await bg.prepare()
-  const originalQuestionsLength = bg.questions.length
-  bg.addQuestion(question)
-
-  assert.equal(bg.questions.length, originalQuestionsLength + 1)
-  assert.deepEqual(bg.questions[originalQuestionsLength], {
-    type: 'input',
-    name: 'serviceName',
-    message: 'What is the name of the service?'
+    module: '@platformatic/service'
   })
-})
-
-test('should remove question', async (t) => {
-  const bg = new BaseGenerator()
-
-  await bg.prepare()
-
-  bg.removeQuestion('typescript')
-
-  bg.questions.forEach((question) => {
-    if (question.name === 'typescript') {
-      assert.fail()
-    }
-  })
-})
-
-test('should throw if preapare fails', async (t) => {
-  const bg = new BaseGenerator()
 
   bg._beforePrepare = async () => {
     throw new Error('beforePrepare error')
@@ -337,7 +330,9 @@ test('should throw if preapare fails', async (t) => {
 })
 
 test('should throw if there is a missing env variable', async () => {
-  const bg = new BaseGenerator()
+  const bg = new BaseGenerator({
+    module: '@platformatic/service'
+  })
 
   bg._getConfigFileContents = async () => {
     return {
@@ -361,9 +356,32 @@ test('should throw if there is a missing env variable', async () => {
   }
 })
 
+test('should add package', async () => {
+  const bg = new BaseGenerator({
+    module: '@platformatic/service'
+  })
+
+  const packageDefinition = {
+    name: '@my/package',
+    options: [
+      {
+        path: 'foobar',
+        type: 'string',
+        value: 'foobar'
+      }
+    ]
+  }
+  bg.addPackage(packageDefinition)
+
+  assert.equal(bg.packages.length, 1)
+  assert.deepEqual(bg.packages[0], packageDefinition)
+})
+
 describe('runtime context', () => {
   test('should set config.envPrefix correctly', async (t) => {
-    const bg = new BaseGenerator()
+    const bg = new BaseGenerator({
+      module: '@platformatic/service'
+    })
 
     bg.setConfig({
       isRuntimeContext: true,
@@ -390,7 +408,9 @@ describe('runtime context', () => {
   })
 
   test('should generate correct env file from config.env', async (t) => {
-    const bg = new BaseGenerator()
+    const bg = new BaseGenerator({
+      module: '@platformatic/service'
+    })
 
     bg.setConfig({
       isRuntimeContext: true,
@@ -412,7 +432,7 @@ describe('runtime context', () => {
 
   test('should return service metadata', async (t) => {
     const bg = new BaseGenerator({
-      type: 'service'
+      module: '@platformatic/service'
     })
     // partial config with defaults
     bg.setConfig({
@@ -435,7 +455,7 @@ describe('runtime context', () => {
 
   test('should generate service name if not provided', async () => {
     const bg = new BaseGenerator({
-      type: 'service'
+      module: '@platformatic/service'
     })
     bg.setConfig({
       targetDirectory: '/foo/bar',

package/test/utils.test.js

@@ -2,8 +2,7 @@
 
 const { test, describe } = require('node:test')
 const assert = require('node:assert')
-const { stripVersion, convertServiceNameToPrefix, addPrefixToEnv, envObjectToString } = require('../lib/utils')
-const { extractEnvVariablesFromText } = require('../lib/utils')
+const { stripVersion, convertServiceNameToPrefix, addPrefixToEnv, envObjectToString, extractEnvVariablesFromText, getPackageConfigurationObject } = require('../lib/utils')
 
 describe('utils', () => {
   describe('stripVersion', async () => {
@@ -86,4 +85,67 @@ describe('utils', () => {
       assert.deepEqual(env, [])
     })
   })
+
+  describe('getPackageConfigurationObject', async () => {
+    const input = [
+      {
+        path: 'prefix',
+        value: '/foo',
+        type: 'string'
+      },
+      {
+        path: 'foo.fooOption1',
+        value: 'value1',
+        type: 'string'
+      },
+      {
+        path: 'foo.fooOption2',
+        value: 'value2',
+        type: 'string'
+      },
+      {
+        path: 'foobar',
+        value: '123',
+        type: 'number'
+      },
+      {
+        path: 'boolean.truthy',
+        value: 'true',
+        type: 'boolean'
+      },
+      {
+        path: 'boolean.falsey',
+        value: 'false',
+        type: 'boolean'
+      }
+    ]
+    const config = getPackageConfigurationObject(input)
+    assert.deepEqual(config, {
+      prefix: '/foo',
+      foo: {
+        fooOption1: 'value1',
+        fooOption2: 'value2'
+      },
+      foobar: 123,
+      boolean: {
+        truthy: true,
+        falsey: false
+      }
+    })
+
+    // should throw
+    try {
+      getPackageConfigurationObject([
+        {
+          path: 'wrong',
+          type: 'object',
+          value: {}
+        }
+      ])
+      assert.fail()
+    } catch (err) {
+      assert.equal(err.code, 'PLT_GEN_WRONG_TYPE')
+      assert.equal(err.message, 'Invalid value type. Accepted values are \'string\', \'number\' and \'boolean\', found \'object\'.')
+    }
+  })
 })