status command outputs funtion URL info.

Author: fujiwara

deploy.go

@@ -24,6 +24,7 @@ type DeployOption struct {
 	SkipArchive   bool   `help:"skip to create zip archive. requires Code.S3Bucket and Code.S3Key in function definition" default:"false"`
 	KeepVersions  int    `help:"Number of latest versions to keep. Older versions will be deleted. (Optional value: default 0)." default:"0"`
 	FunctionURL   string `help:"path to function-url definiton" default:""`
+	SkipFunction  bool   `help:"skip to deploy a function. deploy function-url only" default:"false"`
 
 	ExcludeFileOption
 }
@@ -81,15 +82,20 @@ func (app *App) Deploy(ctx context.Context, opt *DeployOption) error {
 
 	deployFunctionURL := func(context.Context) error { return nil }
 	if opt.FunctionURL != "" {
-		fc, err := app.loadFunctionUrl(opt.FunctionURL, *fn.FunctionName)
-		if err != nil {
-			return fmt.Errorf("failed to load function url config: %w", err)
-		}
 		deployFunctionURL = func(ctx context.Context) error {
+			fc, err := app.loadFunctionUrl(opt.FunctionURL, *fn.FunctionName)
+			if err != nil {
+				return fmt.Errorf("failed to load function url config: %w", err)
+			}
 			return app.deployFunctionURL(ctx, fc)
 		}
 	}
 
+	if opt.SkipFunction {
+		// skip to deploy a function. deploy function-url only
+		return deployFunctionURL(ctx)
+	}
+
 	log.Printf("[info] starting deploy function %s", *fn.FunctionName)
 	if current, err := app.lambda.GetFunction(ctx, &lambda.GetFunctionInput{
 		FunctionName: fn.FunctionName,

diff.go

@@ -22,10 +22,10 @@ import (
 
 // DiffOption represents options for Diff()
 type DiffOption struct {
-	Src        string `help:"function zip archive or src dir" default:"."`
-	CodeSha256 bool   `help:"diff of code sha256" default:"false"`
-	Unified    bool   `help:"unified diff" default:"true" negatable:"" short:"u"`
-	Qualifier  string `help:"compare with" default:"$LATEST"`
+	Src        string  `help:"function zip archive or src dir" default:"."`
+	CodeSha256 bool    `help:"diff of code sha256" default:"false"`
+	Unified    bool    `help:"unified diff" default:"true" negatable:"" short:"u"`
+	Qualifier  *string `help:"compare with"`
 
 	ExcludeFileOption
 }
@@ -51,7 +51,7 @@ func (app *App) Diff(ctx context.Context, opt *DiffOption) error {
 	var packageType types.PackageType
 	if res, err := app.lambda.GetFunction(ctx, &lambda.GetFunctionInput{
 		FunctionName: &name,
-		Qualifier:    &opt.Qualifier,
+		Qualifier:    opt.Qualifier,
 	}); err != nil {
 		return fmt.Errorf("failed to GetFunction %s: %w", name, err)
 	} else {
@@ -76,7 +76,7 @@ func (app *App) Diff(ctx context.Context, opt *DiffOption) error {
 
 	latestJSON, _ := marshalJSON(latestFunc)
 	newJSON, _ := marshalJSON(newFunc)
-	remoteArn := app.functionArn(ctx, name) + ":" + opt.Qualifier
+	remoteArn := fullQualifiedFunctionName(app.functionArn(ctx, name), opt.Qualifier)
 
 	if opt.Unified {
 		edits := myers.ComputeEdits(span.URIFromPath(remoteArn), string(latestJSON), string(newJSON))

functionurl.go

@@ -203,13 +203,15 @@ func (app *App) deployFunctionURL(ctx context.Context, fc *FunctionURL) error {
 
 func (app *App) deployFunctionURLConfig(ctx context.Context, fc *FunctionURL) error {
 	create := false
-	if _, err := app.lambda.GetFunctionUrlConfig(ctx, &lambda.GetFunctionUrlConfigInput{
+	fqFunctionName := fullQualifiedFunctionName(*fc.Config.FunctionName, fc.Config.Qualifier)
+	functinoUrlConfig, err := app.lambda.GetFunctionUrlConfig(ctx, &lambda.GetFunctionUrlConfigInput{
 		FunctionName: fc.Config.FunctionName,
 		Qualifier:    fc.Config.Qualifier,
-	}); err != nil {
+	})
+	if err != nil {
 		var nfe *types.ResourceNotFoundException
 		if errors.As(err, &nfe) {
-			log.Printf("[info] function url config for %s not found. creating", *fc.Config.FunctionName)
+			log.Printf("[info] function url config for %s not found. creating", fqFunctionName)
 			create = true
 		} else {
 			return fmt.Errorf("failed to get function url config: %w", err)
@@ -221,9 +223,14 @@ func (app *App) deployFunctionURLConfig(ctx context.Context, fc *FunctionURL) er
 		if err != nil {
 			return fmt.Errorf("failed to create function url config: %w", err)
 		}
-		log.Printf("[info] created function url config for %s", *fc.Config.FunctionName)
+		log.Printf("[info] created function url config for %s", fqFunctionName)
 		log.Printf("[info] Function URL: %s", *res.FunctionUrl)
 	} else {
+		log.Printf("[info] updating function url config for %s", fqFunctionName)
+		if functinoUrlConfig.Cors != nil && fc.Config.Cors == nil {
+			// reset cors config
+			fc.Config.Cors = &types.Cors{}
+		}
 		res, err := app.lambda.UpdateFunctionUrlConfig(ctx, &lambda.UpdateFunctionUrlConfigInput{
 			FunctionName: fc.Config.FunctionName,
 			Qualifier:    fc.Config.Qualifier,
@@ -234,13 +241,14 @@ func (app *App) deployFunctionURLConfig(ctx context.Context, fc *FunctionURL) er
 		if err != nil {
 			return fmt.Errorf("failed to update function url config: %w", err)
 		}
-		log.Printf("[info] updated function url config for %s", *fc.Config.FunctionName)
+		log.Printf("[info] updated function url config for %s", fqFunctionName)
 		log.Printf("[info] Function URL: %s", *res.FunctionUrl)
 	}
 	return nil
 }
 
 func (app *App) deployFunctionURLPermissions(ctx context.Context, fc *FunctionURL) error {
+	fqFunctionName := fullQualifiedFunctionName(*fc.Config.FunctionName, fc.Config.Qualifier)
 	existsSids := []string{}
 	{
 		res, err := app.lambda.GetPolicy(ctx, &lambda.GetPolicyInput{
@@ -256,7 +264,7 @@ func (app *App) deployFunctionURLPermissions(ctx context.Context, fc *FunctionUR
 			}
 		}
 		if res != nil {
-			log.Printf("[debug] policy for %s: %s", *fc.Config.FunctionName, *res.Policy)
+			log.Printf("[debug] policy for %s: %s", fqFunctionName, *res.Policy)
 			var policy PolicyOutput
 			if err := json.Unmarshal([]byte(*res.Policy), &policy); err != nil {
 				return fmt.Errorf("failed to unmarshal policy: %w", err)
@@ -299,7 +307,7 @@ func (app *App) deployFunctionURLPermissions(ctx context.Context, fc *FunctionUR
 		if _, err := app.lambda.AddPermission(ctx, in); err != nil {
 			return fmt.Errorf("failed to add permission: %w", err)
 		}
-		log.Printf("[info] added permission for %s", *fc.Config.FunctionName)
+		log.Printf("[info] added permission for %s", fqFunctionName)
 	}
 
 	for _, sid := range removeSids {
@@ -331,6 +339,7 @@ func (app *App) initFunctionURL(ctx context.Context, fn *Function, opt *InitOpti
 			return fmt.Errorf("failed to get function url config: %w", err)
 		}
 	}
+	fqFunctionName := fullQualifiedFunctionName(*fn.FunctionName, opt.Qualifier)
 	fu := &FunctionURL{
 		Config: &lambda.CreateFunctionUrlConfigInput{
 			Cors:       fc.Cors,
@@ -354,7 +363,7 @@ func (app *App) initFunctionURL(ctx context.Context, fn *Function, opt *InitOpti
 			}
 		}
 		if res != nil {
-			log.Printf("[debug] policy for %s: %s", *fn.FunctionName, *res.Policy)
+			log.Printf("[debug] policy for %s: %s", fqFunctionName, *res.Policy)
 			var policy PolicyOutput
 			if err := json.Unmarshal([]byte(*res.Policy), &policy); err != nil {
 				return fmt.Errorf("failed to unmarshal policy: %w", err)

status.go

@@ -2,25 +2,28 @@ package lambroll
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
 	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/service/lambda"
 	"github.com/aws/aws-sdk-go-v2/service/lambda/types"
+	"github.com/samber/lo"
 )
 
 // StatusOption represents options for Status()
 type StatusOption struct {
-	Qualifier string `help:"compare with" default:"$LATEST"`
-	Output    string `default:"text" enum:"text,json" help:"output format"`
+	Qualifier *string `help:"compare with"`
+	Output    string  `default:"text" enum:"text,json" help:"output format"`
 }
 
 type FunctionStatusOutput struct {
 	Configuration *types.FunctionConfiguration
 	Code          *types.FunctionCodeLocation
 	Tags          Tags
+	FunctionURL   *types.FunctionUrlConfig
 }
 
 // Status prints status of function
@@ -37,7 +40,7 @@ func (app *App) Status(ctx context.Context, opt *StatusOption) error {
 
 	if res, err := app.lambda.GetFunction(ctx, &lambda.GetFunctionInput{
 		FunctionName: &name,
-		Qualifier:    &opt.Qualifier,
+		Qualifier:    opt.Qualifier,
 	}); err != nil {
 		return fmt.Errorf("failed to GetFunction %s: %w", name, err)
 	} else {
@@ -56,11 +59,34 @@ func (app *App) Status(ctx context.Context, opt *StatusOption) error {
 			tags = res.Tags
 		}
 	}
+
 	st := &FunctionStatusOutput{
 		Configuration: configuration,
 		Code:          code,
 		Tags:          tags,
 	}
+
+	if res, err := app.lambda.GetFunctionUrlConfig(ctx, &lambda.GetFunctionUrlConfigInput{
+		FunctionName: fn.FunctionName,
+		Qualifier:    opt.Qualifier,
+	}); err != nil {
+		var nfe *types.ResourceNotFoundException
+		if errors.As(err, &nfe) {
+			// ignore
+			log.Println("[debug] FunctionUrlConfig not found")
+		} else {
+			return fmt.Errorf("failed to get function url config: %w", err)
+		}
+	} else {
+		log.Println("[debug] FunctionUrlConfig found")
+		st.FunctionURL = &types.FunctionUrlConfig{
+			FunctionUrl: res.FunctionUrl,
+			AuthType:    res.AuthType,
+			Cors:        res.Cors,
+			InvokeMode:  res.InvokeMode,
+		}
+	}
+
 	switch opt.Output {
 	case "text":
 		fmt.Print(st.String())
@@ -101,7 +127,7 @@ func (st *FunctionStatusOutput) String() string {
 		}, "\n")
 	}
 
-	res := strings.Join([]string{
+	res := []string{
 		"FunctionName: " + aws.ToString(st.Configuration.FunctionName),
 		"Description: " + aws.ToString(st.Configuration.Description),
 		"Version: " + aws.ToString(st.Configuration.Version),
@@ -120,6 +146,36 @@ func (st *FunctionStatusOutput) String() string {
 		"CodeSize: " + fmt.Sprintf("%d", st.Configuration.CodeSize),
 		"CodeSha256: " + aws.ToString(st.Configuration.CodeSha256),
 		"Tags: " + strings.Join(tags, ","),
-	}, "\n") + "\n"
-	return res
+	}
+
+	if st.FunctionURL != nil {
+		res = append(res, []string{
+			"FunctionUrl:",
+			"  FunctionUrl: " + aws.ToString(st.FunctionURL.FunctionUrl),
+			"  AuthType: " + string(st.FunctionURL.AuthType),
+			"  InvokeMode: " + string(st.FunctionURL.InvokeMode),
+		}...)
+		if cors := st.FunctionURL.Cors; cors != nil {
+			res = append(res, "  Cors:", formatCors(cors, 4))
+		}
+	}
+	return strings.Join(res, "\n") + "\n"
+}
+
+func formatCors(cors *types.Cors, indentLevel int) string {
+	if cors == nil {
+		return ""
+	}
+	indent := strings.Repeat(" ", indentLevel)
+	res := lo.Map([]string{
+		"AllowCredentials: " + fmt.Sprintf("%t", aws.ToBool(cors.AllowCredentials)),
+		"AllowOrigins: " + strings.Join(cors.AllowOrigins, ","),
+		"AllowHeaders: " + strings.Join(cors.AllowHeaders, ","),
+		"AllowMethods: " + strings.Join(cors.AllowMethods, ","),
+		"ExposeHeaders: " + strings.Join(cors.ExposeHeaders, ","),
+		"MaxAge: " + fmt.Sprintf("%d", aws.ToInt32(cors.MaxAge)),
+	}, func(item string, _ int) string {
+		return indent + item
+	})
+	return strings.Join(res, "\n")
 }

utils.go

@@ -84,3 +84,10 @@ func resolveLogGroup(fn *Function) string {
 	}
 	return fmt.Sprintf("/aws/lambda/%s", *fn.FunctionName)
 }
+
+func fullQualifiedFunctionName(name string, qualifier *string) string {
+	if qualifier != nil {
+		return name + ":" + *qualifier
+	}
+	return name + ":" + versionLatest
+}