restructure the cli codebase

.github/workflows/test.yaml

@@ -41,6 +41,7 @@ jobs:
           skip-cache: true
       - name: Run Go unit tests for the SDK
         run: |
+          cp go.work.testing go.work
           rm cmd/hasura-ndc-go/go.mod
           rm cmd/hasura-ndc-go/go.sum
           go mod tidy

Makefile

@@ -32,8 +32,8 @@ test: test-sdk test-hasura-ndc-go test-example-codegen
 go-tidy:
 	go mod tidy
 	cd $(ROOT_DIR)/cmd/hasura-ndc-go && go mod tidy
-	cd $(ROOT_DIR)/cmd/hasura-ndc-go/testdata/basic/source && go mod tidy
-	cd $(ROOT_DIR)/cmd/hasura-ndc-go/testdata/empty/source && go mod tidy
+	cd $(ROOT_DIR)/cmd/hasura-ndc-go/command/internal/testdata/basic/source && go mod tidy
+	cd $(ROOT_DIR)/cmd/hasura-ndc-go/command/internal/testdata/empty/source && go mod tidy
 	cd $(ROOT_DIR)/example/codegen && go mod tidy
 
 # Install golangci-lint tool to run lint locally
@@ -46,11 +46,11 @@ lint:
 .PHONY: clean
 clean:
 	rm -rf "$(OUTPUT_DIR)"
-	rm -f cmd/hasura-ndc-go/testdata/*/source/connector.generated.go
-	rm -f cmd/hasura-ndc-go/testdata/*/source/**/connector.generated.go
-	rm -f cmd/hasura-ndc-go/testdata/*/source/schema.generated.json
-	rm -f cmd/hasura-ndc-go/testdata/*/source/**/schema.generated.json
-	rm -f cmd/hasura-ndc-go/testdata/*/source/**/types.generated.go
+	rm -f cmd/hasura-ndc-go/command/internal/testdata/*/source/connector.generated.go
+	rm -f cmd/hasura-ndc-go/command/internal/testdata/*/source/**/connector.generated.go
+	rm -f cmd/hasura-ndc-go/command/internal/testdata/*/source/schema.generated.json
+	rm -f cmd/hasura-ndc-go/command/internal/testdata/*/source/**/schema.generated.json
+	rm -f cmd/hasura-ndc-go/command/internal/testdata/*/source/**/types.generated.go
 	rm -rf cmd/hasura-ndc-go/testdata/**/testdata
 
 .PHONY: build-codegen

cmd/hasura-ndc-go/connector.go → cmd/hasura-ndc-go/command/internal/connector.go

