implementation for an artifactory service.

services/artifactory/artifactory.service.js

@@ -0,0 +1,211 @@
+import Joi from 'joi'
+import { optionalUrl } from '../validators.js'
+import { BaseService } from '../index.js'
+import { renderVersionBadge } from '../version.js'
+import { getCachedResource } from '../../core/base-service/resource-cache.js'
+
+const ARTIFACTORY_LATEST_VERSION_ENDPOINT = 'api/search/latestVersion'
+const ONE_HOUR = 1 * 3600 * 1000
+
+const queryParamSchema = Joi.object({
+  // auth related optional properties
+  server: optionalUrl.default(''),
+  token: Joi.string().default(''),
+  username: Joi.string().default(''),
+  password: Joi.string().default(''),
+
+  // api related optional properties
+  repos: Joi.string().default(''),
+  remote: Joi.string().default(''),
+  version: Joi.string().default(''),
+}).required()
+
+const documentation = `
+  <p>
+    Query for the last released version of an artifact using the <b>Latest Version</b> endpoint.
+    <br />
+    <br />
+    This service will cache results for <b>1 hour</b> so as not to overload a given Artifactory instance with potentially long running query operations.
+    <br />
+    <br />
+    Authentication is done either through basic auth or using a bearer token. While the options exist to pass along credentials as query params, users
+    are strongly encouraged to instead set the relevant auth related environment variables server side which this service will pick up and read at runtime.
+    <br />
+    <br />
+    The following environment variables are supported:
+    <ul>
+      <li>ARTIFACTORY_URL</li>
+      <li>ARTIFACTORY_TOKEN</li>
+      <li>ARTIFACTORY_USERNAME</li>
+      <li>ARTIFACTORY_PASSWORD</li>
+    </ul>
+    If using a <b>Token</b> for authentication you do not need to set the username and password env-vars.
+    <br />
+    <br />
+    For more technical information on the available properties the <b>Latest Version</b> endpoint uses, and their potential drawbacks and limitations, please consult the following <a target="_blank" href="https://jfrog.com/help/r/jfrog-rest-apis/artifact-latest-version-search-based-on-layout">developer documentation here</a>.
+  </p>
+  `
+
+export default class Artifactory extends BaseService {
+  static category = 'version'
+  static route = {
+    base: 'artifactory/v',
+    pattern: ':group/:artifact?',
+    queryParamSchema,
+  }
+
+  static examples = [
+    {
+      title: 'Artifactory Latest Version',
+      documentation,
+      namedParams: {
+        group: 'org.jfrog.artifactory.client',
+        artifact: 'artifactory-java-client-services',
+      },
+      queryParams: {
+        repos: 'libs-release-local',
+        remote: '1',
+        version: '1.0-SNAPSHOT',
+        server: 'https://my.artifactory.server/artifactory',
+        token: 'OTEfj876SDF2345JKIB/H&+FFGH',
+        username: 'jerry',
+        password: 'seinfeld',
+      },
+      staticPreview: Artifactory.render('2.1.0'),
+    },
+  ]
+
+  static defaultBadgeData = { label: 'artifactory' }
+
+  static render(version) {
+    return renderVersionBadge({ version })
+  }
+
+  static orElseEnvVar(possibleValue, envVarName) {
+    if (possibleValue !== '') {
+      return possibleValue
+    } else {
+      const envValue = process.env[envVarName]
+      if (envValue && envValue !== 'undefined') {
+        return envValue
+      } else {
+        return ''
+      }
+    }
+  }
+
+  static getAuthorizationHeaderValue(
+    possibleToken,
+    possibleUsername,
+    possiblePassword,
+  ) {
+    // check for token value first
+    const artToken = Artifactory.orElseEnvVar(
+      possibleToken,
+      'ARTIFACTORY_TOKEN',
+    )
+    if (artToken !== '') {
+      return `Bearer ${artToken}`
+    }
+
+    // if no token then check for username and password
+    const artUsername = Artifactory.orElseEnvVar(
+      possibleUsername,
+      'ARTIFACTORY_USERNAME',
+    )
+    if (artUsername !== '') {
+      const artPassword = Artifactory.orElseEnvVar(
+        possiblePassword,
+        'ARTIFACTORY_PASSWORD',
+      )
+      if (artUsername !== '') {
+        return `Basic ${btoa(`${artUsername}:${artPassword}`)}`
+      }
+    }
+
+    return ''
+  }
+
+  async fetchVersion({ requestParams }) {
+    // cache results so as not to overload
+    const result = await getCachedResource({
+      url: requestParams.artifactoryEndpoint,
+      ttl: ONE_HOUR,
+      json: false,
+      scraper: response => response,
+      options: requestParams.options,
+    })
+
+    //  Request path here does not use caching but does
+    //  allow us to catch specific errors and return
+    //  more specific responses: can we do something
+    //  similar when using the cachedResource function?
+    //
+    // const { res, buffer } = await this._request({
+    //  url: requestParams.artifactoryEndpoint,
+    //  options: requestParams.options,
+    //  httpErrors: { 404: 'Not Found', 401: 'Bad Credentials' },
+    // })
+
+    return result
+  }
+
+  async handle(
+    { group, artifact },
+    { server, token, username, password, repos, remote, version },
+  ) {
+    // Artifactory can return plain/text or json for this endpoint we're hitting so
+    // we need to effectively accept all as we're not sure what we're going to be returned
+    const defaultHeaders = { Accept: '*/*' }
+
+    // dump query params to debug console
+    console.debug(`***** artifactory found the following query properties *****
+
+      group=${group}
+      artifact=${artifact}
+      server=${server}
+      token=${token}
+      username=${username}
+      password=${password}
+      repos=${repos}
+      remote=${remote}
+      version=${version}
+    `)
+
+    // set and check Artifactory URL
+    const artifactoryUrl = Artifactory.orElseEnvVar(server, 'ARTIFACTORY_URL')
+    if (artifactoryUrl === '') {
+      const msg = 'No Artifactory URL found'
+      return this.constructor.render({ msg })
+    }
+    const artifactoryEndpoint = `${artifactoryUrl}/${ARTIFACTORY_LATEST_VERSION_ENDPOINT}`
+
+    // set and check authorization values
+    const authValue = Artifactory.getAuthorizationHeaderValue(
+      token,
+      username,
+      password,
+    )
+    if (authValue) {
+      defaultHeaders.Authorization = authValue
+    }
+
+    // set our request parameters to query Artifactory
+    const requestParams = {
+      artifactoryEndpoint,
+      options: {
+        headers: defaultHeaders,
+        searchParams: {
+          g: group,
+          a: artifact,
+          v: version,
+          remote,
+          repos,
+        },
+      },
+    }
+
+    const foundVersion = await this.fetchVersion({ requestParams })
+    return Artifactory.render(foundVersion)
+  }
+}