@ackee/create-node-app 1.0.1 → 2.0.2

package/src/Mergers/ContainerMerger.ts

@@ -0,0 +1,241 @@
+import { Merger } from './Merger.js'
+import * as ts from 'typescript'
+import { Files } from '../Files.js'
+
+export class ContainerMerger extends Merger {
+  async merge(originDir: string): Promise<string> {
+    const content = await this.getWhichExistsOrNull(originDir)
+    if (content) {
+      return content
+    }
+
+    const { originPath, destPath } = this.getPaths(originDir)
+
+    const [originContainer, destContainer] = await Promise.all([
+      Files.readUtf8File(originPath),
+      Files.readUtf8File(destPath),
+    ])
+
+    const originAst = this.parseFile(originContainer)
+    const destAst = this.parseFile(destContainer)
+
+    const mergedImports = this.mergeImports(originAst, destAst)
+    const mergedInterface = this.mergeInterface(originAst, destAst)
+    const mergedFunction = this.mergeFunction(originAst, destAst)
+
+    return `${mergedImports}\n\n${mergedInterface}\n\nexport type ContainerFactory = () => Promise<Container>\n\n${mergedFunction}\n`
+  }
+
+  protected parseFile(content: string): ts.SourceFile {
+    return ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true)
+  }
+
+  protected mergeImports(
+    originAst: ts.SourceFile,
+    destAst: ts.SourceFile
+  ): string {
+    const imports: string[] = []
+
+    const addImports = (node: ts.Node) => {
+      if (!ts.isImportDeclaration(node)) {
+        node.forEachChild(addImports)
+        return
+      }
+
+      const importText = node.getText()
+      if (!imports.includes(importText)) {
+        imports.push(importText)
+      }
+
+      node.forEachChild(addImports)
+    }
+
+    addImports(originAst)
+    addImports(destAst)
+
+    return imports.join('\n')
+  }
+
+  protected mergeInterface(
+    originAst: ts.SourceFile,
+    destAst: ts.SourceFile
+  ): string {
+    const properties: string[] = []
+
+    const extractProperties = (node: ts.Node) => {
+      if (!ts.isInterfaceDeclaration(node) || node.name.text !== 'Container') {
+        node.forEachChild(extractProperties)
+        return
+      }
+
+      node.members.forEach(member => {
+        if (!ts.isPropertySignature(member)) {
+          return
+        }
+
+        const propText = member.getText().trim()
+        if (!properties.includes(propText)) {
+          properties.push(propText)
+        }
+      })
+
+      node.forEachChild(extractProperties)
+    }
+
+    extractProperties(originAst)
+    extractProperties(destAst)
+
+    return `export interface Container {\n  ${properties.join('\n  ')}\n}`
+  }
+
+  protected mergeFunction(
+    originAst: ts.SourceFile,
+    destAst: ts.SourceFile
+  ): string {
+    const originFunctionBody = this.extractFunctionBody(originAst)
+    const destFunctionBody = this.extractFunctionBody(destAst)
+
+    const allFunctionContent = [
+      ...originFunctionBody.content,
+      ...destFunctionBody.content,
+    ]
+
+    const mergedReturnProps = this.mergeReturnProperties(
+      originFunctionBody.returnProps,
+      destFunctionBody.returnProps
+    )
+
+    let body = ''
+    if (allFunctionContent.length > 0) {
+      body += allFunctionContent.join('\n') + '\n\n'
+    }
+
+    body += `  return {\n    ${mergedReturnProps.join(',\n    ')}\n  }`
+
+    return `export const createContainer = async (): Promise<Container> => {\n${body}\n}`
+  }
+
+  protected mergeReturnProperties(
+    originProps: ts.ObjectLiteralElementLike[],
+    destProps: ts.ObjectLiteralElementLike[]
+  ): string[] {
+    const mergedProps = new Map<string, ts.ObjectLiteralElementLike>()
+
+    originProps.forEach(prop => {
+      const propName = this.getPropertyName(prop)
+      if (propName) {
+        mergedProps.set(propName, prop)
+      }
+    })
+
+    destProps.forEach(prop => {
+      const propName = this.getPropertyName(prop)
+      if (propName) {
+        mergedProps.set(propName, prop)
+      }
+    })
+
+    return Array.from(mergedProps.values()).map(prop => {
+      const propText = prop.getText()
+      if (
+        ts.isPropertyAssignment(prop) &&
+        ts.isObjectLiteralExpression(prop.initializer)
+      ) {
+        return this.formatNestedObject(propText)
+      }
+      return propText
+    })
+  }
+
+  protected getPropertyName(prop: ts.ObjectLiteralElementLike): string | null {
+    if (ts.isPropertyAssignment(prop)) {
+      if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) {
+        return prop.name.text
+      }
+    } else if (ts.isShorthandPropertyAssignment(prop)) {
+      return prop.name.text
+    }
+    return null
+  }
+
+  protected formatNestedObject(propText: string): string {
+    const lines = propText.split('\n')
+    return lines
+      .map((line, index) => {
+        if (index === 0) {
+          return line
+        }
+        return '    ' + line
+      })
+      .join('\n')
+  }
+
+  protected extractFunctionBody(ast: ts.SourceFile): {
+    content: string[]
+    returnProps: ts.ObjectLiteralElementLike[]
+  } {
+    const content: string[] = []
+    const returnProps: ts.ObjectLiteralElementLike[] = []
+
+    const visit = (node: ts.Node) => {
+      if (!this.isCreateContainer(node)) {
+        ts.forEachChild(node, visit)
+        return
+      }
+
+      if (!node.initializer || !ts.isArrowFunction(node.initializer)) {
+        ts.forEachChild(node, visit)
+        return
+      }
+
+      const body = node.initializer.body
+      if (!ts.isBlock(body)) {
+        ts.forEachChild(node, visit)
+        return
+      }
+
+      body.statements.forEach(statement => {
+        if (this.isContentStatement(statement)) {
+          content.push(statement.getText().trim())
+        } else if (this.isReturnWithObject(statement)) {
+          // Extract the actual property nodes, not just their names
+          statement.expression.properties.forEach(prop => {
+            returnProps.push(prop)
+          })
+        }
+      })
+
+      ts.forEachChild(node, visit)
+    }
+
+    visit(ast)
+    return { content, returnProps }
+  }
+
+  protected isCreateContainer(node: ts.Node): node is ts.VariableDeclaration {
+    return (
+      ts.isVariableDeclaration(node) &&
+      node.name.getText() === 'createContainer'
+    )
+  }
+
+  protected isContentStatement(statement: ts.Statement): boolean {
+    return (
+      ts.isVariableStatement(statement) ||
+      (ts.isExpressionStatement(statement) &&
+        ts.isCallExpression(statement.expression))
+    )
+  }
+
+  protected isReturnWithObject(
+    statement: ts.Statement
+  ): statement is ts.ReturnStatement & {
+    expression: ts.ObjectLiteralExpression
+  } {
+    return (
+      ts.isReturnStatement(statement) &&
+      !!statement.expression &&
+      ts.isObjectLiteralExpression(statement.expression)
+    )
+  }
+}