@@ -1,9 +1,8 @@
-package main
+package internal
 
 import (
 	"bufio"
 	"context"
-	_ "embed"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -18,6 +17,15 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+// ConnectorGenerationArguments represent input arguments of the ConnectorGenerator
+type ConnectorGenerationArguments struct {
+	Path         string   `help:"The path of the root directory where the go.mod file is present" short:"p" env:"HASURA_PLUGIN_CONNECTOR_CONTEXT_PATH" default:"."`
+	ConnectorDir string   `help:"The directory where the connector.go file is placed" default:"."`
+	PackageTypes string   `help:"The name of types package where the State struct is in"`
+	Directories  []string `help:"Folders contain NDC operation functions" short:"d"`
+	Trace        string   `help:"Enable tracing and write to target file path."`
+}
+
 type connectorTypeBuilder struct {
 	packageName string
 	packagePath string
@@ -76,11 +84,12 @@ func NewConnectorGenerator(basePath string, connectorDir string, moduleName stri
 	}
 }
 
-func parseAndGenerateConnector(args *UpdateArguments, moduleName string) error {
-	if cli.Generate.Trace != "" {
-		w, err := os.Create(cli.Generate.Trace)
+// ParseAndGenerateConnector parses and generate connector codes
+func ParseAndGenerateConnector(args ConnectorGenerationArguments, moduleName string) error {
+	if args.Trace != "" {
+		w, err := os.Create(args.Trace)
 		if err != nil {
-			return fmt.Errorf("failed to create trace file at %s", cli.Generate.Trace)
+			return fmt.Errorf("failed to create trace file at %s", args.Trace)
 		}
 		defer func() {
 			_ = w.Close()
@@ -92,7 +101,7 @@ func parseAndGenerateConnector(args *UpdateArguments, moduleName string) error {
 	}
 
 	parseCtx, parseTask := trace.NewTask(context.TODO(), "parse")
-	sm, err := parseRawConnectorSchemaFromGoCode(parseCtx, moduleName, ".", args)
+	sm, err := parseRawConnectorSchemaFromGoCode(parseCtx, moduleName, ".", &args)
 	if err != nil {
 		parseTask.End()
 		return err

cmd/hasura-ndc-go/connector_test.go → cmd/hasura-ndc-go/command/internal/connector_test.go

@@ -1,4 +1,4 @@
-package main
+package internal
 
 import (
 	"encoding/json"
@@ -8,7 +8,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/hasura/ndc-sdk-go/cmd/hasura-ndc-go/command"
 	"github.com/hasura/ndc-sdk-go/schema"
 	"github.com/stretchr/testify/assert"
 )
@@ -91,8 +90,7 @@ func TestConnectorGeneration(t *testing.T) {
 
 			srcDir := path.Join(tc.BasePath, "source")
 			assert.NoError(t, os.Chdir(srcDir))
-
-			err = parseAndGenerateConnector(&UpdateArguments{
+			err = ParseAndGenerateConnector(ConnectorGenerationArguments{
 				ConnectorDir: tc.ConnectorDir,
 				PackageTypes: tc.PackageTypes,
 				Directories:  tc.Directories,
@@ -134,12 +132,6 @@ func TestConnectorGeneration(t *testing.T) {
 					assert.NoError(t, err)
 				}
 			}
-
-			// generate test cases
-			assert.NoError(t, command.GenTestSnapshots(&command.GenTestSnapshotArguments{
-				Dir:    "testdata",
-				Schema: path.Join("source", tc.ConnectorDir, "schema.generated.json"),
-			}))
 		})
 	}
 }

cmd/hasura-ndc-go/command/internal/constant.go

@@ -0,0 +1,192 @@
+package internal
+
+import (
+	_ "embed"
+	"fmt"
+	"regexp"
+	"text/template"
+
+	"github.com/hasura/ndc-sdk-go/schema"
+)
+
+const (
+	connectorOutputFile   = "connector.generated.go"
+	schemaOutputFile      = "schema.generated.json"
+	typeMethodsOutputFile = "types.generated.go"
+)
+
+//go:embed templates/connector/connector.go.tmpl
+var connectorTemplateStr string
+var connectorTemplate *template.Template
+
+func init() {
+	var err error
+	connectorTemplate, err = template.New(connectorOutputFile).Parse(connectorTemplateStr)
+	if err != nil {
+		panic(fmt.Errorf("failed to parse connector template: %s", err))
+	}
+}
+
+type ScalarName string
+
+const (
+	ScalarBoolean     ScalarName = "Boolean"
+	ScalarString      ScalarName = "String"
+	ScalarInt8        ScalarName = "Int8"
+	ScalarInt16       ScalarName = "Int16"
+	ScalarInt32       ScalarName = "Int32"
+	ScalarInt64       ScalarName = "Int64"
+	ScalarFloat32     ScalarName = "Float32"
+	ScalarFloat64     ScalarName = "Float64"
+	ScalarBigInt      ScalarName = "BigInt"
+	ScalarBigDecimal  ScalarName = "BigDecimal"
+	ScalarUUID        ScalarName = "UUID"
+	ScalarDate        ScalarName = "Date"
+	ScalarTimestamp   ScalarName = "Timestamp"
+	ScalarTimestampTZ ScalarName = "TimestampTZ"
+	ScalarGeography   ScalarName = "Geography"
+	ScalarBytes       ScalarName = "Bytes"
+	ScalarJSON        ScalarName = "JSON"
+	// ScalarRawJSON is a special scalar for raw json data serialization.
+	// The underlying Go type for this scalar is json.RawMessage.
+	// Note: we don't recommend to use this scalar for function arguments
+	// because the decoder will re-encode the value to []byte that isn't performance-wise.
+	ScalarRawJSON ScalarName = "RawJSON"
+)
+
+var defaultScalarTypes = map[ScalarName]schema.ScalarType{
+	ScalarBoolean: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationBoolean().Encode(),
+	},
+	ScalarString: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationString().Encode(),
+	},
+	ScalarInt8: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationInt8().Encode(),
+	},
+	ScalarInt16: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationInt16().Encode(),
+	},
+	ScalarInt32: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationInt32().Encode(),
+	},
+	ScalarInt64: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationInt64().Encode(),
+	},
+	ScalarFloat32: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationFloat32().Encode(),
+	},
+	ScalarFloat64: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationFloat64().Encode(),
+	},
+	ScalarBigInt: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationBigInteger().Encode(),
+	},
+	ScalarBigDecimal: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationBigDecimal().Encode(),
+	},
+	ScalarUUID: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationUUID().Encode(),
+	},
+	ScalarDate: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationDate().Encode(),
+	},
+	ScalarTimestamp: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationTimestamp().Encode(),
+	},
+	ScalarTimestampTZ: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationTimestampTZ().Encode(),
+	},
+	ScalarGeography: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationGeography().Encode(),
+	},
+	ScalarBytes: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationBytes().Encode(),
+	},
+	ScalarJSON: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationJSON().Encode(),
+	},
+	ScalarRawJSON: {
+		AggregateFunctions:  schema.ScalarTypeAggregateFunctions{},
+		ComparisonOperators: map[string]schema.ComparisonOperatorDefinition{},
+		Representation:      schema.NewTypeRepresentationJSON().Encode(),
+	},
+}
+
+var ndcOperationNameRegex = regexp.MustCompile(`^(Function|Procedure)([A-Z][A-Za-z0-9]*)$`)
+var ndcOperationCommentRegex = regexp.MustCompile(`^@(function|procedure)(\s+([A-Za-z]\w*))?`)
+var ndcScalarNameRegex = regexp.MustCompile(`^Scalar([A-Z]\w*)$`)
+var ndcScalarCommentRegex = regexp.MustCompile(`^@scalar(\s+(\w+))?(\s+([a-z]+))?$`)
+var ndcEnumCommentRegex = regexp.MustCompile(`^@enum\s+([\w-.,!@#$%^&*()+=~\s\t]+)$`)
+
+type nativeScalarPackageConfig struct {
+	PackageName string
+	Pattern     *regexp.Regexp
+}
+
+var fieldNameRegex = regexp.MustCompile(`[^\w]`)
+
+var nativeScalarPackages map[string]nativeScalarPackageConfig = map[string]nativeScalarPackageConfig{
+	"scalar": {
+		PackageName: "github.com/hasura/ndc-sdk-go/scalar",
+		Pattern:     regexp.MustCompile(`^(\[\]|\*)*github\.com\/hasura\/ndc-sdk-go\/scalar\.`),
+	},
+	"json": {
+		PackageName: "encoding/json",
+		Pattern:     regexp.MustCompile(`^(\[\]|\*)*encoding\/json\.`),
+	},
+	"uuid": {
+		PackageName: "github.com/google/uuid",
+		Pattern:     regexp.MustCompile(`^(\[\]|\*)*github\.com\/google\/uuid\.`),
+	},
+	"time": {
+		PackageName: "time",
+		Pattern:     regexp.MustCompile(`^(\[\]|\*)*time\.`),
+	},
+}
+
+const textBlockErrorCheck = `
+    if err != nil {
+		  return err
+    }
+`
+
+const textBlockErrorCheck2 = `
+    if err != nil {
+      return nil, err
+    }
+`