npm-update-package 0.31.2 → 0.31.3

package/src/core/OutdatedPackageProcessor.ts

@@ -0,0 +1,136 @@
+import {
+  left,
+  right,
+  type Either
+} from 'fp-ts/lib/Either'
+import {
+  createBranchName,
+  type CommitMessageCreator,
+  type Git
+} from '../git'
+import type {
+  BranchFinder,
+  PullRequestCloser,
+  PullRequestCreator,
+  PullRequestFinder
+} from '../github'
+import type { Logger } from '../logger'
+import type { Ncu } from '../ncu'
+import type { PackageManager } from '../package-manager'
+import type { FailedResult } from './FailedResult'
+import type { OutdatedPackage } from './OutdatedPackage'
+import type { SucceededResult } from './SucceededResult'
+
+// TODO: add test
+export class OutdatedPackageProcessor {
+  private readonly git: Git
+  private readonly ncu: Ncu
+  private readonly packageManager: PackageManager
+  private readonly pullRequestCreator: PullRequestCreator
+  private readonly branchFinder: BranchFinder
+  private readonly logger: Logger
+  private readonly commitMessageCreator: CommitMessageCreator
+  private readonly pullRequestFinder: PullRequestFinder
+  private readonly pullRequestCloser: PullRequestCloser
+
+  constructor ({
+    git,
+    ncu,
+    packageManager,
+    pullRequestCreator,
+    branchFinder,
+    logger,
+    commitMessageCreator,
+    pullRequestFinder,
+    pullRequestCloser
+  }: {
+    git: Git
+    ncu: Ncu
+    packageManager: PackageManager
+    pullRequestCreator: PullRequestCreator
+    branchFinder: BranchFinder
+    logger: Logger
+    commitMessageCreator: CommitMessageCreator
+    pullRequestFinder: PullRequestFinder
+    pullRequestCloser: PullRequestCloser
+  }) {
+    this.git = git
+    this.ncu = ncu
+    this.packageManager = packageManager
+    this.pullRequestCreator = pullRequestCreator
+    this.branchFinder = branchFinder
+    this.logger = logger
+    this.commitMessageCreator = commitMessageCreator
+    this.pullRequestFinder = pullRequestFinder
+    this.pullRequestCloser = pullRequestCloser
+  }
+
+  /**
+   * Don't run in parallel because it includes file operations.
+   */
+  async process (outdatedPackage: OutdatedPackage): Promise<Either<FailedResult, SucceededResult>> {
+    const branchName = createBranchName(outdatedPackage)
+    this.logger.debug(`branchName=${branchName}`)
+
+    if (this.branchFinder.findByName(branchName) !== undefined) {
+      this.logger.info(`Skip ${outdatedPackage.name} because ${branchName} branch already exists on remote.`)
+      return right({
+        outdatedPackage,
+        skipped: true
+      })
+    }
+
+    await this.git.createBranch(branchName)
+    this.logger.info(`${branchName} branch has created.`)
+
+    try {
+      try {
+        const updatedPackages = await this.ncu.update(outdatedPackage)
+
+        if (updatedPackages.length !== 1) {
+          throw new Error(`Failed to update ${outdatedPackage.name}.`)
+        }
+
+        await this.packageManager.install()
+      } catch (error) {
+        this.logger.error(error)
+        return left({
+          outdatedPackage,
+          error
+        })
+      }
+
+      this.logger.info(`${outdatedPackage.name} has updated from v${outdatedPackage.currentVersion.version} to v${outdatedPackage.newVersion.version}`)
+
+      await this.git.add(this.packageManager.packageFile, this.packageManager.lockFile)
+      const message = this.commitMessageCreator.create(outdatedPackage)
+      this.logger.debug(`message=${message}`)
+
+      await this.git.commit(message)
+      await this.git.push(branchName)
+
+      const pullRequest = await this.pullRequestCreator.create({
+        outdatedPackage,
+        branchName
+      })
+      this.logger.info(`Pull request for ${outdatedPackage.name} has created. ${pullRequest.html_url}`)
+
+      const pullRequests = this.pullRequestFinder.findByPackageName(outdatedPackage.name)
+      this.logger.debug(`pullRequests=${JSON.stringify(pullRequests)}`)
+
+      await Promise.all(pullRequests.map(async (pullRequest) => {
+        await this.pullRequestCloser.close(pullRequest)
+        this.logger.info(`Pull request for ${outdatedPackage.name} has closed. ${pullRequest.html_url}`)
+      }))
+      return right({
+        outdatedPackage,
+        created: true
+      })
+    } finally {
+      await this.git.restore(this.packageManager.packageFile, this.packageManager.lockFile)
+      await this.git.switch('-')
+      await this.git.removeBranch(branchName)
+      this.logger.info(`${branchName} branch has removed.`)
+    }
+  }
+}

