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

main
ts 346 lines 13.6 KB
Raw
1 import * as IdentityCenter from "@alchemy.run/aws/IdentityCenter";
2 import * as Lambda from "@alchemy.run/aws/Lambda";
3 import * as Duration from "effect/Duration";
4 import * as Effect from "effect/Effect";
5 import { HttpServerRequest } from "effect/http/HttpServerRequest";
6 import * as HttpServerResponse from "effect/http/HttpServerResponse";
7 import * as Layer from "effect/Layer";
8 import * as Redacted from "effect/Redacted";
9 import * as Result from "effect/Result";
10 import path from "pathe";
11
12 const main = path.resolve(import.meta.dirname, "handler.ts");
13
14 export class IdentityCenterBindingsFunction extends Lambda.Function<Lambda.Function>()(
15 "IdentityCenterBindingsFunction",
16 ) {}
17
18 /**
19 * Lambda fixture exercising every IdentityCenter runtime binding against the
20 * account's (pre-enabled) Identity Center instance. Deploying this fixture
21 * requires an enabled instance, so the E2E suite that drives it is gated
22 * behind ALCHEMY_TEST_IDENTITY_CENTER=1 (see Bindings.test.ts).
23 */
24 export default IdentityCenterBindingsFunction.make(
25 {
26 main,
27 functionUrl: true,
28 timeout: Duration.seconds(60),
29 },
30 Effect.gen(function* () {
31 const instance = yield* IdentityCenter.Instance("IdcInstance", {
32 mode: "existing",
33 });
34 const group = yield* IdentityCenter.Group("IdcBindingsGroup", {
35 identityStoreId: instance.identityStoreId,
36 displayName: "alchemy-idc-bindings-group",
37 description: "Group used by the IdentityCenter Bindings E2E fixture",
38 });
39 const permissionSet = yield* IdentityCenter.PermissionSet("IdcBindingsPermissionSet", {
40 instanceArn: instance.instanceArn,
41 name: "AlchemyIdcBindings",
42 description: "Permission set used by the Bindings E2E fixture",
43 sessionDuration: "1 hour",
44 });
45
46 // Identity Store data plane
47 const createUser = yield* IdentityCenter.CreateUser(instance);
48 const updateUser = yield* IdentityCenter.UpdateUser(instance);
49 const deleteUser = yield* IdentityCenter.DeleteUser(instance);
50 const describeUser = yield* IdentityCenter.DescribeUser(instance);
51 const getUserId = yield* IdentityCenter.GetUserId(instance);
52 const listUsers = yield* IdentityCenter.ListUsers(instance);
53 const getGroupId = yield* IdentityCenter.GetGroupId(instance);
54 const listGroups = yield* IdentityCenter.ListGroups(instance);
55 const createGroupMembership = yield* IdentityCenter.CreateGroupMembership(instance);
56 const deleteGroupMembership = yield* IdentityCenter.DeleteGroupMembership(instance);
57 const describeGroupMembership = yield* IdentityCenter.DescribeGroupMembership(instance);
58 const getGroupMembershipId = yield* IdentityCenter.GetGroupMembershipId(instance);
59 const listGroupMemberships = yield* IdentityCenter.ListGroupMemberships(instance);
60 const listGroupMembershipsForMember =
61 yield* IdentityCenter.ListGroupMembershipsForMember(instance);
62 const isMemberInGroups = yield* IdentityCenter.IsMemberInGroups(instance);
63
64 // sso-admin audit reads
65 const listAccountAssignments = yield* IdentityCenter.ListAccountAssignments(instance);
66 const listAccountAssignmentsForPrincipal =
67 yield* IdentityCenter.ListAccountAssignmentsForPrincipal(instance);
68 const listAccountsForProvisionedPermissionSet =
69 yield* IdentityCenter.ListAccountsForProvisionedPermissionSet(instance);
70 const listPermissionSets = yield* IdentityCenter.ListPermissionSets(instance);
71 const describePermissionSet = yield* IdentityCenter.DescribePermissionSet(instance);
72
73 const groupId = yield* group.groupId;
74 const permissionSetArn = yield* permissionSet.permissionSetArn;
75
76 const bound = {
77 createUser,
78 updateUser,
79 deleteUser,
80 describeUser,
81 getUserId,
82 listUsers,
83 getGroupId,
84 listGroups,
85 createGroupMembership,
86 deleteGroupMembership,
87 describeGroupMembership,
88 getGroupMembershipId,
89 listGroupMemberships,
90 listGroupMembershipsForMember,
91 isMemberInGroups,
92 listAccountAssignments,
93 listAccountAssignmentsForPrincipal,
94 listAccountsForProvisionedPermissionSet,
95 listPermissionSets,
96 describePermissionSet,
97 };
98
99 const TEST_USER_NAME = "alchemy-idc-bindings-user";
100
101 /**
102 * distilled types Identity Store PII (user names, display names) as
103 * sensitive (`string | Redacted<string>`); unwrap before JSON-encoding
104 * so the E2E assertions see the plain value.
105 */
106 const unwrap = (value: string | Redacted.Redacted<string> | undefined): string | undefined =>
107 Redacted.isRedacted(value) ? Redacted.value(value) : value;
108
109 /**
110 * Create the deterministic test user, tolerating a leftover from a
111 * previously crashed run by resolving the existing user's id instead.
112 */
113 const ensureTestUser = Effect.gen(function* () {
114 const created = yield* Effect.result(
115 createUser({
116 UserName: TEST_USER_NAME,
117 DisplayName: "Alchemy Bindings Test User",
118 Name: { GivenName: "Alchemy", FamilyName: "Test" },
119 Emails: [{ Value: "alchemy-idc-test@example.com", Primary: true }],
120 }),
121 );
122 if (Result.isSuccess(created) && created.success.UserId) {
123 return created.success.UserId;
124 }
125 const { UserId } = yield* getUserId({
126 AlternateIdentifier: {
127 UniqueAttribute: {
128 AttributePath: "userName",
129 AttributeValue: TEST_USER_NAME,
130 },
131 },
132 });
133 return UserId!;
134 });
135
136 return {
137 fetch: Effect.gen(function* () {
138 const request = yield* HttpServerRequest;
139 const url = new URL(request.originalUrl);
140 const pathname = url.pathname;
141
142 if (request.method === "GET" && pathname === "/bindings") {
143 return yield* HttpServerResponse.json({
144 bound: Object.keys(bound),
145 });
146 }
147
148 if (request.method === "GET" && pathname === "/groups") {
149 const { Groups } = yield* listGroups({ MaxResults: 50 });
150 return yield* HttpServerResponse.json({
151 displayNames: (Groups ?? []).map((g) => unwrap(g.DisplayName)),
152 });
153 }
154
155 if (request.method === "GET" && pathname === "/users") {
156 const { Users } = yield* listUsers({ MaxResults: 50 });
157 return yield* HttpServerResponse.json({
158 userNames: (Users ?? []).map((u) => unwrap(u.UserName)),
159 });
160 }
161
162 if (request.method === "GET" && pathname === "/group-id") {
163 const { GroupId } = yield* getGroupId({
164 AlternateIdentifier: {
165 UniqueAttribute: {
166 AttributePath: "displayName",
167 AttributeValue: "alchemy-idc-bindings-group",
168 },
169 },
170 });
171 return yield* HttpServerResponse.json({
172 groupId: GroupId,
173 matchesBoundGroup: GroupId === (yield* groupId),
174 });
175 }
176
177 // Full user lifecycle: create -> getUserId -> describe -> update ->
178 // describe -> delete. Deterministic user name; a leftover user from
179 // a crashed run is adopted instead of failing.
180 if (request.method === "POST" && pathname === "/user-roundtrip") {
181 const userId = yield* ensureTestUser;
182 const { UserId: resolvedId } = yield* getUserId({
183 AlternateIdentifier: {
184 UniqueAttribute: {
185 AttributePath: "userName",
186 AttributeValue: TEST_USER_NAME,
187 },
188 },
189 });
190 const before = yield* describeUser({ UserId: userId });
191 yield* updateUser({
192 UserId: userId,
193 Operations: [
194 {
195 AttributePath: "displayName",
196 AttributeValue: "Alchemy Bindings Test User (updated)",
197 },
198 ],
199 });
200 const after = yield* describeUser({ UserId: userId });
201 yield* deleteUser({ UserId: userId });
202 return yield* HttpServerResponse.json({
203 userId,
204 resolvedMatches: resolvedId === userId,
205 userName: unwrap(before.UserName),
206 displayNameBefore: unwrap(before.DisplayName),
207 displayNameAfter: unwrap(after.DisplayName),
208 });
209 }
210
211 // Full membership lifecycle against the fixture group: create user,
212 // add to group, resolve/describe/query the membership, check
213 // isMemberInGroups, then tear everything down.
214 if (request.method === "POST" && pathname === "/membership-roundtrip") {
215 const GroupId = yield* groupId;
216 const userId = yield* ensureTestUser;
217 const { MembershipId } = yield* createGroupMembership({
218 GroupId,
219 MemberId: { UserId: userId },
220 });
221 const resolved = yield* getGroupMembershipId({
222 GroupId,
223 MemberId: { UserId: userId },
224 });
225 const described = yield* describeGroupMembership({
226 MembershipId: MembershipId!,
227 });
228 const members = yield* listGroupMemberships({ GroupId });
229 const groupsOfUser = yield* listGroupMembershipsForMember({
230 MemberId: { UserId: userId },
231 });
232 const check = yield* isMemberInGroups({
233 MemberId: { UserId: userId },
234 GroupIds: [GroupId],
235 });
236 yield* deleteGroupMembership({ MembershipId: MembershipId! });
237 const checkAfter = yield* isMemberInGroups({
238 MemberId: { UserId: userId },
239 GroupIds: [GroupId],
240 });
241 yield* deleteUser({ UserId: userId });
242 return yield* HttpServerResponse.json({
243 membershipId: MembershipId,
244 resolvedMatches: resolved.MembershipId === MembershipId,
245 describedGroupMatches: described.GroupId === GroupId,
246 memberCount: (members.GroupMemberships ?? []).length,
247 memberOfCount: (groupsOfUser.GroupMemberships ?? []).length,
248 isMember: check.Results?.[0]?.MembershipExists === true,
249 isMemberAfterDelete: checkAfter.Results?.[0]?.MembershipExists === true,
250 });
251 }
252
253 if (request.method === "GET" && pathname === "/permission-sets") {
254 const arn = yield* permissionSetArn;
255 const { PermissionSets } = yield* listPermissionSets({
256 MaxResults: 100,
257 });
258 const { PermissionSet } = yield* describePermissionSet({
259 PermissionSetArn: arn,
260 });
261 const { AccountIds } = yield* listAccountsForProvisionedPermissionSet({
262 PermissionSetArn: arn,
263 });
264 return yield* HttpServerResponse.json({
265 containsFixturePermissionSet: (PermissionSets ?? []).includes(arn),
266 name: PermissionSet?.Name,
267 sessionDuration: PermissionSet?.SessionDuration,
268 provisionedAccounts: AccountIds ?? [],
269 });
270 }
271
272 // Assignment audit reads. `listAccountAssignmentsForPrincipal` is
273 // only valid on organization instances (from the management
274 // account), so its failure tag is reported rather than crashing the
275 // route. `listAccountAssignments` needs a target account id, passed
276 // as ?accountId=.
277 if (request.method === "GET" && pathname === "/assignments") {
278 const GroupId = yield* groupId;
279 const arn = yield* permissionSetArn;
280 const forPrincipal = yield* Effect.result(
281 listAccountAssignmentsForPrincipal({
282 PrincipalId: GroupId,
283 PrincipalType: "GROUP",
284 }),
285 );
286 const accountId = url.searchParams.get("accountId");
287 const direct = accountId
288 ? yield* Effect.result(
289 listAccountAssignments({
290 AccountId: accountId,
291 PermissionSetArn: arn,
292 }),
293 )
294 : undefined;
295 return yield* HttpServerResponse.json({
296 forPrincipal: Result.isSuccess(forPrincipal)
297 ? {
298 ok: true,
299 count: (forPrincipal.success.AccountAssignments ?? []).length,
300 }
301 : { ok: false, errorTag: forPrincipal.failure._tag },
302 direct:
303 direct === undefined
304 ? undefined
305 : Result.isSuccess(direct)
306 ? {
307 ok: true,
308 count: (direct.success.AccountAssignments ?? []).length,
309 }
310 : { ok: false, errorTag: direct.failure._tag },
311 });
312 }
313
314 return yield* HttpServerResponse.json(
315 { error: "Not found", method: request.method, pathname },
316 { status: 404 },
317 );
318 }).pipe(Effect.orDie),
319 };
320 }).pipe(
321 Effect.provide(
322 Layer.mergeAll(
323 IdentityCenter.CreateUserHttp,
324 IdentityCenter.UpdateUserHttp,
325 IdentityCenter.DeleteUserHttp,
326 IdentityCenter.DescribeUserHttp,
327 IdentityCenter.GetUserIdHttp,
328 IdentityCenter.ListUsersHttp,
329 IdentityCenter.GetGroupIdHttp,
330 IdentityCenter.ListGroupsHttp,
331 IdentityCenter.CreateGroupMembershipHttp,
332 IdentityCenter.DeleteGroupMembershipHttp,
333 IdentityCenter.DescribeGroupMembershipHttp,
334 IdentityCenter.GetGroupMembershipIdHttp,
335 IdentityCenter.ListGroupMembershipsHttp,
336 IdentityCenter.ListGroupMembershipsForMemberHttp,
337 IdentityCenter.IsMemberInGroupsHttp,
338 IdentityCenter.ListAccountAssignmentsHttp,
339 IdentityCenter.ListAccountAssignmentsForPrincipalHttp,
340 IdentityCenter.ListAccountsForProvisionedPermissionSetHttp,
341 IdentityCenter.ListPermissionSetsHttp,
342 IdentityCenter.DescribePermissionSetHttp,
343 ),
344 ),
345 ),
346 );