diff --git a/build/golang.go b/build/golang.go index 64f20327..e1bfe472 100644 --- a/build/golang.go +++ b/build/golang.go @@ -30,7 +30,6 @@ import ( "github.com/loopholelabs/scale/extension" "github.com/loopholelabs/scale/compile/golang" - "github.com/loopholelabs/scale/extension" "github.com/loopholelabs/scale/scalefile" "github.com/loopholelabs/scale/scalefunc" "github.com/loopholelabs/scale/signature" @@ -122,7 +121,7 @@ func LocalGolang(options *LocalGolangOptions) (*scalefunc.V1BetaSchema, error) { } if len(options.ExtensionSchemas) != len(options.Scalefile.Extensions) { - return nil, fmt.Errorf("number of extension schemas does not match number of extensions in scalefile") + return nil, fmt.Errorf("number of extension schemas does not match number of extensions in scalefile %d %d", len(options.ExtensionSchemas), len(options.Scalefile.Extensions)) } if !filepath.IsAbs(options.SourceDirectory) { @@ -195,7 +194,7 @@ func LocalGolang(options *LocalGolangOptions) (*scalefunc.V1BetaSchema, error) { _ = options.Storage.Delete(build) }() - modfile, err := golang.GenerateGoModfile(signatureInfo, functionInfo) + modfile, err := golang.GenerateGoModfile(signatureInfo, functionInfo, options.Extensions) if err != nil { return nil, fmt.Errorf("unable to generate go.mod file: %w", err) } diff --git a/compile/golang/generator.go b/compile/golang/generator.go index f489d915..62021be1 100644 --- a/compile/golang/generator.go +++ b/compile/golang/generator.go @@ -18,6 +18,7 @@ import ( "go/format" "text/template" + "github.com/loopholelabs/scale/extension" "github.com/loopholelabs/scale/signature" "github.com/loopholelabs/scale/version" @@ -28,8 +29,8 @@ import ( var generator *Generator -func GenerateGoModfile(signatureInfo *SignatureInfo, functionInfo *FunctionInfo) ([]byte, error) { - return generator.GenerateGoModfile(signatureInfo, functionInfo) +func GenerateGoModfile(signatureInfo *SignatureInfo, functionInfo *FunctionInfo, extensionInfo []extension.Info) ([]byte, error) { + return generator.GenerateGoModfile(signatureInfo, functionInfo, extensionInfo) } func GenerateGoMain(scalefileSchema *scalefile.Schema, signatureSchema *signature.Schema, functionInfo *FunctionInfo) ([]byte, error) { @@ -50,14 +51,15 @@ func New() *Generator { } } -func (g *Generator) GenerateGoModfile(signatureInfo *SignatureInfo, functionInfo *FunctionInfo) ([]byte, error) { +func (g *Generator) GenerateGoModfile(signatureInfo *SignatureInfo, functionInfo *FunctionInfo, extensionInfo []extension.Info) ([]byte, error) { signatureInfo.normalize() functionInfo.normalize() buf := new(bytes.Buffer) err := g.template.ExecuteTemplate(buf, "mod.go.templ", map[string]interface{}{ - "function": functionInfo, - "signature": signatureInfo, + "function": functionInfo, + "signature": signatureInfo, + "extensions": extensionInfo, }) if err != nil { return nil, err diff --git a/compile/golang/templates/mod.go.templ b/compile/golang/templates/mod.go.templ index 5a992ba4..4fde2cb2 100644 --- a/compile/golang/templates/mod.go.templ +++ b/compile/golang/templates/mod.go.templ @@ -9,6 +9,10 @@ replace signature v0.1.0 => {{ .signature.ImportPath }} {{ .signature.ImportVers replace {{ .function.PackageName }} v0.1.0 => {{ .function.ImportPath }} +{{ range $extension := .extensions }} + replace {{ $extension.Name }} => {{ $extension.Path }} +{{ end }} + require ( signature v0.1.0 {{ .function.PackageName }} v0.1.0 diff --git a/extension/schema.go b/extension/extension.go similarity index 81% rename from extension/schema.go rename to extension/extension.go index 59e48713..2fbe1032 100644 --- a/extension/schema.go +++ b/extension/extension.go @@ -18,44 +18,20 @@ package extension import ( "crypto/sha256" - "errors" "fmt" "os" - "regexp" "github.com/hashicorp/hcl/v2" "github.com/hashicorp/hcl/v2/gohcl" "github.com/hashicorp/hcl/v2/hclsyntax" "github.com/hashicorp/hcl/v2/hclwrite" - "golang.org/x/text/cases" - "golang.org/x/text/language" "github.com/loopholelabs/scale/signature" ) -const ( - V1AlphaVersion = "v1alpha" -) - -var ( - ErrInvalidName = errors.New("invalid name") - ErrInvalidFunctionName = errors.New("invalid function name") - ErrInvalidTag = errors.New("invalid tag") -) - -var ( - ValidLabel = regexp.MustCompile(`^[A-Za-z0-9]*$`) - InvalidString = regexp.MustCompile(`[^A-Za-z0-9-.]`) -) - -var ( - TitleCaser = cases.Title(language.Und, cases.NoLower) -) - +// Schema is the top-level structure of a Scale Extension schema type Schema struct { Version string `hcl:"version,attr"` - Name string `hcl:"name,attr"` - Tag string `hcl:"tag,attr"` Interfaces []*InterfaceSchema `hcl:"interface,block"` Functions []*FunctionSchema `hcl:"function,block"` Enums []*signature.EnumSchema `hcl:"enum,block"` @@ -66,6 +42,7 @@ type Schema struct { hasCaseModifier bool } +// ReadSchema reads a Scale Extension schema from a file at the given path func ReadSchema(path string) (*Schema, error) { data, err := os.ReadFile(path) if err != nil { @@ -76,6 +53,9 @@ func ReadSchema(path string) (*Schema, error) { return s, s.Decode(data) } +// Decode decodes the given byte slice into the Schema +// +// Note: This function modifies the Schema in-place and validates/normalizes it as well. func (s *Schema) Decode(data []byte) error { file, diag := hclsyntax.ParseConfig(data, "", hcl.Pos{Line: 1, Column: 1}) if diag.HasErrors() { @@ -87,36 +67,47 @@ func (s *Schema) Decode(data []byte) error { return diag.Errs()[0] } + err := s.validateAndNormalize() + if err != nil { + return err + } + return nil } +// Encode encodes the Schema into a byte slice func (s *Schema) Encode() ([]byte, error) { f := hclwrite.NewEmptyFile() gohcl.EncodeIntoBody(s, f.Body()) return f.Bytes(), nil } -func (s *Schema) Validate() error { +// validateAndNormalize validates the Schema and normalizes it +// +// Note: This function modifies the Schema in-place +func (s *Schema) validateAndNormalize() error { switch s.Version { - case V1AlphaVersion: - if !ValidLabel.MatchString(s.Name) { - return ErrInvalidName - } - - if InvalidString.MatchString(s.Tag) { - return ErrInvalidTag - } - + case signature.V1AlphaVersion: // Transform all model names and references to TitleCase (e.g. "myModel" -> "MyModel") for _, model := range s.Models { model.Normalize() } - // Transform all model names and references to TitleCase (e.g. "myModel" -> "MyModel") + // Transform all enum names to TitleCase (e.g. "myModel" -> "MyModel") for _, enum := range s.Enums { enum.Normalize() } + // Transform all function names and references to TitleCase (e.g. "myFunction" -> "MyFunction") + for _, function := range s.Functions { + function.Normalize() + } + + // Transform all interface names and references to TitleCase (e.g. "myInterface" -> "MyInterface") + for _, inter := range s.Interfaces { + inter.Normalize() + } + // Validate all models knownModels := make(map[string]struct{}) for _, model := range s.Models { @@ -135,6 +126,22 @@ func (s *Schema) Validate() error { } } + knownFunctions := make(map[string]struct{}) + for _, function := range s.Functions { + err := function.Validate(knownFunctions) + if err != nil { + return err + } + } + + knownInterfaces := make(map[string]map[string]struct{}) + for _, inter := range s.Interfaces { + err := inter.Validate(knownInterfaces) + if err != nil { + return err + } + } + // Ensure all model and enum references are valid for _, model := range s.Models { for _, modelReference := range model.Models { @@ -262,69 +269,37 @@ func (s *Schema) Validate() error { } } - // Map of interfaces, and check for name collisions. - knownInterfaces := make(map[string]struct{}) - for _, inter := range s.Interfaces { - _, dupe := knownModels[inter.Name] - if dupe { - return fmt.Errorf("interface name collides with a model %s", inter.Name) - } - _, dupe = knownInterfaces[inter.Name] - if dupe { - return fmt.Errorf("interface name collides with an interface %s", inter.Name) - } - knownInterfaces[inter.Name] = struct{}{} - } - - for _, inter := range s.Interfaces { - for _, f := range inter.Functions { - // Make sure the function name is ok - if !ValidLabel.MatchString(f.Name) { - return ErrInvalidFunctionName - } - - // Make sure the params exist as model. - if f.Params != "" { - f.Params = TitleCaser.String(f.Params) - if _, ok := knownModels[f.Params]; !ok { - return fmt.Errorf("unknown params in function %s: %s", f.Name, f.Params) - } + // Ensure all model and enum references are valid + for _, function := range s.Functions { + if function.Params != "" { + if _, ok := knownModels[function.Params]; !ok { + return fmt.Errorf("unknown %s.params: %s", function.Name, function.Params) } + } - // Return can either be a model or interface - if f.Return != "" { - f.Return = TitleCaser.String(f.Return) - _, foundModel := knownModels[f.Return] - _, foundInterface := knownInterfaces[f.Return] - if !foundModel && !foundInterface { - return fmt.Errorf("unknown return in function %s: %s", f.Name, f.Return) + if function.Return != "" { + if _, ok := knownModels[function.Return]; !ok { + if _, ok = knownInterfaces[function.Return]; !ok { + return fmt.Errorf("unknown %s.return: %s", function.Name, function.Return) } } } } - // Check any global functions - for _, f := range s.Functions { - // Make sure the function name is ok - if !ValidLabel.MatchString(f.Name) { - return ErrInvalidFunctionName - } - - // Make sure the params exist as model. - if f.Params != "" { - f.Params = TitleCaser.String(f.Params) - if _, ok := knownModels[f.Params]; !ok { - return fmt.Errorf("unknown params in function %s: %s", f.Name, f.Params) + for _, inter := range s.Interfaces { + for _, function := range inter.Functions { + if function.Params != "" { + if _, ok := knownModels[function.Params]; !ok { + return fmt.Errorf("unknown %s.%s.params: %s", inter.Name, function.Name, function.Params) + } } - } - // Return can either be a model or interface - if f.Return != "" { - f.Return = TitleCaser.String(f.Return) - _, foundModel := knownModels[f.Return] - _, foundInterface := knownInterfaces[f.Return] - if !foundModel && !foundInterface { - return fmt.Errorf("unknown return in function %s: %s", f.Name, f.Return) + if function.Return != "" { + if _, ok := knownModels[function.Return]; !ok { + if _, ok = knownInterfaces[function.Return]; !ok { + return fmt.Errorf("unknown %s.%s.return: %s", inter.Name, function.Name, function.Return) + } + } } } } @@ -520,16 +495,6 @@ func (s *Schema) CloneWithDisabledAccessorsValidatorsAndModifiers() (*Schema, er return clone, clone.validateAndNormalize() } -// validateAndNormalize validates the Schema and normalizes it -// -// Note: This function modifies the Schema in-place -func (s *Schema) validateAndNormalize() error { - - // TODO... - - return nil -} - func (s *Schema) HasLimitValidator() bool { return s.hasLimitValidator } @@ -557,8 +522,6 @@ func ValidPrimitiveType(t string) bool { const MasterTestingSchema = ` version = "v1alpha" -name = "HttpFetch" -tag = "alpha" function New { params = "HttpConfig" diff --git a/extension/generator/generator.go b/extension/generator/generator.go index b4f884e5..2d62b741 100644 --- a/extension/generator/generator.go +++ b/extension/generator/generator.go @@ -54,7 +54,6 @@ type Options struct { GolangPackageImportPath string GolangPackageName string - GolangPackageVersion string RustPackageName string RustPackageVersion string @@ -75,12 +74,12 @@ func GenerateGuestLocal(options *Options) (*GuestLocalPackage, error) { return nil, err } - golangGuest, err := golang.GenerateGuest(options.Extension, hashString, options.GolangPackageName, options.GolangPackageVersion) + golangGuest, err := golang.GenerateGuest(options.Extension, hashString, options.GolangPackageName) if err != nil { return nil, err } - golangInterfaces, err := golang.GenerateInterfaces(options.Extension, options.GolangPackageName, options.GolangPackageVersion) + golangInterfaces, err := golang.GenerateInterfaces(options.Extension, options.GolangPackageName) if err != nil { return nil, err } @@ -136,12 +135,12 @@ func GenerateHostLocal(options *Options) (*HostLocalPackage, error) { return nil, err } - golangHost, err := golang.GenerateHost(options.Extension, hashString, options.GolangPackageName, options.GolangPackageVersion) + golangHost, err := golang.GenerateHost(options.Extension, hashString, options.GolangPackageName) if err != nil { return nil, err } - golangInterfaces, err := golang.GenerateInterfaces(options.Extension, options.GolangPackageName, options.GolangPackageVersion) + golangInterfaces, err := golang.GenerateInterfaces(options.Extension, options.GolangPackageName) if err != nil { return nil, err } diff --git a/extension/generator/golang/generator.go b/extension/generator/golang/generator.go index 0726a921..6eaffd97 100644 --- a/extension/generator/golang/generator.go +++ b/extension/generator/golang/generator.go @@ -18,13 +18,15 @@ import ( "go/format" "text/template" + "github.com/loopholelabs/scale/signature" + "github.com/loopholelabs/scale/signature/generator/golang" + scaleVersion "github.com/loopholelabs/scale/version" + polyglotVersion "github.com/loopholelabs/polyglot/version" interfacesVersion "github.com/loopholelabs/scale-extension-interfaces/version" "github.com/loopholelabs/scale/extension" - scaleVersion "github.com/loopholelabs/scale/version" - "github.com/loopholelabs/scale/extension/generator/golang/templates" "github.com/loopholelabs/scale/signature/generator/utils" ) @@ -35,24 +37,24 @@ const ( var generator *Generator -func GenerateTypes(schema *extension.Schema, packageName string) ([]byte, error) { - return generator.GenerateTypes(schema, packageName) +func GenerateTypes(extensionSchema *extension.Schema, packageName string) ([]byte, error) { + return generator.GenerateTypes(extensionSchema, packageName) } -func GenerateInterfaces(schema *extension.Schema, packageName string, version string) ([]byte, error) { - return generator.GenerateInterfaces(schema, packageName, version) -} - -func GenerateGuest(schema *extension.Schema, extensionHash string, packageName string, version string) ([]byte, error) { - return generator.GenerateGuest(schema, extensionHash, packageName, version) +func GenerateInterfaces(extensionSchema *extension.Schema, packageName string) ([]byte, error) { + return generator.GenerateInterfaces(extensionSchema, packageName) } func GenerateModfile(packageName string) ([]byte, error) { return generator.GenerateModfile(packageName) } -func GenerateHost(schema *extension.Schema, extensionHash string, packageName string, version string) ([]byte, error) { - return generator.GenerateHost(schema, extensionHash, packageName, version) +func GenerateGuest(extensionSchema *extension.Schema, extensionHash string, packageName string) ([]byte, error) { + return generator.GenerateGuest(extensionSchema, extensionHash, packageName) +} + +func GenerateHost(extensionSchema *extension.Schema, extensionHash string, packageName string) ([]byte, error) { + return generator.GenerateHost(extensionSchema, extensionHash, packageName) } func init() { @@ -65,7 +67,8 @@ func init() { // Generator is the go generator type Generator struct { - templ *template.Template + templ *template.Template + signature *golang.Generator } // New creates a new go generator @@ -75,25 +78,42 @@ func New() (*Generator, error) { return nil, err } + sig, err := golang.New() + if err != nil { + return nil, err + } + return &Generator{ - templ: templ, + templ: templ, + signature: sig, }, nil } -// Generate generates the go code -func (g *Generator) GenerateTypes(schema *extension.Schema, packageName string) ([]byte, error) { - if packageName == "" { - packageName = defaultPackageName +// GenerateTypes generates the types for the extension +func (g *Generator) GenerateTypes(extensionSchema *extension.Schema, packageName string) ([]byte, error) { + signatureSchema := &signature.Schema{ + Version: extensionSchema.Version, + Enums: extensionSchema.Enums, + Models: extensionSchema.Models, } - ext, err := schema.CloneWithDisabledAccessorsValidatorsAndModifiers() - if err != nil { - return nil, err + signatureSchema.SetHasLengthValidator(extensionSchema.HasLengthValidator()) + signatureSchema.SetHasCaseModifier(extensionSchema.HasCaseModifier()) + signatureSchema.SetHasLimitValidator(extensionSchema.HasLimitValidator()) + signatureSchema.SetHasRegexValidator(extensionSchema.HasRegexValidator()) + + return g.signature.GenerateTypes(signatureSchema, packageName) +} + +// GenerateInterfaces generates the interfaces for the extension +func (g *Generator) GenerateInterfaces(extensionSchema *extension.Schema, packageName string) ([]byte, error) { + if packageName == "" { + packageName = defaultPackageName } buf := new(bytes.Buffer) - err = g.templ.ExecuteTemplate(buf, "types.go.templ", map[string]any{ - "signature_schema": ext, + err := g.templ.ExecuteTemplate(buf, "interfaces.go.templ", map[string]any{ + "extension_schema": extensionSchema, "generator_version": scaleVersion.Version(), "package_name": packageName, }) @@ -104,36 +124,33 @@ func (g *Generator) GenerateTypes(schema *extension.Schema, packageName string) return format.Source(buf.Bytes()) } -func (g *Generator) GenerateInterfaces(schema *extension.Schema, packageName string, version string) ([]byte, error) { - if packageName == "" { - packageName = defaultPackageName - } - +// GenerateModfile generates the modfile for the signature +func (g *Generator) GenerateModfile(packageImportPath string) ([]byte, error) { buf := new(bytes.Buffer) - err := g.templ.ExecuteTemplate(buf, "interfaces.go.templ", map[string]any{ - "schema": schema, - "version": version, - "package": packageName, + err := g.templ.ExecuteTemplate(buf, "mod.go.templ", map[string]any{ + "polyglot_version": polyglotVersion.Version(), + "scale_extension_interfaces_version": interfacesVersion.Version(), + "package_import_path": packageImportPath, }) if err != nil { return nil, err } - return format.Source(buf.Bytes()) + return buf.Bytes(), nil } // GenerateGuest generates the guest bindings -func (g *Generator) GenerateGuest(schema *extension.Schema, schemaHash string, packageName string, version string) ([]byte, error) { +func (g *Generator) GenerateGuest(extensionSchema *extension.Schema, extensionHash string, packageName string) ([]byte, error) { if packageName == "" { packageName = defaultPackageName } buf := new(bytes.Buffer) err := g.templ.ExecuteTemplate(buf, "guest.go.templ", map[string]any{ - "extension_schema": schema, - "extension_hash": schemaHash, - "version": version, - "package": packageName, + "extension_hash": extensionHash, + "extension_schema": extensionSchema, + "generator_version": scaleVersion.Version(), + "package_name": packageName, }) if err != nil { return nil, err @@ -142,33 +159,18 @@ func (g *Generator) GenerateGuest(schema *extension.Schema, schemaHash string, p return format.Source(buf.Bytes()) } -// GenerateModfile generates the modfile for the signature -func (g *Generator) GenerateModfile(packageImportPath string) ([]byte, error) { - buf := new(bytes.Buffer) - err := g.templ.ExecuteTemplate(buf, "mod.go.templ", map[string]any{ - "polyglot_version": polyglotVersion.Version(), - "scale_extension_interfaces_version": interfacesVersion.Version(), - "package_import_path": packageImportPath, - }) - if err != nil { - return nil, err - } - - return buf.Bytes(), nil -} - // GenerateHost generates the host bindings -func (g *Generator) GenerateHost(schema *extension.Schema, schemaHash string, packageName string, version string) ([]byte, error) { +func (g *Generator) GenerateHost(extensionSchema *extension.Schema, extensionHash string, packageName string) ([]byte, error) { if packageName == "" { packageName = defaultPackageName } buf := new(bytes.Buffer) err := g.templ.ExecuteTemplate(buf, "host.go.templ", map[string]any{ - "extension_schema": schema, - "extension_hash": schemaHash, - "version": version, - "package": packageName, + "extension_hash": extensionHash, + "extension_schema": extensionSchema, + "generator_version": scaleVersion.Version(), + "package_name": packageName, }) if err != nil { return nil, err diff --git a/extension/generator/golang/generator_test.go b/extension/generator/golang/generator_test.go index b050de4d..13276382 100644 --- a/extension/generator/golang/generator_test.go +++ b/extension/generator/golang/generator_test.go @@ -30,13 +30,11 @@ func TestGenerator(t *testing.T) { err := s.Decode([]byte(extension.MasterTestingSchema)) require.NoError(t, err) - require.NoError(t, s.Validate()) - packageName := "extfetch" - interfaces, err := GenerateInterfaces(s, packageName, "v0.1.0") + interfaces, err := GenerateInterfaces(s, packageName) require.NoError(t, err) - // os.WriteFile("./interfaces.txt", interfaces, 0644) + // os.WriteFile("./interfaces.txt", interfaces, 0644) expInterfaces, err := os.ReadFile("./interfaces.txt") require.NoError(t, err) @@ -44,7 +42,7 @@ func TestGenerator(t *testing.T) { formatted, err := GenerateTypes(s, "types") require.NoError(t, err) - // os.WriteFile("./generated.txt", formatted, 0644) + // os.WriteFile("./generated.txt", formatted, 0644) expTypes, err := os.ReadFile("./generated.txt") require.NoError(t, err) @@ -55,23 +53,23 @@ func TestGenerator(t *testing.T) { hash := hex.EncodeToString(sHash) - host, err := GenerateHost(s, hash, packageName, "v0.1.0") + host, err := GenerateHost(s, hash, packageName) require.NoError(t, err) - os.WriteFile("./host.txt", host, 0644) + // os.WriteFile("./host.txt", host, 0644) expHost, err := os.ReadFile("./host.txt") require.NoError(t, err) require.Equal(t, string(expHost), string(host)) - guest, err := GenerateGuest(s, hash, packageName, "v0.1.0") + guest, err := GenerateGuest(s, hash, packageName) require.NoError(t, err) - os.WriteFile("./guest.txt", guest, 0644) + // os.WriteFile("./guest.txt", guest, 0644) expGuest, err := os.ReadFile("./guest.txt") require.NoError(t, err) require.Equal(t, string(expGuest), string(guest)) mod, err := GenerateModfile(packageName) require.NoError(t, err) - // os.WriteFile("./modfile.txt", mod, 0644) + // os.WriteFile("./modfile.txt", mod, 0644) expMod, err := os.ReadFile("./modfile.txt") require.NoError(t, err) require.Equal(t, string(expMod), string(mod)) diff --git a/extension/generator/golang/guest.txt b/extension/generator/golang/guest.txt index 6c869373..bc8e701c 100644 --- a/extension/generator/golang/guest.txt +++ b/extension/generator/golang/guest.txt @@ -1,5 +1,4 @@ -// Code generated by scale-extension v0.1.0, DO NOT EDIT. -// schema: HttpFetch:alpha +// Code generated by scale-extension v0.4.5, DO NOT EDIT. // output: extfetch package extfetch @@ -14,9 +13,9 @@ var ( readBuffer []byte ) -//export ext_HttpFetch_Resize -//go:linkname ext_HttpFetch_Resize -func ext_HttpFetch_Resize(size uint32) uint32 { +//export ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize +//go:linkname ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize +func ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize(size uint32) uint32 { readBuffer = make([]byte, size) //if uint32(cap(readBuffer)) < size { // readBuffer = append(make([]byte, 0, uint32(len(readBuffer))+size), readBuffer...) @@ -46,24 +45,29 @@ func (d *_HttpConnector) Fetch(params *ConnectionDetails) (HttpResponse, error) l := uint32(writeBuffer.Len()) // Now make the call to the host. - ext_HttpFetch_HttpConnector_Fetch(d.instanceId, off, l) + ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch(d.instanceId, off, l) // IF the return type is a model, we should read the data from the read buffer. ret := &HttpResponse{} r, err := DecodeHttpResponse(ret, readBuffer) + + if err != nil { + return HttpResponse{}, err + } + return *r, err } -//export ext_HttpFetch_HttpConnector_Fetch -//go:linkname ext_HttpFetch_HttpConnector_Fetch -func ext_HttpFetch_HttpConnector_Fetch(instance uint64, offset uint32, length uint32) uint64 +//export ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch +//go:linkname ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch +func ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch(instance uint64, offset uint32, length uint32) uint64 // Define any global functions here... -//export ext_HttpFetch_New -//go:linkname ext_HttpFetch_New -func ext_HttpFetch_New(instance uint64, offset uint32, length uint32) uint64 +//export ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New +//go:linkname ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New +func ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New(instance uint64, offset uint32, length uint32) uint64 func New(params *HttpConfig) (HttpConnector, error) { // First we take the params, serialize them. @@ -76,10 +80,18 @@ func New(params *HttpConfig) (HttpConnector, error) { l := uint32(writeBuffer.Len()) // Now make the call to the host. - v := ext_HttpFetch_New(0, off, l) + readBuffer = nil + v := ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New(0, off, l) // IF the return type is an interface return ifc, which contains hidden instanceId. - // TODO: Handle error from host. In this case there'll be an error in the readBuffer + // Handle error from host. In this case there'll be an error in the readBuffer + if readBuffer != nil { + val, err := polyglot.GetDecoder(readBuffer).Error() + if err != nil { + panic(err) + } + return nil, val + } ret := &_HttpConnector{ instanceId: v, diff --git a/extension/generator/golang/host.txt b/extension/generator/golang/host.txt index b2b45b17..772e8f5a 100644 --- a/extension/generator/golang/host.txt +++ b/extension/generator/golang/host.txt @@ -1,26 +1,23 @@ -// Code generated by scale-extension v0.1.0, DO NOT EDIT. -// schema: HttpFetch:alpha +// Code generated by scale-extension v0.4.5, DO NOT EDIT. // output: extfetch package extfetch import ( "errors" - "github.com/loopholelabs/polyglot" "sync" "sync/atomic" + "github.com/loopholelabs/polyglot" extension "github.com/loopholelabs/scale-extension-interfaces" ) -const identifier = "HttpFetch:alpha" - // Write an error to the scale function guest buffer. func hostError(mem extension.ModuleMemory, resize extension.Resizer, err error) { b := polyglot.NewBuffer() polyglot.Encoder(b).Error(err) - writeBuffer, err := resize("ext_HttpFetch_Resize", uint64(b.Len())) + writeBuffer, err := resize("ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize", uint64(b.Len())) if err != nil { panic(err) @@ -33,7 +30,7 @@ func hostError(mem extension.ModuleMemory, resize extension.Resizer, err error) type hostExt struct { functions map[string]extension.InstallableFunc - host *HttpFetchHost + host *Host } func (he *hostExt) Init() map[string]extension.InstallableFunc { @@ -47,18 +44,18 @@ func (he *hostExt) Reset() { } -func New(impl HttpFetchIfc) extension.Extension { - hostWrapper := &HttpFetchHost{impl: impl} +func New(impl Interface) extension.Extension { + hostWrapper := &Host{impl: impl} fns := make(map[string]extension.InstallableFunc) // Add global functions to the runtime - fns["ext_HttpFetch_New"] = hostWrapper.host_ext_HttpFetch_New + fns["ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New"] = hostWrapper.host_ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New hostWrapper.instances_HttpConnector = make(map[uint64]HttpConnector) - fns["ext_HttpFetch_HttpConnector_Fetch"] = hostWrapper.host_ext_HttpFetch_HttpConnector_Fetch + fns["ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch"] = hostWrapper.host_ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch return &hostExt{ functions: fns, @@ -66,8 +63,8 @@ func New(impl HttpFetchIfc) extension.Extension { } } -type HttpFetchHost struct { - impl HttpFetchIfc +type Host struct { + impl Interface gid_HttpConnector uint64 instancesLock_HttpConnector sync.Mutex @@ -76,21 +73,24 @@ type HttpFetchHost struct { // Global functions -func (h *HttpFetchHost) host_ext_HttpFetch_New(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { - ptr := uint32(params[0]) - length := uint32(params[1]) +func (h *Host) host_ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { + + ptr := uint32(params[1]) + length := uint32(params[2]) data, _ := mem.Read(ptr, length) cd := &HttpConfig{} cd, err := DecodeHttpConfig(cd, data) if err != nil { hostError(mem, resize, err) + return } // Call the implementation r, err := h.impl.New(cd) if err != nil { hostError(mem, resize, err) + return } id := atomic.AddUint64(&h.gid_HttpConnector, 1) @@ -103,12 +103,13 @@ func (h *HttpFetchHost) host_ext_HttpFetch_New(mem extension.ModuleMemory, resiz } -func (h *HttpFetchHost) host_ext_HttpFetch_HttpConnector_Fetch(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { +func (h *Host) host_ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { h.instancesLock_HttpConnector.Lock() r, ok := h.instances_HttpConnector[params[0]] h.instancesLock_HttpConnector.Unlock() if !ok { hostError(mem, resize, errors.New("Instance ID not found!")) + return } ptr := uint32(params[1]) @@ -119,24 +120,28 @@ func (h *HttpFetchHost) host_ext_HttpFetch_HttpConnector_Fetch(mem extension.Mod cd, err := DecodeConnectionDetails(cd, data) if err != nil { hostError(mem, resize, err) + return } resp, err := r.Fetch(cd) if err != nil { hostError(mem, resize, err) + return } b := polyglot.NewBuffer() resp.Encode(b) - writeBuffer, err := resize("ext_HttpFetch_Resize", uint64(b.Len())) + writeBuffer, err := resize("ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize", uint64(b.Len())) if err != nil { hostError(mem, resize, err) + return } if !mem.Write(uint32(writeBuffer), b.Bytes()) { hostError(mem, resize, err) + return } } diff --git a/extension/generator/golang/interfaces.txt b/extension/generator/golang/interfaces.txt index 5d37b4d8..b388b612 100644 --- a/extension/generator/golang/interfaces.txt +++ b/extension/generator/golang/interfaces.txt @@ -1,12 +1,10 @@ -// Code generated by scale-extension v0.1.0, DO NOT EDIT. -// schema: HttpFetch:alpha +// Code generated by scale-extension v0.4.5, DO NOT EDIT. // output: extfetch package extfetch -// Interface to the extension impl. This is what the implementor should create - -type HttpFetchIfc interface { +// Interface must be implemented by the host. +type Interface interface { New(params *HttpConfig) (HttpConnector, error) } diff --git a/extension/generator/golang/templates/guest.go.templ b/extension/generator/golang/templates/guest.go.templ index 1a246529..36011bbd 100644 --- a/extension/generator/golang/templates/guest.go.templ +++ b/extension/generator/golang/templates/guest.go.templ @@ -1,16 +1,16 @@ -// Code generated by scale-extension {{ .version }}, DO NOT EDIT. -// schema: {{ .extension_schema.Name }}:{{ .extension_schema.Tag }} -// output: {{ .package }} +// Code generated by scale-extension {{ .generator_version }}, DO NOT EDIT. +// output: {{ .package_name }} -{{ $hash := .extension_hash }} - -package {{ .package }} +package {{ .package_name }} import ( "github.com/loopholelabs/polyglot" "unsafe" ) +{{ $schema := .extension_schema }} +{{ $hash := .extension_hash }} + var ( writeBuffer = polyglot.NewBuffer() readBuffer []byte @@ -20,15 +20,13 @@ var ( //go:linkname ext_{{ $hash }}_Resize func ext_{{ $hash }}_Resize(size uint32) uint32 { readBuffer = make([]byte, size) - //if uint32(cap(readBuffer)) < size { + //if uint32(cap(readBuffer)) < size { // readBuffer = append(make([]byte, 0, uint32(len(readBuffer))+size), readBuffer...) //} //readBuffer = readBuffer[:size] return uint32(uintptr(unsafe.Pointer(&readBuffer[0]))) } -{{ $schema := .extension_schema }} - // Define any interfaces we need here... // Also define structs we can use to hold instanceId diff --git a/extension/generator/golang/templates/host.go.templ b/extension/generator/golang/templates/host.go.templ index 4d191a43..139b07e1 100644 --- a/extension/generator/golang/templates/host.go.templ +++ b/extension/generator/golang/templates/host.go.templ @@ -1,22 +1,19 @@ -// Code generated by scale-extension {{ .version }}, DO NOT EDIT. -// schema: {{ .extension_schema.Name }}:{{ .extension_schema.Tag }} -// output: {{ .package }} +// Code generated by scale-extension {{ .generator_version }}, DO NOT EDIT. +// output: {{ .package_name }} -{{ $schema := .extension_schema }} -{{ $hash := .extension_hash }} - -package {{ .package }} +package {{ .package_name }} import ( "errors" "sync/atomic" "sync" - "github.com/loopholelabs/polyglot" - extension "github.com/loopholelabs/scale-extension-interfaces" + "github.com/loopholelabs/polyglot" + extension "github.com/loopholelabs/scale-extension-interfaces" ) -const identifier = "{{ .extension_schema.Name }}:{{ .extension_schema.Tag }}" +{{ $schema := .extension_schema }} +{{ $hash := .extension_hash }} // Write an error to the scale function guest buffer. func hostError(mem extension.ModuleMemory, resize extension.Resizer, err error) { @@ -36,7 +33,7 @@ func hostError(mem extension.ModuleMemory, resize extension.Resizer, err error) type hostExt struct { functions map[string]extension.InstallableFunc - host *{{ .extension_schema.Name }}Host + host *Host } func (he *hostExt) Init() map[string]extension.InstallableFunc { @@ -50,14 +47,14 @@ func (he *hostExt) Reset() { {{ end }} } -func New(impl {{ .extension_schema.Name }}Ifc) extension.Extension { - hostWrapper := &{{ .extension_schema.Name }}Host{ impl: impl } +func New(impl Interface) extension.Extension { + hostWrapper := &Host{ impl: impl } fns := make(map[string]extension.InstallableFunc) // Add global functions to the runtime {{ range $fn := .extension_schema.Functions }} - fns["ext_{{ $hash }}_{{ $fn.Name }}"] = hostWrapper.host_ext_{{ $schema.Name }}_{{ $fn.Name }} + fns["ext_{{ $hash }}_{{ $fn.Name }}"] = hostWrapper.host_ext_{{ $hash }}_{{ $fn.Name }} {{ end }} {{ range $ifc := .extension_schema.Interfaces }} @@ -65,7 +62,7 @@ func New(impl {{ .extension_schema.Name }}Ifc) extension.Extension { {{ range $fn := $ifc.Functions }} - fns["ext_{{ $hash }}_{{ $ifc.Name }}_{{ $fn.Name }}"] = hostWrapper.host_ext_{{ $schema.Name }}_{{ $ifc.Name }}_{{ $fn.Name }} + fns["ext_{{ $hash }}_{{ $ifc.Name }}_{{ $fn.Name }}"] = hostWrapper.host_ext_{{ $hash }}_{{ $ifc.Name }}_{{ $fn.Name }} {{ end }} {{ end }} @@ -76,22 +73,19 @@ func New(impl {{ .extension_schema.Name }}Ifc) extension.Extension { } } -type {{ .extension_schema.Name }}Host struct { - impl {{ .extension_schema.Name }}Ifc -{{ range $ifc := .extension_schema.Interfaces }} - +type Host struct { + impl Interface + {{ range $ifc := .extension_schema.Interfaces }} gid_{{ $ifc.Name }} uint64 instancesLock_{{ $ifc.Name }} sync.Mutex instances_{{ $ifc.Name }} map[uint64]{{ $ifc.Name }} - -{{ end }} - + {{ end }} } // Global functions {{ range $fn := .extension_schema.Functions }} -func (h *{{ $schema.Name }}Host) host_ext_{{ $schema.Name }}_{{ $fn.Name}}(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { +func (h *Host) host_ext_{{ $hash }}_{{ $fn.Name}}(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { ptr := uint32(params[1]) length := uint32(params[2]) @@ -126,7 +120,7 @@ func (h *{{ $schema.Name }}Host) host_ext_{{ $schema.Name }}_{{ $fn.Name}}(mem e b := polyglot.NewBuffer() r.Encode(b) - writeBuffer, err := resize("ext_{{ $schema.Name }}_Resize", uint64(b.Len())) + writeBuffer, err := resize("ext_{{ $hash }}_Resize", uint64(b.Len())) if err != nil { hostError(mem, resize, err) @@ -148,7 +142,7 @@ func (h *{{ $schema.Name }}Host) host_ext_{{ $schema.Name }}_{{ $fn.Name}}(mem e {{ range $fn := $ifc.Functions }} -func (h *{{ $schema.Name }}Host) host_ext_{{ $schema.Name }}_{{ $ifc.Name }}_{{ $fn.Name }}(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { +func (h *Host) host_ext_{{ $hash }}_{{ $ifc.Name }}_{{ $fn.Name }}(mem extension.ModuleMemory, resize extension.Resizer, params []uint64) { h.instancesLock_{{ $ifc.Name }}.Lock() r, ok := h.instances_{{ $ifc.Name }}[params[0]] h.instancesLock_{{ $ifc.Name }}.Unlock() diff --git a/extension/generator/golang/templates/interfaces.go.templ b/extension/generator/golang/templates/interfaces.go.templ index 4da9d46f..c0aca0ab 100644 --- a/extension/generator/golang/templates/interfaces.go.templ +++ b/extension/generator/golang/templates/interfaces.go.templ @@ -1,29 +1,19 @@ -// Code generated by scale-extension {{ .version }}, DO NOT EDIT. -// schema: {{ .schema.Name }}:{{ .schema.Tag }} -// output: {{ .package }} +// Code generated by scale-extension {{ .generator_version }}, DO NOT EDIT. +// output: {{ .package_name }} -package {{ .package }} +package {{ .package_name }} - -// Interface to the extension impl. This is what the implementor should create - -type {{ .schema.Name }}Ifc interface { -{{ range $fn := .schema.Functions }} +// Interface must be implemented by the host. +type Interface interface { + {{ range $fn := .extension_schema.Functions }} {{ $fn.Name }}(params *{{ $fn.Params }}) ({{ $fn.Return }}, error) -{{ end }} + {{ end }} } - -{{ range $ifc := .schema.Interfaces }} - +{{ range $ifc := .extension_schema.Interfaces }} type {{ $ifc.Name }} interface { - -{{ range $fn := $ifc.Functions }} - + {{ range $fn := $ifc.Functions }} {{ $fn.Name }}(*{{ $fn.Params }}) ({{ $fn.Return }}, error) - -{{ end }} - + {{ end }} } - -{{ end }} \ No newline at end of file +{{ end }} diff --git a/extension/generator/rust/guest.txt b/extension/generator/rust/guest.txt index 5fa5dce4..efc29a5f 100644 --- a/extension/generator/rust/guest.txt +++ b/extension/generator/rust/guest.txt @@ -4,13 +4,14 @@ + pub mod types; use crate::types::{Encode, Decode}; use std::io::Cursor; use polyglot_rs::{Decoder, Encoder}; -static HASH: &'static str = "3914ee157703d809e20bf4e9f4a6d0cf0db287ec4b3dcfe4982c25b0101bc156"; +static HASH: &'static str = "0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe"; static mut READ_BUFFER: Vec = Vec::new(); static mut WRITE_BUFFER: Vec = Vec::new(); @@ -35,9 +36,9 @@ pub trait HttpConnector { // resize resizes the extensions READ_BUFFER to the given size and returns the pointer to the buffer // // Users should not use this method. -#[export_name = "ext_HttpFetch_Resize"] +#[export_name = "ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize"] #[no_mangle] -pub unsafe fn ext_HttpFetch_Resize(size: u32) -> *const u8 { +pub unsafe fn ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_Resize(size: u32) -> *const u8 { READ_BUFFER.resize(size as usize, 0); return READ_BUFFER.as_ptr(); } @@ -49,8 +50,8 @@ pub unsafe fn ext_HttpFetch_Resize(size: u32) -> *const u8 { #[link(wasm_import_module = "env")] extern "C" { - #[link_name = "ext_HttpFetch_HttpConnector_Fetch"] - fn _ext_HttpFetch_HttpConnector_Fetch(instance: u64, ptr: u32, size: u32) -> u64; + #[link_name = "ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch"] + fn _ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_HttpConnector_Fetch(instance: u64, ptr: u32, size: u32) -> u64; } @@ -92,7 +93,7 @@ fn Fetch(&self, params: types::ConnectionDetails) -> Result Result u64; + #[link_name = "ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New"] + fn _ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New(instance: u64, ptr: u32, size: u32) -> u64; } pub fn New(params: types::HttpConfig) -> Result, Box> { @@ -138,7 +139,7 @@ pub fn New(params: types::HttpConfig) -> Result, Box< let mut off = WRITE_BUFFER.as_ptr() as u32; let mut l = WRITE_BUFFER.len() as u32; READ_BUFFER.resize(0, 0); - let v = _ext_HttpFetch_New(0, off, l); + let v = _ext_0673aeaed6f027b5bc7b4a79de1b4be4bc096366c1e406bf44face690c217cbe_New(0, off, l); // IF the return type is an interface return ifc, which contains hidden instanceId. // Check for an error @@ -150,8 +151,6 @@ pub fn New(params: types::HttpConfig) -> Result, Box< } } - // TODO: Handle error from host. In this case there'll be an error in the readBuffer - let c = _HttpConnector{ instanceId: v, }; diff --git a/extension/schema_test.go b/extension/schema_test.go deleted file mode 100644 index e4359e02..00000000 --- a/extension/schema_test.go +++ /dev/null @@ -1,48 +0,0 @@ -//go:build !integration - -/* - Copyright 2023 Loophole Labs - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -*/ - -package extension - -import ( - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestSchema(t *testing.T) { - s := new(Schema) - err := s.Decode([]byte(MasterTestingSchema)) - require.NoError(t, err) - - require.NoError(t, s.Validate()) - - assert.Equal(t, V1AlphaVersion, s.Version) - assert.Equal(t, "HttpFetch", s.Name) - assert.Equal(t, "alpha", s.Tag) - - // Make sure there's a global function defined... - assert.Equal(t, 1, len(s.Functions)) - - assert.Equal(t, "New", s.Functions[0].Name) - assert.Equal(t, "HttpConfig", s.Functions[0].Params) - assert.Equal(t, "HttpConnector", s.Functions[0].Return) - - // NB You could test the models, but that should be done in signature already. - -} diff --git a/scalefile/scalefile.go b/scalefile/scalefile.go index 05ef4aa4..d9c8282e 100644 --- a/scalefile/scalefile.go +++ b/scalefile/scalefile.go @@ -53,12 +53,6 @@ type ExtensionSchema struct { Tag string `hcl:"tag,attr"` } -type ExtensionSchema struct { - Organization string `hcl:"organization,optional"` - Name string `hcl:"name,attr"` - Tag string `hcl:"tag,attr"` -} - type Schema struct { Version string `hcl:"version,attr"` Name string `hcl:"name,attr"` @@ -69,7 +63,7 @@ type Schema struct { Function string `hcl:"function,attr"` Initialize string `hcl:"initialize,attr"` Description string `hcl:"description,optional"` - Extensions []ExtensionSchema `hcl:"extension,optional"` + Extensions []ExtensionSchema `hcl:"extension,block"` } func ReadSchema(path string) (*Schema, error) { diff --git a/signature/signature.go b/signature/signature.go index 980c0c05..d3ec2c10 100644 --- a/signature/signature.go +++ b/signature/signature.go @@ -458,21 +458,41 @@ func (s *Schema) HasLimitValidator() bool { return s.hasLimitValidator } +// SetHasLimitValidator sets the hasLimitValidator flag +func (s *Schema) SetHasLimitValidator(value bool) { + s.hasLimitValidator = value +} + // HasLengthValidator returns true if the schema has a length validator func (s *Schema) HasLengthValidator() bool { return s.hasLengthValidator } +// SetHasLengthValidator sets the hasLengthValidator flag +func (s *Schema) SetHasLengthValidator(value bool) { + s.hasLengthValidator = value +} + // HasRegexValidator returns true if the schema has a regex validator func (s *Schema) HasRegexValidator() bool { return s.hasRegexValidator } +// SetHasRegexValidator sets the hasRegexValidator flag +func (s *Schema) SetHasRegexValidator(value bool) { + s.hasRegexValidator = value +} + // HasCaseModifier returns true if the schema has a case modifier func (s *Schema) HasCaseModifier() bool { return s.hasCaseModifier } +// SetHasCaseModifier sets the hasCaseModifier flag +func (s *Schema) SetHasCaseModifier(value bool) { + s.hasCaseModifier = value +} + func ValidPrimitiveType(t string) bool { switch t { case "string", "int32", "int64", "uint32", "uint64", "float32", "float64", "bool", "bytes": diff --git a/storage/extension.go b/storage/extension.go index 4db6201f..99e19fb4 100644 --- a/storage/extension.go +++ b/storage/extension.go @@ -309,12 +309,11 @@ func GenerateExtension(ext *extension.Schema, name string, tag string, org strin guestPackage, err := generator.GenerateGuestLocal(&generator.Options{ Extension: ext, - GolangPackageImportPath: "extension", - GolangPackageName: ext.Name, - GolangPackageVersion: "v0.1.0", + GolangPackageImportPath: fmt.Sprintf("%s_%s_%s_guest", org, name, tag), + GolangPackageName: fmt.Sprintf("%s_%s_%s_guest", org, name, tag), RustPackageName: fmt.Sprintf("%s_%s_%s_guest", org, name, tag), - RustPackageVersion: "0.1.0", + RustPackageVersion: defaultVersion, }) if err != nil { return err @@ -336,9 +335,8 @@ func GenerateExtension(ext *extension.Schema, name string, tag string, org strin hostPackage, err := generator.GenerateHostLocal(&generator.Options{ Extension: ext, - GolangPackageImportPath: "extension", - GolangPackageName: ext.Name, - GolangPackageVersion: "v0.1.0", + GolangPackageImportPath: fmt.Sprintf("%s_%s_%s_guest", org, name, tag), + GolangPackageName: fmt.Sprintf("%s_%s_%s_guest", org, name, tag), }) if err != nil { return err