chore: Generate ID and ObjectType Show Object Methods

pkg/sdk/api_integrations_def.go

@@ -150,6 +150,7 @@ var ApiIntegrationsDef = g.NewInterface(
 			Show().
 			SQL("API INTEGRATIONS").
 			OptionalLike(),
+		g.ResourceIDHelperMethod,
 	).
 	ShowByIdOperationWithFiltering(
 		g.ShowByIDLikeFiltering,
@@ -172,4 +173,4 @@ var ApiIntegrationsDef = g.NewInterface(
 			SQL("API INTEGRATION").
 			Name().
 			WithValidation(g.ValidIdentifier, "name"),
-	).HelperMethodID()
+	)

pkg/sdk/api_integrations_gen.go

@@ -130,6 +130,10 @@ type ApiIntegration struct {
 	CreatedOn time.Time
 }
 
+func (v *ApiIntegration) ID() AccountObjectIdentifier {
+	return NewAccountObjectIdentifier(v.Name)
+}
+
 // DescribeApiIntegrationOptions is based on https://docs.snowflake.com/en/sql-reference/sql/desc-integration.
 type DescribeApiIntegrationOptions struct {
 	describe       bool                    `ddl:"static" sql:"DESCRIBE"`
@@ -150,7 +154,3 @@ type ApiIntegrationProperty struct {
 	Value   string
 	Default string
 }
-
-func (v *ApiIntegration) ID() AccountObjectIdentifier {
-	return NewAccountObjectIdentifier(v.Name)
-}

pkg/sdk/notification_integrations_def.go

@@ -180,6 +180,7 @@ var NotificationIntegrationsDef = g.NewInterface(
 			Show().
 			SQL("NOTIFICATION INTEGRATIONS").
 			OptionalLike(),
+		g.ResourceIDHelperMethod,
 	).
 	ShowByIdOperationWithFiltering(
 		g.ShowByIDLikeFiltering,
@@ -202,4 +203,4 @@ var NotificationIntegrationsDef = g.NewInterface(
 			SQL("NOTIFICATION INTEGRATION").
 			Name().
 			WithValidation(g.ValidIdentifier, "name"),
-	).HelperMethodID()
+	)

pkg/sdk/notification_integrations_gen.go

@@ -161,6 +161,10 @@ type NotificationIntegration struct {
 	CreatedOn        time.Time
 }
 
+func (v *NotificationIntegration) ID() AccountObjectIdentifier {
+	return NewAccountObjectIdentifier(v.Name)
+}
+
 // DescribeNotificationIntegrationOptions is based on https://docs.snowflake.com/en/sql-reference/sql/desc-integration.
 type DescribeNotificationIntegrationOptions struct {
 	describe                bool                    `ddl:"static" sql:"DESCRIBE"`
@@ -181,7 +185,3 @@ type NotificationIntegrationProperty struct {
 	Value   string
 	Default string
 }
-
-func (v *NotificationIntegration) ID() AccountObjectIdentifier {
-	return NewAccountObjectIdentifier(v.Name)
-}

pkg/sdk/poc/generator/interface.go

@@ -10,8 +10,6 @@
 	Operations []*Operation
 	// IdentifierKind keeps identifier of the underlying object (e.g. DatabaseObjectIdentifier)
 	IdentifierKind string
-	// HelperMethods contains helper methods for the Interface file (i.e. ID(), ObjectType())
-	HelperMethods []*HelperMethod
 }
 
 func NewInterface(name string, nameSingular string, identifierKind string, operations ...*Operation) *Interface {
@@ -33,3 +31,4 @@
 	// return strings.Replace(i.IdentifierKind, "ObjectIdentifier", "", 1)
 	return identifierStringToPrefix(i.IdentifierKind)
 }
+

pkg/sdk/poc/generator/operation.go

@@ -40,6 +40,8 @@ type Operation struct {
 	DescribeMapping *Mapping
 	// ShowByIDFiltering defines a kind of filterings performed in ShowByID operation
 	ShowByIDFiltering []ShowByIDFiltering
+	// ResourceHelperMethods contains helper methods for the Interface file (i.e. ID(), ObjectType())
+	ResourceHelperMethods []*ResourceHelperMethod
 }
 
 type Mapping struct {
@@ -79,6 +81,11 @@ func (s *Operation) withHelperStructs(helperStructs ...*Field) *Operation {
 	return s
 }
 
+func (s *Operation) withObjectInterface(objectInterface *Interface) *Operation {
+	s.ObjectInterface = objectInterface
+	return s
+}
+
 func addShowMapping(op *Operation, from, to *Field) {
 	op.ShowMapping = newMapping("convert", from, to)
 }
@@ -117,6 +124,7 @@ func (i *Interface) newOperationWithDBMapping(
 	resourceRepresentation *plainStruct,
 	queryStruct *QueryStruct,
 	addMappingFunc func(op *Operation, from, to *Field),
+	resourceHelperMethods ...ResourceHelperMethodKind,
 ) *Operation {
 	db := dbRepresentation.IntoField()
 	res := resourceRepresentation.IntoField()
@@ -126,7 +134,10 @@ func (i *Interface) newOperationWithDBMapping(
 	op := newOperation(kind, doc).
 		withHelperStruct(db).
 		withHelperStruct(res).
-		withOptionsStruct(queryStruct.IntoField())
+		withOptionsStruct(queryStruct.IntoField()).
+		withObjectInterface(i).
+		withResourceHelperMethods(res.Name, resourceHelperMethods...)
+
 	addMappingFunc(op, db, res)
 	i.Operations = append(i.Operations, op)
 	return op
@@ -156,8 +167,8 @@ func (i *Interface) RevokeOperation(doc string, queryStruct *QueryStruct) *Inter
 	return i.newSimpleOperation(string(OperationKindRevoke), doc, queryStruct)
 }
 
-func (i *Interface) ShowOperation(doc string, dbRepresentation *dbStruct, resourceRepresentation *plainStruct, queryStruct *QueryStruct) *Interface {
-	i.newOperationWithDBMapping(string(OperationKindShow), doc, dbRepresentation, resourceRepresentation, queryStruct, addShowMapping)
+func (i *Interface) ShowOperation(doc string, dbRepresentation *dbStruct, resourceRepresentation *plainStruct, queryStruct *QueryStruct, helperMethods ...ResourceHelperMethodKind) *Interface {
+	i.newOperationWithDBMapping(string(OperationKindShow), doc, dbRepresentation, resourceRepresentation, queryStruct, addShowMapping, helperMethods...)
 	return i
 }
 
@@ -170,9 +181,9 @@ func (i *Interface) ShowByIdOperationWithNoFiltering() *Interface {
 
 // ShowByIdOperationWithFiltering adds a ShowByID operation to the interface with filtering. Should be used for objects that implement filtering options e.g. Like or In.
 func (i *Interface) ShowByIdOperationWithFiltering(filter ShowByIDFilteringKind, filtering ...ShowByIDFilteringKind) *Interface {
-	op := newNoSqlOperation(string(OperationKindShowByID))
-	op.ObjectInterface = i
-	op.withFiltering(append([]ShowByIDFilteringKind{filter}, filtering...)...)
+	op := newNoSqlOperation(string(OperationKindShowByID)).
+		withObjectInterface(i).
+		withFiltering(append(filtering, filter)...)
 	i.Operations = append(i.Operations, op)
 	return i
 }

pkg/sdk/poc/generator/resource_helper_methods.go

@@ -0,0 +1,122 @@
+package generator
+
+import (
+	"fmt"
+	"log"
+	"slices"
+)
+
+type objectIdentifier string
+
+const (
+	AccountObjectIdentifier             objectIdentifier = "AccountObjectIdentifier"
+	DatabaseObjectIdentifier            objectIdentifier = "DatabaseObjectIdentifier"
+	SchemaObjectIdentifier              objectIdentifier = "SchemaObjectIdentifier"
+	SchemaObjectIdentifierWithArguments objectIdentifier = "SchemaObjectIdentifierWithArguments"
+)
+
+func identifierStringToObjectIdentifier(s string) objectIdentifier {
+	switch s {
+	case "AccountObjectIdentifier":
+		return AccountObjectIdentifier
+	case "DatabaseObjectIdentifier":
+		return DatabaseObjectIdentifier
+	case "SchemaObjectIdentifier":
+		return SchemaObjectIdentifier
+	case "SchemaObjectIdentifierWithArguments":
+		return SchemaObjectIdentifierWithArguments
+	default:
+		return ""
+	}
+}
+
+type ResourceHelperMethodKind uint
+
+const (
+	ResourceIDHelperMethod ResourceHelperMethodKind = iota
+	ResourceObjectTypeHelperMethod
+)
+
+type ResourceHelperMethod struct {
+	Name        string
+	StructName  string
+	ReturnValue string
+	ReturnType  string
+}
+
+func newResourceHelperMethod(name, structName, returnValue string, returnType string) *ResourceHelperMethod {
+	return &ResourceHelperMethod{
+		Name:        name,
+		StructName:  structName,
+		ReturnValue: returnValue,
+		ReturnType:  returnType,
+	}
+}
+
+var requiredFieldsForIDMethodMapping map[objectIdentifier][]string = map[objectIdentifier][]string{
+	AccountObjectIdentifier:  {"Name"},
+	DatabaseObjectIdentifier: {"Name", "DatabaseName"},
+	SchemaObjectIdentifier:   {"Name", "DatabaseName", "SchemaName"},
+}
+
+func hasRequiredFieldsForIDMethod(structName string, helperStructs []*Field, requiredFields ...string) bool {
+	for _, field := range helperStructs {
+		if field.Name == structName {
+			return containsFieldNames(field.Fields, requiredFields...)
+		}
+	}
+	return false
+}
+
+func containsFieldNames(fields []*Field, names ...string) bool {
+	fieldNames := []string{}
+	for _, field := range fields {
+		fieldNames = append(fieldNames, field.Name)
+	}
+
+	for _, name := range names {
+		if !slices.Contains(fieldNames, name) {
+			return false
+		}
+	}
+	return true
+}
+
+func newResourceIDHelperMethod(structName string, helperStructs []*Field, identifierString string) *ResourceHelperMethod {
+	objectIdentifier := identifierStringToObjectIdentifier(identifierString)
+	requiredFields, ok := requiredFieldsForIDMethodMapping[objectIdentifier]
+	if !ok {
+		log.Printf("WARNING: No required fields mapping defined for identifier %s", objectIdentifier)
+		return nil
+	}
+	if !hasRequiredFieldsForIDMethod(structName, helperStructs, requiredFields...) {
+		log.Printf("WARNING: Struct '%s' does not contain needed fields to build ID() helper method. Create the method manually in _ext file or add missing one of required fields: %v.\n", structName, requiredFields)
+		return nil
+	}
+
+	var args string
+	for _, field := range requiredFields {
+		args += fmt.Sprintf("v.%v, ", field)
+	}
+
+	returnValue := fmt.Sprintf("New%v(%v)", objectIdentifier, args)
+	return newResourceHelperMethod("ID", structName, returnValue, string(objectIdentifier))
+}
+
+func newResourceObjectTypeHelperMethod(structName string) *ResourceHelperMethod {
+	return newResourceHelperMethod("ObjectType", structName, "ObjectType"+structName, "ObjectType")
+}
+
+func (s *Operation) withResourceHelperMethods(structName string, helperMethods ...ResourceHelperMethodKind) *Operation {
+	for _, helperMethod := range helperMethods {
+		switch helperMethod {
+		case ResourceIDHelperMethod:
+			s.ResourceHelperMethods = append(s.ResourceHelperMethods, newResourceIDHelperMethod(structName, s.HelperStructs, s.ObjectInterface.IdentifierKind))
+		case ResourceObjectTypeHelperMethod:
+			s.ResourceHelperMethods = append(s.ResourceHelperMethods, newResourceObjectTypeHelperMethod(structName))
+		default:
+			log.Println("No resourceHelperMethod found for kind:", helperMethod)
+		}
+	}
+	return s
+}