npm-update-package 0.1.0

package/src/main.ts

@@ -0,0 +1,105 @@
+import {
+  Committer,
+  Git
+} from './git'
+import {
+  createGitHub,
+  PullRequestCreator,
+  RemoteBranchExistenceChecker
+} from './github'
+import type { Logger } from './logger'
+import { Ncu } from './ncu'
+import type { Options } from './options'
+import { OutdatedPackageProcessor } from './outdated-package-processor'
+import { OutdatedPackagesProcessor } from './outdated-packages-processor'
+import { createPackageManager } from './package-manager'
+import { Terminal } from './terminal'
+
+// TODO: add test
+export const main = async ({
+  options,
+  logger
+}: {
+  options: Options
+  logger: Logger
+}): Promise<void> => {
+  logger.debug(`options=${JSON.stringify(options)}`)
+
+  const ncu = new Ncu()
+  const outdatedPackages = await ncu.check()
+  logger.debug(`outdatedPackages=${JSON.stringify(outdatedPackages)}`)
+
+  if (outdatedPackages.length === 0) {
+    logger.info('All packages are up-to-date.')
+    return
+  }
+
+  logger.info(`There are ${outdatedPackages.length} outdated packages.`)
+
+  const terminal = new Terminal()
+  const git = new Git(terminal)
+  const gitRepo = await git.getRepository()
+  logger.debug(`gitRepo=${JSON.stringify(gitRepo)}`)
+
+  const github = createGitHub({
+    repository: gitRepo,
+    token: options.githubToken
+  })
+  const githubRepo = await github.fetchRepository({
+    owner: gitRepo.owner,
+    repo: gitRepo.name
+  })
+  logger.debug(`githubRepo=${JSON.stringify(githubRepo)}`)
+
+  const remoteBranches = await github.fetchBranches({
+    owner: gitRepo.owner,
+    repo: gitRepo.name
+  })
+  logger.debug(`remoteBranches=${JSON.stringify(remoteBranches)}`)
+
+  const remoteBranchExistenceChecker = RemoteBranchExistenceChecker.of(remoteBranches)
+  const committer = new Committer({
+    git,
+    user: {
+      name: options.gitUserName,
+      email: options.gitUserEmail
+    }
+  })
+  const packageManager = createPackageManager({
+    terminal,
+    packageManager: options.packageManager
+  })
+  const pullRequestCreator = new PullRequestCreator({
+    github,
+    gitRepo,
+    githubRepo,
+    logger
+  })
+  const outdatedPackageProcessor = new OutdatedPackageProcessor({
+    committer,
+    git,
+    ncu,
+    packageManager,
+    pullRequestCreator,
+    remoteBranchExistenceChecker,
+    logger
+  })
+  const outdatedPackagesProcessor = new OutdatedPackagesProcessor({
+    outdatedPackageProcessor,
+    logger
+  })
+  const results = await outdatedPackagesProcessor.process(outdatedPackages)
+  logger.debug(`results=${JSON.stringify(results)}`)
+
+  const updatedPackages = results
+    .filter(({ updated }) => updated)
+    .map(({ outdatedPackage }) => outdatedPackage)
+  logger.debug(`updatedPackages=${JSON.stringify(updatedPackages)}`)
+
+  const skippedPackages = results
+    .filter(({ skipped }) => skipped)
+    .map(({ outdatedPackage }) => outdatedPackage)
+  logger.debug(`skippedPackages=${JSON.stringify(skippedPackages)}`)
+
+  logger.info(`${updatedPackages.length} packages has updated. ${skippedPackages.length} packages has skipped.`)
+}

package/src/ncu/Ncu.ts

@@ -0,0 +1,41 @@
+import { run } from 'npm-check-updates'
+import type { Options } from 'npm-check-updates/build/src/types'
+import { readPackageJson } from '../read-package-json'
+import type { OutdatedPackage } from '../types'
+import { isNcuOutdatedPackages } from './isNcuOutdatedPackages'
+import { NcuOutdatedPackagesConverter } from './NcuOutdatedPackagesConverter'
+
+// TODO: add test
+export class Ncu {
+  async check (): Promise<OutdatedPackage[]> {
+    return await this.run({
+      jsonUpgraded: true
+    })
+  }
+
+  async update (outdatedPackage: OutdatedPackage): Promise<OutdatedPackage[]> {
+    return await this.run({
+      jsonUpgraded: true,
+      filter: outdatedPackage.name,
+      upgrade: true
+    })
+  }
+
+  private async run (options: Options): Promise<OutdatedPackage[]> {
+    const pkg = await readPackageJson('./package.json')
+    const currentDependencies = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+      ...pkg.peerDependencies,
+      ...pkg.optionalDependencies
+    }
+    const result = await run(options)
+
+    if (!isNcuOutdatedPackages(result)) {
+      throw new Error('result is not NcuOutdatedPackages')
+    }
+
+    const ncuOutdatedPackagesConverter = new NcuOutdatedPackagesConverter(currentDependencies)
+    return ncuOutdatedPackagesConverter.toOutdatedPackages(result)
+  }
+}