package/src/Mergers/EnvJsoncMerger.ts

@@ -0,0 +1,24 @@
+import { Merger } from './Merger.js'
+import { Files } from '../Files.js'
+
+export class EnvJsoncMerger extends Merger {
+  async merge(originDir: string): Promise<string> {
+    const content = await this.getWhichExistsOrNull(originDir)
+    if (content) {
+      return content
+    }
+
+    const { originPath, destPath } = this.getPaths(originDir)
+
+    const [destEnvConfig, originEnvConfig] = await Promise.all([
+      Files.readUtf8File(destPath),
+      Files.readUtf8File(originPath),
+    ])
+
+    const originWithoutOpenBracket = originEnvConfig.replace('{\n', '')
+
+    return destEnvConfig
+      .replace(',\n}\n', '\n}\n')
+      .replace('\n}\n', `,\n${originWithoutOpenBracket}`)
+  }
+}

package/src/Mergers/Merger.ts

@@ -0,0 +1,51 @@
+import path from 'path'
+import { Files } from '../Files.js'
+
+export abstract class Merger {
+  abstract merge(originDir: string): Promise<string>
+
+  protected destPath: string
+
+  constructor(
+    protected readonly destDir: string,
+    protected readonly pathToFile: string
+  ) {
+    this.destPath = path.join(this.destDir, this.pathToFile)
+  }
+
+  public getDestPath() {
+    return this.destPath
+  }
+
+  protected getPaths(originDir: string) {
+    return {
+      originPath: path.join(originDir, this.pathToFile),
+      destPath: this.getDestPath(),
+    }
+  }
+
+  protected async getWhichExistsOrNull(
+    originDir: string
+  ): Promise<string | null> {
+    const { originPath, destPath } = this.getPaths(originDir)
+
+    const [originExists, destExists] = await Promise.all([
+      Files.exists(originPath),
+      Files.exists(destPath),
+    ])
+
+    if (!originExists && destExists) {
+      return Files.readUtf8File(destPath)
+    }
+
+    if (!destExists && originExists) {
+      return Files.readUtf8File(originPath)
+    }
+
+    if (!originExists && !destExists) {
+      throw new Error(`No file found to merge: ${this.pathToFile}`)
+    }
+
+    return null
+  }
+}

