npm-update-package 0.6.0 → 0.9.0

package/src/git/Git.ts

@@ -1,55 +0,0 @@
-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 checkout (branchName: string): Promise<void> {
-    await this.terminal.run('git', 'checkout', branchName)
-  }
-
-  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 setConfig (key: string, value: string): Promise<void> {
-    await this.terminal.run('git', 'config', key, value)
-  }
-}

package/src/git/GitRepository.test.ts

@@ -1,61 +0,0 @@
-import { GitRepository } from './GitRepository'
-
-describe('GitRepository', () => {
-  describe('of', () => {
-    describe('if URL is HTTPS', () => {
-      describe('if URL is github.com', () => {
-        const url = 'https://github.com/npm-update-package/npm-update-package.git'
-
-        it('returns new GitRepository instance', () => {
-          const repo = GitRepository.of(url)
-          expect(repo.host).toBe('github.com')
-          expect(repo.owner).toBe('npm-update-package')
-          expect(repo.name).toBe('npm-update-package')
-          expect(repo.apiEndPoint).toBe('https://api.github.com')
-          expect(repo.isGitHubDotCom).toBe(true)
-        })
-      })
-
-      describe('if URL is not github.com', () => {
-        const url = 'https://git.example.com/npm-update-package/npm-update-package.git'
-
-        it('returns new GitRepository instance', () => {
-          const repo = GitRepository.of(url)
-          expect(repo.host).toBe('git.example.com')
-          expect(repo.owner).toBe('npm-update-package')
-          expect(repo.name).toBe('npm-update-package')
-          expect(repo.apiEndPoint).toBe('https://git.example.com/api/v3')
-          expect(repo.isGitHubDotCom).toBe(false)
-        })
-      })
-    })
-
-    describe('if URL is SSH', () => {
-      describe('if URL is github.com', () => {
-        const url = 'git@github.com:npm-update-package/npm-update-package.git'
-
-        it('returns new GitRepository instance', () => {
-          const repo = GitRepository.of(url)
-          expect(repo.host).toBe('github.com')
-          expect(repo.owner).toBe('npm-update-package')
-          expect(repo.name).toBe('npm-update-package')
-          expect(repo.apiEndPoint).toBe('https://api.github.com')
-          expect(repo.isGitHubDotCom).toBe(true)
-        })
-      })
-
-      describe('if URL is not github.com', () => {
-        const url = 'git@git.example.com:npm-update-package/npm-update-package.git'
-
-        it('returns new GitRepository instance', () => {
-          const repo = GitRepository.of(url)
-          expect(repo.host).toBe('git.example.com')
-          expect(repo.owner).toBe('npm-update-package')
-          expect(repo.name).toBe('npm-update-package')
-          expect(repo.apiEndPoint).toBe('https://git.example.com/api/v3')
-          expect(repo.isGitHubDotCom).toBe(false)
-        })
-      })
-    })
-  })
-})

package/src/git/GitRepository.ts

@@ -1,57 +0,0 @@
-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/index.ts

@@ -1,5 +0,0 @@
-export { BranchNameCreator } from './BranchNameCreator'
-export { CommitMessageCreator } from './CommitMessageCreator'
-export { Committer } from './Committer'
-export { Git } from './Git'
-export type { GitRepository } from './GitRepository'

package/src/github/Branch.ts

@@ -1,4 +0,0 @@
-import type { RestEndpointMethodTypes } from '@octokit/rest'
-import type { ValuesType } from 'utility-types'
-
-export type Branch = ValuesType<RestEndpointMethodTypes['repos']['listBranches']['response']['data']>

package/src/github/GitHub.ts

@@ -1,27 +0,0 @@
-import type {
-  Octokit,
-  RestEndpointMethodTypes
-} from '@octokit/rest'
-import type { Branch } from './Branch'
-import type { PullRequest } from './PullRequest'
-import type { Repository } from './Repository'
-
-// TODO: add test
-export class GitHub {
-  constructor (private readonly octokit: Octokit) {}
-
-  async createPullRequest (params: RestEndpointMethodTypes['pulls']['create']['parameters']): Promise<PullRequest> {
-    const { data } = await this.octokit.pulls.create(params)
-    return data
-  }
-
-  async fetchBranches (params: RestEndpointMethodTypes['repos']['listBranches']['parameters']): Promise<Branch[]> {
-    const { data } = await this.octokit.repos.listBranches(params)
-    return data
-  }
-
-  async fetchRepository (params: RestEndpointMethodTypes['repos']['get']['parameters']): Promise<Repository> {
-    const { data } = await this.octokit.repos.get(params)
-    return data
-  }
-}

package/src/github/PullRequest.ts

@@ -1,3 +0,0 @@
-import type { RestEndpointMethodTypes } from '@octokit/rest'
-
-export type PullRequest = RestEndpointMethodTypes['pulls']['create']['response']['data']

package/src/github/PullRequestCreator.ts

