@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 131 lines 4.86 KB
Raw
1 import * as Namespace from "alchemy/Namespace";
2 import * as Effect from "effect/Effect";
3 import * as Layer from "effect/Layer";
4 import type { UserPool, UserPoolTriggerName } from "../Cognito/UserPool.ts";
5 import {
6 UserPoolTriggerEventSource as CognitoUserPoolTriggerEventSource,
7 type UserPoolTriggerEvent,
8 type UserPoolTriggerEventSourceService,
9 type UserPoolTriggerHandler,
10 type UserPoolTriggerProps,
11 userPoolTriggerSourcePrefixes,
12 } from "../Cognito/UserPoolTriggerEventSource.ts";
13 import * as Lambda from "./Function.ts";
14 import { Permission as LambdaPermission } from "./Permission.ts";
15
16 /**
17 * The `version`/`triggerSource`/`userPoolId`/`request`/`response` envelope
18 * shared by every user pool Lambda trigger. Declared structurally —
19 * `@types/aws-lambda` keeps `BaseTriggerEvent` in an internal `_common`
20 * module that its package root does not re-export.
21 */
22 export interface UserPoolTriggerEnvelope {
23 version: string;
24 triggerSource: string;
25 region: string;
26 userPoolId: string;
27 userName?: string;
28 request: Record<string, unknown>;
29 response: Record<string, unknown>;
30 }
31
32 /**
33 * A Cognito user pool trigger invocation — the
34 * `version`/`triggerSource`/`userPoolId`/`request`/`response` envelope
35 * shared by every user pool Lambda trigger.
36 */
37 export const isUserPoolTriggerEvent = (event: any): event is UserPoolTriggerEnvelope =>
38 typeof event?.version === "string" &&
39 typeof event?.triggerSource === "string" &&
40 typeof event?.userPoolId === "string" &&
41 typeof event?.request === "object" &&
42 event?.request !== null &&
43 typeof event?.response === "object" &&
44 event?.response !== null;
45
46 /**
47 * Connects a Cognito user pool Lambda trigger to the current Lambda
48 * function.
49 *
50 * At deploy time this layer injects the function ARN into the pool's
51 * `LambdaConfig` through the pool's binding contract and materializes the
52 * `lambda:InvokeFunction` Permission for `cognito-idp.amazonaws.com`; at
53 * runtime it dispatches matching trigger events (matched on `userPoolId` +
54 * `triggerSource` prefix) to the registered handler and returns the
55 * handler's (mutated) event to Cognito.
56 * ### Handling user pool triggers
57 * **Example:** Auto-confirm sign-ups
58 * ```typescript
59 * yield* Cognito.onPreSignUp(pool, (event) =>
60 * Effect.sync(() => Cognito.autoConfirmUser(event, { verifyEmail: true })),
61 * );
62 * ```
63 *
64 * @binding
65 */
66 export const UserPoolTriggerEventSource = Layer.effect(
67 CognitoUserPoolTriggerEventSource,
68 Effect.gen(function* () {
69 // this layer can only be used in a Lambda Function
70 const host = yield* Lambda.eventSourceHost("AWS.Lambda.UserPoolTriggerEventSource");
71 const Permission = yield* LambdaPermission;
72
73 return Effect.fn(function* <T extends UserPoolTriggerName, Req = never>(
74 userPool: UserPool,
75 props: UserPoolTriggerProps<T>,
76 handler: UserPoolTriggerHandler<T, Req>,
77 ) {
78 const UserPoolId = yield* userPool.userPoolId;
79
80 // Deploy-time: inject this function's ARN into the pool's
81 // LambdaConfig (the pool's provider syncs it) and create the invoke
82 // Permission for cognito-idp. Skipped once running inside the
83 // deployed Function (the global guard), where the only work is
84 // registering the runtime dispatcher below. Namespaced under the
85 // host for stable logical identity.
86 if (!globalThis.__ALCHEMY_RUNTIME__) {
87 yield* Namespace.push(
88 host.LogicalId,
89 Effect.gen(function* () {
90 yield* userPool.bind`AWS.Cognito.UserPoolTrigger(${host}, ${userPool}, ${props.trigger})`(
91 {
92 lambdaConfig: { [props.trigger]: Lambda.qualifiedArnOf(host) },
93 },
94 );
95
96 yield* Permission(`${userPool.LogicalId}-${props.trigger}-Permission`, {
97 action: "lambda:InvokeFunction",
98 functionName: Lambda.qualifiedNameOf(host),
99 principal: "cognito-idp.amazonaws.com",
100 sourceArn: userPool.userPoolArn,
101 });
102 }),
103 );
104 }
105
106 yield* host.listen(
107 Effect.gen(function* () {
108 const userPoolId = yield* UserPoolId;
109 const prefix = userPoolTriggerSourcePrefixes[props.trigger];
110
111 return (event: any) => {
112 if (
113 isUserPoolTriggerEvent(event) &&
114 event.userPoolId === userPoolId &&
115 event.triggerSource.startsWith(prefix)
116 ) {
117 // Cognito triggers are request-response: the Lambda's return
118 // value (the event with a mutated `response`) IS the trigger
119 // response. `void` from the handler answers with the event
120 // as-is.
121 return handler(event as UserPoolTriggerEvent<T>).pipe(
122 Effect.map((result) => result ?? event),
123 Effect.orDie,
124 );
125 }
126 };
127 }),
128 );
129 }) as UserPoolTriggerEventSourceService;
130 }),
131 );