fixed nil pointer

.gcloudignore

@@ -6,4 +6,5 @@ e2e/
 .gitignore
 *.yaml
 *.md
-secrets.json
+secrets.json
+.meta

.gitignore

@@ -2,20 +2,18 @@
 secrets.json
 *.db
 local_test.go
-vendor
+vendor/
 datly
 other
 mydb
 tmp/
 *.gz
 .DS_Store
 autogen
-dql
-dql
 *.iml
 *.so
 logs
 .extension
 .datly
 *.zip
-local
+v1/

Version

@@ -1 +1 @@
-v0.20.2
+v0.38.0

cmd/cli.go

@@ -3,13 +3,13 @@ package cmd
 import (
 	"context"
 	"fmt"
+
 	"github.com/jessevdk/go-flags"
 	"github.com/viant/datly/cmd/command"
 	soptions "github.com/viant/datly/cmd/options"
 )
 
 func RunApp(version string, args soptions.Arguments) error {
-
 	options, err := buildOptions(args)
 	if err != nil {
 		return err

cmd/command/async_defaults.go

@@ -0,0 +1,33 @@
+package command
+
+import (
+	"github.com/viant/afs/file"
+	"github.com/viant/afs/url"
+	"github.com/viant/datly/gateway/runtime/standalone"
+)
+
+const (
+	defaultJobURL       = "/tmp/datly/jobs"
+	defaultFailedJobURL = "/tmp/datly/failed"
+)
+
+func applyAsyncJobDefaults(config *standalone.Config) {
+	if config == nil {
+		return
+	}
+
+	if config.JobURL == "" && config.FailedJobURL == "" {
+		config.JobURL = defaultJobURL
+		config.FailedJobURL = defaultFailedJobURL
+		return
+	}
+
+	if config.JobURL == "" {
+		config.JobURL = defaultJobURL
+	}
+
+	if config.FailedJobURL == "" {
+		parent, _ := url.Split(config.JobURL, file.Scheme)
+		config.FailedJobURL = url.Join(parent, "failed", "jobs")
+	}
+}

cmd/command/async_defaults_test.go

@@ -0,0 +1,51 @@
+package command
+
+import (
+	"testing"
+
+	"github.com/viant/datly/gateway"
+	"github.com/viant/datly/gateway/runtime/standalone"
+)
+
+func TestApplyAsyncJobDefaults(t *testing.T) {
+	testCases := []struct {
+		name         string
+		jobURL       string
+		failedJobURL string
+		expectJob    string
+		expectFailed string
+	}{
+		{
+			name:         "both empty use tmp defaults",
+			expectJob:    "/tmp/datly/jobs",
+			expectFailed: "/tmp/datly/failed",
+		},
+		{
+			name:         "custom job only derives failed path",
+			jobURL:       "/custom/jobs",
+			expectJob:    "/custom/jobs",
+			expectFailed: "file://localhost/custom/failed/jobs",
+		},
+		{
+			name:         "failed only keeps failed and defaults job",
+			failedJobURL: "/custom/failed",
+			expectJob:    "/tmp/datly/jobs",
+			expectFailed: "/custom/failed",
+		},
+	}
+
+	for _, testCase := range testCases {
+		cfg := &standalone.Config{Config: &gateway.Config{}}
+		cfg.JobURL = testCase.jobURL
+		cfg.FailedJobURL = testCase.failedJobURL
+
+		applyAsyncJobDefaults(cfg)
+
+		if cfg.JobURL != testCase.expectJob {
+			t.Fatalf("%s: expected JobURL=%s, got %s", testCase.name, testCase.expectJob, cfg.JobURL)
+		}
+		if cfg.FailedJobURL != testCase.expectFailed {
+			t.Fatalf("%s: expected FailedJobURL=%s, got %s", testCase.name, testCase.expectFailed, cfg.FailedJobURL)
+		}
+	}
+}

cmd/command/generate.go

@@ -42,6 +42,9 @@ func (s *Service) generate(ctx context.Context, options *options.Options) error
 	if _, err := s.loadPlugin(ctx, options); err != nil {
 		return err
 	}
+	if ruleOption.EffectiveEngine() == "shape" && options.Generate.Operation != "get" {
+		return fmt.Errorf("shape engine currently supports gen get only")
+	}
 	if options.Generate.Operation == "get" {
 		return s.generateGet(ctx, options)
 	}
@@ -144,8 +147,51 @@ func (s *Service) generateGet(ctx context.Context, opts *options.Options) (err e
 	if err = s.translate(ctx, opts); err != nil {
 		return err
 	}
-	if err = s.persistRepository(ctx); err != nil {
-		return err
+	if opts.Rule().EffectiveEngine() != options.EngineShape {
+		if err = s.persistRepository(ctx); err != nil {
+			return err
+		}
+	}
+
+	if opts.Rule().EffectiveEngine() == options.EngineShape {
+		componentURL := url.Join(translate.Repository.RepositoryURL, "Datly", "routes")
+		datlySrv, err := datly.New(ctx, repository.WithComponentURL(componentURL))
+		if err != nil {
+			return err
+		}
+		for i, source := range sources {
+			translate.Rule.Index = i
+			sourceText, loadErr := translate.Rule.LoadSource(ctx, s.fs, source)
+			if loadErr != nil {
+				return loadErr
+			}
+			method, uri := parseShapeRulePath(sourceText, translate.Rule.RuleName(), translate.Repository.APIPrefix)
+			key := uri
+			if !strings.EqualFold(method, "GET") {
+				key = method + ":" + uri
+			}
+			aComponent, compErr := datlySrv.Component(ctx, key)
+			if compErr != nil {
+				return compErr
+			}
+			applyDefaultComponentPackage(aComponent, translate.Rule.ModulePrefix)
+			_, sourceName := path.Split(url.Path(source))
+			sourceName = trimExt(sourceName)
+			var embeds = map[string]string{}
+			var namedResources []string
+			if repo := opts.Repository(); repo != nil && len(repo.SubstitutesURL) > 0 {
+				namedResources = append(namedResources, repo.SubstitutesURL...)
+			}
+			code := aComponent.GenerateOutputCode(ctx, defComp, true, embeds, namedResources...)
+			destURL := path.Join(translate.Rule.ModuleLocation, translate.Rule.ModulePrefix, sourceName+".go")
+			if err = s.fs.Upload(ctx, destURL, file.DefaultFileOsMode, strings.NewReader(code)); err != nil {
+				return err
+			}
+			if err = s.persistEmbeds(ctx, translate.Rule.ModuleLocation, translate.Rule.ModulePrefix, embeds, aComponent); err != nil {
+				return err
+			}
+		}
+		return nil
 	}
 
 	for i, resource := range s.translator.Repository.Resource {
@@ -167,6 +213,7 @@ func (s *Service) generateGet(ctx context.Context, opts *options.Options) (err e
 		if err != nil {
 			return err
 		}
+		applyDefaultComponentPackage(aComponent, modulePrefix)
 		var embeds = map[string]string{}
 		var namedResources []string
 
@@ -190,6 +237,24 @@ func (s *Service) generateGet(ctx context.Context, opts *options.Options) (err e
 	return nil
 }
 
+func applyDefaultComponentPackage(component *repository.Component, modulePrefix string) {
+	if component == nil {
+		return
+	}
+	if component.Output.Type.Package != "" || component.Input.Type.Package != "" {
+		return
+	}
+	modulePrefix = strings.Trim(modulePrefix, "/")
+	if modulePrefix == "" {
+		return
+	}
+	base := path.Base(modulePrefix)
+	if base == "" || base == "." || base == "/" {
+		return
+	}
+	component.Output.Type.Package = strings.ReplaceAll(base, "-", "_")
+}
+
 func (s *Service) persistEmbeds(ctx context.Context, moduleLocation string, modulePrefix string, embeds map[string]string, component *repository.Component) error {
 	rootName := component.View.Name
 	formatter := text.DetectCaseFormat(rootName)
@@ -340,6 +405,7 @@ func (s *Service) buildHandlerIfNeeded(ruleOptions *options.Rule, dSQL *string)
 	if aType != nil {
 		tmpl.EnsureImports(aType)
 	}
+	addLocalHandlerParameterTypes(&tmpl.Imports, rule.InputType, aState)
 
 	tmpl.State = aState
 	handlerDSQL, err := tmpl.GenerateDSQL(codegen.WithoutBusinessLogic())
@@ -359,6 +425,44 @@ func (s *Service) buildHandlerIfNeeded(ruleOptions *options.Rule, dSQL *string)
 	return nil
 }
 
+func addLocalHandlerParameterTypes(imports *inference.Imports, inputType string, inputState inference.State) {
+	// A handler input can reference local named structs outside its request body.
+	// Import them explicitly so they are available to runtime type discovery.
+	inputType = state.RawComponentType(inputType)
+	separator := strings.LastIndex(inputType, ".")
+	if separator == -1 {
+		return
+	}
+	inputPackage := strings.Trim(inputType[:separator], "/")
+	if inputPackage == "" {
+		return
+	}
+
+	for _, parameter := range inputState {
+		if parameter == nil || parameter.Schema == nil || parameter.Output != nil {
+			continue
+		}
+
+		parameterType := parameter.Schema.Type()
+		for parameterType != nil && (parameterType.Kind() == reflect.Ptr || parameterType.Kind() == reflect.Slice) {
+			parameterType = parameterType.Elem()
+		}
+		if parameterType == nil || parameterType.Kind() != reflect.Struct || parameterType.Name() == "" {
+			continue
+		}
+
+		packagePath := strings.Trim(parameter.Schema.PackagePath, "/")
+		if packagePath == "" {
+			packagePath = strings.Trim(parameterType.PkgPath(), "/")
+		}
+		if packagePath != inputPackage && !strings.HasSuffix(packagePath, "/"+inputPackage) {
+			continue
+		}
+
+		imports.AddType(inputPackage + "." + parameterType.Name())
+	}
+}
+
 func (s *Service) updateImportPath(path string, file *modfile.Module) string {
 	ret := strings.Replace(path, file.Mod.Path, "", 1)
 	if strings.HasPrefix(ret, "/") {

cmd/command/generate_handler_test.go

@@ -0,0 +1,61 @@
+package command
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/viant/datly/internal/inference"
+	"github.com/viant/datly/view/state"
+)
+
+type HandlerImportRequestFixture struct{}
+type HandlerImportOptionsFixture struct{}
+type HandlerImportExternalFixture struct{}
+
+func TestAddLocalHandlerParameterTypes(t *testing.T) {
+	imports := inference.NewImports()
+	imports.AddType("advancedreporting/run.Input")
+	imports.AddType("advancedreporting/run.Handler")
+	imports.AddType("advancedreporting/run.HandlerImportRequestFixture")
+
+	inputState := inference.State{
+		handlerInputParameter(reflect.TypeOf(&HandlerImportRequestFixture{}), "github.com/example/project/pkg/advancedreporting/run", false),
+		handlerInputParameter(reflect.TypeOf(&HandlerImportOptionsFixture{}), "github.com/example/project/pkg/advancedreporting/run", false),
+		handlerInputParameter(reflect.TypeOf(&HandlerImportOptionsFixture{}), "github.com/example/project/pkg/advancedreporting/run", false),
+		handlerInputParameter(reflect.TypeOf(&HandlerImportExternalFixture{}), "github.com/example/project/pkg/platform/auth", false),
+		handlerInputParameter(reflect.TypeOf(&HandlerImportOptionsFixture{}), "github.com/example/project/pkg/advancedreporting/run", true),
+		{Parameter: state.Parameter{Schema: state.NewSchema(reflect.TypeOf(map[string]interface{}{}))}},
+		nil,
+	}
+
+	addLocalHandlerParameterTypes(&imports, "advancedreporting/run.Input", inputState)
+
+	assert.Equal(t, []string{
+		"advancedreporting/run.Input",
+		"advancedreporting/run.Handler",
+		"advancedreporting/run.HandlerImportRequestFixture",
+		"advancedreporting/run.HandlerImportOptionsFixture",
+	}, imports.Types)
+}
+
+func TestAddLocalHandlerParameterTypesIgnoresUnqualifiedInput(t *testing.T) {
+	imports := inference.NewImports()
+	inputState := inference.State{
+		handlerInputParameter(reflect.TypeOf(&HandlerImportOptionsFixture{}), "github.com/example/project/pkg/advancedreporting/run", false),
+	}
+
+	addLocalHandlerParameterTypes(&imports, "Input", inputState)
+
+	assert.Empty(t, imports.Types)
+}
+
+func handlerInputParameter(rType reflect.Type, packagePath string, codecOutput bool) *inference.Parameter {
+	parameter := &inference.Parameter{Parameter: state.Parameter{
+		Schema: state.NewSchema(rType, state.WithPackagePath(packagePath)),
+	}}
+	if codecOutput {
+		parameter.Output = &state.Codec{}
+	}
+	return parameter
+}

cmd/command/mcp.go

@@ -24,10 +24,7 @@ func (s *Service) mcp(ctx context.Context, mcpOption *options.Mcp) error {
 	setter.SetStringIfEmpty(&s.config.JobURL, mcpOption.JobURL)
 	setter.SetStringIfEmpty(&s.config.FailedJobURL, mcpOption.FailedJobURL)
 	setter.SetIntIfZero(&s.config.MaxJobs, mcpOption.MaxJobs)
-	if s.config.FailedJobURL == "" && s.config.JobURL != "" {
-		parent, _ := url.Split(s.config.JobURL, file.Scheme)
-		s.config.FailedJobURL = url.Join(parent, "failed", "jobs")
-	}
+	applyAsyncJobDefaults(s.config)
 	if mcpOption.LoadPlugin && s.config.Config.PluginsURL != "" {
 		parent, _ := url.Split(mcpOption.PluginInfo, file.Scheme)
 		_ = s.fs.Copy(ctx, parent, s.config.Config.PluginsURL)
@@ -49,6 +46,7 @@ func (s *Service) mcp(ctx context.Context, mcpOption *options.Mcp) error {
 		Port:            mcpOption.Port,
 		OAuth2ConfigURL: mcpOption.OAuth2ConfigURL,
 		IssuerURL:       mcpOption.IssuerURL,
+		ResourceURL:     mcpOption.ResourceURL,
 		AuthorizerMode:  mcpOption.AuthorizerMode,
 	})
 	if err != nil {

cmd/command/plugin.go

@@ -190,7 +190,7 @@ func (s *Service) reportPluginIssue(ctx context.Context, destURL string) error {
 	if fixBuilder.Len() > 0 {
 		fmt.Printf("[FIXME]: to address pulugin dependency run the following:\n")
 	}
-	fmt.Printf(fixBuilder.String())
+	fmt.Print(fixBuilder.String())
 	return nil
 }