npm-update-package 0.6.0 → 0.9.0

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,26 +0,0 @@
-import {
-  intersection,
-  literal,
-  partial,
-  string,
-  type,
-  union
-} from 'io-ts'
-import type { TypeOf } from 'io-ts'
-
-const Options = intersection([
-  type({
-    branchName: string,
-    commitMessage: string,
-    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

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

package/src/options/initOptions.ts

@@ -1,44 +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)
-    )
-  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'

package/src/processors/OutdatedPackageProcessor.ts

@@ -1,109 +0,0 @@
-import type {
-  BranchNameCreator,
-  CommitMessageCreator,
-  Committer,
-  Git
-} from '../git'
-import type {
-  PullRequestCreator,
-  RemoteBranchExistenceChecker
-} from '../github'
-import type { Logger } from '../logger'
-import type {
-  Ncu,
-  OutdatedPackage
-} from '../ncu'
-import type { PackageManager } from '../package-manager'
-import type { Result } from './Result'
-
-// 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
-  private readonly branchNameCreator: BranchNameCreator
-  private readonly commitMessageCreator: CommitMessageCreator
-
-  constructor ({
-    committer,
-    git,
-    ncu,
-    packageManager,
-    pullRequestCreator,
-    remoteBranchExistenceChecker,
-    logger,
-    branchNameCreator,
-    commitMessageCreator
-  }: {
-    committer: Committer
-    git: Git
-    ncu: Ncu
-    packageManager: PackageManager
-    pullRequestCreator: PullRequestCreator
-    remoteBranchExistenceChecker: RemoteBranchExistenceChecker
-    logger: Logger
-    branchNameCreator: BranchNameCreator
-    commitMessageCreator: CommitMessageCreator
-  }) {
-    this.committer = committer
-    this.git = git
-    this.ncu = ncu
-    this.packageManager = packageManager
-    this.pullRequestCreator = pullRequestCreator
-    this.remoteBranchExistenceChecker = remoteBranchExistenceChecker
-    this.logger = logger
-    this.branchNameCreator = branchNameCreator
-    this.commitMessageCreator = commitMessageCreator
-  }
-
-  /**
-   * Don't run in parallel because it includes file operations.
-   */
-  async process (outdatedPackage: OutdatedPackage): Promise<Result> {
-    const branchName = this.branchNameCreator.create(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 = this.commitMessageCreator.create(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/processors/OutdatedPackagesProcessor.ts

@@ -1,32 +0,0 @@
-import type { Logger } from '../logger'
-import type { OutdatedPackage } from '../ncu'
-import type { OutdatedPackageProcessor } from './OutdatedPackageProcessor'
-import type { Result } from './Result'
-
-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/processors/Result.ts

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

package/src/processors/index.ts

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

package/src/terminal/Terminal.ts

@@ -1,30 +0,0 @@
-import execa from 'execa'
-import type { ExecaReturnValue } from 'execa'
-import { isExecaReturnValue } from './isExecaReturnValue'
-
-// TODO: add test
-export class Terminal {
-  async run (
-    command: string,
-    ...args: string[]
-  ): Promise<ExecaReturnValue<string>> {
-    return await execa(command, args)
-  }
-
-  async runWithErrorHandling (
-    command: string,
-    ...args: string[]
-  ): Promise<ExecaReturnValue<string>> {
-    try {
-      return await this.run(command, ...args)
-    } catch (e) {
-      const value: unknown = e instanceof Error ? JSON.parse(JSON.stringify(e)) : e
-
-      if (isExecaReturnValue(value)) {
-        return value
-      } else {
-        throw e
-      }
-    }
-  }
-}

package/src/terminal/index.ts

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