npm-update-package 0.30.0 → 0.31.3

package/src/github/pull-request/metadata/createPullRequestMetadata.test.ts

@@ -0,0 +1,31 @@
+
+import pkg from '../../../../package.json'
+import type { OutdatedPackage } from '../../../core'
+import { SemVer } from '../../../semver'
+import { createPullRequestMetadata } from './createPullRequestMetadata'
+
+describe('createPullRequestMetadata', () => {
+  it('returns PullRequestMetadata', () => {
+    const outdatedPackages: OutdatedPackage[] = [
+      {
+        name: '@npm-update-package/example',
+        currentVersion: SemVer.of('1.0.0'),
+        newVersion: SemVer.of('2.0.0'),
+        level: 'major'
+      }
+    ]
+    const metadata = createPullRequestMetadata(outdatedPackages)
+
+    expect(metadata).toEqual({
+      version: pkg.version,
+      packages: [
+        {
+          name: '@npm-update-package/example',
+          currentVersion: '1.0.0',
+          newVersion: '2.0.0',
+          level: 'major'
+        }
+      ]
+    })
+  })
+})

package/src/github/pull-request/metadata/createPullRequestMetadata.ts

@@ -0,0 +1,21 @@
+
+import pkg from '../../../../package.json'
+import type { OutdatedPackage } from '../../../core'
+import type { PullRequestMetadata } from './PullRequestMetadata'
+
+export const createPullRequestMetadata = (outdatedPackages: OutdatedPackage[]): PullRequestMetadata => {
+  return {
+    version: pkg.version,
+    packages: outdatedPackages.map(({
+      name,
+      currentVersion,
+      newVersion,
+      level
+    }) => ({
+      name,
+      currentVersion: currentVersion.version,
+      newVersion: newVersion.version,
+      level
+    }))
+  }
+}

package/src/github/pull-request/metadata/extractPullRequestMetadata.test.ts

@@ -0,0 +1,53 @@
+import { extractPullRequestMetadata } from './extractPullRequestMetadata'
+
+describe('extractPullRequestMetadata', () => {
+  it('returns PullRequestMetadata if body contains metadata', () => {
+    const body = `<div id="npm-update-package-metadata">
+
+\`\`\`json
+{
+  "version": "1.0.0",
+  "packages": [
+    {
+      "name": "@npm-update-package/example",
+      "level": "major",
+      "currentVersion": "1.0.0",
+      "newVersion": "2.0.0"
+    }
+  ]
+}
+\`\`\`
+
+</div>`
+    const metadata = extractPullRequestMetadata(body)
+    expect(metadata).toEqual({
+      version: '1.0.0',
+      packages: [
+        {
+          name: '@npm-update-package/example',
+          level: 'major',
+          currentVersion: '1.0.0',
+          newVersion: '2.0.0'
+        }
+      ]
+    })
+  })
+
+  it('returns undefined if body does not contain metadata', () => {
+    const body = ''
+    const metadata = extractPullRequestMetadata(body)
+    expect(metadata).toBeUndefined()
+  })
+
+  it('returns undefined if metadata is invalid', () => {
+    const body = `<div id="npm-update-package-metadata">
+
+\`\`\`json
+{}
+\`\`\`
+
+</div>`
+    const metadata = extractPullRequestMetadata(body)
+    expect(metadata).toBeUndefined()
+  })
+})

package/src/github/pull-request/metadata/extractPullRequestMetadata.ts

@@ -0,0 +1,21 @@
+import {
+  isPullRequestMetadata,
+  type PullRequestMetadata
+} from './PullRequestMetadata'
+
+export const extractPullRequestMetadata = (pullRequestBody: string): PullRequestMetadata | undefined => {
+  const matched = pullRequestBody.match(/<div id="npm-update-package-metadata">\s*```json\s*([\s\S]+?)\s*```\s*<\/div>/)
+  const json = matched?.[1]
+
+  if (json === undefined) {
+    return undefined
+  }
+
+  const metadata: unknown = JSON.parse(json)
+
+  if (!isPullRequestMetadata(metadata)) {
+    return undefined
+  }
+
+  return metadata
+}

package/src/github/pull-request/metadata/index.ts

@@ -0,0 +1,3 @@
+export * from './createPullRequestMetadata'
+export * from './extractPullRequestMetadata'
+export * from './PullRequestMetadata'

