nodejs

Documentation

Overview

Package nodejs provides backends for Node.js using Yarn, PNPM and NPM.

Index

• Variables

Variables

var BunBackend = api.LanguageBackend{
	Name:             "bun",
	Specfile:         "package.json",
	Lockfile:         "bun.lockb",
	IsAvailable:      bunIsAvailable,
	FilenamePatterns: nodejsPatterns,
	Quirks: api.QuirksAddRemoveAlsoLocks |
		api.QuirksAddRemoveAlsoInstalls |
		api.QuirksLockAlsoInstalls,
	GetPackageDir: func() string {
		return "node_modules"
	},
	Search: nodejsSearch,
	Info:   nodejsInfo,
	Add: func(ctx context.Context, pkgs map[api.PkgName]api.PkgSpec, projectName string) {

		span, ctx := tracer.StartSpanFromContext(ctx, "bun (init) add")
		defer span.Finish()

		if !util.Exists("package.json") {
			util.RunCmd([]string{"bun", "init", "-y"})
		}
		cmd := []string{"bun", "add"}
		for name, spec := range pkgs {
			arg := string(name)
			if spec != "" {
				arg += "@" + string(spec)
			}
			cmd = append(cmd, arg)
		}
		util.RunCmd(cmd)
	},
	Remove: func(ctx context.Context, pkgs map[api.PkgName]bool) {

		span, ctx := tracer.StartSpanFromContext(ctx, "bun remove")
		defer span.Finish()

		cmd := []string{"bun", "remove"}
		for name := range pkgs {
			cmd = append(cmd, string(name))
		}
		util.RunCmd(cmd)
	},
	Lock: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "bun install")
		defer span.Finish()
		util.RunCmd([]string{"bun", "install"})
	},
	Install: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "bun install")
		defer span.Finish()
		util.RunCmd([]string{"bun", "install"})
	},
	ListSpecfile: nodejsListSpecfile,
	ListLockfile: func() map[api.PkgName]api.PkgVersion {
		hashString, err := exec.Command("bun", "pm", "hash-string").Output()
		if err != nil {
			util.DieSubprocess("bun pm hash-string: %s", err)
		}

		r := regexp.MustCompile(`(?m)^(@?[^@ \n]+)@(.+)$`)
		pkgs := map[api.PkgName]api.PkgVersion{}

		for _, match := range r.FindAllStringSubmatch(string(hashString), -1) {
			name := api.PkgName(match[1])
			pkgs[name] = api.PkgVersion(match[2])
		}

		return pkgs
	},

	GuessRegexps:                       nodejsGuessRegexps,
	Guess:                              nodejsGuess,
	InstallReplitNixSystemDependencies: nix.DefaultInstallReplitNixSystemDependencies,
}