package/src/ncu/NcuOutdatedPackages.ts

@@ -0,0 +1,6 @@
+import type {
+  Index,
+  VersionSpec
+} from 'npm-check-updates/build/src/types'
+
+export type NcuOutdatedPackages = Index<VersionSpec>

package/src/ncu/NcuOutdatedPackagesConverter.ts

@@ -0,0 +1,25 @@
+import type { PackageDependencies } from '../read-package-json'
+import type { OutdatedPackage } from '../types'
+import { PackageVersion } from '../values'
+import type { NcuOutdatedPackages } from './NcuOutdatedPackages'
+import { toUpdateType } from './toUpdateType'
+
+// TODO: add test
+export class NcuOutdatedPackagesConverter {
+  constructor (private readonly currentDependencies: PackageDependencies) {}
+
+  toOutdatedPackages (outdatedPackages: NcuOutdatedPackages): OutdatedPackage[] {
+    return Object.entries(outdatedPackages)
+      .map(([name, newVersion]) => ({
+        name,
+        currentVersion: PackageVersion.of(this.currentDependencies[name]),
+        newVersion: PackageVersion.of(newVersion)
+      }))
+      .map(({ name, currentVersion, newVersion }) => ({
+        name,
+        currentVersion,
+        newVersion,
+        type: toUpdateType(currentVersion, newVersion)
+      }))
+  }
+}

package/src/ncu/index.ts

@@ -0,0 +1 @@
+export { Ncu } from './Ncu'

package/src/ncu/isNcuOutdatedPackages.ts

@@ -0,0 +1,6 @@
+import type { NcuOutdatedPackages } from './NcuOutdatedPackages'
+
+// TODO: add test
+export const isNcuOutdatedPackages = (value: unknown): value is NcuOutdatedPackages => {
+  return typeof value === 'object' && value !== null && Object.values(value).every(value => typeof value === 'string')
+}

package/src/ncu/toUpdateType.test.ts

@@ -0,0 +1,21 @@
+import { UpdateType } from '../enums'
+import { PackageVersion } from '../values'
+import { toUpdateType } from './toUpdateType'
+
+describe('toUpdateType', () => {
+  const currentVersion = PackageVersion.of('1.0.0')
+
+  describe('if both versions are different', () => {
+    it('returns UpdateType', () => {
+      expect(toUpdateType(currentVersion, PackageVersion.of('1.0.1'))).toBe(UpdateType.Patch)
+      expect(toUpdateType(currentVersion, PackageVersion.of('1.1.1'))).toBe(UpdateType.Minor)
+      expect(toUpdateType(currentVersion, PackageVersion.of('2.1.1'))).toBe(UpdateType.Major)
+    })
+  })
+
+  describe('if both versions are same', () => {
+    it('throws error', () => {
+      expect(() => toUpdateType(currentVersion, PackageVersion.of('1.0.0'))).toThrow(Error)
+    })
+  })
+})

package/src/ncu/toUpdateType.ts

@@ -0,0 +1,18 @@
+import { UpdateType } from '../enums'
+import type { PackageVersion } from '../values'
+
+export const toUpdateType = (currentVersion: PackageVersion, newVersion: PackageVersion): UpdateType => {
+  if (currentVersion.major !== newVersion.major) {
+    return UpdateType.Major
+  }
+
+  if (currentVersion.minor !== newVersion.minor) {
+    return UpdateType.Minor
+  }
+
+  if (currentVersion.patch !== newVersion.patch) {
+    return UpdateType.Patch
+  }
+
+  throw new Error('Both versions are same.')
+}

package/src/options/Options.ts

@@ -0,0 +1,24 @@
+import {
+  intersection,
+  literal,
+  partial,
+  string,
+  type,
+  union
+} from 'io-ts'
+import type { TypeOf } from 'io-ts'
+
+export const Options = intersection([
+  type({
+    githubToken: string,
+    logLevel: union([literal('info'), literal('debug')]),
+    packageManager: union([literal('npm'), literal('yarn')])
+  }),
+  partial({
+    gitUserEmail: string,
+    gitUserName: string
+  })
+])
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type Options = TypeOf<typeof Options>
+export const isOptions = Options.is

