feat: [#576] add package manager functionality

contracts/packages/manager.go

@@ -0,0 +1,24 @@
+package packages
+
+import (
+	"github.com/dave/dst"
+	"github.com/dave/dst/dstutil"
+)
+
+type FileModifier interface {
+	Apply(dir string) error
+}
+
+type Manager interface {
+	Install(dir string) error
+	Uninstall(dir string) error
+}
+
+type GoNodeMatcher interface {
+	MatchNode(node dst.Node) bool
+	MatchCursor(cursor *dstutil.Cursor) bool
+}
+
+type GoNodeModifier interface {
+	Apply(node dst.Node) error
+}

foundation/application.go

@@ -61,6 +61,8 @@
 		console.NewEnvDecryptCommand(),
 		console.NewTestMakeCommand(),
 		console.NewPackageMakeCommand(),
+		console.NewPackageInstallCommand(),
+		console.NewPackageUninstallCommand(),
 		console.NewVendorPublishCommand(app.publishes, app.publishGroups),
 	})
 	app.setTimezone()

foundation/console/package_install_command.go

@@ -0,0 +1,126 @@
+package console
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"github.com/goravel/framework/contracts/console"
+	"github.com/goravel/framework/contracts/console/command"
+	"github.com/goravel/framework/errors"
+	"github.com/goravel/framework/support/color"
+)
+
+type PackageInstallCommand struct {
+}
+
+func NewPackageInstallCommand() *PackageInstallCommand {
+	return &PackageInstallCommand{}
+}
+
+// Signature The name and signature of the console command.
+func (r *PackageInstallCommand) Signature() string {
+	return "package:install"
+}
+
+// Description The console command description.
+func (r *PackageInstallCommand) Description() string {
+	return "Install a package"
+}
+
+// Extend The console command extend.
+func (r *PackageInstallCommand) Extend() command.Extend {
+	return command.Extend{
+		ArgsUsage: " <package@version>",
+		Category:  "package",
+	}
+}
+
+// Handle Execute the console command.
+func (r *PackageInstallCommand) Handle(ctx console.Context) error {
+	var (
+		err error
+		pkg = ctx.Argument(0)
+	)
+	if pkg == "" {
+		pkg, err = ctx.Ask("Enter the package name to install", console.AskOption{
+			Description: "If no version is specified, install the latest",
+			Placeholder: " E.g example.com/pkg or example.com/pkg@v1.0.0",
+			Prompt:      ">",
+			Validate: func(s string) error {
+				if s == "" {
+					return errors.CommandEmptyPackageName
+				}
+
+				return nil
+			},
+		})
+		if err != nil {
+			ctx.Error(err.Error())
+			return nil
+		}
+	}
+
+	// handle package version
+	pkg, version, ok := strings.Cut(pkg, "@")
+	manager := pkg + "/manager"
+	if ok {
+		pkg = pkg + "@" + version
+	}
+
+	// get package
+	var output []byte
+	get := exec.Command("go", "get", pkg)
+	if err = ctx.Spinner(fmt.Sprintf("> @%s", strings.Join(get.Args, " ")), console.SpinnerOption{
+		Action: func() error {
+			output, err = get.CombinedOutput()
+
+			return err
+		},
+	}); err != nil {
+		color.Errorf("failed to get package: %s\n", err.Error())
+		if len(output) > 0 {
+			color.Red().Println(string(output))
+		}
+
+		return nil
+	}
+
+	// install package
+	install := exec.Command("go", "run", manager, "install")
+	if err = ctx.Spinner(fmt.Sprintf("> @%s", strings.Join(install.Args, " ")), console.SpinnerOption{
+		Action: func() error {
+			output, err = install.CombinedOutput()
+
+			return err
+		},
+	}); err != nil {
+		color.Errorf("failed to install package: %s\n", err.Error())
+		if len(output) > 0 {
+			color.Red().Println(string(output))
+		}
+
+		return nil
+	}
+
+	// tidy go.mod file
+	tidy := exec.Command("go", "mod", "tidy")
+	if err = ctx.Spinner(fmt.Sprintf("> @%s", strings.Join(tidy.Args, " ")), console.SpinnerOption{
+		Action: func() error {
+			output, err = tidy.CombinedOutput()
+
+			return err
+		},
+	}); err != nil {
+		color.Errorf("failed to tidy go.mod file: %s\n", err.Error())
+		if len(output) > 0 {
+			color.Red().Println(string(output))
+		}
+
+		return nil
+	}
+
+	color.Successf("Package %s installed successfully\n", pkg)
+
+	return nil
+}

