@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 101 lines 3.67 KB
Raw
1 import type { GcpOpContext } from "@distilled.cloud/gcp/Protocol";
2 import type { Input } from "alchemy/Input";
3 import * as Output from "alchemy/Output";
4 import * as Effect from "effect/Effect";
5 import * as GCPBindings from "./GCPBindings.ts";
6 import { type GcpIamGrant } from "./Host.ts";
7 import type { GcpIamResourceKind } from "./IamPolicy.ts";
8
9 /**
10 * Distilled ops are `OperationMethod`s: resolve them once at Layer
11 * construction through `GCPBindings.withCredentials`, so the inner runtime
12 * Effect is `Effect<A, E>` and does not leak `GcpOpContext`. On a host that
13 * runs as a service account its Layer provides Credentials/HttpClient; on
14 * any other host `withCredentials` provides them from the created key.
15 */
16 export type GcpHttpOp<I, A, E> = Effect.Effect<
17 (input: I) => Effect.Effect<A, E>,
18 never,
19 GcpOpContext
20 > &
21 ((input: I) => Effect.Effect<A, E, GcpOpContext>);
22
23 /**
24 * IAM a binding grants the host's runtime service account on the bound
25 * resource: `role` is the narrowest predefined role covering the
26 * operation. With `on`, the role is granted on the bound resource's own
27 * IAM policy (resource-scoped, like an AWS statement's `Resource: [arn]`);
28 * without it — only for services that have no resource-level IAM — the
29 * role is granted on the project.
30 */
31 export interface BindingIam {
32 role: string;
33 on?: Exclude<GcpIamResourceKind, "project">;
34 /**
35 * For services with no per-resource IAM policy but IAM Conditions
36 * support (Firestore, Cloud SQL, Managed Kafka): grant on the project
37 * under a condition matching only the bound resource and its children.
38 */
39 scopeByCondition?: boolean;
40 }
41
42 const nameExpression = (value: string) =>
43 `resource.name == "${value}" || resource.name.startsWith("${value}/")`;
44
45 /** IAM Condition matching one resource (by full name) and its children. */
46 export const resourceNameCondition = (name: Input<string>) => ({
47 title: "alchemy-scoped",
48 expression:
49 typeof name === "string"
50 ? nameExpression(name)
51 : Output.map(name as Output.Output<string>, nameExpression),
52 });
53
54 /** Build the grant for `iam` against a bound resource's full name. */
55 export const grantFor = (iam: BindingIam, name: Input<string>): Input<GcpIamGrant> =>
56 iam.on !== undefined
57 ? // The engine resolves the name Output before the host reconciles.
58 { role: iam.role, resource: { kind: iam.on, name } }
59 : iam.scopeByCondition
60 ? { role: iam.role, condition: resourceNameCondition(name) }
61 : { role: iam.role };
62
63 /**
64 * Shared HTTP scaffolding for GCP named-resource bindings.
65 *
66 * Yields the distilled operation (no double-provide) and, at deploy
67 * time, grants `iam` on the ambient Cloud Run / Function host the way
68 * AWS bindings attach IAM policy statements.
69 */
70 export const makeNamedHttpBinding = <
71 Resource extends { LogicalId: string },
72 I extends { name?: string },
73 A,
74 E,
75 >(options: {
76 tag: string;
77 operation: GcpHttpOp<I, A, E>;
78 iam: BindingIam;
79 resourceName: (resource: Resource) => Output.Output<string, never>;
80 }) =>
81 Effect.gen(function* () {
82 const bind = yield* GCPBindings.Bind;
83 const run = yield* GCPBindings.withCredentials(options.operation);
84 return Effect.fn(function* (resource: Resource) {
85 const resourceName = options.resourceName(resource);
86 if (!globalThis.__ALCHEMY_RUNTIME__) {
87 yield* bind`${options.tag}(${resource})`({
88 iam: [grantFor(options.iam, resourceName)],
89 });
90 }
91 const name = yield* resourceName;
92 return Effect.fn(`${options.tag}(${resource.LogicalId})`)(function* (
93 request?: Omit<I, "name">,
94 ) {
95 return yield* run({
96 ...request,
97 name: yield* name,
98 } as I);
99 });
100 });
101 });