package/src/json/index.ts

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

package/src/json/toJSON.test.ts

@@ -0,0 +1,65 @@
+import { toJSON } from './toJSON'
+
+type TestCase = [unknown, string]
+
+describe('toJSON', () => {
+  describe('returns not indented JSON string if pretty option is false', () => {
+    const cases: TestCase[] = [
+      [
+        {
+          number: 1,
+          string: 'string'
+        },
+        '{"number":1,"string":"string"}'
+      ],
+      [
+        [
+          {
+            number: 1,
+            string: 'string'
+          }
+        ],
+        '[{"number":1,"string":"string"}]'
+      ]
+    ]
+
+    it.each<TestCase>(cases)('value=%j', (value, expected) => {
+      const json = toJSON(value)
+      expect(json).toBe(expected)
+    })
+  })
+
+  describe('returns indented JSON string if pretty option is true', () => {
+    const cases: TestCase[] = [
+      [
+        {
+          number: 1,
+          string: 'string'
+        },
+`{
+  "number": 1,
+  "string": "string"
+}`
+      ],
+      [
+        [
+          {
+            number: 1,
+            string: 'string'
+          }
+        ],
+`[
+  {
+    "number": 1,
+    "string": "string"
+  }
+]`
+      ]
+    ]
+
+    it.each<TestCase>(cases)('value=%j', (value, expected) => {
+      const json = toJSON(value, { pretty: true })
+      expect(json).toBe(expected)
+    })
+  })
+})

package/src/json/toJSON.ts

@@ -0,0 +1,13 @@
+interface Options {
+  pretty?: boolean
+}
+
+export const toJSON = (value: unknown, options?: Options): string => {
+  const pretty = options?.pretty ?? false
+
+  if (pretty) {
+    return JSON.stringify(value, null, 2)
+  } else {
+    return JSON.stringify(value)
+  }
+}

package/src/logger/LogLevel.ts

@@ -0,0 +1,13 @@
+export const LogLevel = {
+  Debug: 'debug',
+  Error: 'error',
+  Fatal: 'fatal',
+  Info: 'info',
+  Off: 'off',
+  Trace: 'trace',
+  Warn: 'warn'
+} 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

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

package/src/logger/createLogger.ts

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

@@ -0,0 +1,3 @@
+export * from './createLogger'
+export * from './Logger'
+export * from './LogLevel'

package/src/main.ts