package/src/options/index.ts

@@ -0,0 +1,2 @@
+export { initOptions } from './initOptions'
+export type { Options } from './Options'

package/src/options/initOptions.ts

@@ -0,0 +1,34 @@
+import {
+  Option,
+  program
+} from 'commander'
+import { app } from '../app'
+import { isOptions } from './Options'
+import type { Options } from './Options'
+
+// TODO: add test
+export const initOptions = (): Options => {
+  program
+    .version(app.version)
+    .option('--git-user-email <value>', 'User email of commit')
+    .option('--git-user-name <value>', 'User name of commit')
+    .requiredOption('--github-token <value>', 'GitHub token')
+    .addOption(
+      new Option('--log-level <value>', 'Log level to show')
+        .choices(['info', 'debug'])
+        .default('info')
+    )
+    .addOption(
+      new Option('--package-manager <value>', 'Package manager of your project')
+        .choices(['npm', 'yarn'])
+        .default('npm')
+    )
+  program.parse(process.argv)
+  const options = program.opts()
+
+  if (!isOptions(options)) {
+    throw new Error(`Failed to parse command-line options. options=${JSON.stringify(options)}`)
+  }
+
+  return options
+}

package/src/outdated-package-processor/OutdatedPackageProcessor.ts

@@ -0,0 +1,101 @@
+import type {
+  Committer,
+  Git
+} from '../git'
+import type {
+  PullRequestCreator,
+  RemoteBranchExistenceChecker
+} from '../github'
+import type { Logger } from '../logger'
+import type { Ncu } from '../ncu'
+import type { PackageManager } from '../package-manager'
+import type {
+  OutdatedPackage,
+  Result
+} from '../types'
+import { createBranchName } from './createBranchName'
+import { createCommitMessage } from './createCommitMessage'
+
+// TODO: add test
+export class OutdatedPackageProcessor {
+  private readonly committer: Committer
+  private readonly git: Git
+  private readonly ncu: Ncu
+  private readonly packageManager: PackageManager
+  private readonly pullRequestCreator: PullRequestCreator
+  private readonly remoteBranchExistenceChecker: RemoteBranchExistenceChecker
+  private readonly logger: Logger
+
+  constructor ({
+    committer,
+    git,
+    ncu,
+    packageManager,
+    pullRequestCreator,
+    remoteBranchExistenceChecker,
+    logger
+  }: {
+    committer: Committer
+    git: Git
+    ncu: Ncu
+    packageManager: PackageManager
+    pullRequestCreator: PullRequestCreator
+    remoteBranchExistenceChecker: RemoteBranchExistenceChecker
+    logger: Logger
+  }) {
+    this.committer = committer
+    this.git = git
+    this.ncu = ncu
+    this.packageManager = packageManager
+    this.pullRequestCreator = pullRequestCreator
+    this.remoteBranchExistenceChecker = remoteBranchExistenceChecker
+    this.logger = logger
+  }
+
+  /**
+   * Don't run in parallel because it includes file operations.
+   */
+  async process (outdatedPackage: OutdatedPackage): Promise<Result> {
+    const branchName = createBranchName(outdatedPackage)
+    this.logger.debug(`branchName=${branchName}`)
+
+    if (this.remoteBranchExistenceChecker.check(branchName)) {
+      this.logger.info(`Skip ${outdatedPackage.name} because ${branchName} branch already exists on remote.`)
+      return {
+        outdatedPackage,
+        skipped: true
+      }
+    }
+
+    await this.git.createBranch(branchName)
+    this.logger.info(`${branchName} branch has created.`)
+
+    const updatedPackages = await this.ncu.update(outdatedPackage)
+
+    if (updatedPackages.length !== 1) {
+      throw new Error(`Failed to update ${outdatedPackage.name}.`)
+    }
+
+    await this.packageManager.install()
+    this.logger.info(`${outdatedPackage.name} has updated from v${outdatedPackage.currentVersion.version} to v${outdatedPackage.newVersion.version}`)
+
+    await this.git.add(...this.packageManager.packageFiles)
+    const message = createCommitMessage(outdatedPackage)
+    this.logger.debug(`message=${message}`)
+
+    await this.committer.commit(message)
+    await this.git.push(branchName)
+    await this.pullRequestCreator.create({
+      outdatedPackage,
+      branchName
+    })
+    await this.git.checkout('-')
+    await this.git.removeBranch(branchName)
+    this.logger.info(`${branchName} branch has removed.`)
+
+    return {
+      outdatedPackage,
+      updated: true
+    }
+  }
+}

package/src/outdated-package-processor/createBranchName.test.ts

