Implement resource importing without Tfid

move schemaType type to properties package

Support for importing list resources

assets/terraform/internal/manager/uuid.go

@@ -439,7 +439,6 @@ func (o *UuidObjectManager[E, L, S]) UpdateMany(ctx context.Context, location L,
 		} else {
 			// If entry from the plan was found in the state check if they match and set the
 			// processedEntry State accordingly.
-			elt.SetEntryUuid(stateEntry.Entry.EntryUuid())
 			processedEntry = uuidObjectWithState[E]{
 				Entry:    elt,
 				StateIdx: idx,
@@ -503,8 +502,8 @@ func (o *UuidObjectManager[E, L, S]) UpdateMany(ctx context.Context, location L,
 					Xpath:  util.AsXpath(path),
 					Target: o.client.GetTarget(),
 				})
+				continue
 			}
-			continue
 		}
 
 		existingEntryUuid := existingEntry.EntryUuid()

pkg/commands/codegen/codegen.go

@@ -74,6 +74,7 @@ func (c *Command) Execute() error {
 	}
 	var resourceList []string
 	var dataSourceList []string
+	specMetadata := make(map[string]properties.TerraformProviderSpecMetadata)
 
 	for _, specPath := range c.specs {
 		log.Printf("Parsing %s...\n", specPath)
@@ -126,13 +127,18 @@ func (c *Command) Execute() error {
 				}
 
 				terraformGenerator := generate.NewCreator(config.Output.TerraformProvider, c.templatePath, spec)
-				dataSources, resources, err := terraformGenerator.RenderTerraformProviderFile(spec, resourceTyp)
+				dataSources, resources, partialNames, err := terraformGenerator.RenderTerraformProviderFile(spec, resourceTyp)
 				if err != nil {
 					return fmt.Errorf("error rendering Terraform provider file for %s - %s", specPath, err)
 				}
 
 				resourceList = append(resourceList, resources...)
 				dataSourceList = append(dataSourceList, dataSources...)
+
+				for k, v := range partialNames {
+					specMetadata[k] = v
+				}
+
 			}
 
 			if pluralVariant {
@@ -149,13 +155,17 @@ func (c *Command) Execute() error {
 				}
 
 				terraformGenerator := generate.NewCreator(config.Output.TerraformProvider, c.templatePath, spec)
-				dataSources, resources, err := terraformGenerator.RenderTerraformProviderFile(spec, resourceTyp)
+				dataSources, resources, partialNames, err := terraformGenerator.RenderTerraformProviderFile(spec, resourceTyp)
 				if err != nil {
 					return fmt.Errorf("error rendering Terraform provider file for %s - %s", specPath, err)
 				}
 
 				resourceList = append(resourceList, resources...)
 				dataSourceList = append(dataSourceList, dataSources...)
+
+				for k, v := range partialNames {
+					specMetadata[k] = v
+				}
 			}
 		} else if c.commandType == properties.CommandTypeSDK && !spec.GoSdkSkip {
 			generator := generate.NewCreator(config.Output.GoSdk, c.templatePath, spec)
@@ -173,6 +183,7 @@ func (c *Command) Execute() error {
 		newProviderObject := properties.NewTerraformProviderFile(providerSpec.Name)
 		newProviderObject.DataSources = append(newProviderObject.DataSources, dataSourceList...)
 		newProviderObject.Resources = append(newProviderObject.Resources, resourceList...)
+		newProviderObject.SpecMetadata = specMetadata
 
 		terraformGenerator := generate.NewCreator(config.Output.TerraformProvider, c.templatePath, providerSpec)
 		err = terraformGenerator.RenderTerraformProvider(newProviderObject, providerSpec, config.TerraformProviderConfig)

pkg/generate/generator.go

@@ -57,7 +57,7 @@ func (c *Creator) RenderTemplate() error {
 }
 
 // RenderTerraformProviderFile generates a Go file for a Terraform provider based on the provided TerraformProviderFile and Normalization arguments.
-func (c *Creator) RenderTerraformProviderFile(spec *properties.Normalization, typ properties.ResourceType) ([]string, []string, error) {
+func (c *Creator) RenderTerraformProviderFile(spec *properties.Normalization, typ properties.ResourceType) ([]string, []string, map[string]properties.TerraformProviderSpecMetadata, error) {
 	var name string
 	switch typ {
 	case properties.ResourceUuidPlural:
@@ -72,19 +72,19 @@ func (c *Creator) RenderTerraformProviderFile(spec *properties.Normalization, ty
 	tfp := terraform_provider.GenerateTerraformProvider{}
 
 	if err := tfp.GenerateTerraformDataSource(typ, spec, terraformProvider); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	if err := tfp.GenerateTerraformResource(typ, spec, terraformProvider); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	if err := tfp.GenerateCommonCode(typ, spec, terraformProvider); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	if err := tfp.GenerateTerraformProviderFile(spec, terraformProvider); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	var filePath string
@@ -100,10 +100,10 @@ func (c *Creator) RenderTerraformProviderFile(spec *properties.Normalization, ty
 	}
 
 	if err := c.writeFormattedContentToFile(filePath, terraformProvider.Code.String()); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
-	return terraformProvider.DataSources, terraformProvider.Resources, nil
+	return terraformProvider.DataSources, terraformProvider.Resources, terraformProvider.SpecMetadata, nil
 }
 
 // RenderTerraformProvider generates and writes a Terraform provider file.

pkg/properties/provider_file.go

@@ -1,9 +1,11 @@
 package properties
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/paloaltonetworks/pan-os-codegen/pkg/imports"
+	"github.com/paloaltonetworks/pan-os-codegen/pkg/naming"
 )
 
 // NewTerraformProviderFile returns a new handler for a file that the
@@ -19,16 +21,65 @@ func NewTerraformProviderFile(filename string) *TerraformProviderFile {
 		ImportManager: imports.NewManager(),
 		DataSources:   make([]string, 0, 10),
 		Resources:     make([]string, 0, 10),
+		SpecMetadata:  make(map[string]TerraformProviderSpecMetadata),
 		Code:          &code,
 	}
 }
 
+type TerraformNameProvider struct {
+	TfName               string
+	MetaName             string
+	StructName           string
+	DataSourceStructName string
+	ResourceStructName   string
+	PackageName          string
+}
+
+func NewTerraformNameProvider(spec *Normalization, resourceTyp ResourceType) *TerraformNameProvider {
+	var tfName string
+	switch resourceTyp {
+	case ResourceEntry, ResourceCustom:
+		tfName = spec.TerraformProviderConfig.Suffix
+	case ResourceEntryPlural:
+		tfName = spec.TerraformProviderConfig.PluralSuffix
+	case ResourceUuid:
+		tfName = spec.TerraformProviderConfig.Suffix
+	case ResourceUuidPlural:
+		suffix := spec.TerraformProviderConfig.Suffix
+		pluralName := spec.TerraformProviderConfig.PluralName
+		tfName = fmt.Sprintf("%s_%s", suffix, pluralName)
+	}
+	objectName := tfName
+
+	metaName := fmt.Sprintf("_%s", naming.Underscore("", strings.ToLower(objectName), ""))
+	structName := naming.CamelCase("", tfName, "", true)
+	dataSourceStructName := naming.CamelCase("", tfName, "DataSource", true)
+	resourceStructName := naming.CamelCase("", tfName, "Resource", true)
+	packageName := spec.GoSdkPath[len(spec.GoSdkPath)-1]
+	return &TerraformNameProvider{tfName, metaName, structName, dataSourceStructName, resourceStructName, packageName}
+}
+
+type TerraformSpecFlags uint
+
+const (
+	TerraformSpecDatasource = 0x01
+	TerraformSpecResource   = 0x02
+	TerraformSpecImportable = 0x04
+)
+
+type TerraformProviderSpecMetadata struct {
+	ResourceSuffix string
+	StructName     string
+	Flags          TerraformSpecFlags
+}
+
 // TerraformProviderFile is a Terraform provider file handler.
 type TerraformProviderFile struct {
 	Filename      string
 	Directory     []string
 	ImportManager *imports.Manager
 	DataSources   []string
 	Resources     []string
+	SpecMetadata  map[string]TerraformProviderSpecMetadata
 	Code          *strings.Builder
 }

pkg/properties/resourcetype.go

@@ -9,3 +9,12 @@ const (
 	ResourceUuid        ResourceType = iota
 	ResourceUuidPlural  ResourceType = iota
 )
+
+type SchemaType int
+
+const (
+	SchemaResource   SchemaType = iota
+	SchemaDataSource SchemaType = iota
+	SchemaCommon     SchemaType = iota
+	SchemaProvider   SchemaType = iota
+)

pkg/translate/terraform_provider/device_group_parent_crud.go

@@ -167,7 +167,6 @@ if err := assignParent(ctx, r.client, deviceGroup, parent); err != nil {
 	return
 }
 
-state.Tfid = types.StringValue("")
 resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
 `
 const deviceGroupParentResourceUpdate = deviceGroupParentResourceCreate