@@ -0,0 +1,149 @@
+import {
+  isLeft,
+  isRight
+} from 'fp-ts/lib/Either'
+import {
+  OutdatedPackageProcessor,
+  OutdatedPackagesProcessor
+} from './core'
+import {
+  CommitMessageCreator,
+  Git
+} from './git'
+import {
+  BranchFinder,
+  createGitHub,
+  LabelCreator,
+  PullRequestCloser,
+  PullRequestCreator,
+  PullRequestFinder,
+  PullRequestTitleCreator
+} from './github'
+import type { Logger } from './logger'
+import { Ncu } from './ncu'
+import type { Options } from './options'
+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,
+    githubToken: options.githubToken !== '' ? '***' : ''
+  })}`)
+
+  const ncu = new Ncu(logger)
+  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 branches = await github.fetchBranches({
+    owner: gitRepo.owner,
+    repo: gitRepo.name
+  })
+  logger.debug(`branches=${JSON.stringify(branches)}`)
+
+  const pullRequests = await github.fetchPullRequests({
+    owner: gitRepo.owner,
+    repo: gitRepo.name
+  })
+  logger.debug(`pullRequests=${JSON.stringify(pullRequests)}`)
+
+  const labelCreator = new LabelCreator({
+    github,
+    gitRepo,
+    logger
+  })
+  await labelCreator.create({
+    name: 'npm-update-package',
+    description: 'Created by npm-update-package',
+    color: 'A00F21'
+  })
+
+  const branchFinder = new BranchFinder(branches)
+  const packageManager = createPackageManager({
+    terminal,
+    packageManager: options.packageManager
+  })
+  const pullRequestTitleCreator = new PullRequestTitleCreator(options.pullRequestTitle)
+  const pullRequestCreator = new PullRequestCreator({
+    github,
+    gitRepo,
+    githubRepo,
+    pullRequestTitleCreator,
+    logger,
+    reviewers: options.reviewers
+  })
+  const commitMessageCreator = new CommitMessageCreator(options.commitMessage)
+  const pullRequestFinder = new PullRequestFinder(pullRequests)
+  const pullRequestCloser = new PullRequestCloser(github)
+  const outdatedPackageProcessor = new OutdatedPackageProcessor({
+    git,
+    ncu,
+    packageManager,
+    pullRequestCreator,
+    branchFinder,
+    logger,
+    commitMessageCreator,
+    pullRequestFinder,
+    pullRequestCloser
+  })
+  const outdatedPackagesProcessor = new OutdatedPackagesProcessor({
+    outdatedPackageProcessor,
+    logger
+  })
+  const results = await outdatedPackagesProcessor.process(outdatedPackages)
+  logger.debug(`results=${JSON.stringify(results)}`)
+
+  const succeededResults = results.filter(isRight).map(({ right }) => right)
+  logger.debug(`succeededResults=${JSON.stringify(succeededResults)}`)
+
+  const createdPackages = succeededResults
+    .filter(({ created }) => created)
+    .map(({ outdatedPackage }) => outdatedPackage)
+  logger.debug(`createdPackages=${JSON.stringify(createdPackages)}`)
+
+  const skippedPackages = succeededResults
+    .filter(({ skipped }) => skipped)
+    .map(({ outdatedPackage }) => outdatedPackage)
+  logger.debug(`skippedPackages=${JSON.stringify(skippedPackages)}`)
+
+  const failedResults = results.filter(isLeft).map(({ left }) => left)
+  logger.debug(`failedResults=${JSON.stringify(failedResults)}`)
+
+  const failedPackages = failedResults.map(({ outdatedPackage }) => outdatedPackage)
+  logger.debug(`failedPackages=${JSON.stringify(failedPackages)}`)
+
+  // TODO: show as table
+  logger.info(`Processed ${succeededResults.length + failedPackages.length} packages:
+- ${createdPackages.length} packages: created (${createdPackages.map(({ name }) => name).join(',')})
+- ${skippedPackages.length} packages: skipped: (${skippedPackages.map(({ name }) => name).join(',')})
+- ${failedPackages.length} packages: failed: (${failedPackages.map(({ name }) => name).join(',')})`)
+}

package/src/ncu/Ncu.ts

@@ -0,0 +1,84 @@
+import { run } from 'npm-check-updates'
+import type { RunOptions } from 'npm-check-updates/build/src/types'
+import { isNotUndefined } from 'type-guards'
+import type { OutdatedPackage } from '../core'
+import { readFile } from '../file'
+import type { Logger } from '../logger'
+import { parsePackageJson } from '../package-json'
+import {
+  compareSemVers,
+  SemVer
+} from '../semver'
+import { isNcuResult } from './NcuResult'
+
+// TODO: add test
+export class Ncu {
+  constructor (private readonly logger: Logger) {}
+
+  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: RunOptions): Promise<OutdatedPackage[]> {
+    // Read package.json before running ncu
+    const json = await readFile('./package.json')
+    const pkg = parsePackageJson(json)
+    this.logger.debug(`pkg=${JSON.stringify(pkg)}`)
+
+    const result = await run(options)
+    this.logger.debug(`result=${JSON.stringify(result)}`)
+
+    if (!isNcuResult(result)) {
+      throw new Error('Failed to running ncu.')
+    }
+
+    const currentDependencies = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+      ...pkg.peerDependencies,
+      ...pkg.optionalDependencies
+    }
+    const resultEntries = Object.entries(result)
+    const outdatedPackages: OutdatedPackage[] = resultEntries
+      .map(([name, newVersionString]) => {
+        const currentVersionString = currentDependencies[name]
+
+        if (currentVersionString === undefined) {
+          return undefined
+        }
+
+        const currentVersion = SemVer.of(currentVersionString)
+        const newVersion = SemVer.of(newVersionString)
+        const level = compareSemVers(currentVersion, newVersion)
+
+        if (level === undefined) {
+          return undefined
+        }
+
+        const outdatedPackage: OutdatedPackage = {
+          name,
+          currentVersion,
+          newVersion,
+          level
+        }
+        return outdatedPackage
+      })
+      .filter(isNotUndefined)
+
+    if (resultEntries.length !== outdatedPackages.length) {
+      throw new Error('Failed to running ncu.')
+    }
+
+    return outdatedPackages
+  }
+}

package/src/ncu/NcuResult.ts

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

package/src/ncu/index.ts

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

package/src/options/CLIOption.ts

@@ -0,0 +1,19 @@
+import type { OptionType } from './OptionType'
+
+interface OptionBase {
+  name: string
+  description: string
+  type: OptionType
+  choices?: string[]
+}
+
+interface RequiredOption extends OptionBase {
+  required: true
+}
+
+interface OptionalOption extends OptionBase {
+  required: false
+  default?: string
+}
+
+export type CLIOption = RequiredOption | OptionalOption

package/src/options/OptionType.ts

@@ -0,0 +1,8 @@
+export const OptionType = {
+  String: 'string',
+  StringArray: 'string[]'
+} as const
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type OptionType = typeof OptionType[keyof typeof OptionType]
+const optionTypes = Object.values(OptionType)
+export const isOptionType = (value: any): value is OptionType => optionTypes.includes(value)

package/src/options/Options.ts

@@ -0,0 +1,40 @@
+import {
+  array,
+  intersection,
+  literal,
+  partial,
+  string,
+  type,
+  union,
+  type TypeOf
+} from 'io-ts'
+import { LogLevel } from '../logger'
+import { PackageManagerName } from '../package-manager'
+
+const Options = intersection([
+  type({
+    commitMessage: string,
+    githubToken: string,
+    logLevel: union([
+      literal(LogLevel.Off),
+      literal(LogLevel.Fatal),
+      literal(LogLevel.Error),
+      literal(LogLevel.Warn),
+      literal(LogLevel.Info),
+      literal(LogLevel.Debug),
+      literal(LogLevel.Trace)
+    ]),
+    packageManager: union([
+      literal(PackageManagerName.Npm),
+      literal(PackageManagerName.Yarn)
+    ]),
+    pullRequestTitle: string
+  }),
+  partial({
+    reviewers: array(string)
+  })
+])
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type Options = TypeOf<typeof Options>
+export const isOptions = Options.is

package/src/options/cliOptions.ts

@@ -0,0 +1,60 @@
+import { LogLevel } from '../logger'
+import { PackageManagerName } from '../package-manager'
+import type { CLIOption } from './CLIOption'
+import { OptionType } from './OptionType'
+
+export const cliOptions: CLIOption[] = [
+  {
+    name: 'commit-message',
+    description: 'Commit message template',
+    type: OptionType.String,
+    required: false,
+    default: 'chore(deps): {{level}} update {{{packageName}}} to v{{newVersion}}'
+  },
+  {
+    name: 'github-token',
+    description: 'GitHub token',
+    type: OptionType.String,
+    required: true
+  },
+  {
+    name: 'log-level',
+    description: 'Log level to show',
+    type: OptionType.String,
+    required: false,
+    choices: [
+      LogLevel.Off,
+      LogLevel.Fatal,
+      LogLevel.Error,
+      LogLevel.Warn,
+      LogLevel.Info,
+      LogLevel.Debug,
+      LogLevel.Trace
+    ],
+    default: LogLevel.Info
+  },
+  {
+    name: 'package-manager',
+    description: 'Package manager of your project',
+    type: OptionType.String,
+    required: false,
+    choices: [
+      PackageManagerName.Npm,
+      PackageManagerName.Yarn
+    ],
+    default: PackageManagerName.Npm
+  },
+  {
+    name: 'pull-request-title',
+    description: 'Pull request title template',
+    type: OptionType.String,
+    required: false,
+    default: 'chore(deps): {{level}} update {{{packageName}}} to v{{newVersion}}'
+  },
+  {
+    name: 'reviewers',
+    description: 'User names to request reviews',
+    type: OptionType.StringArray,
+    required: false
+  }
+]

package/src/options/index.ts

@@ -0,0 +1,2 @@
+export * from './initOptions'
+export * from './Options'

package/src/options/initOptions.ts

@@ -0,0 +1,24 @@
+import { program } from 'commander'
+import pkg from '../../package.json'
+import { cliOptions } from './cliOptions'
+import {
+  isOptions,
+  type Options
+} from './Options'
+import { toCommanderOption } from './toCommanderOption'
+
+// TODO: add test
+export const initOptions = (): Options => {
+  program.version(pkg.version)
+  cliOptions
+    .map(toCommanderOption)
+    .forEach(option => program.addOption(option))
+  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
+}