@@ -0,0 +1,14 @@
+import { PackageVersion } from '../values'
+import { createBranchName } from './createBranchName'
+
+describe('createBranchName', () => {
+  it('returns branch name', () => {
+    const actual = createBranchName({
+      name: '@typescript-eslint/eslint-plugin',
+      currentVersion: PackageVersion.of('1.0.0'),
+      newVersion: PackageVersion.of('1.2.3'),
+      type: 'major'
+    })
+    expect(actual).toBe('npm-update-package/@typescript-eslint/eslint-plugin/v1.2.3')
+  })
+})

package/src/outdated-package-processor/createBranchName.ts

@@ -0,0 +1,7 @@
+import type { OutdatedPackage } from '../types'
+
+export const createBranchName = (outdatedPackage: OutdatedPackage): string => {
+  const packageName = outdatedPackage.name
+  const newVersion = outdatedPackage.newVersion.version
+  return `npm-update-package/${packageName}/v${newVersion}`
+}

package/src/outdated-package-processor/createCommitMessage.test.ts

@@ -0,0 +1,43 @@
+import { UpdateType } from '../enums'
+import { PackageVersion } from '../values'
+import { createCommitMessage } from './createCommitMessage'
+
+describe('createCommitMessage', () => {
+  const currentVersion = PackageVersion.of('1.0.0')
+
+  describe('if update type is patch', () => {
+    it('returns commit message', () => {
+      const actual = createCommitMessage({
+        name: '@typescript-eslint/eslint-plugin',
+        currentVersion,
+        newVersion: PackageVersion.of('1.0.1'),
+        type: UpdateType.Patch
+      })
+      expect(actual).toBe('chore(deps): patch update @typescript-eslint/eslint-plugin to v1.0.1')
+    })
+  })
+
+  describe('if update type is minor', () => {
+    it('returns commit message', () => {
+      const actual = createCommitMessage({
+        name: '@typescript-eslint/eslint-plugin',
+        currentVersion,
+        newVersion: PackageVersion.of('1.1.0'),
+        type: UpdateType.Minor
+      })
+      expect(actual).toBe('chore(deps): minor update @typescript-eslint/eslint-plugin to v1.1.0')
+    })
+  })
+
+  describe('if update type is major', () => {
+    it('returns commit message', () => {
+      const actual = createCommitMessage({
+        name: '@typescript-eslint/eslint-plugin',
+        currentVersion,
+        newVersion: PackageVersion.of('2.0.0'),
+        type: UpdateType.Major
+      })
+      expect(actual).toBe('chore(deps): major update @typescript-eslint/eslint-plugin to v2.0.0')
+    })
+  })
+})

package/src/outdated-package-processor/createCommitMessage.ts

@@ -0,0 +1,8 @@
+import type { OutdatedPackage } from '../types'
+
+export const createCommitMessage = (outdatedPackage: OutdatedPackage): string => {
+  const packageName = outdatedPackage.name
+  const newVersion = outdatedPackage.newVersion.version
+  const updateType = outdatedPackage.type
+  return `chore(deps): ${updateType} update ${packageName} to v${newVersion}`
+}

package/src/outdated-package-processor/index.ts

@@ -0,0 +1 @@
+export { OutdatedPackageProcessor } from './OutdatedPackageProcessor'

package/src/outdated-packages-processor/OutdatedPackagesProcessor.ts

@@ -0,0 +1,34 @@
+import type { Logger } from '../logger'
+import type { OutdatedPackageProcessor } from '../outdated-package-processor'
+import type {
+  OutdatedPackage,
+  Result
+} from '../types'
+
+export class OutdatedPackagesProcessor {
+  private readonly outdatedPackageProcessor: OutdatedPackageProcessor
+  private readonly logger: Logger
+
+  constructor ({
+    outdatedPackageProcessor,
+    logger
+  }: {
+    outdatedPackageProcessor: OutdatedPackageProcessor
+    logger: Logger
+  }) {
+    this.outdatedPackageProcessor = outdatedPackageProcessor
+    this.logger = logger
+  }
+
+  async process (outdatedPackages: OutdatedPackage[]): Promise<Result[]> {
+    const results: Result[] = []
+
+    for (const outdatedPackage of outdatedPackages) {
+      this.logger.debug(`outdatedPackage=${JSON.stringify(outdatedPackage)}`)
+      const result = await this.outdatedPackageProcessor.process(outdatedPackage)
+      results.push(result)
+    }
+
+    return results
+  }
+}

package/src/outdated-packages-processor/index.ts

@@ -0,0 +1 @@
+export { OutdatedPackagesProcessor } from './OutdatedPackagesProcessor'

