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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Owner string
}
func (r *Container) WithMountedSecret(path string, source *Secret, opts ...ContainerWithMountedSecretOpts) *Container {
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) |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | }
}
q = q.Arg("path", path)
q = q.Arg("source", source)
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 |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | }
func (r *Container) WithNewFile(path string, opts ...ContainerWithNewFileOpts) *Container {
q := r.q.Select("withNewFile")
for i := len(opts) - 1; i >= 0; i-- {
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 {
q := r.q.Select("withRegistryAuth")
q = q.Arg("address", address)
q = q.Arg("username", username)
q = q.Arg("secret", secret)
return &Container{
q: q, |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | c: r.c,
}
}
func (r *Container) WithRootfs(id *Directory) *Container {
q := r.q.Select("withRootfs")
q = q.Arg("id", id)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithSecretVariable(name string, secret *Secret) *Container {
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 *Container) *Container {
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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Owner string
}
func (r *Container) WithUnixSocket(path string, source *Socket, opts ...ContainerWithUnixSocketOpts) *Container {
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)
return &Container{
q: q,
c: r.c,
}
}
func (r *Container) WithUser(name string) *Container { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | 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 {
Protocol NetworkProtocol
}
func (r *Container) WithoutExposedPort(port int, opts ...ContainerWithoutExposedPortOpts) *Container {
q := r.q.Select("withoutExposedPort")
for i := len(opts) - 1; i >= 0; i-- { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | 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,
}
}
func (r *Container) WithoutMount(path string) *Container {
q := r.q.Select("withoutMount")
q = q.Arg("path", path)
return &Container{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | 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
}
q := r.q.Select("workdir")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type Directory struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | 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)
}
func (r *Directory) Diff(other *Directory) *Directory {
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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Dockerfile string
Platform Platform
BuildArgs []BuildArg
Target string
Secrets []*Secret
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | func (r *Directory) DockerBuild(opts ...DirectoryDockerBuildOpts) *Container {
q := r.q.Select("dockerBuild")
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].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 { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Path string
}
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 { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q := r.q.Select("file")
q = q.Arg("path", path)
return &File{
q: q,
c: r.c,
}
}
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
}
type DirectoryPipelineOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Exclude []string
Include []string
}
func (r *Directory) WithDirectory(path string, directory *Directory, opts ...DirectoryWithDirectoryOpts) *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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Permissions int
}
func (r *Directory) WithFile(path string, source *File, opts ...DirectoryWithFileOpts) *Directory {
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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 File struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | 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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | }
func (r *File) Secret() *Secret {
q := r.q.Select("secret")
return &Secret{
q: q,
c: r.c,
}
}
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 GitRef struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
}
func (r *GitRepository) Branch(name string) *GitRef {
q := r.q.Select("branch")
q = q.Arg("name", name)
return &GitRef{
q: q,
c: r.c,
}
}
func (r *GitRepository) Commit(id string) *GitRef {
q := r.q.Select("commit")
q = q.Arg("id", id)
return &GitRef{
q: q,
c: r.c,
}
}
func (r *GitRepository) Tag(name string) *GitRef {
q := r.q.Select("tag")
q = q.Arg("name", name)
return &GitRef{
q: q,
c: r.c,
}
}
type Host struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
}
type HostDirectoryOpts struct {
Exclude []string
Include []string
}
func (r *Host) Directory(path string, opts ...HostDirectoryOpts) *Directory {
q := r.q.Select("directory")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
}
q = q.Arg("path", path) |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | return &Directory{
q: q,
c: r.c,
}
}
func (r *Host) EnvVariable(name string) *HostVariable {
q := r.q.Select("envVariable")
q = q.Arg("name", name)
return &HostVariable{
q: q,
c: r.c,
}
}
func (r *Host) File(path string) *File {
q := r.q.Select("file")
q = q.Arg("path", path)
return &File{
q: q,
c: r.c,
}
}
func (r *Host) UnixSocket(path string) *Socket {
q := r.q.Select("unixSocket")
q = q.Arg("path", path)
return &Socket{
q: q,
c: r.c,
}
}
type HostWorkdirOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Exclude []string
Include []string
}
func (r *Host) Workdir(opts ...HostWorkdirOpts) *Directory {
q := r.q.Select("workdir")
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)
}
}
return &Directory{
q: q,
c: r.c,
}
}
type HostVariable struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
value *string
}
func (r *HostVariable) Secret() *Secret {
q := r.q.Select("secret")
return &Secret{
q: q,
c: r.c,
}
}
func (r *HostVariable) 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 Label struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
name *string
value *string
}
func (r *Label) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.q.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Label) Value(ctx context.Context) (string, error) {
if r.value != nil {
return *r.value, nil
}
q := r.q.Select("value")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type Port struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
description *string
port *int
protocol *NetworkProtocol
}
func (r *Port) 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 *Port) Port(ctx context.Context) (int, error) {
if r.port != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | return *r.port, nil
}
q := r.q.Select("port")
var response int
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Port) Protocol(ctx context.Context) (NetworkProtocol, error) {
if r.protocol != nil {
return *r.protocol, nil
}
q := r.q.Select("protocol")
var response NetworkProtocol
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type Project struct {
q *querybuilder.Selection
c graphql.Client
id *ProjectID
name *string
}
type WithProjectFunc func(r *Project) *Project
func (r *Project) With(f WithProjectFunc) *Project {
return f(r)
}
func (r *Project) Commands(ctx context.Context) ([]ProjectCommand, error) {
q := r.q.Select("commands")
q = q.Select("description id name resultType")
type commands struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Description string
Id ProjectCommandID
Name string
ResultType string
}
convert := func(fields []commands) []ProjectCommand {
out := []ProjectCommand{}
for i := range fields {
out = append(out, ProjectCommand{description: &fields[i].Description, id: &fields[i].Id, name: &fields[i].Name, resultType: &fields[i].ResultType})
}
return out
}
var response []commands
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *Project) ID(ctx context.Context) (ProjectID, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response ProjectID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Project) XXX_GraphQLType() string {
return "Project"
}
func (r *Project) XXX_GraphQLIDType() string {
return "ProjectID"
}
func (r *Project) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Project) Load(source *Directory, configPath string) *Project {
q := r.q.Select("load")
q = q.Arg("source", source)
q = q.Arg("configPath", configPath)
return &Project{
q: q,
c: r.c,
}
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | func (r *Project) 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)
}
type ProjectCommand struct {
q *querybuilder.Selection
c graphql.Client
description *string
id *ProjectCommandID
name *string
resultType *string
}
func (r *ProjectCommand) 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 *ProjectCommand) Flags(ctx context.Context) ([]ProjectCommandFlag, error) {
q := r.q.Select("flags")
q = q.Select("description name")
type flags struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Description string
Name string
}
convert := func(fields []flags) []ProjectCommandFlag {
out := []ProjectCommandFlag{}
for i := range fields {
out = append(out, ProjectCommandFlag{description: &fields[i].Description, name: &fields[i].Name})
}
return out
}
var response []flags
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
func (r *ProjectCommand) ID(ctx context.Context) (ProjectCommandID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response ProjectCommandID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *ProjectCommand) XXX_GraphQLType() string {
return "ProjectCommand" |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | }
func (r *ProjectCommand) XXX_GraphQLIDType() string {
return "ProjectCommandID"
}
func (r *ProjectCommand) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *ProjectCommand) 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 *ProjectCommand) ResultType(ctx context.Context) (string, error) {
if r.resultType != nil {
return *r.resultType, nil
}
q := r.q.Select("resultType")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *ProjectCommand) Subcommands(ctx context.Context) ([]ProjectCommand, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q := r.q.Select("subcommands")
q = q.Select("description id name resultType")
type subcommands struct {
Description string
Id ProjectCommandID
Name string
ResultType string
}
convert := func(fields []subcommands) []ProjectCommand {
out := []ProjectCommand{}
for i := range fields {
out = append(out, ProjectCommand{description: &fields[i].Description, id: &fields[i].Id, name: &fields[i].Name, resultType: &fields[i].ResultType})
}
return out
}
var response []subcommands
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err
}
return convert(response), nil
}
type ProjectCommandFlag struct {
q *querybuilder.Selection
c graphql.Client
description *string
name *string
}
func (r *ProjectCommandFlag) Description(ctx context.Context) (string, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | 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 *ProjectCommandFlag) 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)
}
type WithClientFunc func(r *Client) *Client
func (r *Client) With(f WithClientFunc) *Client {
return f(r)
}
func (r *Client) CacheVolume(key string) *CacheVolume {
q := r.q.Select("cacheVolume")
q = q.Arg("key", key)
return &CacheVolume{
q: q,
c: r.c,
}
}
type ContainerOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | ID ContainerID
Platform Platform
}
func (r *Client) Container(opts ...ContainerOpts) *Container {
q := r.q.Select("container")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
if !querybuilder.IsZeroValue(opts[i].Platform) {
q = q.Arg("platform", opts[i].Platform)
}
}
return &Container{
q: q,
c: r.c,
}
}
func (r *Client) DefaultPlatform(ctx context.Context) (Platform, error) {
q := r.q.Select("defaultPlatform")
var response Platform
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type DirectoryOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | ID DirectoryID
}
func (r *Client) Directory(opts ...DirectoryOpts) *Directory {
q := r.q.Select("directory")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
}
return &Directory{
q: q,
c: r.c,
}
}
func (r *Client) File(id FileID) *File {
q := r.q.Select("file")
q = q.Arg("id", id)
return &File{
q: q,
c: r.c,
}
}
type GitOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | KeepGitDir bool
ExperimentalServiceHost *Container
}
func (r *Client) Git(url string, opts ...GitOpts) *GitRepository {
q := r.q.Select("git")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].KeepGitDir) {
q = q.Arg("keepGitDir", opts[i].KeepGitDir)
}
if !querybuilder.IsZeroValue(opts[i].ExperimentalServiceHost) {
q = q.Arg("experimentalServiceHost", opts[i].ExperimentalServiceHost)
}
}
q = q.Arg("url", url)
return &GitRepository{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q: q,
c: r.c,
}
}
func (r *Client) Host() *Host {
q := r.q.Select("host")
return &Host{
q: q,
c: r.c,
}
}
type HTTPOpts struct {
ExperimentalServiceHost *Container
}
func (r *Client) HTTP(url string, opts ...HTTPOpts) *File {
q := r.q.Select("http")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].ExperimentalServiceHost) {
q = q.Arg("experimentalServiceHost", opts[i].ExperimentalServiceHost)
}
}
q = q.Arg("url", url)
return &File{
q: q,
c: r.c,
}
}
type PipelineOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | Description string
Labels []PipelineLabel
}
func (r *Client) Pipeline(name string, opts ...PipelineOpts) *Client {
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 &Client{
q: q,
c: r.c,
}
}
type ProjectOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | ID ProjectID
}
func (r *Client) Project(opts ...ProjectOpts) *Project {
q := r.q.Select("project")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
}
return &Project{
q: q,
c: r.c,
}
}
type ProjectCommandOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | ID ProjectCommandID
}
func (r *Client) ProjectCommand(opts ...ProjectCommandOpts) *ProjectCommand {
q := r.q.Select("projectCommand")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
}
return &ProjectCommand{
q: q,
c: r.c,
}
}
func (r *Client) Secret(id SecretID) *Secret {
q := r.q.Select("secret")
q = q.Arg("id", id)
return &Secret{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q: q,
c: r.c,
}
}
func (r *Client) SetSecret(name string, plaintext string) *Secret {
q := r.q.Select("setSecret")
q = q.Arg("name", name)
q = q.Arg("plaintext", plaintext)
return &Secret{
q: q,
c: r.c,
}
}
type SocketOpts struct {
ID SocketID
}
func (r *Client) Socket(opts ...SocketOpts) *Socket {
q := r.q.Select("socket")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
}
return &Socket{
q: q,
c: r.c,
}
}
type Secret struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
id *SecretID
plaintext *string
}
func (r *Secret) ID(ctx context.Context) (SecretID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response SecretID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Secret) XXX_GraphQLType() string {
return "Secret"
}
func (r *Secret) XXX_GraphQLIDType() string {
return "SecretID"
}
func (r *Secret) 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 | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | func (r *Secret) Plaintext(ctx context.Context) (string, error) {
if r.plaintext != nil {
return *r.plaintext, nil
}
q := r.q.Select("plaintext")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
type Socket struct {
q *querybuilder.Selection
c graphql.Client
id *SocketID
}
func (r *Socket) ID(ctx context.Context) (SocketID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response SocketID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Socket) XXX_GraphQLType() string {
return "Socket"
}
func (r *Socket) XXX_GraphQLIDType() string {
return "SocketID"
}
func (r *Socket) XXX_GraphQLID(ctx context.Context) (string, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 4,192 | Rename `id` argument name in fields that don’t return its type | Some top-level fields return an object if you have their ID:
```graphql
type Query {
container(id: ContainerID, platform: Platform): Container!
directory(id: DirectoryID): Directory!
file(id: FileID!): File
secret(id: SecretID!): Secret!
socket(id: SocketID): Socket!
}
```
There’s one exception to this “rule”. I think it makes sense for us to rename this parameter to make it more consistent:
```diff
type Container {
"Initializes this container from this DirectoryID."
- withRootfs(id: DirectoryID!): Container!
+ withRootfs(directory: DirectoryID!): Container!
}
```
### Notes
- `directory` is consistent with `withDirectory(path: String!, directory: DirectoryID!)`. `withRootfs` is similar just with `path` set to `/`;
- `Container.withFS` doesn’t matter as it’s deprecated and is going to be removed;
- Downside is the breaking change but for codegen clients, `withRootfs`‘s `id` being a required argument, the name is hidden from usage so it shouldn’t actually break most users;
- This was surfaced in https://github.com/dagger/dagger/issues/4191.
| https://github.com/dagger/dagger/issues/4192 | https://github.com/dagger/dagger/pull/5513 | 18f57d142656400fd6318d1d6ed486101f3c14d6 | cf4c4689391d801fbfee00a56134ba03417eb8c2 | 2022-12-13T23:59:19Z | go | 2023-07-27T18:08:17Z | sdk/go/api.gen.go | id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
type CacheSharingMode string
const (
Locked CacheSharingMode = "LOCKED"
Private CacheSharingMode = "PRIVATE"
Shared CacheSharingMode = "SHARED"
)
type ImageLayerCompression string
const (
Estargz ImageLayerCompression = "EStarGZ"
Gzip ImageLayerCompression = "Gzip"
Uncompressed ImageLayerCompression = "Uncompressed"
Zstd ImageLayerCompression = "Zstd"
)
type ImageMediaTypes string
const (
Dockermediatypes ImageMediaTypes = "DockerMediaTypes"
Ocimediatypes ImageMediaTypes = "OCIMediaTypes"
)
type NetworkProtocol string
const (
Tcp NetworkProtocol = "TCP"
Udp NetworkProtocol = "UDP"
) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | package core
import (
"context"
"os"
"path/filepath"
"testing"
"dagger.io/dagger"
"github.com/stretchr/testify/require"
)
func TestHostWorkdir(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | t.Parallel()
dir := t.TempDir()
err := os.WriteFile(filepath.Join(dir, "foo"), []byte("bar"), 0600)
require.NoError(t, err)
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithWorkdir(dir))
require.NoError(t, err)
defer c.Close()
t.Run("contains the workdir's content", func(t *testing.T) {
contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", c.Host().Directory(".")).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo\n", contents)
})
t.Run("does NOT re-sync on each call", func(t *testing.T) {
err := os.WriteFile(filepath.Join(dir, "fizz"), []byte("buzz"), 0600)
require.NoError(t, err)
contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", c.Host().Directory(".")).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo\n", contents)
})
}
func TestHostWorkdirExcludeInclude(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | t.Parallel()
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "a.txt"), []byte("1"), 0600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "b.txt"), []byte("2"), 0600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "c.txt.rar"), []byte("3"), 0600))
require.NoError(t, os.MkdirAll(filepath.Join(dir, "subdir"), 0755))
require.NoError(t, os.WriteFile(filepath.Join(dir, "subdir", "sub-file"), []byte("goodbye"), 0600))
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithWorkdir(dir), dagger.WithLogOutput(os.Stderr))
require.NoError(t, err)
defer c.Close()
t.Run("exclude", func(t *testing.T) {
wd := c.Host().Directory(".", dagger.HostDirectoryOpts{
Exclude: []string{"*.rar"},
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", wd).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "a.txt\nb.txt\nsubdir\n", contents)
})
t.Run("exclude directory", func(t *testing.T) {
wd := c.Host().Directory(".", dagger.HostDirectoryOpts{
Exclude: []string{"subdir"},
})
contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", wd).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "a.txt\nb.txt\nc.txt.rar\n", contents)
})
t.Run("include", func(t *testing.T) {
wd := c.Host().Directory(".", dagger.HostDirectoryOpts{
Include: []string{"*.rar"},
})
contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", wd).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | require.Equal(t, "c.txt.rar\n", contents)
})
t.Run("exclude overrides include", func(t *testing.T) {
wd := c.Host().Directory(".", dagger.HostDirectoryOpts{
Include: []string{"*.txt"},
Exclude: []string{"b.txt"},
})
contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", wd).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "a.txt\n", contents)
})
t.Run("include does not override exclude", func(t *testing.T) {
wd := c.Host().Directory(".", dagger.HostDirectoryOpts{
Include: []string{"a.txt"},
Exclude: []string{"*.txt"},
})
contents, err := c.Container().
From(alpineImage).
WithMountedDirectory("/host", wd).
WithExec([]string{"ls", "/host"}).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "", contents)
})
}
func TestHostDirectoryRelative(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | t.Parallel()
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "some-file"), []byte("hello"), 0600))
require.NoError(t, os.MkdirAll(filepath.Join(dir, "some-dir"), 0755))
require.NoError(t, os.WriteFile(filepath.Join(dir, "some-dir", "sub-file"), []byte("goodbye"), 0600))
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithWorkdir(dir))
require.NoError(t, err)
defer c.Close()
t.Run(". is same as workdir", func(t *testing.T) {
wdID1, err := c.Host().Directory(".").ID(ctx)
require.NoError(t, err)
wdID2, err := c.Host().Directory(".").ID(ctx)
require.NoError(t, err)
require.Equal(t, wdID1, wdID2)
})
t.Run("./foo is relative to workdir", func(t *testing.T) {
contents, err := c.Host().Directory("some-dir").Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{"sub-file"}, contents)
})
t.Run("../ does not allow escaping", func(t *testing.T) {
_, err := c.Host().Directory("../").ID(ctx)
require.Error(t, err)
require.NotContains(t, err.Error(), dir)
})
}
func TestHostDirectoryAbsolute(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | t.Parallel()
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "some-file"), []byte("hello"), 0600))
require.NoError(t, os.MkdirAll(filepath.Join(dir, "some-dir"), 0755))
require.NoError(t, os.WriteFile(filepath.Join(dir, "some-dir", "sub-file"), []byte("goodbye"), 0600))
ctx := context.Background()
c, err := dagger.Connect(ctx, dagger.WithWorkdir(dir))
require.NoError(t, err)
defer c.Close()
entries, err := c.Host().Directory(filepath.Join(dir, "some-dir")).Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{"sub-file"}, entries)
}
func TestHostDirectoryExcludeInclude(t *testing.T) {
t.Parallel()
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "a.txt"), []byte("1"), 0600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "b.txt"), []byte("2"), 0600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "c.txt.rar"), []byte("3"), 0600))
require.NoError(t, os.MkdirAll(filepath.Join(dir, "subdir"), 0755))
require.NoError(t, os.WriteFile(filepath.Join(dir, "subdir", "d.txt"), []byte("1"), 0600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "subdir", "e.txt"), []byte("2"), 0600))
require.NoError(t, os.WriteFile(filepath.Join(dir, "subdir", "f.txt.rar"), []byte("3"), 0600))
c, ctx := connect(t)
defer c.Close()
t.Run("exclude", func(t *testing.T) {
entries, err := c.Host().Directory(dir, dagger.HostDirectoryOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | Exclude: []string{"*.rar"},
}).Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{"a.txt", "b.txt", "subdir"}, entries)
})
t.Run("include", func(t *testing.T) {
entries, err := c.Host().Directory(dir, dagger.HostDirectoryOpts{
Include: []string{"*.rar"},
}).Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{"c.txt.rar"}, entries)
})
t.Run("exclude overrides include", func(t *testing.T) {
entries, err := c.Host().Directory(dir, dagger.HostDirectoryOpts{
Include: []string{"*.txt"},
Exclude: []string{"b.txt"},
}).Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{"a.txt"}, entries)
})
t.Run("include does not override exclude", func(t *testing.T) {
entries, err := c.Host().Directory(dir, dagger.HostDirectoryOpts{
Include: []string{"a.txt"},
Exclude: []string{"*.txt"},
}).Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{}, entries)
})
}
func TestHostFile(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/integration/host_test.go | t.Parallel()
dir := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(dir, "a.txt"), []byte("1"), 0600))
require.NoError(t, os.MkdirAll(filepath.Join(dir, "subdir"), 0755))
require.NoError(t, os.WriteFile(filepath.Join(dir, "subdir", "d.txt"), []byte("hello world"), 0600))
c, ctx := connect(t)
defer c.Close()
t.Run("get simple file", func(t *testing.T) {
content, err := c.Host().File(filepath.Join(dir, "a.txt")).Contents(ctx)
require.NoError(t, err)
require.Equal(t, "1", content)
})
t.Run("get nested file", func(t *testing.T) {
content, err := c.Host().File(filepath.Join(dir, "subdir", "d.txt")).Contents(ctx)
require.NoError(t, err)
require.Equal(t, "hello world", content)
})
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/host.go | package schema
import (
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/router"
)
type hostSchema struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/host.go | *baseSchema
host *core.Host
}
var _ router.ExecutableSchema = &hostSchema{}
func (s *hostSchema) Name() string {
return "host"
}
func (s *hostSchema) Schema() string {
return Host
}
func (s *hostSchema) Resolvers() router.Resolvers {
return router.Resolvers{
"Query": router.ObjectResolver{
"host": router.PassthroughResolver,
},
"Host": router.ObjectResolver{
"directory": router.ToResolver(s.directory),
"file": router.ToResolver(s.file),
"unixSocket": router.ToResolver(s.socket),
},
}
}
func (s *hostSchema) Dependencies() []router.ExecutableSchema {
return nil
}
type hostDirectoryArgs struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/host.go | Path string
core.CopyFilter
}
func (s *hostSchema) directory(ctx *router.Context, parent *core.Query, args hostDirectoryArgs) (*core.Directory, error) {
return s.host.Directory(ctx, s.gw, args.Path, parent.PipelinePath(), "host.directory", s.platform, args.CopyFilter)
}
type hostSocketArgs struct {
Path string
}
func (s *hostSchema) socket(ctx *router.Context, _ any, args hostSocketArgs) (*core.Socket, error) {
return s.host.Socket(ctx, args.Path)
}
type hostFileArgs struct {
Path string
}
func (s *hostSchema) file(ctx *router.Context, parent *core.Query, args hostFileArgs) (*core.File, error) {
return s.host.File(ctx, s.gw, args.Path, parent.PipelinePath(), s.platform)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/secret.go | package schema
import (
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/router"
)
type secretSchema struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/secret.go | *baseSchema
}
var _ router.ExecutableSchema = &secretSchema{}
func (s *secretSchema) Name() string {
return "secret"
}
func (s *secretSchema) Schema() string {
return Secret
}
var secretIDResolver = stringResolver(core.SecretID(""))
func (s *secretSchema) Resolvers() router.Resolvers {
return router.Resolvers{
"SecretID": secretIDResolver,
"Query": router.ObjectResolver{
"secret": router.ToResolver(s.secret),
"setSecret": router.ToResolver(s.setSecret),
},
"Secret": router.ObjectResolver{
"id": router.ToResolver(s.id),
"plaintext": router.ToResolver(s.plaintext),
},
}
}
func (s *secretSchema) Dependencies() []router.ExecutableSchema {
return nil
}
func (s *secretSchema) id(ctx *router.Context, parent *core.Secret, args any) (core.SecretID, error) {
return parent.ID()
}
type secretArgs struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/secret.go | ID core.SecretID
}
func (s *secretSchema) secret(ctx *router.Context, parent any, args secretArgs) (*core.Secret, error) {
return args.ID.ToSecret()
}
type SecretPlaintext string
func (s SecretPlaintext) MarshalText() ([]byte, error) {
return []byte("***"), nil
}
type setSecretArgs struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | core/schema/secret.go | Name string
Plaintext SecretPlaintext
}
func (s *secretSchema) setSecret(ctx *router.Context, parent any, args setSecretArgs) (*core.Secret, error) {
secretID, err := s.secrets.AddSecret(ctx, args.Name, string(args.Plaintext))
if err != nil {
return nil, err
}
return secretID.ToSecret()
}
func (s *secretSchema) plaintext(ctx *router.Context, parent *core.Secret, args any) (string, error) {
id, err := parent.ID()
if err != nil {
return "", err
}
bytes, err := s.secrets.GetSecret(ctx, id.String())
if err != nil {
return "", err
}
return string(bytes), nil
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | package dagger
import (
"context"
"dagger.io/dagger/internal/querybuilder"
"github.com/Khan/genqlient/graphql"
)
type CacheID string
type ContainerID string
type DirectoryID string
type FileID string
type Platform string
type ProjectCommandID string
type ProjectID string
type SecretID string
type SocketID string
type BuildArg struct {
Name string `json:"name"`
Value string `json:"value"`
}
type PipelineLabel struct {
Name string `json:"name"`
Value string `json:"value"`
}
type CacheVolume struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
id *CacheID
}
func (r *CacheVolume) ID(ctx context.Context) (CacheID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.q.Select("id")
var response CacheID
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 "CacheID"
}
func (r *CacheVolume) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
type Container struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | q *querybuilder.Selection
c graphql.Client
endpoint *string
envVariable *string
export *bool
hostname *string
id *ContainerID
imageRef *string
label *string
platform *Platform
publish *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)
}
type ContainerBuildOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Dockerfile string
BuildArgs []BuildArg
Target string
Secrets []*Secret
}
func (r *Container) Build(context *Directory, opts ...ContainerBuildOpts) *Container {
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)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | 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)
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,
}
}
type ContainerEndpointOpts struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Port int
Scheme string
}
func (r *Container) Endpoint(ctx context.Context, opts ...ContainerEndpointOpts) (string, error) {
if r.endpoint != nil {
return *r.endpoint, nil
}
q := r.q.Select("endpoint")
for i := len(opts) - 1; i >= 0; i-- {
if !querybuilder.IsZeroValue(opts[i].Port) {
q = q.Arg("port", opts[i].Port) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | }
if !querybuilder.IsZeroValue(opts[i].Scheme) {
q = q.Arg("scheme", opts[i].Scheme)
}
}
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, 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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Name string
Value string
}
convert := func(fields []envVariables) []EnvVariable {
out := []EnvVariable{}
for i := range fields {
out = append(out, EnvVariable{name: &fields[i].Name, value: &fields[i].Value})
}
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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 {
out = append(out, Port{description: &fields[i].Description, port: &fields[i].Port, protocol: &fields[i].Protocol})
}
return out
}
var response []exposedPorts
q = q.Bind(&response)
err := q.Execute(ctx, r.c)
if err != nil {
return nil, err |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | }
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) Hostname(ctx context.Context) (string, error) {
if r.hostname != nil {
return *r.hostname, nil
}
q := r.q.Select("hostname")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
func (r *Container) ID(ctx context.Context) (ContainerID, error) {
if r.id != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | return *r.id, nil
}
q := r.q.Select("id")
var response ContainerID
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
}
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) 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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Tag string
}
func (r *Container) Import(source *File, opts ...ContainerImportOpts) *Container {
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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 {
out = append(out, Label{name: &fields[i].Name, value: &fields[i].Value})
}
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | 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
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 |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | }
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) {
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) Stderr(ctx context.Context) (string, error) {
if r.stderr != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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 {
Exclude []string
Include []string
Owner string
}
func (r *Container) WithDirectory(path string, directory *Directory, opts ...ContainerWithDirectoryOpts) *Container {
q := r.q.Select("withDirectory") |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Permissions int
Owner string
}
func (r *Container) WithFile(path string, source *File, opts ...ContainerWithFileOpts) *Container {
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{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | q: q,
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Owner string
}
func (r *Container) WithMountedCache(path string, cache *CacheVolume, opts ...ContainerWithMountedCacheOpts) *Container {
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Owner string
}
func (r *Container) WithMountedDirectory(path string, source *Directory, opts ...ContainerWithMountedDirectoryOpts) *Container {
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Owner string
}
func (r *Container) WithMountedFile(path string, source *File, opts ...ContainerWithMountedFileOpts) *Container {
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,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | Owner string
}
func (r *Container) WithMountedSecret(path string, source *Secret, opts ...ContainerWithMountedSecretOpts) *Container {
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) |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | }
}
q = q.Arg("path", path)
q = q.Arg("source", source)
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 |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | }
func (r *Container) WithNewFile(path string, opts ...ContainerWithNewFileOpts) *Container {
q := r.q.Select("withNewFile")
for i := len(opts) - 1; i >= 0; i-- {
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 {
q := r.q.Select("withRegistryAuth")
q = q.Arg("address", address)
q = q.Arg("username", username)
q = q.Arg("secret", secret)
return &Container{
q: q, |
closed | dagger/dagger | https://github.com/dagger/dagger | 5,069 | Handling Binary Data | ## Background
While trying to implement examples for issue [Allow directories to be mounted as secrets](https://github.com/dagger/dagger/issues/4896), it became apparent that there are limitations when dealing with binary data in GraphQL using strings. This is relevant for the purpose of mounting directories as secrets, where binary data needs to be handled.
I encountered a problem when attempting to handle GPG files. The goal was to create and GPG-sign a built binary with Dagger by mounting the `~/.gnupg` directory into the container and running `gpg --detach-sign --armor binary-name`.
This required the following files:
- ~/.gnupg/pubring.kbx
- ~/.gnupg/trustdb.gpg
- ~/.gnupg/private-keys-v1.d/*
Handling binary data like GPG files in GraphQL led to errors due to improper escaping:
```shell
go run .
Connected to engine c01f0fd17590
panic: input:1: Syntax Error GraphQL request (1:49) Invalid character escape sequence: \\x.
```
The initial idea was to implement a union type `SecretData = String | Bytes` in the `setSecret` query. However, according to the [discussion](https://github.com/dagger/dagger/issues/5000#issuecomment-1518352932), using unions as input values in GraphQL is not feasible.
## Issue
The main issue is finding a solution to handle both string and binary data when setting secrets in GraphQL, as the initial proposal of using a union type is not possible. This is important for mounting directories as secrets and handling binary data efficiently.
## Proposed Solution
Based on the comments and limitations mentioned in the discussion, the best solution seems to be to create a new function that accepts binary data as Base64 encoded string as input. This function would be a variation of withSecretVariable and handle binary data separately.
### Advantages
- No character encoding issues: By using Base64 encoding, we can ensure that all binary data is properly serialized and deserialized without any issues related to character encoding.
- Efficient data transfer: Base64-encoded binary data is more compact than a string representation, reducing the overhead associated with transferring binary data in GraphQL queries or mutations.
- Clear type information: Defining a custom type allows us to be explicit regarding the expected encoded format
#### Steps to implement the solution:
1. Create a new custom type `Base64` in the GraphQL schema to handle binary data.
```graphql
type Base64 string
```
2. Define a new function in the client SDK called WithSecretBytes that accepts an environment variable name and Base64 data as input.
```go
func (c *Container) setSecretBytes(name string, data Base64) *Container
```
3. Update the GraphQL schema to include the new function setSecretBytes.
```graphql
extend type Query {
"Sets a secret given a user-defined name to its binary data and returns the secret."
setSecretBytes(
"""
The user-defined name for this secret
"""
name: String!
"""
The binary data of the secret
"""
data: Base64!
): Secret!
}
```
4. Implement deserialization functions for the Base64 `setSecretBytes`, handling the decoding of binary from Base64.
5. Update the SDK example to show how to convert binary data to Base64-encoded strings before sending them as secret arguments.
By implementing this new function, we can effectively handle binary data in GraphQL, making it possible to mount directories as secrets in a more convenient and efficient manner.
cc @vikram-dagger @helderco @vito | https://github.com/dagger/dagger/issues/5069 | https://github.com/dagger/dagger/pull/5500 | 99a054bc0bc14baf91783871d8364b5be5d10177 | 09677c0311acb73891b7798d65777957f1a5d513 | 2023-05-02T14:47:43Z | go | 2023-07-28T00:04:29Z | sdk/go/api.gen.go | c: r.c,
}
}
func (r *Container) WithRootfs(directory *Directory) *Container {
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 {
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 *Container) *Container {
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 { |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.