status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
timestamp[us, tz=UTC] | language
stringclasses 5
values | commit_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | {
testName: "dagger checks/" + ctr.EnvArg,
cmdCtr: ctr.CallChecks(),
expectedOutput: "Usage:\n dagger checks",
},
} {
tc := tc
t.Run(tc.testName, func(t *testing.T) {
t.Parallel()
stdout, err := tc.cmdCtr.Stdout(ctx)
require.NoError(t, err)
require.Contains(t, stdout, tc.expectedOutput)
})
}
}
}
func TestEnvCmdInit(t *testing.T) {
t.Skip("pending conversion to modules")
t.Parallel()
type testCase struct {
testName string
environmentPath string
sdk string
name string
root string
expectedErrorMessage string
}
for _, tc := range []testCase{
{
testName: "explicit environment dir/go", |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | environmentPath: "/var/testenvironment/subdir",
sdk: "go",
name: identity.NewID(),
root: "../",
},
{
testName: "explicit environment dir/python",
environmentPath: "/var/testenvironment/subdir",
sdk: "python",
name: identity.NewID(),
root: "../..",
},
{
testName: "explicit environment file",
environmentPath: "/var/testenvironment/subdir/dagger.json",
sdk: "python",
name: identity.NewID(),
},
{
testName: "implicit environment",
sdk: "go",
name: identity.NewID(),
},
{
testName: "implicit environment with root",
environmentPath: "/var/testenvironment",
sdk: "python",
name: identity.NewID(),
root: "..",
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | {
testName: "invalid sdk",
environmentPath: "/var/testenvironment",
sdk: "c++--",
name: identity.NewID(),
expectedErrorMessage: "unsupported environment SDK",
},
{
testName: "error on git",
environmentPath: "git://github.com/dagger/dagger.git",
sdk: "go",
name: identity.NewID(),
expectedErrorMessage: "environment init is not supported for git environments",
},
} {
tc := tc
t.Run(tc.testName, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := CLITestContainer(ctx, t, c).
WithEnvArg(tc.environmentPath).
WithSDKArg(tc.sdk).
WithNameArg(tc.name).
CallEnvInit()
if tc.expectedErrorMessage != "" {
_, err := ctr.Sync(ctx)
require.ErrorContains(t, err, tc.expectedErrorMessage)
return
}
expectedConfigPath := tc.environmentPath |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | if !strings.HasSuffix(expectedConfigPath, "dagger.json") {
expectedConfigPath = filepath.Join(expectedConfigPath, "dagger.json")
}
_, err := ctr.File(expectedConfigPath).Contents(ctx)
require.NoError(t, err)
if tc.sdk == "go" {
codegenFile := filepath.Join(filepath.Dir(expectedConfigPath), "dagger.gen.go")
_, err := ctr.File(codegenFile).Contents(ctx)
require.NoError(t, err)
}
stderr, err := ctr.CallEnv().Stderr(ctx)
require.NoError(t, err)
require.Contains(t, stderr, fmt.Sprintf(`"name": %q`, tc.name))
require.Contains(t, stderr, fmt.Sprintf(`"sdk": %q`, tc.sdk))
})
}
t.Run("error on existing environment", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := CLITestContainer(ctx, t, c).
WithLoadedEnv("core/integration/testdata/environments/go/basic", false).
WithSDKArg("go").
WithNameArg("foo").
CallEnvInit().
Sync(ctx)
require.ErrorContains(t, err, "environment init config path already exists")
})
}
func TestEnvChecks(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | t.Skip("pending conversion to modules")
t.Parallel()
allChecks := []string{
"cool-static-check",
"sad-static-check",
"cool-container-check",
"sad-container-check",
"cool-composite-check",
"sad-composite-check",
"another-cool-static-check",
"another-sad-static-check",
"cool-composite-check-from-explicit-dep",
"sad-composite-check-from-explicit-dep",
"cool-composite-check-from-dynamic-dep",
"sad-composite-check-from-dynamic-dep",
"cool-check-only-return",
"cool-check-result-only-return",
"cool-string-only-return",
"cool-error-only-return",
"sad-error-only-return",
"cool-string-error-return",
"sad-string-error-return",
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | compositeCheckToSubcheckNames := map[string][]string{
"cool-composite-check": {
"cool-subcheck-a",
"cool-subcheck-b",
},
"sad-composite-check": {
"sad-subcheck-a",
"sad-subcheck-b",
},
"cool-composite-check-from-explicit-dep": {
"another-cool-static-check",
"another-cool-container-check",
"another-cool-composite-check",
},
"sad-composite-check-from-explicit-dep": {
"another-sad-static-check",
"another-sad-container-check",
"another-sad-composite-check",
},
"cool-composite-check-from-dynamic-dep": {
"yet-another-cool-static-check",
"yet-another-cool-container-check",
"yet-another-cool-composite-check",
},
"sad-composite-check-from-dynamic-dep": {
"yet-another-sad-static-check",
"yet-another-sad-container-check",
"yet-another-sad-composite-check",
},
"another-cool-composite-check": { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | "another-cool-subcheck-a",
"another-cool-subcheck-b",
},
"another-sad-composite-check": {
"another-sad-subcheck-a",
"another-sad-subcheck-b",
},
"yet-another-cool-composite-check": {
"yet-another-cool-subcheck-a",
"yet-another-cool-subcheck-b",
},
"yet-another-sad-composite-check": {
"yet-another-sad-subcheck-a",
"yet-another-sad-subcheck-b",
},
}
checkOutput := func(name string) string {
return "WE ARE RUNNING CHECK " + strcase.ToKebab(name)
}
type testCase struct {
name string
environmentPath string
selectedChecks []string
expectFailure bool
}
for _, tc := range []testCase{
{
name: "happy-path",
environmentPath: "core/integration/testdata/environments/go/basic", |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | selectedChecks: []string{
"cool-static-check",
"cool-container-check",
"cool-composite-check",
"another-cool-static-check",
"cool-composite-check-from-explicit-dep",
"cool-composite-check-from-dynamic-dep",
"cool-check-only-return",
"cool-check-result-only-return",
"cool-string-only-return",
"cool-error-only-return",
"cool-string-error-return",
},
},
{
name: "sad-path",
expectFailure: true,
environmentPath: "core/integration/testdata/environments/go/basic",
selectedChecks: []string{
"sad-static-check",
"sad-container-check",
"sad-composite-check",
"another-sad-static-check",
"sad-composite-check-from-explicit-dep",
"sad-composite-check-from-dynamic-dep",
"sad-error-only-return",
"sad-string-error-return",
},
},
{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | name: "mixed-path",
expectFailure: true,
environmentPath: "core/integration/testdata/environments/go/basic",
},
} {
tc := tc
for _, testGitEnv := range []bool{false, true} {
testGitEnv := testGitEnv
testName := tc.name
testName += "/gitenv=" + strconv.FormatBool(testGitEnv)
testName += "/" + tc.environmentPath
t.Run(testName, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
stderr, err := CLITestContainer(ctx, t, c).
WithLoadedEnv(tc.environmentPath, testGitEnv).
CallChecks(tc.selectedChecks...).
Stderr(ctx)
if tc.expectFailure {
require.Error(t, err)
execErr := new(dagger.ExecError)
require.True(t, errors.As(err, &execErr))
stderr = execErr.Stderr
} else {
require.NoError(t, err)
}
selectedChecks := tc.selectedChecks
if len(selectedChecks) == 0 {
selectedChecks = allChecks |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | }
curChecks := selectedChecks
for len(curChecks) > 0 {
var nextChecks []string
for _, checkName := range curChecks {
subChecks, ok := compositeCheckToSubcheckNames[checkName]
if ok {
nextChecks = append(nextChecks, subChecks...)
} else {
if checkName == "cool-error-only-return" {
continue
}
require.Contains(t, stderr, checkOutput(checkName))
}
}
curChecks = nextChecks
}
})
}
}
}
func daggerExec(args ...string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithExec(append([]string{"dagger", "--debug"}, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerQuery(query string) dagger.WithContainerFunc { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | return func(c *dagger.Container) *dagger.Container {
return c.WithExec([]string{"dagger", "--debug", "query"}, dagger.ContainerWithExecOpts{
Stdin: query,
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerCall(fnName string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithExec([]string{"dagger", "--debug", "call", fnName}, dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func goGitBase(t *testing.T, c *dagger.Client) *dagger.Container {
t.Helper()
return c.Container().From(golangImage).
WithExec([]string{"apk", "add", "git"}).
WithExec([]string{"git", "config", "--global", "user.email", "dagger@example.com"}).
WithExec([]string{"git", "config", "--global", "user.name", "Dagger Tests"}).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"git", "init"})
}
func logGen(ctx context.Context, t *testing.T, modSrc *dagger.Directory) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | t.Helper()
generated, err := modSrc.File("dagger.gen.go").Contents(ctx)
require.NoError(t, err)
t.Cleanup(func() {
t.Name()
fileName := filepath.Join(
os.TempDir(),
t.Name(),
fmt.Sprintf("dagger.gen.%d.go", time.Now().Unix()),
)
if err := os.MkdirAll(filepath.Dir(fileName), 0o755); err != nil {
t.Logf("failed to create temp dir for generated code: %v", err)
return
}
if err := os.WriteFile(fileName, []byte(generated), 0644); err != nil {
t.Logf("failed to write generated code to %s: %v", fileName, err)
} else {
t.Logf("wrote generated code to %s", fileName)
}
})
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/testdata/modules/go/minimal/main.go | package main
import (
"context"
"strings"
)
type Minimal struct{} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/testdata/modules/go/minimal/main.go | func (m *Minimal) Hello() string {
return "hello"
}
func (m *Minimal) Echo(msg string) string {
return m.EchoOpts(msg, EchoOpts{
Suffix: "...",
Times: 3,
})
}
func (m *Minimal) HelloContext(ctx context.Context) string {
return "hello context"
}
func (m *Minimal) EchoContext(ctx context.Context, msg string) string {
return m.Echo("ctx." + msg)
}
func (m *Minimal) HelloStringError(ctx context.Context) (string, error) {
return "hello i worked", nil
}
func (m *Minimal) HelloVoid() {}
func (m *Minimal) HelloVoidError() error {
return nil
}
type EchoOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | core/integration/testdata/modules/go/minimal/main.go | Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
func (m *Minimal) EchoOptsInline(msg string, opts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}) string {
msg += opts.Suffix
return strings.Repeat(msg, opts.Times)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | package dagger
import (
"context"
"encoding/json"
"fmt"
"reflect"
"github.com/Khan/genqlient/graphql"
"dagger.io/dagger/querybuilder"
)
func assertNotNil(argName string, value any) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | if reflect.ValueOf(value).IsNil() {
panic(fmt.Sprintf("unexpected nil pointer for argument %q", argName))
}
}
type CacheVolumeID string
type ContainerID string
type DirectoryID string
type FileID string
type FunctionArgID string
type FunctionID string
type GeneratedCodeID string
type JSON string
type ModuleID string
type Platform string
type SecretID string
type ServiceID string
type SocketID string
type TypeDefID string
type Void string
type BuildArg struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Name string `json:"name"`
Value string `json:"value"`
}
type PipelineLabel struct {
Name string `json:"name"`
Value string `json:"value"`
}
type PortForward struct {
Backend int `json:"backend"`
Frontend int `json:"frontend"`
Protocol NetworkProtocol `json:"protocol,omitempty"`
}
type CacheVolume struct {
q *querybuilder.Selection
c graphql.Client
id *CacheVolumeID
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *CacheVolume) ID(ctx context.Context) (CacheVolumeID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response CacheVolumeID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *CacheVolume) XXX_GraphQLType() string {
return "CacheVolume"
}
func (r *CacheVolume) XXX_GraphQLIDType() string {
return "CacheVolumeID"
}
func (r *CacheVolume) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *CacheVolume) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
type Container struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
envVariable *string
export *bool
id *ContainerID
imageRef *string
label *string
platform *Platform
publish *string
shellEndpoint *string
stderr *string
stdout *string
sync *ContainerID
user *string
workdir *string
}
type WithContainerFunc func(r *Container) *Container
func (r *Container) With(f WithContainerFunc) *Container {
return f(r)
}
func (r *Container) AsService() *Service {
q := r.q.Select("asService")
return &Service{
q: q,
c: r.c,
}
}
type ContainerAsTarballOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | PlatformVariants []*Container
ForcedCompression ImageLayerCompression
MediaTypes ImageMediaTypes
}
func (r *Container) AsTarball(opts ...ContainerAsTarballOpts) *File {
q := r.q.Select("asTarball")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].PlatformVariants) {
q = q.Arg("platformVariants", opts[i].PlatformVariants)
}
if !querybuilder.IsZeroValue(opts[i].ForcedCompression) {
q = q.Arg("forcedCompression", opts[i].ForcedCompression) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
if !querybuilder.IsZeroValue(opts[i].MediaTypes) {
q = q.Arg("mediaTypes", opts[i].MediaTypes)
}
}
return &File{
q: q,
c: r.c,
}
}
type ContainerBuildOpts struct {
Dockerfile string
BuildArgs []BuildArg
Target string
Secrets []*Secret
}
func (r *Container) Build(context *Directory, opts ...ContainerBuildOpts) *Container { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | assertNotNil("context", context)
q := r.q.Select("build")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Dockerfile) {
q = q.Arg("dockerfile", opts[i].Dockerfile)
}
if !querybuilder.IsZeroValue(opts[i].BuildArgs) {
q = q.Arg("buildArgs", opts[i].BuildArgs)
}
if !querybuilder.IsZeroValue(opts[i].Target) {
q = q.Arg("target", opts[i].Target)
}
if !querybuilder.IsZeroValue(opts[i].Secrets) {
q = q.Arg("secrets", opts[i].Secrets)
}
}
q = q.Arg("context", context)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) DefaultArgs(ctx context.Context) ([]string, error) {
q := r.q.Select("defaultArgs")
var response []string
q = q.Bind(&response) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return response, q.Execute(ctx, r.c)
}
func (r *Container) Directory(path string) *Directory {
q := r.q.Select("directory")
q = q.Arg("path", path)
return &Directory{
q: q,
c: r.c,
}
}
func (r *Container) Entrypoint(ctx context.Context) ([]string, error) {
q := r.q.Select("entrypoint")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) EnvVariable(ctx context.Context, name string) (string, error) {
if r.envVariable != nil {
return *r.envVariable, nil
}
q := r.q.Select("envVariable")
q = q.Arg("name", name)
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) EnvVariables(ctx context.Context) ([]EnvVariable, error) {
q := r.q.Select("envVariables")
q = q.Select("name value")
type envVariables struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Name string
Value string
}
convert := func(fields []envVariables) []EnvVariable {
out := []EnvVariable{}
for i := range fields {
val := EnvVariable{name: &fields[i].Name, value: &fields[i].Value}
out = append(out, val)
}
return out
}
var response []envVariables
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
type ContainerExportOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | PlatformVariants []*Container
ForcedCompression ImageLayerCompression
MediaTypes ImageMediaTypes
}
func (r *Container) Export(ctx context.Context, path string, opts ...ContainerExportOpts) (bool, error) {
if r.export != nil {
return *r.export, nil
}
q := r.q.Select("export")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].PlatformVariants) {
q = q.Arg("platformVariants", opts[i].PlatformVariants)
}
if !querybuilder.IsZeroValue(opts[i].ForcedCompression) {
q = q.Arg("forcedCompression", opts[i].ForcedCompression) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
if !querybuilder.IsZeroValue(opts[i].MediaTypes) {
q = q.Arg("mediaTypes", opts[i].MediaTypes)
}
}
q = q.Arg("path", path)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) ExposedPorts(ctx context.Context) ([]Port, error) {
q := r.q.Select("exposedPorts")
q = q.Select("description port protocol")
type exposedPorts struct {
Description string
Port int
Protocol NetworkProtocol
}
convert := func(fields []exposedPorts) []Port {
out := []Port{}
for i := range fields {
val := Port{description: &fields[i].Description, port: &fields[i].Port, protocol: &fields[i].Protocol}
out = append(out, val)
}
return out
}
var response []exposedPorts
q = q.Bind(&response)
err := q.Execute(ctx, r.c) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *Container) File(path string) *File {
q := r.q.Select("file")
q = q.Arg("path", path)
return &File{
q: q,
c: r.c,
}
}
func (r *Container) From(address string) *Container {
q := r.q.Select("from")
q = q.Arg("address", address)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) ID(ctx context.Context) (ContainerID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response ContainerID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *Container) XXX_GraphQLType() string {
return "Container"
}
func (r *Container) XXX_GraphQLIDType() string {
return "ContainerID"
}
func (r *Container) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Container) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
func (r *Container) ImageRef(ctx context.Context) (string, error) {
if r.imageRef != nil {
return *r.imageRef, nil
}
q := r.q.Select("imageRef")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type ContainerImportOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Tag string
}
func (r *Container) Import(source *File, opts ...ContainerImportOpts) *Container {
assertNotNil("source", source)
q := r.q.Select("import")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Tag) {
q = q.Arg("tag", opts[i].Tag)
}
}
q = q.Arg("source", source)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) Label(ctx context.Context, name string) (string, error) {
if r.label != nil {
return *r.label, nil
}
q := r.q.Select("label")
q = q.Arg("name", name)
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *Container) Labels(ctx context.Context) ([]Label, error) {
q := r.q.Select("labels")
q = q.Select("name value")
type labels struct {
Name string
Value string
}
convert := func(fields []labels) []Label {
out := []Label{}
for i := range fields {
val := Label{name: &fields[i].Name, value: &fields[i].Value}
out = append(out, val)
}
return out
}
var response []labels
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *Container) Mounts(ctx context.Context) ([]string, error) {
q := r.q.Select("mounts")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type ContainerPipelineOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Description string
Labels []PipelineLabel
}
func (r *Container) Pipeline(name string, opts ...ContainerPipelineOpts) *Container {
q := r.q.Select("pipeline")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
if !querybuilder.IsZeroValue(opts[i].Labels) {
q = q.Arg("labels", opts[i].Labels)
}
}
q = q.Arg("name", name)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) Platform(ctx context.Context) (Platform, error) {
if r.platform != nil {
return *r.platform, nil
}
q := r.q.Select("platform")
var response Platform |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type ContainerPublishOpts struct {
PlatformVariants []*Container
ForcedCompression ImageLayerCompression
MediaTypes ImageMediaTypes
}
func (r *Container) Publish(ctx context.Context, address string, opts ...ContainerPublishOpts) (string, error) {
if r.publish != nil {
return *r.publish, nil
}
q := r.q.Select("publish")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].PlatformVariants) {
q = q.Arg("platformVariants", opts[i].PlatformVariants)
}
if !querybuilder.IsZeroValue(opts[i].ForcedCompression) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q = q.Arg("forcedCompression", opts[i].ForcedCompression)
}
if !querybuilder.IsZeroValue(opts[i].MediaTypes) {
q = q.Arg("mediaTypes", opts[i].MediaTypes)
}
}
q = q.Arg("address", address)
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) Rootfs() *Directory {
q := r.q.Select("rootfs")
return &Directory{
q: q,
c: r.c,
}
}
func (r *Container) ShellEndpoint(ctx context.Context) (string, error) {
if r.shellEndpoint != nil {
return *r.shellEndpoint, nil
}
q := r.q.Select("shellEndpoint")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) Stderr(ctx context.Context) (string, error) {
if r.stderr != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return *r.stderr, nil
}
q := r.q.Select("stderr")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) Stdout(ctx context.Context) (string, error) {
if r.stdout != nil {
return *r.stdout, nil
}
q := r.q.Select("stdout")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) Sync(ctx context.Context) (*Container, error) {
q := r.q.Select("sync")
return r, q.Execute(ctx, r.c)
}
func (r *Container) User(ctx context.Context) (string, error) {
if r.user != nil {
return *r.user, nil
}
q := r.q.Select("user")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type ContainerWithDefaultArgsOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Args []string
}
func (r *Container) WithDefaultArgs(opts ...ContainerWithDefaultArgsOpts) *Container {
q := r.q.Select("withDefaultArgs")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Args) {
q = q.Arg("args", opts[i].Args)
}
}
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithDirectoryOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Exclude []string
Include []string
Owner string
}
func (r *Container) WithDirectory(path string, directory *Directory, opts ...ContainerWithDirectoryOpts) *Container {
assertNotNil("directory", directory)
q := r.q.Select("withDirectory") |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("directory", directory)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithEntrypoint(args []string) *Container {
q := r.q.Select("withEntrypoint")
q = q.Arg("args", args)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithEnvVariableOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Expand bool
}
func (r *Container) WithEnvVariable(name string, value string, opts ...ContainerWithEnvVariableOpts) *Container {
q := r.q.Select("withEnvVariable")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Expand) {
q = q.Arg("expand", opts[i].Expand)
}
}
q = q.Arg("name", name)
q = q.Arg("value", value)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithExecOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | SkipEntrypoint bool
Stdin string
RedirectStdout string
RedirectStderr string
ExperimentalPrivilegedNesting bool
InsecureRootCapabilities bool
}
func (r *Container) WithExec(args []string, opts ...ContainerWithExecOpts) *Container {
q := r.q.Select("withExec")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].SkipEntrypoint) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q = q.Arg("skipEntrypoint", opts[i].SkipEntrypoint)
}
if !querybuilder.IsZeroValue(opts[i].Stdin) {
q = q.Arg("stdin", opts[i].Stdin)
}
if !querybuilder.IsZeroValue(opts[i].RedirectStdout) {
q = q.Arg("redirectStdout", opts[i].RedirectStdout)
}
if !querybuilder.IsZeroValue(opts[i].RedirectStderr) {
q = q.Arg("redirectStderr", opts[i].RedirectStderr)
}
if !querybuilder.IsZeroValue(opts[i].ExperimentalPrivilegedNesting) {
q = q.Arg("experimentalPrivilegedNesting", opts[i].ExperimentalPrivilegedNesting)
}
if !querybuilder.IsZeroValue(opts[i].InsecureRootCapabilities) {
q = q.Arg("insecureRootCapabilities", opts[i].InsecureRootCapabilities)
}
}
q = q.Arg("args", args)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithExposedPortOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Protocol NetworkProtocol
Description string
}
func (r *Container) WithExposedPort(port int, opts ...ContainerWithExposedPortOpts) *Container {
q := r.q.Select("withExposedPort")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Protocol) {
q = q.Arg("protocol", opts[i].Protocol)
}
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
}
q = q.Arg("port", port)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithFileOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Permissions int
Owner string
}
func (r *Container) WithFile(path string, source *File, opts ...ContainerWithFileOpts) *Container {
assertNotNil("source", source)
q := r.q.Select("withFile")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
q: q, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | c: r.c,
}
}
func (r *Container) WithFocus() *Container {
q := r.q.Select("withFocus")
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithLabel(name string, value string) *Container {
q := r.q.Select("withLabel")
q = q.Arg("name", name)
q = q.Arg("value", value)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithMountedCacheOpts struct {
Source *Directory
Sharing CacheSharingMode |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Owner string
}
func (r *Container) WithMountedCache(path string, cache *CacheVolume, opts ...ContainerWithMountedCacheOpts) *Container {
assertNotNil("cache", cache)
q := r.q.Select("withMountedCache")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Source) {
q = q.Arg("source", opts[i].Source)
}
if !querybuilder.IsZeroValue(opts[i].Sharing) {
q = q.Arg("sharing", opts[i].Sharing)
}
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("cache", cache)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithMountedDirectoryOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Owner string
}
func (r *Container) WithMountedDirectory(path string, source *Directory, opts ...ContainerWithMountedDirectoryOpts) *Container {
assertNotNil("source", source)
q := r.q.Select("withMountedDirectory")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithMountedFileOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Owner string
}
func (r *Container) WithMountedFile(path string, source *File, opts ...ContainerWithMountedFileOpts) *Container {
assertNotNil("source", source)
q := r.q.Select("withMountedFile")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithMountedSecretOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Owner string
Mode int
}
func (r *Container) WithMountedSecret(path string, source *Secret, opts ...ContainerWithMountedSecretOpts) *Container {
assertNotNil("source", source)
q := r.q.Select("withMountedSecret")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
if !querybuilder.IsZeroValue(opts[i].Mode) {
q = q.Arg("mode", opts[i].Mode)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithMountedTemp(path string) *Container {
q := r.q.Select("withMountedTemp")
q = q.Arg("path", path)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithNewFileOpts struct {
Contents string
Permissions int
Owner string
}
func (r *Container) WithNewFile(path string, opts ...ContainerWithNewFileOpts) *Container {
q := r.q.Select("withNewFile")
for i := len(opts) - 1; i >= 0; i-- { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | if !querybuilder.IsZeroValue(opts[i].Contents) {
q = q.Arg("contents", opts[i].Contents)
}
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithRegistryAuth(address string, username string, secret *Secret) *Container {
assertNotNil("secret", secret)
q := r.q.Select("withRegistryAuth")
q = q.Arg("address", address)
q = q.Arg("username", username)
q = q.Arg("secret", secret)
return &Container{
q: q,
c: r.c,
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *Container) WithRootfs(directory *Directory) *Container {
assertNotNil("directory", directory)
q := r.q.Select("withRootfs")
q = q.Arg("directory", directory)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithSecretVariable(name string, secret *Secret) *Container {
assertNotNil("secret", secret)
q := r.q.Select("withSecretVariable")
q = q.Arg("name", name)
q = q.Arg("secret", secret)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithServiceBinding(alias string, service *Service) *Container {
assertNotNil("service", service)
q := r.q.Select("withServiceBinding")
q = q.Arg("alias", alias)
q = q.Arg("service", service)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithUnixSocketOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Owner string
}
func (r *Container) WithUnixSocket(path string, source *Socket, opts ...ContainerWithUnixSocketOpts) *Container {
assertNotNil("source", source)
q := r.q.Select("withUnixSocket")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithUser(name string) *Container {
q := r.q.Select("withUser")
q = q.Arg("name", name)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithWorkdir(path string) *Container {
q := r.q.Select("withWorkdir")
q = q.Arg("path", path)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithoutEnvVariable(name string) *Container {
q := r.q.Select("withoutEnvVariable")
q = q.Arg("name", name)
return &Container{
q: q,
c: r.c,
}
}
type ContainerWithoutExposedPortOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Protocol NetworkProtocol
}
func (r *Container) WithoutExposedPort(port int, opts ...ContainerWithoutExposedPortOpts) *Container {
q := r.q.Select("withoutExposedPort")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Protocol) {
q = q.Arg("protocol", opts[i].Protocol)
}
}
q = q.Arg("port", port)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithoutFocus() *Container {
q := r.q.Select("withoutFocus")
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithoutLabel(name string) *Container {
q := r.q.Select("withoutLabel")
q = q.Arg("name", name)
return &Container{
q: q,
c: r.c, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
}
func (r *Container) WithoutMount(path string) *Container {
q := r.q.Select("withoutMount")
q = q.Arg("path", path)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithoutRegistryAuth(address string) *Container {
q := r.q.Select("withoutRegistryAuth")
q = q.Arg("address", address)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithoutUnixSocket(path string) *Container {
q := r.q.Select("withoutUnixSocket")
q = q.Arg("path", path)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) Workdir(ctx context.Context) (string, error) {
if r.workdir != nil {
return *r.workdir, nil
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q := r.q.Select("workdir")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type Directory struct {
q *querybuilder.Selection
c graphql.Client
export *bool
id *DirectoryID
sync *DirectoryID
}
type WithDirectoryFunc func(r *Directory) *Directory
func (r *Directory) With(f WithDirectoryFunc) *Directory {
return f(r)
}
type DirectoryAsModuleOpts struct {
SourceSubpath string
}
func (r *Directory) AsModule(opts ...DirectoryAsModuleOpts) *Module { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q := r.q.Select("asModule")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].SourceSubpath) {
q = q.Arg("sourceSubpath", opts[i].SourceSubpath)
}
}
return &Module{
q: q,
c: r.c,
}
}
func (r *Directory) Diff(other *Directory) *Directory {
assertNotNil("other", other)
q := r.q.Select("diff")
q = q.Arg("other", other)
return &Directory{
q: q,
c: r.c,
}
}
func (r *Directory) Directory(path string) *Directory {
q := r.q.Select("directory")
q = q.Arg("path", path)
return &Directory{
q: q,
c: r.c,
}
}
type DirectoryDockerBuildOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Dockerfile string
Platform Platform
BuildArgs []BuildArg
Target string
Secrets []*Secret
}
func (r *Directory) DockerBuild(opts ...DirectoryDockerBuildOpts) *Container {
q := r.q.Select("dockerBuild")
for i := len(opts) - 1; i >= 0; i-- { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | if !querybuilder.IsZeroValue(opts[i].Dockerfile) {
q = q.Arg("dockerfile", opts[i].Dockerfile)
}
if !querybuilder.IsZeroValue(opts[i].Platform) {
q = q.Arg("platform", opts[i].Platform)
}
if !querybuilder.IsZeroValue(opts[i].BuildArgs) {
q = q.Arg("buildArgs", opts[i].BuildArgs)
}
if !querybuilder.IsZeroValue(opts[i].Target) {
q = q.Arg("target", opts[i].Target)
}
if !querybuilder.IsZeroValue(opts[i].Secrets) {
q = q.Arg("secrets", opts[i].Secrets)
}
}
return &Container{
q: q,
c: r.c,
}
}
type DirectoryEntriesOpts struct {
Path string
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *Directory) Entries(ctx context.Context, opts ...DirectoryEntriesOpts) ([]string, error) {
q := r.q.Select("entries")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Path) {
q = q.Arg("path", opts[i].Path)
}
}
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Directory) Export(ctx context.Context, path string) (bool, error) {
if r.export != nil {
return *r.export, nil
}
q := r.q.Select("export")
q = q.Arg("path", path)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Directory) File(path string) *File {
q := r.q.Select("file")
q = q.Arg("path", path)
return &File{
q: q,
c: r.c,
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *Directory) ID(ctx context.Context) (DirectoryID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response DirectoryID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Directory) XXX_GraphQLType() string {
return "Directory"
}
func (r *Directory) XXX_GraphQLIDType() string {
return "DirectoryID"
}
func (r *Directory) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Directory) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
type DirectoryPipelineOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Description string
Labels []PipelineLabel
}
func (r *Directory) Pipeline(name string, opts ...DirectoryPipelineOpts) *Directory {
q := r.q.Select("pipeline")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
if !querybuilder.IsZeroValue(opts[i].Labels) {
q = q.Arg("labels", opts[i].Labels)
}
}
q = q.Arg("name", name)
return &Directory{
q: q,
c: r.c,
}
}
func (r *Directory) Sync(ctx context.Context) (*Directory, error) {
q := r.q.Select("sync")
return r, q.Execute(ctx, r.c)
}
type DirectoryWithDirectoryOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Exclude []string
Include []string
}
func (r *Directory) WithDirectory(path string, directory *Directory, opts ...DirectoryWithDirectoryOpts) *Directory {
assertNotNil("directory", directory)
q := r.q.Select("withDirectory")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
}
q = q.Arg("path", path)
q = q.Arg("directory", directory)
return &Directory{
q: q,
c: r.c,
}
}
type DirectoryWithFileOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Permissions int
}
func (r *Directory) WithFile(path string, source *File, opts ...DirectoryWithFileOpts) *Directory {
assertNotNil("source", source)
q := r.q.Select("withFile")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Directory{
q: q,
c: r.c,
}
}
type DirectoryWithNewDirectoryOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Permissions int
}
func (r *Directory) WithNewDirectory(path string, opts ...DirectoryWithNewDirectoryOpts) *Directory {
q := r.q.Select("withNewDirectory")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
return &Directory{
q: q,
c: r.c,
}
}
type DirectoryWithNewFileOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Permissions int
}
func (r *Directory) WithNewFile(path string, contents string, opts ...DirectoryWithNewFileOpts) *Directory {
q := r.q.Select("withNewFile")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
q = q.Arg("contents", contents) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return &Directory{
q: q,
c: r.c,
}
}
func (r *Directory) WithTimestamps(timestamp int) *Directory {
q := r.q.Select("withTimestamps")
q = q.Arg("timestamp", timestamp)
return &Directory{
q: q,
c: r.c,
}
}
func (r *Directory) WithoutDirectory(path string) *Directory {
q := r.q.Select("withoutDirectory")
q = q.Arg("path", path)
return &Directory{
q: q,
c: r.c,
}
}
func (r *Directory) WithoutFile(path string) *Directory {
q := r.q.Select("withoutFile")
q = q.Arg("path", path)
return &Directory{
q: q,
c: r.c,
}
}
type EnvVariable struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
name *string
value *string
}
func (r *EnvVariable) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *EnvVariable) Value(ctx context.Context) (string, error) {
if r.value != nil {
return *r.value, nil
}
q := r.q.Select("value")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type FieldTypeDef struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
description *string
name *string
}
func (r *FieldTypeDef) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.q.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FieldTypeDef) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *FieldTypeDef) TypeDef() *TypeDef {
q := r.q.Select("typeDef")
return &TypeDef{
q: q,
c: r.c,
}
}
type File struct {
q *querybuilder.Selection
c graphql.Client
contents *string
export *bool
id *FileID
size *int
sync *FileID
}
type WithFileFunc func(r *File) *File
func (r *File) With(f WithFileFunc) *File {
return f(r)
}
func (r *File) Contents(ctx context.Context) (string, error) {
if r.contents != nil {
return *r.contents, nil
}
q := r.q.Select("contents")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type FileExportOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | AllowParentDirPath bool
}
func (r *File) Export(ctx context.Context, path string, opts ...FileExportOpts) (bool, error) {
if r.export != nil {
return *r.export, nil
}
q := r.q.Select("export")
for i := len(opts) - 1; i >= 0; i-- { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | if !querybuilder.IsZeroValue(opts[i].AllowParentDirPath) {
q = q.Arg("allowParentDirPath", opts[i].AllowParentDirPath)
}
}
q = q.Arg("path", path)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *File) ID(ctx context.Context) (FileID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response FileID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *File) XXX_GraphQLType() string {
return "File"
}
func (r *File) XXX_GraphQLIDType() string {
return "FileID"
}
func (r *File) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
func (r *File) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
func (r *File) Size(ctx context.Context) (int, error) {
if r.size != nil {
return *r.size, nil
}
q := r.q.Select("size")
var response int
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *File) Sync(ctx context.Context) (*File, error) {
q := r.q.Select("sync")
return r, q.Execute(ctx, r.c)
}
func (r *File) WithTimestamps(timestamp int) *File {
q := r.q.Select("withTimestamps")
q = q.Arg("timestamp", timestamp)
return &File{
q: q,
c: r.c,
}
}
type Function struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
description *string
id *FunctionID
name *string
}
type WithFunctionFunc func(r *Function) *Function
func (r *Function) With(f WithFunctionFunc) *Function {
return f(r)
}
func (r *Function) Args(ctx context.Context) ([]FunctionArg, error) {
q := r.q.Select("args")
q = q.Select("id")
type args struct {
Id FunctionArgID
}
convert := func(fields []args) []FunctionArg {
out := []FunctionArg{}
for i := range fields {
val := FunctionArg{id: &fields[i].Id}
val.q = querybuilder.Query().Select("loadFunctionArgFromID").Arg("id", fields[i].Id)
val.c = r.c
out = append(out, val)
}
return out
}
var response []args
q = q.Bind(&response)
err := q.Execute(ctx, r.c) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *Function) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.q.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Function) ID(ctx context.Context) (FunctionID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response FunctionID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Function) XXX_GraphQLType() string {
return "Function"
}
func (r *Function) XXX_GraphQLIDType() string {
return "FunctionID"
}
func (r *Function) XXX_GraphQLID(ctx context.Context) (string, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Function) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
func (r *Function) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Function) ReturnType() *TypeDef {
q := r.q.Select("returnType")
return &TypeDef{
q: q,
c: r.c,
}
}
type FunctionWithArgOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Description string
DefaultValue JSON
}
func (r *Function) WithArg(name string, typeDef *TypeDef, opts ...FunctionWithArgOpts) *Function {
assertNotNil("typeDef", typeDef)
q := r.q.Select("withArg")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
if !querybuilder.IsZeroValue(opts[i].DefaultValue) {
q = q.Arg("defaultValue", opts[i].DefaultValue)
}
}
q = q.Arg("name", name)
q = q.Arg("typeDef", typeDef)
return &Function{
q: q,
c: r.c,
}
}
func (r *Function) WithDescription(description string) *Function { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q := r.q.Select("withDescription")
q = q.Arg("description", description)
return &Function{
q: q,
c: r.c,
}
}
type FunctionArg struct {
q *querybuilder.Selection
c graphql.Client
defaultValue *JSON
description *string
id *FunctionArgID
name *string
}
func (r *FunctionArg) DefaultValue(ctx context.Context) (JSON, error) {
if r.defaultValue != nil {
return *r.defaultValue, nil
}
q := r.q.Select("defaultValue")
var response JSON
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionArg) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.q.Select("description")
var response string |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionArg) ID(ctx context.Context) (FunctionArgID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response FunctionArgID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionArg) XXX_GraphQLType() string {
return "FunctionArg"
}
func (r *FunctionArg) XXX_GraphQLIDType() string {
return "FunctionArgID"
}
func (r *FunctionArg) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *FunctionArg) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return json.Marshal(id)
}
func (r *FunctionArg) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionArg) TypeDef() *TypeDef {
q := r.q.Select("typeDef")
return &TypeDef{
q: q,
c: r.c,
}
}
type FunctionCall struct {
q *querybuilder.Selection
c graphql.Client
name *string
parent *JSON
parentName *string
returnValue *Void
}
func (r *FunctionCall) InputArgs(ctx context.Context) ([]FunctionCallArgValue, error) {
q := r.q.Select("inputArgs")
q = q.Select("name value")
type inputArgs struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Name string
Value JSON
}
convert := func(fields []inputArgs) []FunctionCallArgValue {
out := []FunctionCallArgValue{}
for i := range fields {
val := FunctionCallArgValue{name: &fields[i].Name, value: &fields[i].Value}
out = append(out, val)
}
return out
}
var response []inputArgs
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *FunctionCall) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
func (r *FunctionCall) Parent(ctx context.Context) (JSON, error) {
if r.parent != nil {
return *r.parent, nil
}
q := r.q.Select("parent")
var response JSON
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionCall) ParentName(ctx context.Context) (string, error) {
if r.parentName != nil {
return *r.parentName, nil
}
q := r.q.Select("parentName")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionCall) ReturnValue(ctx context.Context, value JSON) (Void, error) {
if r.returnValue != nil {
return *r.returnValue, nil
}
q := r.q.Select("returnValue")
q = q.Arg("value", value)
var response Void
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type FunctionCallArgValue struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
name *string
value *JSON
}
func (r *FunctionCallArgValue) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *FunctionCallArgValue) Value(ctx context.Context) (JSON, error) {
if r.value != nil {
return *r.value, nil
}
q := r.q.Select("value")
var response JSON
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type GeneratedCode struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
id *GeneratedCodeID
}
type WithGeneratedCodeFunc func(r *GeneratedCode) *GeneratedCode
func (r *GeneratedCode) With(f WithGeneratedCodeFunc) *GeneratedCode {
return f(r)
}
func (r *GeneratedCode) Code() *Directory {
q := r.q.Select("code")
return &Directory{
q: q,
c: r.c, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
}
func (r *GeneratedCode) ID(ctx context.Context) (GeneratedCodeID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response GeneratedCodeID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *GeneratedCode) XXX_GraphQLType() string {
return "GeneratedCode"
}
func (r *GeneratedCode) XXX_GraphQLIDType() string {
return "GeneratedCodeID"
}
func (r *GeneratedCode) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *GeneratedCode) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
func (r *GeneratedCode) VcsGeneratedPaths(ctx context.Context) ([]string, error) {
q := r.q.Select("vcsGeneratedPaths")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *GeneratedCode) VcsIgnoredPaths(ctx context.Context) ([]string, error) {
q := r.q.Select("vcsIgnoredPaths")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *GeneratedCode) WithVCSGeneratedPaths(paths []string) *GeneratedCode {
q := r.q.Select("withVCSGeneratedPaths")
q = q.Arg("paths", paths)
return &GeneratedCode{
q: q,
c: r.c,
}
}
func (r *GeneratedCode) WithVCSIgnoredPaths(paths []string) *GeneratedCode {
q := r.q.Select("withVCSIgnoredPaths")
q = q.Arg("paths", paths)
return &GeneratedCode{
q: q,
c: r.c,
}
}
type GitRef struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
}
type GitRefTreeOpts struct {
SSHKnownHosts string
SSHAuthSocket *Socket
}
func (r *GitRef) Tree(opts ...GitRefTreeOpts) *Directory {
q := r.q.Select("tree")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].SSHKnownHosts) {
q = q.Arg("sshKnownHosts", opts[i].SSHKnownHosts)
}
if !querybuilder.IsZeroValue(opts[i].SSHAuthSocket) {
q = q.Arg("sshAuthSocket", opts[i].SSHAuthSocket)
}
}
return &Directory{
q: q,
c: r.c,
}
}
type GitRepository struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
}
func (r *GitRepository) Branch(name string) *GitRef {
q := r.q.Select("branch")
q = q.Arg("name", name)
return &GitRef{
q: q,
c: r.c,
}
}
func (r *GitRepository) Commit(id string) *GitRef {
q := r.q.Select("commit")
q = q.Arg("id", id)
return &GitRef{
q: q,
c: r.c,
}
}
func (r *GitRepository) Tag(name string) *GitRef {
q := r.q.Select("tag")
q = q.Arg("name", name)
return &GitRef{
q: q,
c: r.c,
}
}
type Host struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
}
type HostDirectoryOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Exclude []string
Include []string
}
func (r *Host) Directory(path string, opts ...HostDirectoryOpts) *Directory {
q := r.q.Select("directory")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
}
q = q.Arg("path", path)
return &Directory{
q: q,
c: r.c,
}
}
func (r *Host) File(path string) *File {
q := r.q.Select("file")
q = q.Arg("path", path)
return &File{
q: q,
c: r.c, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | }
}
type HostServiceOpts struct {
Host string
}
func (r *Host) Service(ports []PortForward, opts ...HostServiceOpts) *Service {
q := r.q.Select("service")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Host) {
q = q.Arg("host", opts[i].Host)
}
}
q = q.Arg("ports", ports)
return &Service{
q: q,
c: r.c,
}
}
func (r *Host) SetSecretFile(name string, path string) *Secret {
q := r.q.Select("setSecretFile")
q = q.Arg("name", name)
q = q.Arg("path", path)
return &Secret{
q: q,
c: r.c,
}
}
type HostTunnelOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Native bool |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Ports []PortForward
}
func (r *Host) Tunnel(service *Service, opts ...HostTunnelOpts) *Service {
assertNotNil("service", service)
q := r.q.Select("tunnel")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Native) {
q = q.Arg("native", opts[i].Native)
}
if !querybuilder.IsZeroValue(opts[i].Ports) {
q = q.Arg("ports", opts[i].Ports)
}
}
q = q.Arg("service", service)
return &Service{
q: q,
c: r.c,
}
}
func (r *Host) UnixSocket(path string) *Socket {
q := r.q.Select("unixSocket")
q = q.Arg("path", path)
return &Socket{
q: q,
c: r.c,
}
}
type Label struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
name *string
value *string
}
func (r *Label) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Label) Value(ctx context.Context) (string, error) {
if r.value != nil {
return *r.value, nil
}
q := r.q.Select("value")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type ListTypeDef struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q *querybuilder.Selection
c graphql.Client
}
func (r *ListTypeDef) ElementTypeDef() *TypeDef {
q := r.q.Select("elementTypeDef")
return &TypeDef{
q: q,
c: r.c,
}
}
type Module struct {
q *querybuilder.Selection
c graphql.Client
description *string
id *ModuleID
name *string
sdk *string
serve *Void
sourceDirectorySubPath *string
}
type WithModuleFunc func(r *Module) *Module
func (r *Module) With(f WithModuleFunc) *Module {
return f(r)
}
func (r *Module) Dependencies(ctx context.Context) ([]Module, error) {
q := r.q.Select("dependencies")
q = q.Select("id")
type dependencies struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Id ModuleID
}
convert := func(fields []dependencies) []Module {
out := []Module{}
for i := range fields {
val := Module{id: &fields[i].Id}
val.q = querybuilder.Query().Select("loadModuleFromID").Arg("id", fields[i].Id)
val.c = r.c
out = append(out, val)
}
return out
}
var response []dependencies
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *Module) DependencyConfig(ctx context.Context) ([]string, error) {
q := r.q.Select("dependencyConfig")
var response []string
q = q.Bind(&response) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | return response, q.Execute(ctx, r.c)
}
func (r *Module) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.q.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Module) GeneratedCode() *GeneratedCode {
q := r.q.Select("generatedCode")
return &GeneratedCode{
q: q,
c: r.c,
}
}
func (r *Module) ID(ctx context.Context) (ModuleID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response ModuleID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Module) XXX_GraphQLType() string {
return "Module"
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | func (r *Module) XXX_GraphQLIDType() string {
return "ModuleID"
}
func (r *Module) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Module) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
func (r *Module) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Module) Objects(ctx context.Context) ([]TypeDef, error) {
q := r.q.Select("objects")
q = q.Select("id")
type objects struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | Id TypeDefID
}
convert := func(fields []objects) []TypeDef {
out := []TypeDef{}
for i := range fields {
val := TypeDef{id: &fields[i].Id}
val.q = querybuilder.Query().Select("loadTypeDefFromID").Arg("id", fields[i].Id)
val.c = r.c
out = append(out, val)
}
return out
}
var response []objects
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *Module) SDK(ctx context.Context) (string, error) {
if r.sdk != nil {
return *r.sdk, nil
}
q := r.q.Select("sdk")
var response string |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,864 | Zenith: Fix `Opts` types in Go SDK | From @jedevc:
---
Looks like `Opt` types can't be pointers, e.g. something like this doesn't work:
```go
type EchoOpts struct {
Suffix string `doc:"String to append to the echoed message." default:"..."`
Times int `doc:"Number of times to repeat the message." default:"3"`
}
func (m *Minimal) EchoOpts(msg string, opts *EchoOpts) string {
return m.EchoOptsInline(msg, opts)
}
```
The arg type needs to be changed to `opts EchoOpts` for it to work as intended.
Giving:
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1809: Undefined type EchoOptsID.
```
---
`Opts` structs cannot be nested:
```go
package main
import "fmt"
type Potato struct{}
type PotatoOptions struct {
Count int
TestingOptions TestingOptions
}
type TestingOptions struct {
Foo string
}
func (m *Potato) HelloWorld(opts PotatoOptions) string {
return fmt.Sprintf("Hello world, I have %d potatoes (%s)", opts.Count, opts.TestingOptions.Foo)
}
```
```
Error: failed to get loaded module ID: input:1: host.directory.asModule.serve failed to install module schema: schema validation failed: input:1803: Undefined type TestingOptionsID.
``` | https://github.com/dagger/dagger/issues/5864 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-10T22:55:05Z | go | 2023-10-25T19:38:59Z | sdk/go/dagger.gen.go | q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Module) Serve(ctx context.Context) (Void, error) {
if r.serve != nil {
return *r.serve, nil
}
q := r.q.Select("serve")
var response Void
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Module) SourceDirectory() *Directory {
q := r.q.Select("sourceDirectory")
return &Directory{
q: q,
c: r.c,
}
}
func (r *Module) SourceDirectorySubPath(ctx context.Context) (string, error) {
if r.sourceDirectorySubPath != nil {
return *r.sourceDirectorySubPath, nil
}
q := r.q.Select("sourceDirectorySubPath")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Module) WithObject(object *TypeDef) *Module {
assertNotNil("object", object) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.