package/src/Mergers/PackageJsonMerger.ts

@@ -0,0 +1,45 @@
+import { Merger } from './Merger.js'
+import { Files } from '../Files.js'
+
+export class PackageJsonMerger extends Merger {
+  constructor(
+    private readonly projectName: string,
+    destDir: string,
+    pathToFile: string
+  ) {
+    super(destDir, pathToFile)
+  }
+
+  async merge(originDir: string): Promise<string> {
+    const content = await this.getWhichExistsOrNull(originDir)
+    if (content) {
+      return content
+    }
+
+    const { originPath, destPath } = this.getPaths(originDir)
+
+    const [destPckgJson, starterPckgJson] = await Promise.all([
+      Files.readUtf8File(destPath),
+      Files.readUtf8File(originPath),
+    ])
+
+    const destPckgJsonObj = JSON.parse(destPckgJson)
+    const starterPckgJsonObj = JSON.parse(starterPckgJson)
+
+    destPckgJsonObj.name = this.projectName
+    destPckgJsonObj.scripts = {
+      ...destPckgJsonObj.scripts,
+      ...starterPckgJsonObj.scripts,
+    }
+    destPckgJsonObj.dependencies = {
+      ...destPckgJsonObj.dependencies,
+      ...starterPckgJsonObj.dependencies,
+    }
+    destPckgJsonObj.devDependencies = {
+      ...destPckgJsonObj.devDependencies,
+      ...starterPckgJsonObj.devDependencies,
+    }
+
+    return JSON.stringify(destPckgJsonObj, null, 2)
+  }
+}

package/src/Npm.ts

@@ -1,27 +1,72 @@
 import * as childProcess from 'child_process'
-import { logger } from './Logger.js'
+import { Logger } from './Logger.js'
 import { Path } from './types.js'
 