package/src/core/OutdatedPackagesProcessor.ts

@@ -0,0 +1,35 @@
+import type { Either } from 'fp-ts/lib/Either'
+import type { Logger } from '../logger'
+import type { FailedResult } from './FailedResult'
+import type { OutdatedPackage } from './OutdatedPackage'
+import type { OutdatedPackageProcessor } from './OutdatedPackageProcessor'
+import type { SucceededResult } from './SucceededResult'
+
+// TODO: add test
+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<Array<Either<FailedResult, SucceededResult>>> {
+    const results: Array<Either<FailedResult, SucceededResult>> = []
+
+    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/core/SucceededResult.ts

@@ -0,0 +1,7 @@
+import type { OutdatedPackage } from './OutdatedPackage'
+
+export interface SucceededResult {
+  outdatedPackage: OutdatedPackage
+  created?: boolean
+  skipped?: boolean
+}

package/src/core/index.ts

@@ -0,0 +1,5 @@
+export * from './FailedResult'
+export * from './OutdatedPackage'
+export * from './OutdatedPackageProcessor'
+export * from './OutdatedPackagesProcessor'
+export * from './SucceededResult'

package/src/file/index.ts

@@ -0,0 +1 @@
+export * from './readFile'

package/src/file/readFile.ts

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

package/src/git/CommitMessageCreator.test.ts

@@ -0,0 +1,17 @@
+import { SemVer } from '../semver'
+import { CommitMessageCreator } from './CommitMessageCreator'
+
+describe('CommitMessageCreator', () => {
+  describe('create', () => {
+    it('returns commit message', () => {
+      const commitMessageCreator = new CommitMessageCreator('chore(deps): {{level}} update {{{packageName}}} from {{currentVersion}} to v{{newVersion}}')
+      const actual = commitMessageCreator.create({
+        name: '@npm-update-package/example',
+        currentVersion: SemVer.of('1.0.0'),
+        newVersion: SemVer.of('2.0.0'),
+        level: 'major'
+      })
+      expect(actual).toBe('chore(deps): major update @npm-update-package/example from 1.0.0 to v2.0.0')
+    })
+  })
+})

package/src/git/CommitMessageCreator.ts

@@ -0,0 +1,19 @@
+import { render } from 'mustache'
+import type { OutdatedPackage } from '../core'
+
+export class CommitMessageCreator {
+  constructor (private readonly template: string) {}
+
+  create (outdatedPackage: OutdatedPackage): string {
+    const packageName = outdatedPackage.name
+    const currentVersion = outdatedPackage.currentVersion.version
+    const newVersion = outdatedPackage.newVersion.version
+    const level = outdatedPackage.level
+    return render(this.template, {
+      packageName,
+      currentVersion,
+      newVersion,
+      level
+    })
+  }
+}

package/src/git/Git.ts

@@ -0,0 +1,59 @@
+import type { Terminal } from '../terminal'
+import { GitRepository } from './GitRepository'
+
+// TODO: add test
+export class Git {
+  constructor (private readonly terminal: Terminal) {}
+
+  async add (...files: string[]): Promise<void> {
+    await this.terminal.run('git', 'add', ...files)
+  }
+
+  async commit (message: string): Promise<void> {
+    await this.terminal.run('git', 'commit', '--message', message)
+  }
+
+  async createBranch (branchName: string): Promise<void> {
+    await this.terminal.run('git', 'checkout', '-b', branchName)
+  }
+
+  async getConfig (key: string): Promise<string> {
+    const { stdout } = await this.terminal.run('git', 'config', key)
+    return stdout.trim()
+  }
+
+  async getCurrentBranch (): Promise<string> {
+    const { stdout } = await this.terminal.run('git', 'rev-parse', '--abbrev-ref', 'HEAD')
+    return stdout.trim()
+  }
+
+  async getRemoteUrl (): Promise<string> {
+    const { stdout } = await this.terminal.run('git', 'remote', 'get-url', '--push', 'origin')
+    return stdout.trim()
+  }
+
+  async getRepository (): Promise<GitRepository> {
+    const url = await this.getRemoteUrl()
+    return GitRepository.of(url)
+  }
+
+  async push (branchName: string): Promise<void> {
+    await this.terminal.run('git', 'push', 'origin', branchName)
+  }
+
+  async removeBranch (branchName: string): Promise<void> {
+    await this.terminal.run('git', 'branch', '-D', branchName)
+  }
+
+  async restore (...files: string[]): Promise<void> {
+    await this.terminal.run('git', 'checkout', ...files)
+  }
+
+  async setConfig (key: string, value: string): Promise<void> {
+    await this.terminal.run('git', 'config', key, value)
+  }
+
+  async switch (branchName: string): Promise<void> {
+    await this.terminal.run('git', 'checkout', branchName)
+  }
+}

package/src/git/GitRepository.test.ts

@@ -0,0 +1,82 @@
+import { GitRepository } from './GitRepository'
+
+describe('GitRepository', () => {
+  describe('of', () => {
+    describe('returns new GitRepository instance if URL is valid', () => {
+      type TestCase = [
+        string,
+        {
+          host: string
+          owner: string
+          name: string
+          apiEndPoint: string
+          isGitHubDotCom: boolean
+        }
+      ]
+      const cases: TestCase[] = [
+        [
+          'https://github.com/npm-update-package/npm-update-package.git',
+          {
+            host: 'github.com',
+            owner: 'npm-update-package',
+            name: 'npm-update-package',
+            apiEndPoint: 'https://api.github.com',
+            isGitHubDotCom: true
+          }
+        ],
+        [
+          'git@github.com:npm-update-package/npm-update-package.git',
+          {
+            host: 'github.com',
+            owner: 'npm-update-package',
+            name: 'npm-update-package',
+            apiEndPoint: 'https://api.github.com',
+            isGitHubDotCom: true
+          }
+        ],
+        [
+          'https://git.example.com/npm-update-package/npm-update-package.git',
+          {
+            host: 'git.example.com',
+            owner: 'npm-update-package',
+            name: 'npm-update-package',
+            apiEndPoint: 'https://git.example.com/api/v3',
+            isGitHubDotCom: false
+          }
+        ],
+        [
+          'git@git.example.com:npm-update-package/npm-update-package.git',
+          {
+            host: 'git.example.com',
+            owner: 'npm-update-package',
+            name: 'npm-update-package',
+            apiEndPoint: 'https://git.example.com/api/v3',
+            isGitHubDotCom: false
+          }
+        ]
+      ]
+
+      it.each<TestCase>(cases)('url=%p', (url, expected) => {
+        const actual = GitRepository.of(url)
+        expect(actual).toBeInstanceOf(GitRepository)
+        expect(actual.host).toBe(expected.host)
+        expect(actual.owner).toBe(expected.owner)
+        expect(actual.name).toBe(expected.name)
+        expect(actual.apiEndPoint).toBe(expected.apiEndPoint)
+        expect(actual.isGitHubDotCom).toBe(expected.isGitHubDotCom)
+      })
+    })
+
+    describe('throws error if URL is invalid', () => {
+      type TestCase = string
+      const cases: TestCase[] = [
+        '',
+        'https://example.com/'
+      ]
+
+      it.each<TestCase>(cases)('url=%p', (url) => {
+        expect(() => GitRepository.of(url)).toThrow(Error)
+      })
+    })
+  })
+})

package/src/git/GitRepository.ts

@@ -0,0 +1,57 @@
+import parse from 'parse-github-url'
+
+export class GitRepository {
+  readonly host: string
+  readonly owner: string
+  readonly name: string
+
+  private constructor ({
+    host,
+    owner,
+    name
+  }: {
+    host: string
+    owner: string
+    name: string
+  }) {
+    this.host = host
+    this.owner = owner
+    this.name = name
+  }
+
+  static of (url: string): GitRepository {
+    const parsed = parse(url)
+
+    if (parsed === null) {
+      throw new Error(`Failed to parse url. url=${url}`)
+    }
+
+    const {
+      host,
+      owner,
+      name
+    } = parsed
+
+    if (host === null || owner === null || name === null) {
+      throw new Error(`Failed to parse url. url=${url}`)
+    }
+
+    return new GitRepository({
+      host,
+      owner,
+      name
+    })
+  }
+
+  get apiEndPoint (): string {
+    if (this.isGitHubDotCom) {
+      return 'https://api.github.com'
+    } else {
+      return `https://${this.host}/api/v3`
+    }
+  }
+
+  get isGitHubDotCom (): boolean {
+    return this.host === 'github.com'
+  }
+}

package/src/git/createBranchName.test.ts

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

package/src/git/createBranchName.ts

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

package/src/git/index.ts

@@ -0,0 +1,4 @@
+export * from './CommitMessageCreator'
+export * from './createBranchName'
+export * from './Git'
+export * from './GitRepository'

package/src/github/GitHub.ts

@@ -0,0 +1,198 @@
+import type {
+  Octokit,
+  RestEndpointMethodTypes
+} from '@octokit/rest'
+import type { ValuesType } from 'utility-types'
+
+export type Branch = ValuesType<RestEndpointMethodTypes['repos']['listBranches']['response']['data']>
+export type CreatedPullRequest = RestEndpointMethodTypes['pulls']['create']['response']['data']
+export type Label = RestEndpointMethodTypes['issues']['getLabel']['response']['data']
+export type PullRequest = ValuesType<RestEndpointMethodTypes['pulls']['list']['response']['data']>
+export type Repository = RestEndpointMethodTypes['repos']['get']['response']['data']
+
+// TODO: add test
+export class GitHub {
+  constructor (private readonly octokit: Octokit) {}
+
+  async addLabels ({
+    owner,
+    repo,
+    issueNumber,
+    labels
+  }: {
+    owner: string
+    repo: string
+    issueNumber: number
+    labels: string[]
+  }): Promise<void> {
+    await this.octokit.issues.addLabels({
+      owner,
+      repo,
+      issue_number: issueNumber,
+      labels
+    })
+  }
+
+  async closePullRequest ({
+    owner,
+    repo,
+    pullNumber
+  }: {
+    owner: string
+    repo: string
+    pullNumber: number
+  }): Promise<void> {
+    await this.octokit.pulls.update({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      state: 'closed'
+    })
+  }
+
+  async createLabel ({
+    owner,
+    repo,
+    name,
+    description,
+    color
+  }: {
+    owner: string
+    repo: string
+    name: string
+    description?: string
+    color?: string
+  }): Promise<void> {
+    await this.octokit.issues.createLabel({
+      owner,
+      repo,
+      name,
+      description,
+      color
+    })
+  }
+
+  async createPullRequest ({
+    owner,
+    repo,
+    baseBranch,
+    headBranch,
+    title,
+    body
+  }: {
+    owner: string
+    repo: string
+    baseBranch: string
+    headBranch: string
+    title: string
+    body: string
+  }): Promise<CreatedPullRequest> {
+    const { data } = await this.octokit.pulls.create({
+      owner,
+      repo,
+      base: baseBranch,
+      head: headBranch,
+      title,
+      body
+    })
+    return data
+  }
+
+  async deleteBranch ({
+    owner,
+    repo,
+    branch
+  }: {
+    owner: string
+    repo: string
+    branch: string
+  }): Promise<void> {
+    await this.octokit.git.deleteRef({
+      owner,
+      repo,
+      ref: `heads/${branch}`
+    })
+  }
+
+  // TODO: fetch all branches with page option
+  async fetchBranches ({
+    owner,
+    repo
+  }: {
+    owner: string
+    repo: string
+  }): Promise<Branch[]> {
+    const { data } = await this.octokit.repos.listBranches({
+      owner,
+      repo,
+      per_page: 100
+    })
+    return data
+  }
+
+  async fetchLabel ({
+    owner,
+    repo,
+    name
+  }: {
+    owner: string
+    repo: string
+    name: string
+  }): Promise<Label> {
+    const { data } = await this.octokit.issues.getLabel({
+      owner,
+      repo,
+      name
+    })
+    return data
+  }
+
+  // TODO: fetch all pull requests with page option
+  async fetchPullRequests ({
+    owner,
+    repo
+  }: {
+    owner: string
+    repo: string
+  }): Promise<PullRequest[]> {
+    const { data } = await this.octokit.pulls.list({
+      owner,
+      repo,
+      per_page: 100
+    })
+    return data
+  }
+
+  async fetchRepository ({
+    owner,
+    repo
+  }: {
+    owner: string
+    repo: string
+  }): Promise<Repository> {
+    const { data } = await this.octokit.repos.get({
+      owner,
+      repo
+    })
+    return data
+  }
+
+  async requestReviewers ({
+    owner,
+    repo,
+    pullNumber,
+    reviewers
+  }: {
+    owner: string
+    repo: string
+    pullNumber: number
+    reviewers: string[]
+  }): Promise<void> {
+    await this.octokit.pulls.requestReviewers({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      reviewers
+    })
+  }
+}

package/src/github/branch/finder/BranchFinder.test.ts

@@ -0,0 +1,21 @@
+import type { Branch } from '../../GitHub'
+import { BranchFinder } from './BranchFinder'
+
+describe('BranchFinder', () => {
+  describe('findByName', () => {
+    const branch = {
+      name: 'test_branch_name'
+    } as unknown as Branch
+    const branchFinder = new BranchFinder([branch])
+
+    it('returns branch if exists', () => {
+      const actual = branchFinder.findByName('test_branch_name')
+      expect(actual).toBe(branch)
+    })
+
+    it('returns undefined if does not exists', () => {
+      const actual = branchFinder.findByName('not_test_branch_name')
+      expect(actual).toBeUndefined()
+    })
+  })
+})

package/src/github/branch/finder/BranchFinder.ts

@@ -0,0 +1,9 @@
+import type { Branch } from '../../GitHub'
+
+export class BranchFinder {
+  constructor (private readonly branches: Branch[]) {}
+
+  findByName (branchName: string): Branch | undefined {
+    return this.branches.find(({ name }) => name === branchName)
+  }
+}