@@ -1,57 +0,0 @@
-import type { GitRepository } from '../git'
-import type { Logger } from '../logger'
-import type { OutdatedPackage } from '../ncu'
-import { createPullRequestBody } from './createPullRequestBody'
-import { createPullRequestTitle } from './createPullRequestTitle'
-import type { GitHub } from './GitHub'
-import type { Repository as GitHubRepository } from './Repository'
-
-// TODO: add test
-export class PullRequestCreator {
-  private readonly github: GitHub
-  private readonly gitRepo: GitRepository
-  private readonly githubRepo: GitHubRepository
-  private readonly logger: Logger
-
-  constructor ({
-    github,
-    gitRepo,
-    githubRepo,
-    logger
-  }: {
-    github: GitHub
-    gitRepo: GitRepository
-    githubRepo: GitHubRepository
-    logger: Logger
-  }) {
-    this.github = github
-    this.gitRepo = gitRepo
-    this.githubRepo = githubRepo
-    this.logger = logger
-  }
-
-  async create ({
-    outdatedPackage,
-    branchName
-  }: {
-    outdatedPackage: OutdatedPackage
-    branchName: string
-  }): Promise<void> {
-    const title = createPullRequestTitle(outdatedPackage)
-    this.logger.debug(`title=${title}`)
-
-    const body = createPullRequestBody(outdatedPackage)
-    this.logger.debug(`body=${body}`)
-
-    const createdPullRequest = await this.github.createPullRequest({
-      owner: this.gitRepo.owner,
-      repo: this.gitRepo.name,
-      base: this.githubRepo.default_branch,
-      head: branchName,
-      title,
-      body
-    })
-    this.logger.debug(`createdPullRequest=${JSON.stringify(createdPullRequest)}`)
-    this.logger.info(`Pull request for ${outdatedPackage.name} has created. ${createdPullRequest.html_url}`)
-  }
-}

package/src/github/RemoteBranchExistenceChecker.ts

@@ -1,15 +0,0 @@
-import type { Branch } from './Branch'
-
-// TODO: add test
-export class RemoteBranchExistenceChecker {
-  constructor (private readonly remoteBranchNames: string[]) {}
-
-  static of (remoteBranches: Branch[]): RemoteBranchExistenceChecker {
-    const remoteBranchNames = remoteBranches.map(({ name }) => name)
-    return new RemoteBranchExistenceChecker(remoteBranchNames)
-  }
-
-  check (branchName: string): boolean {
-    return this.remoteBranchNames.includes(branchName)
-  }
-}

package/src/github/Repository.ts

@@ -1,3 +0,0 @@
-import type { RestEndpointMethodTypes } from '@octokit/rest'
-
-export type Repository = RestEndpointMethodTypes['repos']['get']['response']['data']

package/src/github/createGitHub.ts

@@ -1,18 +0,0 @@
-import type { GitRepository } from '../git'
-import { createOctokit } from './createOctokit'
-import { GitHub } from './GitHub'
-
-// TODO: add test
-export const createGitHub = ({
-  repository,
-  token
-}: {
-  repository: GitRepository
-  token: string
-}): GitHub => {
-  const octokit = createOctokit({
-    repository,
-    token
-  })
-  return new GitHub(octokit)
-}

package/src/github/createOctokit.ts

@@ -1,28 +0,0 @@
-import { Octokit } from '@octokit/rest'
-import { app } from '../app'
-import type { GitRepository } from '../git'
-
-// TODO: add test
-export const createOctokit = ({
-  repository,
-  token
-}: {
-  repository: GitRepository
-  token: string
-}): Octokit => {
-  const auth = `token ${token}`
-  const userAgent = `${app.name}/${app.version}`
-
-  if (repository.isGitHubDotCom) {
-    return new Octokit({
-      auth,
-      userAgent
-    })
-  } else {
-    return new Octokit({
-      auth,
-      userAgent,
-      baseUrl: repository.apiEndPoint
-    })
-  }
-}

package/src/github/createPullRequestBody.test.ts

@@ -1,64 +0,0 @@
-import {
-  PackageVersion,
-  UpdateType
-} from '../ncu'
-import { createPullRequestBody } from './createPullRequestBody'
-
-describe('createPullRequestBody', () => {
-  describe('if update type is patch', () => {
-    it('returns pull request body', () => {
-      const actual = createPullRequestBody({
-        name: '@typescript-eslint/eslint-plugin',
-        currentVersion: PackageVersion.of('1.0.0'),
-        newVersion: PackageVersion.of('1.0.1'),
-        type: UpdateType.Patch
-      })
-      expect(actual).toBe(`This PR updates these packages:
-
-|package|type|current version|new version|
-|---|---|---|---|
-|[@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin)|patch|\`1.0.0\`|\`1.0.1\`|
-
----
-This PR has been generated by [npm-update-package](https://github.com/npm-update-package/npm-update-package)`)
-    })
-  })
-
-  describe('if update type is minor', () => {
-    it('returns pull request body', () => {
-      const actual = createPullRequestBody({
-        name: '@typescript-eslint/eslint-plugin',
-        currentVersion: PackageVersion.of('1.0.0'),
-        newVersion: PackageVersion.of('1.1.0'),
-        type: UpdateType.Minor
-      })
-      expect(actual).toBe(`This PR updates these packages:
-
-|package|type|current version|new version|
-|---|---|---|---|
-|[@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin)|minor|\`1.0.0\`|\`1.1.0\`|
-
----
-This PR has been generated by [npm-update-package](https://github.com/npm-update-package/npm-update-package)`)
-    })
-  })
-
-  describe('if update type is major', () => {
-    it('returns pull request body', () => {
-      const actual = createPullRequestBody({
-        name: '@typescript-eslint/eslint-plugin',
-        currentVersion: PackageVersion.of('1.0.0'),
-        newVersion: PackageVersion.of('2.0.0'),
-        type: UpdateType.Major
-      })
-      expect(actual).toBe(`This PR updates these packages:
-
-|package|type|current version|new version|
-|---|---|---|---|
-|[@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin)|major|\`1.0.0\`|\`2.0.0\`|
-
----
-This PR has been generated by [npm-update-package](https://github.com/npm-update-package/npm-update-package)`)
-    })
-  })
-})

