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, 06:00 UTC
| 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 | ); |