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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=use", "--sdk=go")).
With(daggerExec("mod", "use", "./foo")).
With(daggerExec("mod", "use", "./bar")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
import "fmt"
type Use struct {}
func (m *Use) Names(ctx context.Context) ([]string, error) {
fooName, err := dag.Foo().Name(ctx)
if err != nil {
return nil, fmt.Errorf("foo.name: %w", err)
}
barName, err := dag.Bar().Name(ctx)
if err != nil {
return nil, fmt.Errorf("bar.name: %w", err)
}
return []string{fooName, barName}, nil
}
`,
}).
WithEnvVariable("BUST", identity.NewID())
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(daggerQuery(`{use{names}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"names":["foo", "bar"]}}`, out)
}
var wrapper string
func TestModuleGoWrapping(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=wrapper", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: wrapper,
})
logGen(ctx, t, modGen.Directory("."))
id := identity.NewID()
out, err := modGen.With(daggerQuery(
fmt.Sprintf(`{wrapper{container{echo(msg:%q){unwrap{stdout}}}}}`, id),
)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t,
fmt.Sprintf(`{"wrapper":{"container":{"echo":{"unwrap":{"stdout":%q}}}}}`, id),
out)
}
func TestModuleConfigAPI(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
moduleDir := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/subdir").
With(daggerExec("mod", "init", "--name=test", "--sdk=go", "--root=..")).
Directory("/work")
cfg := c.ModuleConfig(moduleDir, dagger.ModuleConfigOpts{Subpath: "subdir"})
name, err := cfg.Name(ctx)
require.NoError(t, err)
require.Equal(t, "test", name)
sdk, err := cfg.SDK(ctx)
require.NoError(t, err)
require.Equal(t, "go", sdk)
root, err := cfg.Root(ctx)
require.NoError(t, err)
require.Equal(t, "..", root)
}
func TestModulePythonInit(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | t.Run("from scratch", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("mod", "init", "--name=bare", "--sdk=python"))
out, err := modGen.
With(daggerQuery(`{bare{myFunction(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"bare":{"myFunction":{"stdout":"hello\n"}}}`, out)
})
t.Run("respects existing pyproject.toml", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | WithNewFile("pyproject.toml", dagger.ContainerWithNewFileOpts{
Contents: `[project]
name = "has-pyproject"
version = "0.0.0"
`,
}).
With(daggerExec("mod", "init", "--name=hasPyproject", "--sdk=python"))
out, err := modGen.
With(daggerQuery(`{hasPyproject{myFunction(stringArg:"hello"){stdout}}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasPyproject":{"myFunction":{"stdout":"hello\n"}}}`, out)
t.Run("preserves module name", func(t *testing.T) {
generated, err := modGen.File("pyproject.toml").Contents(ctx)
require.NoError(t, err)
require.Contains(t, generated, `name = "has-pyproject"`)
})
})
t.Run("respects existing main.py", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/src/main/__init__.py", dagger.ContainerWithNewFileOpts{
Contents: "from . import notmain\n",
}).
WithNewFile("/work/src/main/notmain.py", dagger.ContainerWithNewFileOpts{
Contents: `from dagger.mod import function
@function |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | def hello() -> str:
return "Hello, world!"
`,
}).
With(daggerExec("mod", "init", "--name=hasMainPy", "--sdk=python"))
out, err := modGen.
With(daggerQuery(`{hasMainPy{hello}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"hasMainPy":{"hello":"Hello, world!"}}`, out)
})
}
func TestModuleLotsOfFunctions(t *testing.T) {
t.Parallel()
const funcCount = 100
t.Run("go sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `
package main
type PotatoSack struct {}
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(`
func (m *PotatoSack) Potato%d() string {
return "potato #%d"
}
`, i, i)
}
modGen := c.Container().From(golangImage). |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: mainSrc,
}).
With(daggerExec("mod", "init", "--name=potatoSack", "--sdk=go"))
logGen(ctx, t, modGen.Directory("."))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i
if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
t.Run("python sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `from dagger.mod import function
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(` |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | @function
def potato_%d() -> str:
return "potato #%d"
`, i, i)
}
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("./src/main.py", dagger.ContainerWithNewFileOpts{
Contents: mainSrc,
}).
With(daggerExec("mod", "init", "--name=potatoSack", "--sdk=python"))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i
if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
}
func TestModuleNamespacing(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
moduleSrcPath, err := filepath.Abs("./testdata/modules/go/namespacing")
require.NoError(t, err)
ctr := c.Container().From(alpineImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithMountedDirectory("/work", c.Host().Directory(moduleSrcPath)).
WithWorkdir("/work")
out, err := ctr.
With(daggerQuery(`{test{fn(s:"yo")}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fn":"1:yo 2:yo"}}`, out)
}
func TestEnvCmd(t *testing.T) {
t.Skip("pending conversion to modules")
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | environmentPath string
expectedSDK string
expectedName string
expectedRoot string
}
for _, tc := range []testCase{
{
environmentPath: "core/integration/testdata/environments/go/basic",
expectedSDK: "go",
expectedName: "basic",
expectedRoot: "../../../../../../",
},
} {
tc := tc
for _, testGitEnv := range []bool{false, true} {
testGitEnv := testGitEnv
testName := "local environment"
if testGitEnv {
testName = "git environment" |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | }
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).
CallEnv().
Stderr(ctx)
require.NoError(t, err)
require.Contains(t, stderr, fmt.Sprintf(`"root": %q`, tc.expectedRoot))
require.Contains(t, stderr, fmt.Sprintf(`"name": %q`, tc.expectedName))
require.Contains(t, stderr, fmt.Sprintf(`"sdk": %q`, tc.expectedSDK))
})
}
}
}
func TestEnvCmdHelps(t *testing.T) {
t.Skip("pending conversion to modules")
t.Parallel()
c, ctx := connect(t)
baseCtr := CLITestContainer(ctx, t, c).WithHelpArg(true)
noEnvCtr := baseCtr
validLocalEnvCtr := baseCtr.WithLoadedEnv("core/integration/testdata/environments/go/basic", false)
brokenLocalEnvCtr := baseCtr.WithLoadedEnv("core/integration/testdata/environments/go/broken", false)
for _, ctr := range []*DaggerCLIContainer{noEnvCtr, validLocalEnvCtr, brokenLocalEnvCtr} {
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | go | 2023-10-25T19:38:59Z | core/integration/module_test.go | testName string
cmdCtr *DaggerCLIContainer
expectedOutput string
}
for _, tc := range []testCase{
{
testName: "dagger env/" + ctr.EnvArg,
cmdCtr: ctr.CallEnv(),
expectedOutput: "Usage:\n dagger environment [flags]\n\nAliases:\n environment, env",
},
{
testName: "dagger env init/" + ctr.EnvArg,
cmdCtr: ctr.CallEnvInit(),
expectedOutput: "Usage:\n dagger environment init",
},
{
testName: "dagger env sync/" + ctr.EnvArg,
cmdCtr: ctr.CallEnvSync(),
expectedOutput: "Usage:\n dagger environment sync",
},
{
testName: "dagger env extend/" + ctr.EnvArg,
cmdCtr: ctr.CallEnvExtend("./fake/dep"),
expectedOutput: "Usage:\n dagger environment extend",
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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,904 | Zenith: fix handling of list inputs | ```go
package main
import (
"fmt"
)
type Test struct{}
type Foo struct {
Msg string
}
func (m *Test) TestListInput(foos []Foo) string {
return fmt.Sprintf("%+v", foos)
}
```
Currently fails when building the module w/ error `41: [0.44s] ./dagger.gen.go:4250:15: undefined: test`
Something must have broken in handling of list input types at some point I'm guessing?
cc @jedevc @vito
This should at least work in terms of codegen, handling it in `dagger call` is also important but probably a separate task, unless of course we already handled it (cc @helderco) | https://github.com/dagger/dagger/issues/5904 | https://github.com/dagger/dagger/pull/5907 | db901c8fe4c70cc32336e304492ca37f12b8f389 | e8ad5c62275172e3d54ae46447e741ff5d603450 | 2023-10-16T18:21:57Z | 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 { |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.