+export class NpmError extends Error {
+  constructor(
+    message: string,
+    public readonly code: number | null
+  ) {
+    super(message)
+    this.name = 'NpmError'
+  }
+}
+
 export class Npm {
+  protected readonly logger: Logger
   public readonly dir: Path
-  constructor(settings?: { dir?: Path }) {
+
+  constructor(settings?: { dir?: Path; logger?: Logger }) {
+    this.logger = settings?.logger ?? new Logger()
     this.dir = settings?.dir as Path
   }
+
+  protected spawn(
+    cmd: string,
+    args: ReadonlyArray<string>,
+    options: childProcess.SpawnOptions = {}
+  ) {
+    return new Promise((resolve, reject) => {
+      const cp = childProcess.spawn(cmd, args, options)
+      const error: string[] = []
+      const stdout: string[] = []
+
+      cp.stdout?.on('data', data => {
+        stdout.push(data.toString())
+      })
+
+      cp.on('error', e => {
+        error.push(e.toString())
+      })
+
+      cp.on('close', code => {
+        if (error.length || (code !== null && code > 0)) {
+          reject(
+            new NpmError(
+              error.length ? error.join('') : stdout.join(''),
+              code ?? null
+            )
+          )
+        } else {
+          resolve(undefined)
+        }
+      })
+    })
+  }
+
   public run(args: string[]) {
-    logger.info(`> npm ${args.join(' ')}`)
-    const result = this.dir
-      ? childProcess.spawnSync('npm', args, {
+    this.logger.debug(`> npm ${args.join(' ')}`)
+    const options: childProcess.SpawnOptions = this.dir
+      ? {
           cwd: this.dir,
-        })
-      : childProcess.spawnSync('npm', args)
-    if ((result?.status ?? 0) > 0) {
-      logger.info(
-        `Failed npm command: npm ${args.join(' ')}. ${String(result.output)}`
-      )
-    }
+          stdio: this.logger.enableDebug ? 'inherit' : 'pipe',
+        }
+      : { stdio: this.logger.enableDebug ? 'inherit' : 'pipe' }
+
+    return this.spawn('npm', args, options)
   }
   public init() {
-    this.run(['init', '--yes'])
+    return this.run(['init', '--yes'])
   }
 
   public i(module?: string) {
@@ -29,10 +74,10 @@ export class Npm {
       return this.run(['i'])
     }
     const args = ['i', module]
-    this.run(args)
+    return this.run(args)
   }
   public iDev(module: string) {
     const args = ['i', '-D', module]
-    this.run(args)
+    return this.run(args)
   }
 }

package/src/PackageJson.ts

@@ -2,19 +2,21 @@ import * as path from 'path'
 import * as fs from 'fs'
 import * as lodash from 'lodash-es'
 import { Npm } from './Npm.js'
-import { logger } from './Logger.js'
 import { Path } from './types.js'
+import { Logger } from './Logger.js'
 
 export class PackageJson {
   public readonly path: Path
   protected npm: Npm
-  constructor(npm: Npm) {
+  protected logger: Logger
+  constructor(npm: Npm, logger: Logger) {
     let packagejsonPath = './package.json' as Path
     if (npm.dir) {
       packagejsonPath = path.normalize(`${npm.dir}/${packagejsonPath}`) as Path
     }
     this.path = packagejsonPath
     this.npm = npm
+    this.logger = logger
   }
   public setType(type: 'module' | 'commonjs') {
     this.mergeWith({
@@ -25,7 +27,7 @@ export class PackageJson {
     return JSON.parse(fs.readFileSync(this.path, 'utf-8'))
   }
   public runScript(name: string) {
-    this.npm.run(['run', name])
+    return this.npm.run(['run', name])
   }
   public addNpmScript(name: string, command: string) {
     this.mergeWith({
@@ -37,7 +39,7 @@ export class PackageJson {
   // Updated package json using merge with given object
   public mergeWith(partialWith: any) {
     const json = lodash.merge(this.toJSON(), partialWith)
-    logger.info(`> package.json updated ${JSON.stringify(partialWith)}`)
+    this.logger.debug(`> package.json updated ${JSON.stringify(partialWith)}`)
     fs.writeFileSync(
       path.join(this.path),
       JSON.stringify(json, null, 2),

package/src/Starter.ts

@@ -1,7 +1,7 @@
-import { Toolbelt } from './Toolbelt.js'
+import { Builder } from './Builder.js'
 
 export interface Starter {
   readonly name: string
-  setToolbelt(toolbelt: Toolbelt): Starter
+  setToolbelt(toolbelt: Builder): Starter
   install(): void
 }

package/src/StarterLoader.ts

@@ -0,0 +1,148 @@
+import glob from 'fast-glob'
+import fs from 'node:fs'
+import path from 'node:path'
+import { Files } from './Files.js'
+
+export interface StarterConfig {
+  module: string
+  name: string
+  id: string
+  prebuild?: string[]
+  replace?: string[]
+  merge?: string[]
+}
+
+export interface LoadedStarter {
+  name: string
+  config: StarterConfig
+
+  path: string
+  configPath: string
+}
+
+export interface StarterModule {
+  name: string
+  starters: string[]
+}
+
+export class StarterLoader {
+  private static readonly starterPath: string = path.normalize(
+    path.join(import.meta.dirname, '..', 'starter')
+  )
+  private readonly starters: Map<string, LoadedStarter> = new Map()
+  private readonly modules: StarterModule[] = []
+
+  constructor() {
+    const configFiles = glob.sync(
+      `${StarterLoader.starterPath}/**/node-app.jsonc`
+    )
+
+    for (const configFile of configFiles) {
+      const config = StarterLoader.validateConfig(
+        configFile,
+        JSON.parse(fs.readFileSync(configFile, 'utf8'))
+      )
+
+      const original = this.starters.get(config.id)
+      if (original) {
+        throw new Error(
+          `Duplicate starter: ${config.name}\n` +
+            `> Starter 1: ${original.path}\n` +
+            `> Starter 2: ${path.dirname(configFile)}`
+        )
+      }
+
+      this.starters.set(config.id, {
+        name: config.name,
+        config,
+        path: path.dirname(configFile),
+        configPath: configFile,
+      })
+
+      const module = this.modules.find(module => module.name === config.module)
+      if (module) {
+        module.starters.push(config.id)
+        continue
+      }
+      this.modules.push({
+        name: config.module,
+        starters: [config.id],
+      })
+    }
+
+    this.modules.sort((a, b) => a.name.localeCompare(b.name))
+  }
+
+  getOptions(): StarterModule[] {
+    return this.modules
+  }
+
+  getStarter(id: string): LoadedStarter {
+    const starter = this.starters.get(id)
+    if (!starter) {
+      throw new Error(`Starter ${id} not found`)
+    }
+    return starter
+  }
+
+  private static validateConfig(
+    configPath: string,
+    config: any
+  ): StarterConfig {
+    if (!config.module) {
+      throw new Error(`Invalid config at ${configPath}: module key is required`)
+    }
+    if (!config.name) {
+      throw new Error(`Invalid config at ${configPath}: name key is required`)
+    }
+    if (!config.id) {
+      throw new Error(`Invalid config at ${configPath}: id key is required`)
+    }
+    if (!StarterLoader.isValidOptionalStringArray(config.prebuild)) {
+      throw new Error(
+        `Invalid config at ${configPath}: "prebuild" must be array of npm script names or empty`
+      )
+    }
+
+    if (!StarterLoader.isValidOptionalStringArray(config.replace)) {
+      throw new Error(
+        `Invalid config at ${configPath}: "replace" must be array of files where strings should be replaced`
+      )
+    }
+    if (config.replace) {
+      const configDir = path.dirname(configPath)
+
+      const invalidReplace = config.replace.find((replace: string) => {
+        const replacePath = path.join(configDir, replace)
+        return (
+          !fs.existsSync(replacePath) ||
+          !Files.isInSameTree(configDir, path.join(configDir, replacePath))
+        )
+      })
+
+      if (invalidReplace) {
+        throw new Error(
+          `Invalid config at ${configPath}: "replace" must be array of files in the project directory, got: ${invalidReplace}`
+        )
+      }
+    }
+
+    const invalidKeys = Object.keys(config).filter(
+      key => !['module', 'name', 'prebuild', 'replace', 'id'].includes(key)
+    )
+    if (invalidKeys.length > 0) {
+      throw new Error(
+        `Invalid config at ${configPath}: Unknown key(s): ${invalidKeys.join(', ')}`
+      )
+    }
+    return config
+  }
+
+  protected static isValidOptionalStringArray(array: any): array is string[] {
+    return (
+      !array ||
+      (Array.isArray(array) &&
+        array.every((item: any) => typeof item === 'string'))
+    )
+  }
+}

package/starter/{cloudrun → _base}/.env.jsonc

@@ -2,9 +2,5 @@
   // Logging level, see https://github.com/pinojs/pino/blob/master/docs/api.md#logger-level
   "LOGGER_DEFAULT_LEVEL": "debug",
   // Enable/disable logging object multiline formatted logging https://github.com/pinojs/pino/blob/master/docs/api.md#prettyprint-boolean--object
-  "LOGGER_PRETTY": false,
-  // API server listening port.
-  "SERVER_PORT": 3000,
-  // Boolean to remove sensitive info from http error responses
-  "ENABLE_PRODUCTION_HTTP_ERROR_RESPONSES": false
+  "LOGGER_PRETTY": false
 }

package/starter/{cloudrun → _base}/.eslintrc.cjs

@@ -1,8 +1,9 @@
+
 module.exports = {
   ...require('@ackee/styleguide-backend-config/eslint'),
   root: true,
-  ignorePatterns: ['dist', 'src/openapi', 'docs'],
+  ignorePatterns: ['dist', 'docs', 'knexfile.ts'],
   parserOptions: {
     project: '.eslint.tsconfig.json',
   },
-}
+}