@platformatic/generators 3.4.1 → 3.5.1

package/lib/import-generator.js

@@ -0,0 +1,228 @@
+import { findConfigurationFileRecursive, safeRemove } from '@platformatic/foundation'
+import { spawnSync } from 'node:child_process'
+import { readFile, readdir, stat } from 'node:fs/promises'
+import { dirname, join, relative, resolve } from 'node:path'
+import { BaseGenerator } from './base-generator.js'
+
+export class ImportGenerator extends BaseGenerator {
+  constructor (options = {}) {
+    const { applicationName, module, version, parent: runtime, ...opts } = options
+    super({ ...opts, module })
+
+    this.runtime = runtime
+    this.setConfig({
+      applicationName,
+      applicationPathEnvName: `PLT_APPLICATION_${applicationName.toUpperCase().replaceAll(/[^A-Z0-9_]/g, '_')}_PATH`,
+      module,
+      version
+    })
+  }
+
+  async prepareQuestions () {
+    await super.prepareQuestions()
+
+    this.questions.push({
+      type: 'input',
+      name: 'applicationPath',
+      message: 'Where is your application located?',
+      async validate (value) {
+        if (value.length === 0) {
+          return 'Please enter a path'
+        }
+
+        try {
+          const pathStat = await stat(value)
+
+          if (!pathStat?.isDirectory()) {
+            return 'Please enter a valid path'
+          }
+        } catch {
+          return 'Please enter a valid path'
+        }
+
+        return true
+      }
+    })
+
+    this.questions.push({
+      type: 'list',
+      name: 'operation',
+      message: 'Do you want to import or copy your application?',
+      default: 'import',
+      choices: [
+        { name: 'import', value: 'import' },
+        { name: 'copy', value: 'copy' }
+      ]
+    })
+  }
+
+  // We can't use prepare as it is not invoked from the runtime when dealing with existing applications
+  /* c8 ignore next 3 - Invoked from base-generator */
+  async prepare () {
+    return { targetDirectory: this.targetDirectory, env: this.config.env }
+  }
+
+  async _beforeWriteFiles (runtime) {
+    const { module: pkg, version, applicationPath: path } = this.config
+
+    const packageJsonPath = join(path, 'package.json')
+
+    if (this.config.operation === 'copy') {
+      await this.#copy(path)
+      await this.#generateConfigFile(path, '')
+      await this.#updatePackageJson(packageJsonPath, 'package.json', pkg, version)
+    } else {
+      await this.#detectGitUrl(path)
+      await this.#generateConfigFile(path, path)
+
+      await this.#updatePackageJson(packageJsonPath, packageJsonPath, pkg, version)
+      await this.#updateRuntime(runtime)
+    }
+  }
+
+  async _afterWriteFiles (runtime) {
+    // No need for an empty folder in the applications folder
+    if (this.config.operation === 'import') {
+      await safeRemove(join(runtime.applicationsBasePath, this.config.applicationName))
+    }
+  }
+
+  async #detectGitUrl (path) {
+    let url
+
+    // First of all, determine if there is a git repository in the application path
+    // Detect if there is a git folder and eventually get the remote
+    for (const candidate of ['origin', 'upstream']) {
+      try {
+        const result = spawnSync('git', ['remote', 'get-url', candidate], { cwd: path })
+
+        /* c8 ignore next 3 - Hard to test */
+        if (result.error || result.status !== 0) {
+          continue
+        }
+
+        url = result.stdout.toString().trim()
+        break
+        /* c8 ignore next 3 - Hard to test */
+      } catch (e) {
+        // No-op
+      }
+    }
+
+    this.setConfig({ gitUrl: url })
+    return url
+  }
+
+  async #generateConfigFile (originalPath, updatedPath) {
+    // Determine if there is a watt.json file in the application path - If it's missing, insert one
+    // For import it means we don't update  the file, for copy it means it was already copied in #copy.
+    const existingConfig = await findConfigurationFileRecursive(originalPath)
+
+    if (existingConfig) {
+      return
+    }
+
+    const { module: pkg, version } = this.config
+
+    if (pkg.startsWith('@platformatic/')) {
+      this.addFile({
+        path: '',
+        file: join(updatedPath, this.runtimeConfig),
+        contents: JSON.stringify({ $schema: `https://schemas.platformatic.dev/${pkg}/${version}.json` }, null, 2)
+      })
+    } else {
+      this.addFile({
+        path: '',
+        file: join(updatedPath, this.runtimeConfig),
+        contents: JSON.stringify({ module: pkg }, null, 2)
+      })
+    }
+  }
+
+  async #updatePackageJson (originalPath, updatedPath, pkg, version) {
+    // Add the module to the package.json dependencies
+    let packageJson = {}
+
+    try {
+      packageJson = JSON.parse(await readFile(originalPath, 'utf-8'))
+    } catch (e) {
+      // No-op, we will create a new package.json
+    }
+
+    packageJson.dependencies ??= {}
+    packageJson.dependencies[pkg] = `^${version}`
+    if (packageJson.devDependencies?.[pkg]) {
+      packageJson.devDependencies[pkg] = undefined
+    }
+
+    this.addFile({ path: '', file: updatedPath, contents: JSON.stringify(packageJson, null, 2) })
+  }
+
+  async #updateRuntime (runtime) {
+    const configObject = runtime.getRuntimeConfigFileObject()
+    /* c8 ignore next - else */
+    const config = JSON.parse(configObject?.contents ?? '{}')
+    const envObject = runtime.getRuntimeEnvFileObject()
+    /* c8 ignore next - else */
+    let env = envObject?.contents ?? ''
+
+    // Find which key is being used for the manual applications
+    let key
+    for (const candidate of new Set([runtime.applicationsFolder, 'applications', 'services', 'web'])) {
+      if (Array.isArray(config[candidate])) {
+        key = candidate
+        break
+      }
+    }
+
+    /* c8 ignore next - else */
+    key ??= runtime.applicationsFolder ?? 'applications'
+    const applications = config[key] ?? []
+
+    if (!applications.some(application => application.id === this.config.applicationName)) {
+      applications.push({
+        id: this.config.applicationName,
+        path: `{${this.config.applicationPathEnvName}}`,
+        url: this.config.gitUrl
+      })
+    }
+
+    config[key] = applications
+
+    if (env.length > 0) {
+      env += '\n'
+    }
+    env += `${this.config.applicationPathEnvName}=${this.config.applicationPath}`
+
+    runtime.updateRuntimeConfig(config)
+    runtime.updateRuntimeEnv(env)
+  }
+
+  async #copy (root) {
+    const files = await readdir(root, { withFileTypes: true, recursive: true })
+
+    for await (const file of files) {
+      const absolutePath = resolve(file.parentPath, file.name)
+      let path = relative(root, dirname(absolutePath))
+
+      if (
+        file.isDirectory() ||
+        ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'].includes(file.name) ||
+        path.includes('node_modules')
+      ) {
+        continue
+      }
+
+      /* c8 ignore next 6 */
+      if (path === '.') {
+        path = ''
+      }
+
+      this.addFile({
+        path,
+        file: file.name,
+        contents: await readFile(resolve(file.parentPath, file.name))
+      })
+    }
+  }
+}

