@ackee/create-node-app 1.0.1 → 2.0.0

package/src/Bootstrap.ts

@@ -1,99 +1,140 @@
-import { CloudRunStarter } from './cloudrun/CloudRunStarter.js'
-import { Npm } from './Npm.js'
-import { Toolbelt } from './Toolbelt.js'
+import inquirer from 'inquirer'
 import * as path from 'path'
-import { PackageJson } from './PackageJson.js'
-import { GraphQLStarter } from './cloudrun-graphql/GraphQLStarter.js'
-import { Path } from './types.js'
+import * as fs from 'fs'
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
-import { logger } from './Logger.js'
-import { Starter } from './Starter.js'
+import { Builder } from './Builder.js'
+import { Logger } from './Logger.js'
+import { Npm } from './Npm.js'
+import { PackageJson } from './PackageJson.js'
+import { LoadedStarter, StarterLoader } from './StarterLoader.js'
+import { Path } from './types.js'
+
+interface ParsedArgs {
+  dir: string
+  debug: boolean
+  force: boolean
+  projectName: string
+  [key: string]: unknown
+}
 
 export class Bootstrap {
-  protected starters: Starter[] = [new CloudRunStarter(), new GraphQLStarter()]
+  protected starterLoader = new StarterLoader()
 
-  public runCLI(args: string[]) {
-    const cli = yargs(hideBin(args))
-      .usage('create-node-app <starter> [options]')
-      .positional('starter', {
+  private async askMissingOptions(parsedArgs: ParsedArgs) {
+    const starters: LoadedStarter[] = []
+
+    for (const module of this.starterLoader.getOptions()) {
+      const moduleOption = parsedArgs[module.name.toLowerCase()] as string
+      if (moduleOption) {
+        if (moduleOption !== 'none') {
+          starters.push(this.starterLoader.getStarter(moduleOption))
+        }
+        continue
+      }
+
+      const answer = await inquirer.prompt<{ starter: string }>({
+        type: 'list',
         name: 'starter',
-        type: 'string',
-        required: true,
-        description: 'Which template to setup (required)',
-        choices: this.starters.map(starter => starter.name),
-      })
-      .option('dir', {
-        type: 'string',
-        alias: 'd',
-        default: './node-app',
-        description: 'Destination directory',
+        message: `Which ${module.name} would you like to use?`,
+        choices: [...module.starters, 'none'],
       })
-      .option('project-name', {
-        type: 'string',
-        alias: 'n',
-        default: 'node-app',
-        description: 'Google Cloud project name',
-      })
-      .option('force', {
-        type: 'boolean',
-        alias: 'f',
-        default: false,
-        description:
-          "Overwrite existing destination directory if it's not empty",
-      })
-      .version('1.0.0')
-      .help()
 
-    const parsedArgs = cli.parseSync()
-    const starterArg = parsedArgs._[0]
+      if (answer.starter !== 'none') {
+        starters.push(this.starterLoader.getStarter(answer.starter))
+      }
+    }
+    return starters
+  }
 
-    const starter = this.starters.find(x => x.name === starterArg)
-    const destination = path.normalize(parsedArgs.dir) as Path
+  public async runCLI(args: string[]) {
+    try {
+      let cli = yargs(hideBin(args))
+        .usage('create-node-app [options]')
+        .option('dir', {
+          type: 'string',
+          alias: 'd',
+          default: './node-app',
+          description: 'Destination directory',
+        })
+        .option('debug', {
+          type: 'boolean',
+          alias: 'D',
+          default: false,
+          description: 'Enables debug logs',
+        })
+        .option('project-name', {
+          type: 'string',
+          alias: 'n',
+          default: 'node-app',
+          description: 'Google Cloud project name',
+        })
+        .option('force', {
+          type: 'boolean',
+          alias: 'f',
+          default: false,
+          description:
+            "Overwrite existing destination directory if it's not empty",
+        })
 
-    if (!starter) {
-      logger.info('Invalid starter')
-      cli.showHelp()
-      process.exit(1)
-    }
+      const starterOptions = this.starterLoader.getOptions()
+      for (const module of starterOptions) {
+        cli = cli.option(module.name.toLowerCase(), {
+          type: 'string',
+          choices: ['none', ...module.starters],
+          description: `Selects ${module.name}`,
+        })
+      }
+
+      cli = cli
+        .version('1.0.0')
+        .help()
+        .check(argv => {
+          for (const [key, val] of Object.entries(argv)) {
+            if (Array.isArray(val) && key !== '_') {
+              throw new Error(`Option --${key} specified multiple times`)
+            }
+          }
+          return true
+        })
+
+      const parsedArgs = cli.parseSync()
+
+      const destination = path.normalize(parsedArgs.dir) as Path
 
-    logger.info(`starter=${starter.name}, destination=${destination}`)
-
-    const npm = new Npm({ dir: destination })
-    const packageJson = new PackageJson(npm)
-    const toolbelt = new Toolbelt({
-      npm,
-      packageJson,
-      assetDirectory: path.join(
-        import.meta.dirname,
-        '..',
-        'starter',
-        starter.name
-      ),
-      sharedDirectory: path.join(
-        import.meta.dirname,
-        '..',
-        'starter',
-        'shared'
-      ),
-      destination: destination,
-      projectName: parsedArgs.projectName,
-    })
-    starter.setToolbelt(toolbelt)
-
-    if (!toolbelt.isDirectoryEmpty(destination)) {
-      if (!parsedArgs.force) {
-        logger.info(
-          `Directory '${destination}' already exists and is not empty. Use --force or -f flag to overwrite the existing directory.`
-        )
-        process.exit(1)
+      const logger = new Logger(parsedArgs.debug)
+      const npm = new Npm({ dir: destination, logger })
+      const packageJson = new PackageJson(npm, logger)
+
+      if (fs.existsSync(destination) && !parsedArgs.force) {
+        const answer = await inquirer.prompt<{ force: boolean }>({
+          type: 'confirm',
+          name: 'force',
+          message: `Destination directory "${destination}" already exists. Do you want to overwrite everything in it?`,
+        })
+        if (!answer.force) {
+          process.exit(0)
+        }
+      }
+
+      const starters = await this.askMissingOptions(parsedArgs)
+
+      const builder = new Builder({
+        npm,
+        logger,
+        packageJson,
+        starters,
+        destination: destination,
+        projectName: parsedArgs.projectName,
+      })
+
+      await builder.build()
+    } catch (error) {
+      if (error instanceof Error && error.name === 'ExitPromptError') {
+        process.exit(0)
       } else {
-        logger.info(`Overwriting existing directory '${destination}'`)
+        throw error
       }
     }
-
-    toolbelt.mkdir(destination, { overwrite: parsedArgs.force })
-    toolbelt.npm.init()
-    starter.install()
   }
 }

package/src/Builder.ts

@@ -0,0 +1,172 @@
+import glob from 'fast-glob'
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { Logger } from './Logger.js'
+import { Npm } from './Npm.js'
+import { PackageJson } from './PackageJson.js'
+import { LoadedStarter, StarterConfig } from './StarterLoader.js'
+import { Merger } from './Mergers/Merger.js'
+import { PackageJsonMerger } from './Mergers/PackageJsonMerger.js'
+import { EnvJsoncMerger } from './Mergers/EnvJsoncMerger.js'
+import { ConfigMerger } from './Mergers/ConfigMerger.js'
+import { ContainerMerger } from './Mergers/ContainerMerger.js'
+import { Files } from './Files.js'
+
+export class Builder {
+  public static readonly BASE_STARTER_DIR = path.normalize(
+    path.join(import.meta.dirname, '..', 'starter', '_base')
+  )
+  public static readonly IGNORED_FILES = ['node-app.jsonc']
+
+  public readonly npm: Npm
+  protected readonly logger: Logger
+  protected readonly starters: LoadedStarter[]
+  protected readonly fileMergers: Merger[]
+  protected readonly destination: string
+  protected readonly projectName: string
+  protected readonly replacements: Record<string, string>
+
+  constructor(params: {
+    npm: Npm
+    logger: Logger
+    packageJson: PackageJson
+    starters: LoadedStarter[]
+    destination: string
+    projectName: string
+  }) {
+    this.npm = params.npm
+    this.logger = params.logger
+    this.starters = params.starters
+    this.destination = params.destination
+    this.projectName = params.projectName
+    this.replacements = {
+      '{{PROJECT_NAME}}': this.projectName,
+    }
+    this.fileMergers = [
+      new PackageJsonMerger(this.projectName, this.destination, 'package.json'),
+      new EnvJsoncMerger(this.destination, '.env.jsonc'),
+      new ConfigMerger(this.destination, 'src/config.ts'),
+      new ContainerMerger(this.destination, 'src/container.ts'),
+    ]
+  }
+
+  protected async prepareFolder() {
+    if (await Files.existsAndIsDir(this.destination)) {
+      await fs.rm(this.destination, { recursive: true })
+    }
+    await fs.mkdir(this.destination, { recursive: true })
+  }
+
+  public async build() {
+    try {
+      await this.logger.loader(`Preparing clean folder`, this.prepareFolder())
+
+      await this.logger.loader(
+        `Preparing folder structure`,
+        this.buildStarter(Builder.BASE_STARTER_DIR)
+      )
+
+      for (const starter of this.starters) {
+        await this.logger.loader(
+          `Adding ${starter.config.name} ${starter.config.module}`,
+          this.buildStarter(starter.path, starter.config)
+        )
+      }
+
+      await this.logger.loader(`npm install`, this.npm.run(['install']))
+
+      const prebuildScripts: Array<string[]> = this.starters
+        .map(starter => starter.config.prebuild)
+        .filter(script => script !== undefined)
+
+      for (const script of prebuildScripts) {
+        await this.logger.loader(
+          `npm run ${script.join(' ')}`,
+          this.npm.run(['run', ...script])
+        )
+      }
+
+      await this.logger.loader(`npm run build`, this.npm.run(['run', 'build']))
+
+      this.logger.info(
+        `Your app is ready in ${path.relative(
+          process.cwd(),
+          this.destination
+        )}! 🚀`
+      )
+    } catch (error) {
+      this.logger.error(error)
+      process.exit(1)
+    }
+  }
+
+  protected async buildStarter(starterDir: string, config?: StarterConfig) {
+    const destDir = path.normalize(path.resolve(this.destination))
+    const files = await glob(`${starterDir}/*`, {
+      cwd: starterDir,
+      dot: true,
+      onlyFiles: false,
+    })
+
+    const ignoredFiles = Builder.IGNORED_FILES.map(file =>
+      path.join(starterDir, file)
+    )
+
+    const mergedFiles = await Promise.all(
+      this.fileMergers.map(async merger => {
+        return {
+          path: merger.getDestPath(),
+          content: await merger.merge(starterDir),
+        }
+      })
+    )
+
+    await Promise.all(
+      files.map(async filePath => {
+        if (ignoredFiles.includes(filePath)) {
+          return
+        }
+        const destFilePath = path.join(destDir, path.basename(filePath))
+        if (await Files.existsAndIsDir(filePath)) {
+          await fs.cp(filePath, destFilePath, { recursive: true })
+          return
+        }
+        await fs.cp(filePath, destFilePath)
+      })
+    )
+
+    await Promise.all(
+      mergedFiles.map(async ({ path, content }) => fs.writeFile(path, content))
+    )
+
+    if (config?.replace) {
+      await Promise.all(
+        config.replace.map(async filePath => this.replaceInFile(filePath))
+      )
+    }
+  }
+
+  public async replaceInFile(filePath: string) {
+    filePath = path.normalize(path.join(this.destination, filePath))
+    let content = await Files.readUtf8File(filePath)
+    content = Object.keys(this.replacements).reduce((acc, key) => {
+      return acc.replaceAll(key, this.replacements[key])
+    }, content)
+    return fs.writeFile(filePath, content)
+  }
+
+  public async symlink(linkName: string, linkedFile: string) {
+    linkName = path.normalize(linkName)
+    linkedFile = path.normalize(linkedFile)
+    this.logger.info(`> ln -s ${linkName} ${linkedFile}`)
+    try {
+      await fs.symlink(linkedFile, linkName)
+    } catch (error) {
+      if ('code' in error && error.code === 'EEXIST') {
+        // OK
+      } else {
+        throw error
+      }
+    }
+  }
+}

package/src/Files.ts

@@ -0,0 +1,22 @@
+import * as fsp from 'fs/promises'
+import path from 'path'
+
+export class Files {
+  public static async exists(filepath: string) {
+    const stat = await fsp.stat(filepath).catch(() => undefined)
+    return Boolean(stat)
+  }
+
+  public static async existsAndIsDir(filepath: string) {
+    const stat = await fsp.stat(filepath).catch(() => undefined)
+    return Boolean(stat?.isDirectory())
+  }
+  public static async readUtf8File(filepath: string) {
+    return fsp.readFile(filepath, 'utf8')
+  }
+  public static isInSameTree(tree: string, filepath: string) {
+    const file = path.normalize(filepath)
+    const fileTree = path.normalize(tree)
+    return file.startsWith(fileTree)
+  }
+}

package/src/Logger.ts

@@ -1,11 +1,30 @@
-export const logger = {
-  info: (message: string) => {
+import { oraPromise } from 'ora'
+
+export class Logger {
+  constructor(public readonly enableDebug: boolean = false) {}
+
+  info(message: string) {
     console.log(message)
-  },
-  verbose: (message: string) => {
+  }
+  verbose(message: string) {
     console.log(message)
-  },
-  error: (message: string) => {
+  }
+  error(message: string) {
     console.log(message)
-  },
+  }
+  debug(message: string) {
+    if (this.enableDebug) {
+      console.log(message)
+    }
+  }
+  loader(message: string, promise: Promise<any>) {
+    if (this.enableDebug) {
+      this.info(message)
+      return promise
+    }
+
+    return oraPromise(promise, {
+      text: message,
+    })
+  }
 }

package/src/Mergers/ConfigMerger.ts

@@ -0,0 +1,28 @@
+import { Files } from '../Files.js'
+import { Merger } from './Merger.js'
+
+export class ConfigMerger extends Merger {
+  name = 'Config'
+
+  async merge(originDir: string): Promise<string> {
+    const content = await this.getWhichExistsOrNull(originDir)
+    if (content) {
+      return content
+    }
+
+    const { originPath, destPath } = this.getPaths(originDir)
+
+    const [destTsConfig, originTsConfig] = await Promise.all([
+      Files.readUtf8File(destPath),
+      Files.readUtf8File(originPath),
+    ])
+    const configContent = /configSchema = {\n(.*?)\n}\n/s.exec(
+      originTsConfig
+    )?.[1]
+
+    return destTsConfig.replace(
+      '\n}\n',
+      configContent ? `${configContent}\n}\n` : '}\n'
+    )
+  }
+}