package/src/package-manager/Npm.ts

@@ -0,0 +1,19 @@
+import type { Terminal } from '../terminal'
+import type { PackageManager } from './PackageManager'
+
+// TODO: add test
+export class Npm implements PackageManager {
+   readonly packageFiles = [
+     'package.json',
+     'package-lock.json'
+   ]
+
+   constructor (private readonly terminal: Terminal) {}
+
+   /**
+   * @see https://docs.npmjs.com/cli/v8/commands/npm-install
+   */
+   async install (): Promise<void> {
+     await this.terminal.run('npm', 'install')
+   }
+}

package/src/package-manager/PackageManager.ts

@@ -0,0 +1,4 @@
+export interface PackageManager {
+  packageFiles: string[]
+  install: () => Promise<void>
+}

package/src/package-manager/Yarn.ts

@@ -0,0 +1,19 @@
+import type { Terminal } from '../terminal'
+import type { PackageManager } from './PackageManager'
+
+// TODO: add test
+export class Yarn implements PackageManager {
+  readonly packageFiles = [
+    'package.json',
+    'yarn.lock'
+  ]
+
+  constructor (private readonly terminal: Terminal) {}
+
+  /**
+   * @see https://classic.yarnpkg.com/en/docs/cli/install
+   */
+  async install (): Promise<void> {
+    await this.terminal.run('yarn', 'install')
+  }
+}

package/src/package-manager/createPackageManager.ts

@@ -0,0 +1,21 @@
+import type { PackageManagerName } from '../enums'
+import type { Terminal } from '../terminal'
+import { Npm } from './Npm'
+import type { PackageManager } from './PackageManager'
+import { Yarn } from './Yarn'
+
+// TODO: add test
+export const createPackageManager = ({
+  terminal,
+  packageManager
+}: {
+  terminal: Terminal
+  packageManager: PackageManagerName
+}): PackageManager => {
+  switch (packageManager) {
+    case 'npm':
+      return new Npm(terminal)
+    case 'yarn':
+      return new Yarn(terminal)
+  }
+}

package/src/package-manager/index.ts

@@ -0,0 +1,4 @@
+export { createPackageManager } from './createPackageManager'
+export { Npm } from './Npm'
+export type { PackageManager } from './PackageManager'
+export { Yarn } from './Yarn'

package/src/read-package-json/Package.ts

@@ -0,0 +1,24 @@
+import {
+  intersection,
+  partial,
+  string,
+  type
+} from 'io-ts'
+import type { TypeOf } from 'io-ts'
+import { PackageDependencies } from './PackageDependencies'
+
+export const Package = intersection([
+  type({
+    name: string,
+    version: string
+  }),
+  partial({
+    dependencies: PackageDependencies,
+    devDependencies: PackageDependencies,
+    peerDependencies: PackageDependencies,
+    optionalDependencies: PackageDependencies
+  })
+])
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type Package = TypeOf<typeof Package>
+export const isPackage = Package.is

package/src/read-package-json/PackageDependencies.ts

@@ -0,0 +1,10 @@
+import {
+  record,
+  string
+} from 'io-ts'
+import type { TypeOf } from 'io-ts'
+
+export const PackageDependencies = record(string, string)
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type PackageDependencies = TypeOf<typeof PackageDependencies>
+export const isPackageDependencies = PackageDependencies.is

package/src/read-package-json/index.ts

@@ -0,0 +1,2 @@
+export type { PackageDependencies } from './PackageDependencies'
+export { readPackageJson } from './readPackageJson'

package/src/read-package-json/parsePackageJson.ts

@@ -0,0 +1,13 @@
+import { isPackage } from './Package'
+import type { Package } from './Package'
+
+// TODO: add test
+export const parsePackageJson = (json: string): Package => {
+  const parsed: unknown = JSON.parse(json)
+
+  if (isPackage(parsed)) {
+    return parsed
+  } else {
+    throw new Error(`Failed to parse package.json. json=${json}`)
+  }
+}

package/src/read-package-json/readFile.ts

@@ -0,0 +1,6 @@
+import fs from 'fs'
+
+// TODO: add test
+export const readFile = async (filePath: string): Promise<string> => {
+  return await fs.promises.readFile(filePath, 'utf8')
+}

package/src/read-package-json/readPackageJson.ts

@@ -0,0 +1,9 @@
+import type { Package } from './Package'
+import { parsePackageJson } from './parsePackageJson'
+import { readFile } from './readFile'
+
+// TODO: add test
+export const readPackageJson = async (filePath: string): Promise<Package> => {
+  const json = await readFile(filePath)
+  return parsePackageJson(json)
+}