package/lib/utils.js

@@ -1,31 +1,30 @@
-'use strict'
+import { EOL } from 'node:os'
+import { join } from 'node:path'
+import { setTimeout } from 'timers/promises'
+import { request } from 'undici'
+import { WrongTypeError } from './errors.js'
 
-const { WrongTypeError } = require('./errors')
-const { join } = require('node:path')
-const { request } = require('undici')
-const { setTimeout } = require('timers/promises')
-const PLT_ROOT = 'PLT_ROOT'
-const { EOL } = require('node:os')
-const { createDirectory } = require('@platformatic/utils')
+export const PLT_ROOT = 'PLT_ROOT'
 
 /**
  * Strip all extra characters from a simple semver version string
  * @param {string} version
  * @returns string
  */
-function stripVersion (version) {
+export function stripVersion (version) {
   const match = version.match(/(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)/)
   if (match) {
     return match[0]
   }
+  /* c8 ignore next */
   return version
 }
 
-function convertServiceNameToPrefix (serviceName) {
-  return serviceName.replace(/-/g, '_').toUpperCase()
+export function convertApplicationNameToPrefix (applicationName) {
+  return applicationName.replace(/-/g, '_').toUpperCase()
 }
 
-function addPrefixToString (input, prefix) {
+export function addPrefixToString (input, prefix) {
   if (!prefix) {
     return input
   }
@@ -39,7 +38,7 @@ function addPrefixToString (input, prefix) {
   }
 }
 
-function envObjectToString (env) {
+export function envObjectToString (env) {
   const output = []
   Object.entries(env).forEach(kv => {
     output.push(`${kv[0]}=${kv[1]}`)
@@ -47,7 +46,7 @@ function envObjectToString (env) {
   return output.join(EOL)
 }
 
-function envStringToObject (envString) {
+export function envStringToObject (envString) {
   const output = {}
   const split = envString.split(/\r?\n/)
   split
@@ -60,17 +59,19 @@ function envStringToObject (envString) {
     })
   return output
 }
-function extractEnvVariablesFromText (text) {
+
+export function extractEnvVariablesFromText (text) {
   const match = text.match(/\{[a-zA-Z0-9-_]*\}/g)
   if (match) {
     return match.map(found => found.replace('{', '').replace('}', '')).filter(found => found !== '')
   }
   return []
 }
-function getPackageConfigurationObject (config, serviceName = '') {
+
+export function getPackageConfigurationObject (config, applicationName = '') {
   const output = {
     config: {},
-    env: {},
+    env: {}
   }
   let current = output.config
   for (const param of config) {
@@ -99,7 +100,7 @@ function getPackageConfigurationObject (config, serviceName = '') {
         if (!param.name) {
           current[prop] = value
         } else {
-          const key = addPrefixToString(param.name, convertServiceNameToPrefix(serviceName))
+          const key = addPrefixToString(param.name, convertApplicationNameToPrefix(applicationName))
           // If it's a path, we need to add it to the env only the relative part of the path
           if (isPath) {
             current[prop] = `${join(`{${PLT_ROOT}}`, `{${key}}`)}`
@@ -121,7 +122,7 @@ function getPackageConfigurationObject (config, serviceName = '') {
   return output
 }
 
-async function getLatestNpmVersion (pkg) {
+export async function getLatestNpmVersion (pkg) {
   const npmCall = request(`https://registry.npmjs.org/${pkg}`)
   const timeout = setTimeout(1000, null)
   const res = await Promise.race([npmCall, timeout])
@@ -135,6 +136,7 @@ async function getLatestNpmVersion (pkg) {
   }
   return null
 }
+
 /**
  * Flatten a deep-nested object to a single level depth one
  * i.e from
@@ -154,7 +156,7 @@ async function getLatestNpmVersion (pkg) {
  * @param {Object} ob
  * @returns Object
  */
-function flattenObject (ob) {
+export function flattenObject (ob) {
   const result = {}
   for (const i in ob) {
     if (typeof ob[i] === 'object' && !Array.isArray(ob[i])) {
@@ -169,26 +171,12 @@ function flattenObject (ob) {
   return result
 }
 
-function getServiceTemplateFromSchemaUrl (schemaUrl) {
+export function getApplicationTemplateFromSchemaUrl (schemaUrl) {
   const splitted = schemaUrl.split('/')
 
+  /* c8 ignore next 3 - Legacy interface */
   if (schemaUrl.startsWith('https://platformatic.dev/schemas')) {
     return `@platformatic/${splitted[splitted.length - 1]}`
   }
   return `@platformatic/${splitted[splitted.length - 2]}`
 }
-
-module.exports = {
-  addPrefixToString,
-  convertServiceNameToPrefix,
-  getPackageConfigurationObject,
-  envObjectToString,
-  envStringToObject,
-  extractEnvVariablesFromText,
-  flattenObject,
-  getServiceTemplateFromSchemaUrl,
-  createDirectory,
-  stripVersion,
-  PLT_ROOT,
-  getLatestNpmVersion,
-}

package/package.json

@@ -1,31 +1,45 @@
 {
   "name": "@platformatic/generators",
-  "version": "3.4.1",
+  "version": "3.5.1",
   "description": "Main classes and utils for generators.",
   "main": "index.js",
-  "keywords": [],
-  "author": "",
+  "type": "module",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/platformatic/platformatic.git"
+  },
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/platformatic/platformatic/issues"
+  },
+  "homepage": "https://docs.platformatic.dev/docs/getting-started/quick-start",
+  "keywords": [],
   "dependencies": {
     "@fastify/error": "^4.0.0",
-    "boring-name-generator": "^1.0.3",
     "change-case-all": "^2.1.0",
+    "execa": "^9.6.0",
     "fastify": "^5.0.0",
-    "pino": "^9.0.0",
-    "undici": "^6.9.0",
-    "@platformatic/utils": "3.4.1"
+    "pino": "^9.9.0",
+    "undici": "^7.0.0",
+    "@platformatic/foundation": "3.5.1"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",
-    "borp": "^0.17.0",
     "c8": "^10.0.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
-    "neostandard": "^0.11.1",
-    "tsd": "^0.31.0",
+    "neostandard": "^0.12.0",
+    "tsd": "^0.33.0",
     "typescript": "^5.5.4"
   },
+  "engines": {
+    "node": ">=22.19.0"
+  },
   "scripts": {
     "lint": "eslint",
-    "test": "pnpm run lint && borp --timeout=180000 -C -X fixtures -X test --concurrency=1 && tsd"
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "posttest": "tsd"
   }
 }

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "esnext",
+    "esModuleInterop": true,
+    "lib": ["es2022"],
+    "target": "esnext",
+    "sourceMap": true,
+    "pretty": true,
+    "noEmitOnError": true,
+    "incremental": true,
+    "strict": true,
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": ["**/node_modules", "dist"]
+  }
+}

package/lib/base-generator.d.ts

@@ -1,122 +0,0 @@
-import { BaseLogger } from 'pino'
-import { FileGenerator } from './file-generator'
-import { PackageConfiguration } from './utils'
-export namespace BaseGenerator {
-  export type BaseGeneratorOptions = FileGenerator.FileGeneratorOptions & {
-    module: string
-    inquirer?: object
-  }
-
-  export type EnvVarValue = string | number | boolean
-  export type Env = {
-    [key: string]: EnvVarValue
-  }
-  type KeyValue = {
-    [key: string]: string | number | undefined | null | boolean | object
-  }
-  type JSONValue =
-    | string
-    | number
-    | boolean
-    | { [x: string]: JSONValue }
-    | object
-    | Array<JSONValue>
-
-  type Dependency = {
-    [key: string]: string
-  }
-
-  type PackageDefinition = {
-    name: string,
-    options: PackageConfiguration
-  }
-  type BaseGeneratorConfig = Record<string, any> & {
-    port?: number
-    hostname?: string
-    plugin?: boolean
-    dependencies?: Dependency
-    devDependencies?: Dependency
-    typescript?: boolean
-    initGitRepository?: boolean
-    env?: KeyValue,
-    isRuntimeContext?: boolean,
-    serviceName?: string,
-    envPrefix?: string
-  }
-
-  type WhereClause = {
-    before?: string
-    after?: string
-  }
-
-  type GeneratorMetadata = {
-    targetDirectory: string
-    env: KeyValue
-  }
-
-  type ConfigFieldDefinition = {
-    label: string
-    var: string
-    default: string
-    type: 'number' | 'string' | 'boolean' | 'path'
-    configValue?: string
-  }
-
-  type ConfigField = {
-    var: string
-    configValue?: string
-    value: string
-  }
-
-  type AddEnvVarOptions = {
-    overwrite: boolean
-  }
-
-  export class BaseGenerator extends FileGenerator.FileGenerator {
-    logger: BaseLogger
-    platformaticVersion: string
-    fastifyVersion: string
-
-    config: BaseGeneratorConfig
-    questions: Array<object>
-
-    packages: PackageConfiguration[]
-    constructor (opts?: BaseGeneratorOptions)
-
-    setConfig (config?: BaseGeneratorConfig): void
-
-    getEnvVarName (envVarName: string): string
-    addEnvVars (envVars: Env, opts: AddEnvVarOptions): void
-    addEnvVar (envVarName: string, envVarValue: EnvVarValue, opts: AddEnvVarOptions): void
-    getEnvVar (envVarName: string): EnvVarValue
-    setEnvVars (env?: Env): void
-
-    getDefaultConfig (): { [x: string]: JSONValue }
-
-    getFastifyVersion (): Promise<string>
-    getPlatformaticVersion (): Promise<string>
-
-    addPackage (pkg: PackageDefinition): Promise<void>
-
-    loadFromDir (dir: string): Promise<void>
-    prepare (): Promise<GeneratorMetadata>
-    run (): Promise<GeneratorMetadata>
-    addQuestion (question: any, where?: WhereClause): Promise<void>
-    removeQuestion (variableName: string): void
-    getTSConfig (): { [x: string]: JSONValue }
-
-    getConfigFieldsDefinitions (): ConfigFieldDefinition[]
-    setConfigFields (fields: ConfigField[]): void
-
-    generateConfigFile (): Promise<void>
-    readPackageJsonFile (): Promise<JSONValue>
-    generatePackageJson (): Promise<{ [x: string]: JSONValue }>
-    getConfigFileName (): string
-    checkEnvVariablesInConfigFile (): boolean
-    _beforePrepare (): Promise<void>
-    _afterPrepare (): Promise<void | JSONValue>
-    _getConfigFileContents (): Promise<{ [x: string]: BaseGenerator.JSONValue }>
-
-    postInstallActions (): Promise<void>
-  }
-}

package/lib/create-plugin.d.ts

@@ -1,13 +0,0 @@
-import { FileGenerator } from './file-generator'
-
-type HelperCustomization = {
-  pre: string
-  post: string
-  config: string
-  requires: string
-}
-
-export function generatePluginWithTypesSupport (typescript: boolean): FileGenerator.FileObject
-export function generateRouteWithTypesSupport (typescript: boolean): FileGenerator.FileObject
-export function generateTests (typescript: boolean, type: string, customization?: HelperCustomization): Array<FileGenerator.FileObject>
-export function generatePlugins (typescript: boolean): Array<FileGenerator.FileObject>