Gleam SDK for Pocketenv
Use ConnectedSandbox for sandbox APIs
Replace client + sandbox_id parameters with ConnectedSandbox across
modules (env, files, network, ports, secrets, services, volume).
Update calls to use sb.client and sb.data.id and refresh README examples
to use sb |> ... and add necessary sandbox imports
+166
-173
+47
-37
README.md
+47
-37
README.md
···
61
61
62
62
```gleam
63
63
import pocketenv
64
+
import pocketenv/sandbox
64
65
import pocketenv/env
65
-
import gleam/option.{None}
66
+
import gleam/option.{None, Some}
66
67
67
68
pub fn main() {
68
69
let client = pocketenv.new_client("your-token")
69
-
let sandbox_id = "sandbox-abc123"
70
+
let assert Ok(Some(sandbox_data)) = sandbox.get(client, "sandbox-abc123")
71
+
let sb = sandbox_data |> sandbox.connect(client)
70
72
71
73
// Set a variable
72
-
let assert Ok(Nil) = env.put(client, sandbox_id, "DATABASE_URL", "postgres://localhost/mydb")
74
+
let assert Ok(Nil) = sb |> env.put("DATABASE_URL", "postgres://localhost/mydb")
73
75
74
76
// List variables
75
-
let assert Ok(vars) = env.list(client, sandbox_id, None, None)
77
+
let assert Ok(vars) = sb |> env.list(None, None)
76
78
77
79
// Delete a variable by its id
78
80
case vars {
79
81
[first, ..] -> {
80
-
let assert Ok(Nil) = env.delete(client, first.id)
82
+
let assert Ok(Nil) = sb |> env.delete(first.id)
81
83
}
82
84
[] -> Nil
83
85
}
···
88
90
89
91
```gleam
90
92
import pocketenv
93
+
import pocketenv/sandbox
91
94
import pocketenv/secrets
92
-
import gleam/option.{None}
95
+
import gleam/option.{None, Some}
93
96
94
97
pub fn main() {
95
98
let client = pocketenv.new_client("your-token")
96
-
let sandbox_id = "sandbox-abc123"
99
+
let assert Ok(Some(sandbox_data)) = sandbox.get(client, "sandbox-abc123")
100
+
let sb = sandbox_data |> sandbox.connect(client)
97
101
98
102
// Store a secret
99
-
let assert Ok(Nil) = secrets.put(client, sandbox_id, "API_KEY", "super-secret-value")
103
+
let assert Ok(Nil) = sb |> secrets.put("API_KEY", "super-secret-value")
100
104
101
105
// List secret names (values are never returned)
102
-
let assert Ok(all) = secrets.list(client, sandbox_id, None, None)
106
+
let assert Ok(all) = sb |> secrets.list(None, None)
103
107
104
108
// Delete a secret
105
109
case all {
106
110
[first, ..] -> {
107
-
let assert Ok(Nil) = secrets.delete(client, first.id)
111
+
let assert Ok(Nil) = sb |> secrets.delete(first.id)
108
112
}
109
113
[] -> Nil
110
114
}
···
115
119
116
120
```gleam
117
121
import pocketenv
122
+
import pocketenv/sandbox
118
123
import pocketenv/files
124
+
import gleam/option.{Some}
119
125
120
126
pub fn main() {
121
127
let client = pocketenv.new_client("your-token")
122
-
let sandbox_id = "sandbox-abc123"
128
+
let assert Ok(Some(sandbox_data)) = sandbox.get(client, "sandbox-abc123")
129
+
let sb = sandbox_data |> sandbox.connect(client)
123
130
124
131
// Write a file into the sandbox
125
-
let assert Ok(Nil) =
126
-
files.write(client, sandbox_id, "/app/config.json", "{\"debug\": true}")
132
+
let assert Ok(Nil) = sb |> files.write("/app/config.json", "{\"debug\": true}")
127
133
128
134
// List files
129
-
let assert Ok(all) = files.list(client, sandbox_id)
135
+
let assert Ok(all) = sb |> files.list()
130
136
131
137
// Delete a file
132
138
case all {
133
139
[first, ..] -> {
134
-
let assert Ok(Nil) = files.delete(client, first.id)
140
+
let assert Ok(Nil) = sb |> files.delete(first.id)
135
141
}
136
142
[] -> Nil
137
143
}
···
142
148
143
149
```gleam
144
150
import pocketenv
151
+
import pocketenv/sandbox
145
152
import pocketenv/volume
153
+
import gleam/option.{Some}
146
154
147
155
pub fn main() {
148
156
let client = pocketenv.new_client("your-token")
149
-
let sandbox_id = "sandbox-abc123"
157
+
let assert Ok(Some(sandbox_data)) = sandbox.get(client, "sandbox-abc123")
158
+
let sb = sandbox_data |> sandbox.connect(client)
150
159
151
160
// Mount a persistent volume
152
-
let assert Ok(Nil) = volume.create(client, sandbox_id, "data-vol", "/mnt/data")
161
+
let assert Ok(Nil) = sb |> volume.create("data-vol", "/mnt/data")
153
162
154
163
// List volumes
155
-
let assert Ok(vols) = volume.list(client, sandbox_id)
164
+
let assert Ok(vols) = sb |> volume.list()
156
165
157
166
// Delete a volume
158
167
case vols {
159
168
[first, ..] -> {
160
-
let assert Ok(Nil) = volume.delete(client, first.id)
169
+
let assert Ok(Nil) = sb |> volume.delete(first.id)
161
170
}
162
171
[] -> Nil
163
172
}
···
168
177
169
178
```gleam
170
179
import pocketenv
180
+
import pocketenv/sandbox
171
181
import pocketenv/services
172
182
import gleam/option.{None, Some}
173
183
174
184
pub fn main() {
175
185
let client = pocketenv.new_client("your-token")
176
-
let sandbox_id = "sandbox-abc123"
186
+
let assert Ok(Some(sandbox_data)) = sandbox.get(client, "sandbox-abc123")
187
+
let sb = sandbox_data |> sandbox.connect(client)
177
188
178
-
// Register and start a web server service
189
+
// Register a web server service
179
190
let assert Ok(Nil) =
180
-
services.create(
181
-
client,
182
-
sandbox_id,
191
+
sb
192
+
|> services.create(
183
193
"web",
184
194
"python -m http.server 8080",
185
195
Some([8080]),
186
196
Some("Simple HTTP server"),
187
197
)
188
198
189
-
let assert Ok(svcs) = services.list(client, sandbox_id)
199
+
let assert Ok(svcs) = sb |> services.list()
190
200
case svcs {
191
201
[svc, ..] -> {
192
-
let assert Ok(Nil) = services.start(client, svc.id)
193
-
let assert Ok(Nil) = services.restart(client, svc.id)
194
-
let assert Ok(Nil) = services.stop(client, svc.id)
195
-
let assert Ok(Nil) = services.delete(client, svc.id)
202
+
let assert Ok(Nil) = sb |> services.start(svc.id)
203
+
let assert Ok(Nil) = sb |> services.restart(svc.id)
204
+
let assert Ok(Nil) = sb |> services.stop(svc.id)
205
+
let assert Ok(Nil) = sb |> services.delete(svc.id)
196
206
}
197
207
[] -> Nil
198
208
}
···
203
213
204
214
```gleam
205
215
import pocketenv
216
+
import pocketenv/sandbox
206
217
import pocketenv/network
207
218
import pocketenv/ports
208
219
import gleam/io
209
-
import gleam/option.{None, Some}
220
+
import gleam/option.{Some}
210
221
211
222
pub fn main() {
212
223
let client = pocketenv.new_client("your-token")
213
-
let sandbox_id = "sandbox-abc123"
224
+
let assert Ok(Some(sandbox_data)) = sandbox.get(client, "sandbox-abc123")
225
+
let sb = sandbox_data |> sandbox.connect(client)
214
226
215
227
// Expose a port and get a preview URL
216
-
let assert Ok(preview_url) =
217
-
network.expose(client, sandbox_id, 3000, Some("Dev server"))
228
+
let assert Ok(preview_url) = sb |> network.expose(3000, Some("Dev server"))
218
229
io.debug(preview_url)
219
230
220
231
// List currently exposed ports
221
-
let assert Ok(exposed) = ports.list(client, sandbox_id)
232
+
let assert Ok(exposed) = sb |> ports.list()
222
233
io.debug(exposed)
223
234
224
235
// Unexpose the port
225
-
let assert Ok(Nil) = network.unexpose(client, sandbox_id, 3000)
236
+
let assert Ok(Nil) = sb |> network.unexpose(3000)
226
237
227
238
// Configure Tailscale networking
228
-
let assert Ok(Nil) =
229
-
network.setup_tailscale(client, sandbox_id, "tskey-auth-xxxx")
239
+
let assert Ok(Nil) = sb |> network.setup_tailscale("tskey-auth-xxxx")
230
240
}
231
241
```
232
242
+14
-17
src/pocketenv/env.gleam
+14
-17
src/pocketenv/env.gleam
···
9
9
import gleam/list
10
10
import gleam/option.{type Option, None, Some}
11
11
import gleam/result
12
-
import pocketenv.{
13
-
type Client, type PocketenvError, JsonDecodeError, do_get, do_post,
14
-
}
12
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get, do_post}
13
+
import pocketenv/sandbox.{type ConnectedSandbox}
15
14
16
15
/// A single environment variable stored in a sandbox.
17
16
pub type Variable {
18
17
Variable(id: String, name: String, value: String, created_at: String)
19
18
}
20
19
21
-
/// Lists environment variables for `sandbox_id`.
20
+
/// Lists environment variables for the sandbox.
22
21
/// Optionally paginate with `limit` and `offset`.
23
22
///
24
23
/// ## Example
25
24
///
26
25
/// ```gleam
27
-
/// let assert Ok(vars) = env.list(client, sandbox_id, None, None)
26
+
/// let assert Ok(vars) = sb |> env.list(None, None)
28
27
/// ```
29
28
pub fn list(
30
-
client: Client,
31
-
sandbox_id: String,
29
+
sb: ConnectedSandbox,
32
30
limit: Option(Int),
33
31
offset: Option(Int),
34
32
) -> Result(List(Variable), PocketenvError) {
35
-
let query = [#("sandboxId", sandbox_id)]
33
+
let query = [#("sandboxId", sb.data.id)]
36
34
let query = case limit {
37
35
Some(l) -> list.append(query, [#("limit", int.to_string(l))])
38
36
None -> query
···
42
40
None -> query
43
41
}
44
42
use body <- result.try(do_get(
45
-
client,
43
+
sb.client,
46
44
"/xrpc/io.pocketenv.variable.getVariables",
47
45
query,
48
46
))
···
53
51
|> result.map_error(JsonDecodeError)
54
52
}
55
53
56
-
/// Creates or updates an environment variable named `name` with `value` in `sandbox_id`.
54
+
/// Creates or updates an environment variable named `name` with `value`.
57
55
///
58
56
/// ## Example
59
57
///
60
58
/// ```gleam
61
-
/// let assert Ok(Nil) = env.put(client, sandbox_id, "PORT", "8080")
59
+
/// let assert Ok(Nil) = sb |> env.put("PORT", "8080")
62
60
/// ```
63
61
pub fn put(
64
-
client: Client,
65
-
sandbox_id: String,
62
+
sb: ConnectedSandbox,
66
63
name: String,
67
64
value: String,
68
65
) -> Result(Nil, PocketenvError) {
···
72
69
#(
73
70
"variable",
74
71
json.object([
75
-
#("sandboxId", json.string(sandbox_id)),
72
+
#("sandboxId", json.string(sb.data.id)),
76
73
#("name", json.string(name)),
77
74
#("value", json.string(value)),
78
75
]),
···
80
77
]),
81
78
)
82
79
use _ <- result.try(do_post(
83
-
client,
80
+
sb.client,
84
81
"/xrpc/io.pocketenv.variable.addVariable",
85
82
[],
86
83
body,
···
89
86
}
90
87
91
88
/// Deletes the environment variable identified by `id`.
92
-
pub fn delete(client: Client, id: String) -> Result(Nil, PocketenvError) {
89
+
pub fn delete(sb: ConnectedSandbox, id: String) -> Result(Nil, PocketenvError) {
93
90
use _ <- result.try(do_post(
94
-
client,
91
+
sb.client,
95
92
"/xrpc/io.pocketenv.variable.deleteVariable",
96
93
[#("id", id)],
97
94
"{}",
+14
-19
src/pocketenv/files.gleam
+14
-19
src/pocketenv/files.gleam
···
5
5
import gleam/dynamic/decode
6
6
import gleam/json
7
7
import gleam/result
8
-
import pocketenv.{
9
-
type Client, type PocketenvError, JsonDecodeError, do_get, do_post,
10
-
}
8
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get, do_post}
9
+
import pocketenv/sandbox.{type ConnectedSandbox}
11
10
12
11
/// Metadata for a file stored in a sandbox.
13
12
pub type File {
14
13
File(id: String, path: String, created_at: String)
15
14
}
16
15
17
-
/// Lists all files in `sandbox_id`.
16
+
/// Lists all files in the sandbox.
18
17
///
19
18
/// ## Example
20
19
///
21
20
/// ```gleam
22
-
/// let assert Ok(files) = files.list(client, sandbox_id)
21
+
/// let assert Ok(files) = sb |> files.list()
23
22
/// ```
24
-
pub fn list(
25
-
client: Client,
26
-
sandbox_id: String,
27
-
) -> Result(List(File), PocketenvError) {
23
+
pub fn list(sb: ConnectedSandbox) -> Result(List(File), PocketenvError) {
28
24
use body <- result.try(
29
-
do_get(client, "/xrpc/io.pocketenv.file.getFiles", [
30
-
#("sandboxId", sandbox_id),
25
+
do_get(sb.client, "/xrpc/io.pocketenv.file.getFiles", [
26
+
#("sandboxId", sb.data.id),
31
27
]),
32
28
)
33
29
json.parse(body, {
···
37
33
|> result.map_error(JsonDecodeError)
38
34
}
39
35
40
-
/// Writes (or overwrites) a file at `path` with `content` in `sandbox_id`.
36
+
/// Writes (or overwrites) a file at `path` with `content`.
41
37
///
42
38
/// ## Example
43
39
///
44
40
/// ```gleam
45
-
/// let assert Ok(Nil) = files.write(client, sandbox_id, "/app/.env", "PORT=8080\n")
41
+
/// let assert Ok(Nil) = sb |> files.write("/app/.env", "PORT=8080\n")
46
42
/// ```
47
43
pub fn write(
48
-
client: Client,
49
-
sandbox_id: String,
44
+
sb: ConnectedSandbox,
50
45
path: String,
51
46
content: String,
52
47
) -> Result(Nil, PocketenvError) {
···
56
51
#(
57
52
"file",
58
53
json.object([
59
-
#("sandboxId", json.string(sandbox_id)),
54
+
#("sandboxId", json.string(sb.data.id)),
60
55
#("path", json.string(path)),
61
56
#("content", json.string(content)),
62
57
]),
···
64
59
]),
65
60
)
66
61
use _ <- result.try(do_post(
67
-
client,
62
+
sb.client,
68
63
"/xrpc/io.pocketenv.file.addFile",
69
64
[],
70
65
body,
···
73
68
}
74
69
75
70
/// Deletes the file identified by `id`.
76
-
pub fn delete(client: Client, id: String) -> Result(Nil, PocketenvError) {
71
+
pub fn delete(sb: ConnectedSandbox, id: String) -> Result(Nil, PocketenvError) {
77
72
use _ <- result.try(do_post(
78
-
client,
73
+
sb.client,
79
74
"/xrpc/io.pocketenv.file.deleteFile",
80
75
[#("id", id)],
81
76
"{}",
+27
-30
src/pocketenv/network.gleam
+27
-30
src/pocketenv/network.gleam
···
7
7
import gleam/json
8
8
import gleam/option.{type Option, None, Some}
9
9
import gleam/result
10
-
import pocketenv.{
11
-
type Client, type PocketenvError, JsonDecodeError, do_get, do_post,
12
-
}
10
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get, do_post}
11
+
import pocketenv/sandbox.{type ConnectedSandbox}
13
12
14
-
/// Exposes `port` on `sandbox_id` to the internet.
13
+
/// Exposes `port` on the sandbox to the internet.
15
14
/// Returns a preview URL if one is generated by the platform.
16
15
///
17
16
/// ## Example
18
17
///
19
18
/// ```gleam
20
-
/// let assert Ok(url) = network.expose(client, sandbox_id, 3000, Some("Dev server"))
21
-
/// io.debug(url) // Some("https://...")
19
+
/// let assert Ok(url) = sb |> network.expose(3000, Some("Dev server"))
22
20
/// ```
23
21
pub fn expose(
24
-
client: Client,
25
-
sandbox_id: String,
22
+
sb: ConnectedSandbox,
26
23
port: Int,
27
24
description: Option(String),
28
25
) -> Result(Option(String), PocketenvError) {
···
33
30
}
34
31
let body = json.to_string(json.object(fields))
35
32
use resp_body <- result.try(do_post(
36
-
client,
33
+
sb.client,
37
34
"/xrpc/io.pocketenv.sandbox.exposePort",
38
-
[#("id", sandbox_id)],
35
+
[#("id", sb.data.id)],
39
36
body,
40
37
))
41
38
json.parse(resp_body, {
···
49
46
|> result.map_error(JsonDecodeError)
50
47
}
51
48
52
-
/// Removes the public exposure of `port` on `sandbox_id`.
49
+
/// Removes the public exposure of `port` on the sandbox.
53
50
///
54
51
/// ## Example
55
52
///
56
53
/// ```gleam
57
-
/// let assert Ok(Nil) = network.unexpose(client, sandbox_id, 3000)
54
+
/// let assert Ok(Nil) = sb |> network.unexpose(3000)
58
55
/// ```
59
-
pub fn unexpose(
60
-
client: Client,
61
-
sandbox_id: String,
62
-
port: Int,
63
-
) -> Result(Nil, PocketenvError) {
56
+
pub fn unexpose(sb: ConnectedSandbox, port: Int) -> Result(Nil, PocketenvError) {
64
57
let body = json.to_string(json.object([#("port", json.int(port))]))
65
58
use _ <- result.try(do_post(
66
-
client,
59
+
sb.client,
67
60
"/xrpc/io.pocketenv.sandbox.unexposePort",
68
-
[#("id", sandbox_id)],
61
+
[#("id", sb.data.id)],
69
62
body,
70
63
))
71
64
Ok(Nil)
72
65
}
73
66
74
-
/// Stores a Tailscale auth key for `sandbox_id`, enabling private network access.
67
+
/// Stores a Tailscale auth key for the sandbox, enabling private network access.
75
68
///
76
69
/// ## Example
77
70
///
78
71
/// ```gleam
79
-
/// let assert Ok(Nil) = network.setup_tailscale(client, sandbox_id, "tskey-auth-xxxx")
72
+
/// let assert Ok(Nil) = sb |> network.setup_tailscale("tskey-auth-xxxx")
80
73
/// ```
81
74
pub fn setup_tailscale(
82
-
client: Client,
83
-
sandbox_id: String,
75
+
sb: ConnectedSandbox,
84
76
auth_key: String,
85
77
) -> Result(Nil, PocketenvError) {
86
78
let body =
87
79
json.to_string(json.object([#("tailscaleAuthKey", json.string(auth_key))]))
88
80
use _ <- result.try(do_post(
89
-
client,
81
+
sb.client,
90
82
"/xrpc/io.pocketenv.sandbox.putTailscaleAuthKey",
91
-
[#("id", sandbox_id)],
83
+
[#("id", sb.data.id)],
92
84
body,
93
85
))
94
86
Ok(Nil)
95
87
}
96
88
97
-
/// Retrieves the stored Tailscale auth key for `sandbox_id`, if any.
89
+
/// Retrieves the stored Tailscale auth key for the sandbox, if any.
90
+
///
91
+
/// ## Example
92
+
///
93
+
/// ```gleam
94
+
/// let assert Ok(key) = sb |> network.get_tailscale_auth_key()
95
+
/// ```
98
96
pub fn get_tailscale_auth_key(
99
-
client: Client,
100
-
sandbox_id: String,
97
+
sb: ConnectedSandbox,
101
98
) -> Result(Option(String), PocketenvError) {
102
99
use body <- result.try(
103
-
do_get(client, "/xrpc/io.pocketenv.sandbox.getTailscaleAuthKey", [
104
-
#("id", sandbox_id),
100
+
do_get(sb.client, "/xrpc/io.pocketenv.sandbox.getTailscaleAuthKey", [
101
+
#("id", sb.data.id),
105
102
]),
106
103
)
107
104
json.parse(body, {
+7
-9
src/pocketenv/ports.gleam
+7
-9
src/pocketenv/ports.gleam
···
6
6
import gleam/json
7
7
import gleam/option.{type Option, None}
8
8
import gleam/result
9
-
import pocketenv.{type Client, type PocketenvError, JsonDecodeError, do_get}
9
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get}
10
+
import pocketenv/sandbox.{type ConnectedSandbox}
10
11
11
12
/// An exposed port on a sandbox.
12
13
pub type Port {
13
14
Port(port: Int, description: Option(String), preview_url: Option(String))
14
15
}
15
16
16
-
/// Lists all currently exposed ports for `sandbox_id`.
17
+
/// Lists all currently exposed ports for the sandbox.
17
18
///
18
19
/// ## Example
19
20
///
20
21
/// ```gleam
21
-
/// let assert Ok(ports) = ports.list(client, sandbox_id)
22
+
/// let assert Ok(ports) = sb |> ports.list()
22
23
/// ```
23
-
pub fn list(
24
-
client: Client,
25
-
sandbox_id: String,
26
-
) -> Result(List(Port), PocketenvError) {
24
+
pub fn list(sb: ConnectedSandbox) -> Result(List(Port), PocketenvError) {
27
25
use body <- result.try(
28
-
do_get(client, "/xrpc/io.pocketenv.sandbox.getExposedPorts", [
29
-
#("id", sandbox_id),
26
+
do_get(sb.client, "/xrpc/io.pocketenv.sandbox.getExposedPorts", [
27
+
#("id", sb.data.id),
30
28
]),
31
29
)
32
30
json.parse(body, {
+14
-17
src/pocketenv/secrets.gleam
+14
-17
src/pocketenv/secrets.gleam
···
10
10
import gleam/list
11
11
import gleam/option.{type Option, None, Some}
12
12
import gleam/result
13
-
import pocketenv.{
14
-
type Client, type PocketenvError, JsonDecodeError, do_get, do_post,
15
-
}
13
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get, do_post}
14
+
import pocketenv/sandbox.{type ConnectedSandbox}
16
15
17
16
/// A secret stored in a sandbox. Only the `name` is exposed; the value is never returned.
18
17
pub type Secret {
19
18
Secret(id: String, name: String, created_at: String)
20
19
}
21
20
22
-
/// Lists secret names for `sandbox_id`. Optionally paginate with `limit` and `offset`.
21
+
/// Lists secret names for the sandbox. Optionally paginate with `limit` and `offset`.
23
22
///
24
23
/// ## Example
25
24
///
26
25
/// ```gleam
27
-
/// let assert Ok(secrets) = secrets.list(client, sandbox_id, None, None)
26
+
/// let assert Ok(secrets) = sb |> secrets.list(None, None)
28
27
/// ```
29
28
pub fn list(
30
-
client: Client,
31
-
sandbox_id: String,
29
+
sb: ConnectedSandbox,
32
30
limit: Option(Int),
33
31
offset: Option(Int),
34
32
) -> Result(List(Secret), PocketenvError) {
35
-
let query = [#("sandboxId", sandbox_id)]
33
+
let query = [#("sandboxId", sb.data.id)]
36
34
let query = case limit {
37
35
Some(l) -> list.append(query, [#("limit", int.to_string(l))])
38
36
None -> query
···
42
40
None -> query
43
41
}
44
42
use body <- result.try(do_get(
45
-
client,
43
+
sb.client,
46
44
"/xrpc/io.pocketenv.secret.getSecrets",
47
45
query,
48
46
))
···
53
51
|> result.map_error(JsonDecodeError)
54
52
}
55
53
56
-
/// Creates or updates a secret named `name` with `value` in `sandbox_id`.
54
+
/// Creates or updates a secret named `name` with `value`.
57
55
///
58
56
/// ## Example
59
57
///
60
58
/// ```gleam
61
-
/// let assert Ok(Nil) = secrets.put(client, sandbox_id, "DB_PASSWORD", "s3cr3t")
59
+
/// let assert Ok(Nil) = sb |> secrets.put("DB_PASSWORD", "s3cr3t")
62
60
/// ```
63
61
pub fn put(
64
-
client: Client,
65
-
sandbox_id: String,
62
+
sb: ConnectedSandbox,
66
63
name: String,
67
64
value: String,
68
65
) -> Result(Nil, PocketenvError) {
···
72
69
#(
73
70
"secret",
74
71
json.object([
75
-
#("sandboxId", json.string(sandbox_id)),
72
+
#("sandboxId", json.string(sb.data.id)),
76
73
#("name", json.string(name)),
77
74
#("value", json.string(value)),
78
75
]),
···
80
77
]),
81
78
)
82
79
use _ <- result.try(do_post(
83
-
client,
80
+
sb.client,
84
81
"/xrpc/io.pocketenv.secret.addSecret",
85
82
[],
86
83
body,
···
89
86
}
90
87
91
88
/// Deletes the secret identified by `id`.
92
-
pub fn delete(client: Client, id: String) -> Result(Nil, PocketenvError) {
89
+
pub fn delete(sb: ConnectedSandbox, id: String) -> Result(Nil, PocketenvError) {
93
90
use _ <- result.try(do_post(
94
-
client,
91
+
sb.client,
95
92
"/xrpc/io.pocketenv.secret.deleteSecret",
96
93
[#("id", id)],
97
94
"{}",
+29
-25
src/pocketenv/services.gleam
+29
-25
src/pocketenv/services.gleam
···
8
8
import gleam/list
9
9
import gleam/option.{type Option, None, Some}
10
10
import gleam/result
11
-
import pocketenv.{
12
-
type Client, type PocketenvError, JsonDecodeError, do_get, do_post,
13
-
}
11
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get, do_post}
12
+
import pocketenv/sandbox.{type ConnectedSandbox}
14
13
15
14
/// A service running (or registered to run) inside a sandbox.
16
15
pub type Service {
···
25
24
)
26
25
}
27
26
28
-
/// Lists all services registered in `sandbox_id`.
27
+
/// Lists all services registered in the sandbox.
29
28
///
30
29
/// ## Example
31
30
///
32
31
/// ```gleam
33
-
/// let assert Ok(svcs) = services.list(client, sandbox_id)
32
+
/// let assert Ok(svcs) = sb |> services.list()
34
33
/// ```
35
-
pub fn list(
36
-
client: Client,
37
-
sandbox_id: String,
38
-
) -> Result(List(Service), PocketenvError) {
34
+
pub fn list(sb: ConnectedSandbox) -> Result(List(Service), PocketenvError) {
39
35
use body <- result.try(
40
-
do_get(client, "/xrpc/io.pocketenv.service.getServices", [
41
-
#("sandboxId", sandbox_id),
36
+
do_get(sb.client, "/xrpc/io.pocketenv.service.getServices", [
37
+
#("sandboxId", sb.data.id),
42
38
]),
43
39
)
44
40
json.parse(body, {
···
48
44
|> result.map_error(JsonDecodeError)
49
45
}
50
46
51
-
/// Registers a new service in `sandbox_id`.
47
+
/// Registers a new service in the sandbox.
52
48
///
53
49
/// - `name` — unique name for the service
54
50
/// - `command` — shell command to run
···
59
55
///
60
56
/// ```gleam
61
57
/// let assert Ok(Nil) =
62
-
/// services.create(client, sandbox_id, "api", "node server.js", Some([3000]), None)
58
+
/// sb |> services.create("api", "node server.js", Some([3000]), None)
63
59
/// ```
64
60
pub fn create(
65
-
client: Client,
66
-
sandbox_id: String,
61
+
sb: ConnectedSandbox,
67
62
name: String,
68
63
command: String,
69
64
ports: Option(List(Int)),
···
85
80
let body =
86
81
json.to_string(json.object([#("service", json.object(service_fields))]))
87
82
use _ <- result.try(do_post(
88
-
client,
83
+
sb.client,
89
84
"/xrpc/io.pocketenv.service.addService",
90
-
[#("sandboxId", sandbox_id)],
85
+
[#("sandboxId", sb.data.id)],
91
86
body,
92
87
))
93
88
Ok(Nil)
94
89
}
95
90
96
91
/// Starts the service identified by `service_id`.
97
-
pub fn start(client: Client, service_id: String) -> Result(Nil, PocketenvError) {
92
+
pub fn start(
93
+
sb: ConnectedSandbox,
94
+
service_id: String,
95
+
) -> Result(Nil, PocketenvError) {
98
96
use _ <- result.try(do_post(
99
-
client,
97
+
sb.client,
100
98
"/xrpc/io.pocketenv.service.startService",
101
99
[#("serviceId", service_id)],
102
100
"{}",
···
105
103
}
106
104
107
105
/// Stops the service identified by `service_id`.
108
-
pub fn stop(client: Client, service_id: String) -> Result(Nil, PocketenvError) {
106
+
pub fn stop(
107
+
sb: ConnectedSandbox,
108
+
service_id: String,
109
+
) -> Result(Nil, PocketenvError) {
109
110
use _ <- result.try(do_post(
110
-
client,
111
+
sb.client,
111
112
"/xrpc/io.pocketenv.service.stopService",
112
113
[#("serviceId", service_id)],
113
114
"{}",
···
117
118
118
119
/// Restarts the service identified by `service_id`.
119
120
pub fn restart(
120
-
client: Client,
121
+
sb: ConnectedSandbox,
121
122
service_id: String,
122
123
) -> Result(Nil, PocketenvError) {
123
124
use _ <- result.try(do_post(
124
-
client,
125
+
sb.client,
125
126
"/xrpc/io.pocketenv.service.restartService",
126
127
[#("serviceId", service_id)],
127
128
"{}",
···
130
131
}
131
132
132
133
/// Deletes the service identified by `service_id`.
133
-
pub fn delete(client: Client, service_id: String) -> Result(Nil, PocketenvError) {
134
+
pub fn delete(
135
+
sb: ConnectedSandbox,
136
+
service_id: String,
137
+
) -> Result(Nil, PocketenvError) {
134
138
use _ <- result.try(do_post(
135
-
client,
139
+
sb.client,
136
140
"/xrpc/io.pocketenv.service.deleteService",
137
141
[#("serviceId", service_id)],
138
142
"{}",
+14
-19
src/pocketenv/volume.gleam
+14
-19
src/pocketenv/volume.gleam
···
5
5
import gleam/dynamic/decode
6
6
import gleam/json
7
7
import gleam/result
8
-
import pocketenv.{
9
-
type Client, type PocketenvError, JsonDecodeError, do_get, do_post,
10
-
}
8
+
import pocketenv.{type PocketenvError, JsonDecodeError, do_get, do_post}
9
+
import pocketenv/sandbox.{type ConnectedSandbox}
11
10
12
11
/// A persistent volume mounted in a sandbox.
13
12
pub type Volume {
14
13
Volume(id: String, name: String, path: String, created_at: String)
15
14
}
16
15
17
-
/// Lists all volumes attached to `sandbox_id`.
16
+
/// Lists all volumes attached to the sandbox.
18
17
///
19
18
/// ## Example
20
19
///
21
20
/// ```gleam
22
-
/// let assert Ok(vols) = volume.list(client, sandbox_id)
21
+
/// let assert Ok(vols) = sb |> volume.list()
23
22
/// ```
24
-
pub fn list(
25
-
client: Client,
26
-
sandbox_id: String,
27
-
) -> Result(List(Volume), PocketenvError) {
23
+
pub fn list(sb: ConnectedSandbox) -> Result(List(Volume), PocketenvError) {
28
24
use body <- result.try(
29
-
do_get(client, "/xrpc/io.pocketenv.volume.getVolumes", [
30
-
#("sandboxId", sandbox_id),
25
+
do_get(sb.client, "/xrpc/io.pocketenv.volume.getVolumes", [
26
+
#("sandboxId", sb.data.id),
31
27
]),
32
28
)
33
29
json.parse(body, {
···
37
33
|> result.map_error(JsonDecodeError)
38
34
}
39
35
40
-
/// Creates a volume named `name` mounted at `path` in `sandbox_id`.
36
+
/// Creates a volume named `name` mounted at `path`.
41
37
///
42
38
/// ## Example
43
39
///
44
40
/// ```gleam
45
-
/// let assert Ok(Nil) = volume.create(client, sandbox_id, "data", "/mnt/data")
41
+
/// let assert Ok(Nil) = sb |> volume.create("data", "/mnt/data")
46
42
/// ```
47
43
pub fn create(
48
-
client: Client,
49
-
sandbox_id: String,
44
+
sb: ConnectedSandbox,
50
45
name: String,
51
46
path: String,
52
47
) -> Result(Nil, PocketenvError) {
···
56
51
#(
57
52
"volume",
58
53
json.object([
59
-
#("sandboxId", json.string(sandbox_id)),
54
+
#("sandboxId", json.string(sb.data.id)),
60
55
#("name", json.string(name)),
61
56
#("path", json.string(path)),
62
57
]),
···
64
59
]),
65
60
)
66
61
use _ <- result.try(do_post(
67
-
client,
62
+
sb.client,
68
63
"/xrpc/io.pocketenv.volume.addVolume",
69
64
[],
70
65
body,
···
73
68
}
74
69
75
70
/// Deletes the volume identified by `id`.
76
-
pub fn delete(client: Client, id: String) -> Result(Nil, PocketenvError) {
71
+
pub fn delete(sb: ConnectedSandbox, id: String) -> Result(Nil, PocketenvError) {
77
72
use _ <- result.try(do_post(
78
-
client,
73
+
sb.client,
79
74
"/xrpc/io.pocketenv.volume.deleteVolume",
80
75
[#("id", id)],
81
76
"{}",