1
0
mirror of https://github.com/SAP/jenkins-library.git synced 2024-12-12 10:55:20 +02:00
sap-jenkins-library/pkg/npm/publish.go
2022-03-04 10:26:46 +01:00

207 lines
5.8 KiB
Go

package npm
import (
"encoding/json"
"fmt"
"path/filepath"
"regexp"
"github.com/pkg/errors"
"github.com/SAP/jenkins-library/pkg/log"
CredentialUtils "github.com/SAP/jenkins-library/pkg/piperutils"
)
type npmMinimalPackageDescriptor struct {
Name string `json:version`
Version string `json:version`
}
func (pd *npmMinimalPackageDescriptor) Scope() string {
r := regexp.MustCompile(`^(?:(?P<scope>@[^\/]+)\/)?(?P<package>.+)$`)
matches := r.FindStringSubmatch(pd.Name)
if len(matches) == 0 {
return ""
}
return matches[1]
}
// PublishAllPackages executes npm publish for all package.json files defined in packageJSONFiles list
func (exec *Execute) PublishAllPackages(packageJSONFiles []string, registry, username, password string, packBeforePublish bool) error {
for _, packageJSON := range packageJSONFiles {
log.Entry().Infof("triggering publish for %s", packageJSON)
fileExists, err := exec.Utils.FileExists(packageJSON)
if err != nil {
return fmt.Errorf("cannot check if '%s' exists: %w", packageJSON, err)
}
if !fileExists {
return fmt.Errorf("package.json file '%s' not found: %w", packageJSON, err)
}
err = exec.publish(packageJSON, registry, username, password, packBeforePublish)
if err != nil {
return err
}
}
return nil
}
// publish executes npm publish for package.json
func (exec *Execute) publish(packageJSON, registry, username, password string, packBeforePublish bool) error {
execRunner := exec.Utils.GetExecRunner()
scope, err := exec.readPackageScope(packageJSON)
if err != nil {
return errors.Wrapf(err, "error reading package scope from %s", packageJSON)
}
npmignore := NewNPMIgnore(filepath.Dir(packageJSON))
if exists, err := exec.Utils.FileExists(npmignore.filepath); exists {
if err != nil {
return errors.Wrapf(err, "failed to check for existing %s file", npmignore.filepath)
}
log.Entry().Debugf("loading existing %s file", npmignore.filepath)
if err = npmignore.Load(); err != nil {
return errors.Wrapf(err, "failed to read existing %s file", npmignore.filepath)
}
} else {
log.Entry().Debug("creating .npmignore file")
}
log.Entry().Debug("adding **/piper")
npmignore.Add("**/piper")
log.Entry().Debug("adding **/sap-piper")
npmignore.Add("**/sap-piper")
npmrc := NewNPMRC(filepath.Dir(packageJSON))
log.Entry().Debugf("adding piper npmrc file %v", npmrc.filepath)
npmignore.Add(npmrc.filepath)
if err := npmignore.Write(); err != nil {
return errors.Wrapf(err, "failed to update %s file", npmignore.filepath)
}
// update .piperNpmrc
if len(registry) > 0 {
// check existing .npmrc file
if exists, err := exec.Utils.FileExists(npmrc.filepath); exists {
if err != nil {
return errors.Wrapf(err, "failed to check for existing %s file", npmrc.filepath)
}
log.Entry().Debugf("loading existing %s file", npmrc.filepath)
if err = npmrc.Load(); err != nil {
return errors.Wrapf(err, "failed to read existing %s file", npmrc.filepath)
}
} else {
log.Entry().Debugf("creating new npmrc file at %s", npmrc.filepath)
}
// set registry
log.Entry().Debugf("adding registry %s", registry)
npmrc.Set("registry", registry)
if len(scope) > 0 {
npmrc.Set(fmt.Sprintf("%s:registry", scope), registry)
}
// set registry auth
if len(username) > 0 && len(password) > 0 {
log.Entry().Debug("adding registry credentials")
npmrc.Set("_auth", CredentialUtils.EncodeUsernamePassword(username, password))
npmrc.Set("always-auth", "true")
}
// update .npmrc
if err := npmrc.Write(); err != nil {
return errors.Wrapf(err, "failed to update %s file", npmrc.filepath)
}
} else {
log.Entry().Debug("no registry provided")
}
if packBeforePublish {
tmpDirectory, err := exec.Utils.TempDir(".", "temp-")
if err != nil {
return errors.Wrap(err, "creating temp directory failed")
}
defer exec.Utils.RemoveAll(tmpDirectory)
err = execRunner.RunExecutable("npm", "pack", "--pack-destination", tmpDirectory)
if err != nil {
return err
}
_, err = exec.Utils.Copy(npmrc.filepath, filepath.Join(tmpDirectory, ".piperNpmrc"))
if err != nil {
return fmt.Errorf("error copying piperNpmrc file from %v to %v with error: %w",
npmrc.filepath, filepath.Join(tmpDirectory, ".piperNpmrc"), err)
}
tarballs, err := exec.Utils.Glob(filepath.Join(tmpDirectory, "*.tgz"))
if err != nil {
return err
}
if len(tarballs) != 1 {
return fmt.Errorf("found more tarballs than expected: %v", tarballs)
}
tarballFilePath, err := exec.Utils.Abs(tarballs[0])
if err != nil {
return err
}
projectNpmrc := filepath.Join(filepath.Dir(packageJSON), ".npmrc")
projectNpmrcExists, _ := exec.Utils.FileExists(projectNpmrc)
if projectNpmrcExists {
// rename the .npmrc file since it interferes with publish
err = exec.Utils.FileRename(projectNpmrc, projectNpmrc+".tmp")
if err != nil {
return fmt.Errorf("error when renaming current .npmrc file : %w", err)
}
}
err = execRunner.RunExecutable("npm", "publish", "--tarball", tarballFilePath, "--userconfig", filepath.Join(tmpDirectory, ".piperNpmrc"), "--registry", registry)
if err != nil {
return errors.Wrap(err, "failed publishing artifact")
}
if projectNpmrcExists {
// undo the renaming ot the .npmrc to keep the workspace like before
err = exec.Utils.FileRename(projectNpmrc+".tmp", projectNpmrc)
if err != nil {
log.Entry().Warnf("unable to rename the .npmrc file : %v", err)
}
}
} else {
err := execRunner.RunExecutable("npm", "publish", "--userconfig", npmrc.filepath, "--registry", registry)
if err != nil {
return errors.Wrap(err, "failed publishing artifact")
}
}
return nil
}
func (exec *Execute) readPackageScope(packageJSON string) (string, error) {
b, err := exec.Utils.FileRead(packageJSON)
if err != nil {
return "", err
}
var pd npmMinimalPackageDescriptor
json.Unmarshal(b, &pd)
return pd.Scope(), nil
}