foundation/console/package_make_command.go

@@ -31,6 +31,12 @@ func (r *PackageMakeCommand) Extend() command.Extend {
 	return command.Extend{
 		Category: "make",
 		Flags: []command.Flag{
+			&command.BoolFlag{
+				Name:               "manager",
+				Aliases:            []string{"m"},
+				Usage:              "Create a package manager",
+				DisableDefaultText: true,
+			},
 			&command.StringFlag{
 				Name:    "root",
 				Aliases: []string{"r"},
@@ -72,12 +78,16 @@ func (r *PackageMakeCommand) Handle(ctx console.Context) error {
 	packageName := packageName(pkg)
 	packageMakeCommandStubs := NewPackageMakeCommandStubs(pkg, root)
 	files := map[string]func() string{
-		"README.md":                        packageMakeCommandStubs.Readme,
-		"service_provider.go":              packageMakeCommandStubs.ServiceProvider,
-		packageName + ".go":                packageMakeCommandStubs.Main,
-		"config/" + packageName + ".go":    packageMakeCommandStubs.Config,
-		"contracts/" + packageName + ".go": packageMakeCommandStubs.Contracts,
-		"facades/" + packageName + ".go":   packageMakeCommandStubs.Facades,
+		"README.md":           packageMakeCommandStubs.Readme,
+		"service_provider.go": packageMakeCommandStubs.ServiceProvider,
+		packageName + ".go":   packageMakeCommandStubs.Main,
+		filepath.Join("config", packageName+".go"):    packageMakeCommandStubs.Config,
+		filepath.Join("contracts", packageName+".go"): packageMakeCommandStubs.Contracts,
+		filepath.Join("facades", packageName+".go"):   packageMakeCommandStubs.Facades,
+	}
+
+	if ctx.OptionBool("manager") {
+		files[filepath.Join("manager", "manager.go")] = packageMakeCommandStubs.Manager
 	}
 
 	for path, content := range files {

foundation/console/package_make_command_stubs.go

@@ -122,3 +122,100 @@ func DummyCamelName() contracts.DummyCamelName {
 
 	return content
 }
+
+func (r PackageMakeCommandStubs) Manager() string {
+	content := `package main
+
+import (
+	"os"
+	"path"
+	"path/filepath"
+	"runtime/debug"
+    "strings"
+
+	pkgcontracts "github.com/goravel/framework/contracts/packages"
+	"github.com/goravel/framework/packages"
+	"github.com/goravel/framework/support/color"
+)
+
+var (
+	module string
+	dir    string
+	force  bool
+)
+
+func init() {
+	for i, arg := range os.Args {
+		if arg == "--force" || arg == "-f" {
+			force = true
+		}
+
+		if (arg == "--dir" || arg == "-d") && len(os.Args) > i+1 {
+			dir = os.Args[i+1]
+		}
+	}
+
+	if info, ok := debug.ReadBuildInfo(); ok && strings.HasSuffix(info.Path, "manager") {
+		module = path.Dir(info.Path)
+	}
+
+	if dir == "" {
+		dir, _ = os.Getwd()
+	}
+}
+
+func main() {
+	var pkg = packages.Manager{
+		ContinueOnError: force,
+		Module:          module,
+		OnInstall: []pkgcontracts.FileModifier{
+			packages.ModifyGoFile{
+				File: filepath.Join("config", "app.go"),
+				Modifiers: []pkgcontracts.GoNodeModifier{
+					packages.AddImportSpec(module),
+					packages.AddProviderSpec(
+						"&DummyName.ServiceProvider{}",
+					),
+				},
+			},
+		},
+		OnUninstall: []pkgcontracts.FileModifier{
+			packages.ModifyGoFile{
+				File: filepath.Join("config", "app.go"),
+				Modifiers: []pkgcontracts.GoNodeModifier{
+					packages.RemoveImportSpec(module),
+					packages.RemoveProviderSpec("&DummyName.ServiceProvider{}"),
+				},
+			},
+		},
+	}
+
+    if module == "" {
+		color.Errorln("Package module name is empty, please run command with module name.")
+		return
+	}
+
+	if len(os.Args) > 1 && os.Args[1] == "install" {
+		err := pkg.Install(dir)
+		if err != nil {
+			color.Errorln(err)
+			return
+		}
+		color.Successf("Package %s installed successfully\n", module)
+	}
+
+	if len(os.Args) > 1 && os.Args[1] == "uninstall" {
+		err := pkg.Uninstall(dir)
+		if err != nil {
+			color.Errorln(err)
+			return
+		}
+		color.Successf("Package %s uninstalled successfully\n", module)
+	}
+}
+
+`
+	content = strings.ReplaceAll(content, "DummyName", r.name)
+
+	return content
+}

foundation/console/package_make_command_test.go

@@ -42,7 +42,12 @@ func (s *PackageMakeCommandTestSuite) TestExtend() {
 
 	if len(got.Flags) > 0 {
 		s.Run("should have correctly configured StringFlag", func() {
-			flag, ok := got.Flags[0].(*command.StringFlag)
+			managerFlag, ok := got.Flags[0].(*command.BoolFlag)
+			if !ok {
+				s.Fail("First flag is not BoolFlag (got type: %T)", got.Flags[0])
+			}
+
+			rootFlag, ok := got.Flags[1].(*command.StringFlag)
 			if !ok {
 				s.Fail("First flag is not StringFlag (got type: %T)", got.Flags[0])
 			}
@@ -52,10 +57,13 @@ func (s *PackageMakeCommandTestSuite) TestExtend() {
 				got      interface{}
 				expected interface{}
 			}{
-				{"Name", flag.Name, "root"},
-				{"Aliases", flag.Aliases, []string{"r"}},
-				{"Usage", flag.Usage, "The root path of package, default: packages"},
-				{"Value", flag.Value, "packages"},
+				{"Name", rootFlag.Name, "root"},
+				{"Aliases", rootFlag.Aliases, []string{"r"}},
+				{"Usage", rootFlag.Usage, "The root path of package, default: packages"},
+				{"Value", rootFlag.Value, "packages"},
+				{"Name", managerFlag.Name, "manager"},
+				{"Aliases", managerFlag.Aliases, []string{"m"}},
+				{"Usage", managerFlag.Usage, "Create a package manager"},
 			}
 
 			for _, tc := range testCases {
@@ -93,10 +101,32 @@ func (s *PackageMakeCommandTestSuite) TestHandle() {
 			},
 		},
 		{
-			name: "name is sms and use default root",
+			name: "name is sms and use default root(hasn't manager)",
+			setup: func() {
+				mockContext.EXPECT().Argument(0).Return("sms").Once()
+				mockContext.EXPECT().Option("root").Return("packages").Once()
+				mockContext.EXPECT().OptionBool("manager").Return(false).Once()
+				mockContext.EXPECT().Success("Package created successfully: packages/sms").Once()
+			},
+			assert: func() {
+				s.NoError(NewPackageMakeCommand().Handle(mockContext))
+				s.True(file.Exists("packages/sms/README.md"))
+				s.True(file.Exists("packages/sms/service_provider.go"))
+				s.True(file.Exists("packages/sms/sms.go"))
+				s.True(file.Exists("packages/sms/config/sms.go"))
+				s.True(file.Exists("packages/sms/contracts/sms.go"))
+				s.True(file.Exists("packages/sms/facades/sms.go"))
+				s.True(file.Contain("packages/sms/facades/sms.go", "goravel/packages/sms"))
+				s.True(file.Contain("packages/sms/facades/sms.go", "goravel/packages/sms/contracts"))
+				s.NoError(file.Remove("packages"))
+			},
+		},
+		{
+			name: "name is sms and use default root(has manager)",
 			setup: func() {
 				mockContext.EXPECT().Argument(0).Return("sms").Once()
 				mockContext.EXPECT().Option("root").Return("packages").Once()
+				mockContext.EXPECT().OptionBool("manager").Return(true).Once()
 				mockContext.EXPECT().Success("Package created successfully: packages/sms").Once()
 			},
 			assert: func() {
@@ -109,6 +139,7 @@ func (s *PackageMakeCommandTestSuite) TestHandle() {
 				s.True(file.Exists("packages/sms/facades/sms.go"))
 				s.True(file.Contain("packages/sms/facades/sms.go", "goravel/packages/sms"))
 				s.True(file.Contain("packages/sms/facades/sms.go", "goravel/packages/sms/contracts"))
+				s.True(file.Exists("packages/sms/manager/manager.go"))
 				s.NoError(file.Remove("packages"))
 			},
 		},
@@ -117,6 +148,7 @@ func (s *PackageMakeCommandTestSuite) TestHandle() {
 			setup: func() {
 				mockContext.EXPECT().Argument(0).Return("github.com/goravel/sms-aws").Once()
 				mockContext.EXPECT().Option("root").Return("package").Once()
+				mockContext.EXPECT().OptionBool("manager").Return(false).Once()
 				mockContext.EXPECT().Success("Package created successfully: package/github_com_goravel_sms_aws").Once()
 			},
 			assert: func() {