package/src/github/createPullRequestBody.ts

@@ -1,17 +0,0 @@
-import { app } from '../app'
-import type { OutdatedPackage } from '../ncu'
-
-export const createPullRequestBody = (outdatedPackage: OutdatedPackage): string => {
-  const packageName = outdatedPackage.name
-  const currentVersion = outdatedPackage.currentVersion.version
-  const newVersion = outdatedPackage.newVersion.version
-  const updateType = outdatedPackage.type
-  return `This PR updates these packages:
-
-|package|type|current version|new version|
-|---|---|---|---|
-|[${packageName}](https://www.npmjs.com/package/${packageName})|${updateType}|\`${currentVersion}\`|\`${newVersion}\`|
-
----
-This PR has been generated by [${app.name}](${app.web})`
-}

package/src/github/createPullRequestTitle.test.ts

@@ -1,42 +0,0 @@
-import { UpdateType, PackageVersion } from '../ncu'
-import { createPullRequestTitle } from './createPullRequestTitle'
-
-describe('createPullRequestTitle', () => {
-  const currentVersion = PackageVersion.of('1.0.0')
-
-  describe('if update type is patch', () => {
-    it('returns pull request title', () => {
-      const actual = createPullRequestTitle({
-        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 pull request title', () => {
-      const actual = createPullRequestTitle({
-        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 pull request title', () => {
-      const actual = createPullRequestTitle({
-        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/github/createPullRequestTitle.ts

@@ -1,8 +0,0 @@
-import type { OutdatedPackage } from '../ncu'
-
-export const createPullRequestTitle = (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/github/index.ts

@@ -1,7 +0,0 @@
-export type { Branch } from './Branch'
-export { createGitHub } from './createGitHub'
-export { GitHub } from './GitHub'
-export type { PullRequest } from './PullRequest'
-export { PullRequestCreator } from './PullRequestCreator'
-export { RemoteBranchExistenceChecker } from './RemoteBranchExistenceChecker'
-export type { Repository } from './Repository'

package/src/logger/LogLevel.ts

@@ -1,8 +0,0 @@
-export const LogLevel = {
-  Info: 'info',
-  Debug: 'debug'
-} as const
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type LogLevel = typeof LogLevel[keyof typeof LogLevel]
-const logLevels = Object.values(LogLevel)
-export const isLogLevel = (value: any): value is LogLevel => logLevels.includes(value)

package/src/logger/Logger.ts

@@ -1 +0,0 @@
-export type { Logger } from 'log4js'

package/src/logger/createLogger.ts

@@ -1,10 +0,0 @@
-import { getLogger } from 'log4js'
-import type { Logger } from './Logger'
-import type { LogLevel } from './LogLevel'
-
-// TODO: add test
-export const createLogger = (logLevel: LogLevel): Logger => {
-  const logger = getLogger()
-  logger.level = logLevel
-  return logger
-}

package/src/logger/index.ts

@@ -1,6 +0,0 @@
-export { createLogger } from './createLogger'
-export type { Logger } from './Logger'
-export {
-  isLogLevel,
-  LogLevel
-} from './LogLevel'

package/src/main.ts

@@ -1,122 +0,0 @@
-import {
-  BranchNameCreator,
-  CommitMessageCreator,
-  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 {
-  PackageJsonParser,
-  PackageJsonReader
-} from './package-json'
-import { createPackageManager } from './package-manager'
-import {
-  OutdatedPackageProcessor,
-  OutdatedPackagesProcessor
-} from './processors'
-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 packageJsonParser = new PackageJsonParser(logger)
-  const packageJsonReader = new PackageJsonReader({
-    packageJsonParser,
-    logger
-  })
-  const ncu = new Ncu(packageJsonReader)
-  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 branchNameCreator = new BranchNameCreator(options.branchName)
-  const commitMessageCreator = new CommitMessageCreator(options.commitMessage)
-  const outdatedPackageProcessor = new OutdatedPackageProcessor({
-    committer,
-    git,
-    ncu,
-    packageManager,
-    pullRequestCreator,
-    remoteBranchExistenceChecker,
-    logger,
-    branchNameCreator,
-    commitMessageCreator
-  })
-  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.`)
-}