BunBackend is a UPM backend for Node.js that uses [Bun](https://bun.sh/).

var NodejsNPMBackend = api.LanguageBackend{
	Name:             "nodejs-npm",
	Specfile:         "package.json",
	Lockfile:         "package-lock.json",
	IsAvailable:      npmIsAvailable,
	FilenamePatterns: nodejsPatterns,
	Quirks: api.QuirksAddRemoveAlsoLocks |
		api.QuirksAddRemoveAlsoInstalls |
		api.QuirksLockAlsoInstalls,
	GetPackageDir: func() string {
		return "node_modules"
	},
	Search: nodejsSearch,
	Info:   nodejsInfo,
	Add: func(ctx context.Context, pkgs map[api.PkgName]api.PkgSpec, projectName string) {

		span, ctx := tracer.StartSpanFromContext(ctx, "npm (init) install")
		defer span.Finish()
		if !util.Exists("package.json") {
			util.RunCmd([]string{"npm", "init", "-y"})
		}
		cmd := []string{"npm", "install"}
		for name, spec := range pkgs {
			arg := string(name)
			if spec != "" {
				arg += "@" + string(spec)
			}
			cmd = append(cmd, arg)
		}
		util.RunCmd(cmd)
	},
	Remove: func(ctx context.Context, pkgs map[api.PkgName]bool) {

		span, ctx := tracer.StartSpanFromContext(ctx, "npm uninstall")
		defer span.Finish()
		cmd := []string{"npm", "uninstall"}
		for name := range pkgs {
			cmd = append(cmd, string(name))
		}
		util.RunCmd(cmd)
	},
	Lock: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "npm install")
		defer span.Finish()
		util.RunCmd([]string{"npm", "install"})
	},
	Install: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "npm ci")
		defer span.Finish()
		util.RunCmd([]string{"npm", "ci"})
	},
	ListSpecfile: nodejsListSpecfile,
	ListLockfile: func() map[api.PkgName]api.PkgVersion {
		contentsB, err := os.ReadFile("package-lock.json")
		if err != nil {
			util.DieIO("package-lock.json: %s", err)
		}
		var cfg packageLockJSON
		if err := json.Unmarshal(contentsB, &cfg); err != nil {
			util.DieProtocol("package-lock.json: %s", err)
		}
		pkgs := map[api.PkgName]api.PkgVersion{}
		if cfg.LockfileVersion <= 2 {
			for nameStr, data := range cfg.Dependencies {
				pkgs[api.PkgName(nameStr)] = api.PkgVersion(data.Version)
			}
		} else {
			for pathStr, data := range cfg.Packages {
				nameStr := strings.TrimPrefix(pathStr, "node_modules/")
				pkgs[api.PkgName(nameStr)] = api.PkgVersion(data.Version)
			}
		}
		return pkgs
	},

	GuessRegexps:                       nodejsGuessRegexps,
	Guess:                              nodejsGuess,
	InstallReplitNixSystemDependencies: nix.DefaultInstallReplitNixSystemDependencies,
}

NodejsNPMBackend is a UPM backend for Node.js that uses [NPM](https://npmjs.com/).

var NodejsPNPMBackend = api.LanguageBackend{
	Name:             "nodejs-pnpm",
	Specfile:         "package.json",
	Lockfile:         "pnpm-lock.yaml",
	IsAvailable:      pnpmIsAvailable,
	FilenamePatterns: nodejsPatterns,
	Quirks: api.QuirksAddRemoveAlsoLocks |
		api.QuirksAddRemoveAlsoInstalls |
		api.QuirksLockAlsoInstalls,
	GetPackageDir: func() string {
		return "node_modules"
	},
	Search: nodejsSearch,
	Info:   nodejsInfo,
	Add: func(ctx context.Context, pkgs map[api.PkgName]api.PkgSpec, projectName string) {

		span, ctx := tracer.StartSpanFromContext(ctx, "pnpm (init) add")
		defer span.Finish()
		if !util.Exists("package.json") {
			util.RunCmd([]string{"pnpm", "init"})
		}
		cmd := []string{"pnpm", "add"}
		for name, spec := range pkgs {
			arg := string(name)
			if spec != "" {
				arg += "@" + string(spec)
			}
			cmd = append(cmd, arg)
		}
		util.RunCmd(cmd)
	},
	Remove: func(ctx context.Context, pkgs map[api.PkgName]bool) {

		span, ctx := tracer.StartSpanFromContext(ctx, "pnpm remove")
		defer span.Finish()
		cmd := []string{"pnpm", "remove"}
		for name := range pkgs {
			cmd = append(cmd, string(name))
		}
		util.RunCmd(cmd)
	},
	Lock: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "pnpm install")
		defer span.Finish()
		util.RunCmd([]string{"pnpm", "install"})
	},
	Install: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "pnpm install")
		defer span.Finish()
		util.RunCmd([]string{"pnpm", "install"})
	},
	ListSpecfile: nodejsListSpecfile,
	ListLockfile: func() map[api.PkgName]api.PkgVersion {
		lockfileBytes, err := os.ReadFile("pnpm-lock.yaml")
		if err != nil {
			util.DieIO("pnpm-lock.yaml: %s", err)
		}

		lockfile := map[string]interface{}{}
		err = yaml.Unmarshal(lockfileBytes, &lockfile)
		if err != nil {
			util.DieProtocol("pnpm-lock.yaml: %s", err)
		}

		lockfileVersion := strings.Split(lockfile["lockfileVersion"].(string), ".")
		lvMajor := lockfileVersion[0]

		pkgs := map[api.PkgName]api.PkgVersion{}
		switch lvMajor {
		case "6":
			dependencies, ok := lockfile["dependencies"]
			if !ok {
				return pkgs
			}

			for pkgName, pkgInfo := range dependencies.(map[interface{}]interface{}) {
				pkgs[api.PkgName(pkgName.(string))] = api.PkgVersion(pkgInfo.(map[interface{}]interface{})["version"].(string))
			}

		default:
			util.DieInitializationError("pnpm-lock.yaml: unsupported lockfile version %s", lockfileVersion)
		}

		return pkgs
	},

	GuessRegexps:                       nodejsGuessRegexps,
	Guess:                              nodejsGuess,
	InstallReplitNixSystemDependencies: nix.DefaultInstallReplitNixSystemDependencies,
}

