npm-update-package 0.8.0 → 0.11.0

package/src/main.ts

@@ -1,128 +0,0 @@
-import {
-  BranchNameCreator,
-  CommitMessageCreator,
-  Committer,
-  Git
-} from './git'
-import {
-  createGitHub,
-  PullRequestBodyCreator,
-  PullRequestCreator,
-  PullRequestTitleCreator,
-  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 pullRequestTitleCreator = new PullRequestTitleCreator(options.pullRequestTitle)
-  const pullRequestBodyCreator = new PullRequestBodyCreator(options.pullRequestBody)
-  const pullRequestCreator = new PullRequestCreator({
-    github,
-    gitRepo,
-    githubRepo,
-    pullRequestTitleCreator,
-    pullRequestBodyCreator,
-    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.`)
-}

package/src/ncu/Ncu.ts

@@ -1,43 +0,0 @@
-import { run } from 'npm-check-updates'
-import type { Options } from 'npm-check-updates/build/src/types'
-import type { OutdatedPackage } from '../ncu'
-import type { PackageJsonReader } from '../package-json'
-import { isNcuOutdatedPackages } from './isNcuOutdatedPackages'
-import { NcuOutdatedPackagesConverter } from './NcuOutdatedPackagesConverter'
-
-// TODO: add test
-export class Ncu {
-  constructor (private readonly packageJsonReader: PackageJsonReader) {}
-
-  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 this.packageJsonReader.read('./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

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

package/src/ncu/NcuOutdatedPackagesConverter.ts

@@ -1,25 +0,0 @@
-import type { PackageDependencies } from '../package-json'
-import type { NcuOutdatedPackages } from './NcuOutdatedPackages'
-import type { OutdatedPackage } from './OutdatedPackage'
-import { PackageVersion } from './PackageVersion'
-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/OutdatedPackage.ts

@@ -1,9 +0,0 @@
-import type { PackageVersion } from './PackageVersion'
-import type { UpdateType } from './UpdateType'
-
-export interface OutdatedPackage {
-  name: string
-  currentVersion: PackageVersion
-  newVersion: PackageVersion
-  type: UpdateType
-}

package/src/ncu/PackageVersion.test.ts

@@ -1,25 +0,0 @@
-import { PackageVersion } from './PackageVersion'
-
-describe('PackageVersion', () => {
-  describe('of', () => {
-    describe('if version is valid', () => {
-      const version = '^1.2.3'
-
-      it('returns new PackageVersion instance', () => {
-        const packageVersion = PackageVersion.of(version)
-        expect(packageVersion.version).toBe('1.2.3')
-        expect(packageVersion.major).toBe(1)
-        expect(packageVersion.minor).toBe(2)
-        expect(packageVersion.patch).toBe(3)
-      })
-    })
-
-    describe('if version is invalid', () => {
-      const version = ''
-
-      it('throws error', () => {
-        expect(() => PackageVersion.of(version)).toThrow(Error)
-      })
-    })
-  })
-})

package/src/ncu/PackageVersion.ts

@@ -1,40 +0,0 @@
-import { coerce } from 'semver'
-
-export class PackageVersion {
-  readonly version: string
-  readonly major: number
-  readonly minor: number
-  readonly patch: number
-
-  private constructor ({
-    version,
-    major,
-    minor,
-    patch
-  }: {
-    version: string
-    major: number
-    minor: number
-    patch: number
-  }) {
-    this.version = version
-    this.major = major
-    this.minor = minor
-    this.patch = patch
-  }
-
-  static of (version: string): PackageVersion {
-    const semver = coerce(version)
-
-    if (semver === null) {
-      throw new Error(`Failed to parse package version. version=${version}`)
-    }
-
-    return new PackageVersion({
-      version: semver.version,
-      major: semver.major,
-      minor: semver.minor,
-      patch: semver.patch
-    })
-  }
-}

package/src/ncu/UpdateType.ts

@@ -1,9 +0,0 @@
-export const UpdateType = {
-  Major: 'major',
-  Minor: 'minor',
-  Patch: 'patch'
-} as const
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type UpdateType = typeof UpdateType[keyof typeof UpdateType]
-const updateTypes = Object.values(UpdateType)
-export const isUpdateType = (value: any): value is UpdateType => updateTypes.includes(value)

package/src/ncu/index.ts

@@ -1,7 +0,0 @@
-export { Ncu } from './Ncu'
-export type { OutdatedPackage } from './OutdatedPackage'
-export { PackageVersion } from './PackageVersion'
-export {
-  isUpdateType,
-  UpdateType
-} from './UpdateType'

package/src/ncu/isNcuOutdatedPackages.ts

@@ -1,6 +0,0 @@
-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

@@ -1,21 +0,0 @@
-import { PackageVersion } from './PackageVersion'
-import { toUpdateType } from './toUpdateType'
-import { UpdateType } from './UpdateType'
-
-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

@@ -1,18 +0,0 @@
-import type { PackageVersion } from './PackageVersion'
-import { UpdateType } from './UpdateType'
-
-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

@@ -1,30 +0,0 @@
-import {
-  intersection,
-  literal,
-  partial,
-  string,
-  type,
-  union
-} from 'io-ts'
-import type { TypeOf } from 'io-ts'
-import { LogLevel } from '../logger'
-import { PackageManagerName } from '../package-manager'
-
-const Options = intersection([
-  type({
-    branchName: string,
-    commitMessage: string,
-    githubToken: string,
-    logLevel: union([literal(LogLevel.Info), literal(LogLevel.Debug)]),
-    packageManager: union([literal(PackageManagerName.Npm), literal(PackageManagerName.Yarn)]),
-    pullRequestBody: string,
-    pullRequestTitle: string
-  }),
-  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

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

package/src/options/initOptions.ts

@@ -1,53 +0,0 @@
-import {
-  Option,
-  program
-} from 'commander'
-import { app } from '../app'
-import { LogLevel } from '../logger'
-import { PackageManagerName } from '../package-manager'
-import { isOptions } from './Options'
-import type { Options } from './Options'
-
-// TODO: add test
-export const initOptions = (): Options => {
-  program
-    .version(app.version)
-    .option('--branch-name <value>', 'Branch name template', 'npm-update-package/{{{packageName}}}/v{{newVersion}}')
-    .option('--commit-message <value>', 'Commit message template', 'chore(deps): {{updateType}} update {{{packageName}}} to v{{newVersion}}')
-    .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([
-          LogLevel.Info,
-          LogLevel.Debug
-        ])
-        .default(LogLevel.Info)
-    )
-    .addOption(
-      new Option('--package-manager <value>', 'Package manager of your project')
-        .choices([
-          PackageManagerName.Npm,
-          PackageManagerName.Yarn
-        ])
-        .default(PackageManagerName.Npm)
-    )
-    .option('--pull-request-body <value>', 'Pull request body template', `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 [{{{appName}}}]({{{appWeb}}}) v{{appVersion}}`)
-    .option('--pull-request-title <value>', 'Pull request title template', 'chore(deps): {{updateType}} update {{{packageName}}} to v{{newVersion}}')
-  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/package-json/Package.ts

@@ -1,24 +0,0 @@
-import {
-  intersection,
-  partial,
-  string,
-  type
-} from 'io-ts'
-import type { TypeOf } from 'io-ts'
-import { PackageDependencies } from './PackageDependencies'
-
-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/package-json/PackageDependencies.ts

@@ -1,10 +0,0 @@
-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/package-json/PackageJsonParser.ts

@@ -1,19 +0,0 @@
-import type { Logger } from '../logger'
-import { isPackage } from './Package'
-import type { Package } from './Package'
-
-// TODO: add test
-export class PackageJsonParser {
-  constructor (private readonly logger: Logger) {}
-
-  parse (json: string): Package {
-    const parsed: unknown = JSON.parse(json)
-    this.logger.debug(`parsed=${JSON.stringify(parsed)}`)
-
-    if (isPackage(parsed)) {
-      return parsed
-    } else {
-      throw new Error(`Failed to parse package.json. json=${json}`)
-    }
-  }
-}

package/src/package-json/PackageJsonReader.ts

@@ -1,27 +0,0 @@
-import fs from 'fs'
-import type { Logger } from '../logger'
-import type { Package } from './Package'
-import type { PackageJsonParser } from './PackageJsonParser'
-
-// TODO: add test
-export class PackageJsonReader {
-  private readonly packageJsonParser: PackageJsonParser
-  private readonly logger: Logger
-
-  constructor ({
-    packageJsonParser,
-    logger
-  }: {
-    packageJsonParser: PackageJsonParser
-    logger: Logger
-  }) {
-    this.packageJsonParser = packageJsonParser
-    this.logger = logger
-  }
-
-  async read (filePath: string): Promise<Package> {
-    const json = await fs.promises.readFile(filePath, 'utf8')
-    this.logger.debug(`json=${json}`)
-    return this.packageJsonParser.parse(json)
-  }
-}

package/src/package-json/index.ts

@@ -1,3 +0,0 @@
-export { PackageJsonParser } from './PackageJsonParser'
-export { PackageJsonReader } from './PackageJsonReader'
-export type { PackageDependencies } from './PackageDependencies'

package/src/package-manager/Npm.ts

@@ -1,19 +0,0 @@
-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

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

package/src/package-manager/PackageManagerName.ts

@@ -1,8 +0,0 @@
-export const PackageManagerName = {
-  Npm: 'npm',
-  Yarn: 'yarn'
-} as const
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type PackageManagerName = typeof PackageManagerName[keyof typeof PackageManagerName]
-const packageManagerNames = Object.values(PackageManagerName)
-export const isPackageManagerName = (value: any): value is PackageManagerName => packageManagerNames.includes(value)

package/src/package-manager/Yarn.ts

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-import type { Terminal } from '../terminal'
-import { Npm } from './Npm'
-import type { PackageManager } from './PackageManager'
-import type { PackageManagerName } from './PackageManagerName'
-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

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