NodejsPNPMBackend is a UPM backend for Node.js that uses [pnpm](https://pnpm.io/).

var NodejsYarnBackend = api.LanguageBackend{
	Name:             "nodejs-yarn",
	Specfile:         "package.json",
	Lockfile:         "yarn.lock",
	IsAvailable:      yarnIsAvailable,
	FilenamePatterns: nodejsPatterns,
	Quirks: api.QuirksAddRemoveAlsoLocks |
		api.QuirksAddRemoveAlsoInstalls |
		api.QuirksLockAlsoInstalls |
		api.QuirkRemoveNeedsLockfile,
	GetPackageDir: func() string {
		return "node_modules"
	},
	Search: nodejsSearch,
	Info:   nodejsInfo,
	Add: func(ctx context.Context, pkgs map[api.PkgName]api.PkgSpec, projectName string) {

		span, ctx := tracer.StartSpanFromContext(ctx, "yarn (init) add")
		defer span.Finish()
		if !util.Exists("package.json") {
			util.RunCmd([]string{"yarn", "init", "-y"})
		}
		cmd := []string{"yarn", "add"}
		for name, spec := range pkgs {
			arg := string(name)
			if spec != "" {
				arg += "@" + string(spec)
			}
			cmd = append(cmd, arg)
		}
		util.RunCmd(cmd)
	},
	Remove: func(ctx context.Context, pkgs map[api.PkgName]bool) {

		span, ctx := tracer.StartSpanFromContext(ctx, "yarn remove")
		defer span.Finish()

		cmd := []string{"yarn", "remove"}
		for name := range pkgs {
			cmd = append(cmd, string(name))
		}
		util.RunCmd(cmd)
	},
	Lock: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "yarn install")
		defer span.Finish()
		util.RunCmd([]string{"yarn", "install"})
	},
	Install: func(ctx context.Context) {

		span, ctx := tracer.StartSpanFromContext(ctx, "yarn install")
		defer span.Finish()
		util.RunCmd([]string{"yarn", "install"})
	},
	ListSpecfile: nodejsListSpecfile,
	ListLockfile: func() map[api.PkgName]api.PkgVersion {
		contentsB, err := os.ReadFile("yarn.lock")
		if err != nil {
			util.DieIO("yarn.lock: %s", err)
		}
		contents := string(contentsB)
		r := regexp.MustCompile(`(?m)^"?((?:@[^@ \n]+\/)?[^@ \n]+).+:\n  version "(.+)"$`)
		pkgs := map[api.PkgName]api.PkgVersion{}
		for _, match := range r.FindAllStringSubmatch(contents, -1) {
			name := api.PkgName(match[1])
			version := api.PkgVersion(match[2])
			pkgs[name] = version
		}
		return pkgs
	},

	GuessRegexps:                       nodejsGuessRegexps,
	Guess:                              nodejsGuess,
	InstallReplitNixSystemDependencies: nix.DefaultInstallReplitNixSystemDependencies,
}

NodejsYarnBackend is a UPM backend for Node.js that uses [Yarn](https://yarnpkg.com/).