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

main
ts 300 lines 11.6 KB
Raw
1 import * as FraudDetector from "@alchemy.run/aws/FraudDetector";
2 import * as Lambda from "@alchemy.run/aws/Lambda";
3 import * as Output from "alchemy/Output";
4 import * as Duration from "effect/Duration";
5 import * as Effect from "effect/Effect";
6 import { HttpServerRequest } from "effect/http/HttpServerRequest";
7 import * as HttpServerResponse from "effect/http/HttpServerResponse";
8 import * as Layer from "effect/Layer";
9 import * as Redacted from "effect/Redacted";
10 import path from "pathe";
11
12 const main = path.resolve(import.meta.dirname, "handler.ts");
13
14 /** The email value the sample rule flags as high-risk. */
15 export const FRAUD_EMAIL = "fraud@example.com";
16 /** The outcome the sample rule returns on a match. */
17 export const REVIEW_OUTCOME = "alchemy_test_review";
18 /** The deny-list element the List resource seeds. */
19 export const SEED_BLOCKED_IP = "203.0.113.7";
20
21 export class FraudDetectorTestFunction extends Lambda.Function<Lambda.Function>()(
22 "FraudDetectorTestFunction",
23 ) {}
24
25 export default FraudDetectorTestFunction.make(
26 {
27 main,
28 functionUrl: true,
29 // getEventPrediction fans out over the detector's active version; give it
30 // headroom over the 3s default.
31 timeout: Duration.seconds(30),
32 },
33 Effect.gen(function* () {
34 // Build the whole rule-based detector: entity type + variables + outcome +
35 // event type + detector + an ACTIVE detector version with one rule. The
36 // Output wiring (eventVariables/entityTypes/eventTypeName/detectorId/rule
37 // outcomes) forces the deploy order EntityType/Variable/Outcome →
38 // EventType → Detector → DetectorVersion.
39 const customer = yield* FraudDetector.EntityType("Customer", {
40 description: "the buyer placing an order",
41 });
42 const email = yield* FraudDetector.Variable("Email", {
43 dataType: "STRING",
44 dataSource: "EVENT",
45 defaultValue: "unknown",
46 variableType: "EMAIL_ADDRESS",
47 });
48 const ip = yield* FraudDetector.Variable("Ip", {
49 dataType: "STRING",
50 dataSource: "EVENT",
51 defaultValue: "0.0.0.0",
52 variableType: "IP_ADDRESS",
53 });
54 const review = yield* FraudDetector.Outcome("Review", {
55 name: REVIEW_OUTCOME,
56 description: "send the event to manual review",
57 });
58 const fraudLabel = yield* FraudDetector.Label("Fraud", {
59 description: "confirmed fraudulent event",
60 });
61 const eventType = yield* FraudDetector.EventType("Purchase", {
62 eventVariables: [email.name, ip.name],
63 entityTypes: [customer.name],
64 labels: [fraudLabel.name],
65 // Stored-event ingestion powers the SendEvent/GetEvent/UpdateEventLabel/
66 // DeleteEvent data-plane round-trip.
67 eventIngestion: "ENABLED",
68 });
69 const detector = yield* FraudDetector.Detector("Checkout", {
70 eventTypeName: eventType.name,
71 description: "rule-based checkout fraud detector",
72 });
73 const blockedIps = yield* FraudDetector.List("BlockedIps", {
74 variableType: "IP_ADDRESS",
75 description: "known-fraud source addresses",
76 elements: [SEED_BLOCKED_IP],
77 });
78
79 // Runtime needs the resolved names to build the prediction request. The
80 // yields return Accessors that resolve to strings inside the handler.
81 const emailVar = yield* email.name;
82 const ipVar = yield* ip.name;
83 const entityTypeName = yield* customer.name;
84 const eventTypeName = yield* eventType.name;
85 const fraudLabelName = yield* fraudLabel.name;
86
87 yield* FraudDetector.DetectorVersion("V1", {
88 detectorId: detector.detectorId,
89 status: "ACTIVE",
90 ruleExecutionMode: "FIRST_MATCHED",
91 rules: [
92 {
93 ruleId: "high_risk",
94 expression: Output.map(email.name, (name) => `$${name} == "${FRAUD_EMAIL}"`),
95 outcomes: [review.name],
96 description: "flag a known-fraud email for review",
97 },
98 ],
99 });
100
101 const getEventPrediction = yield* FraudDetector.GetEventPrediction(detector);
102 const sendEvent = yield* FraudDetector.SendEvent(eventType);
103 const getEvent = yield* FraudDetector.GetEvent(eventType);
104 const updateEventLabel = yield* FraudDetector.UpdateEventLabel(eventType);
105 const deleteEvent = yield* FraudDetector.DeleteEvent(eventType);
106 const getListElements = yield* FraudDetector.GetListElements(blockedIps);
107 const updateList = yield* FraudDetector.UpdateList(blockedIps);
108 const listEventPredictions = yield* FraudDetector.ListEventPredictions(detector);
109 const getEventPredictionMetadata = yield* FraudDetector.GetEventPredictionMetadata(detector);
110 const deleteEventsByEventType = yield* FraudDetector.DeleteEventsByEventType(eventType);
111 const getDeleteEventsByEventTypeStatus =
112 yield* FraudDetector.GetDeleteEventsByEventTypeStatus(eventType);
113
114 return {
115 fetch: Effect.gen(function* () {
116 const request = yield* HttpServerRequest;
117 const url = new URL(request.originalUrl);
118 const pathname = url.pathname;
119
120 if (request.method === "GET" && pathname === "/health") {
121 return yield* HttpServerResponse.json({ ok: true });
122 }
123
124 if (request.method === "POST" && pathname === "/predict") {
125 const body = (yield* request.json) as {
126 email: string;
127 ip?: string;
128 entityId?: string;
129 eventId?: string;
130 };
131 const resolvedEventTypeName = yield* eventTypeName;
132 const resolvedEntityTypeName = yield* entityTypeName;
133 const emailVarName = yield* emailVar;
134 const ipVarName = yield* ipVar;
135 const result = yield* getEventPrediction({
136 eventId: body.eventId ?? `evt-${Date.now()}`,
137 eventTypeName: resolvedEventTypeName,
138 eventTimestamp: new Date().toISOString(),
139 entities: [
140 {
141 entityType: resolvedEntityTypeName,
142 entityId: body.entityId ?? "cust-1",
143 },
144 ],
145 eventVariables: {
146 [emailVarName]: body.email,
147 [ipVarName]: body.ip ?? "1.2.3.4",
148 },
149 });
150 const outcomes = (result.ruleResults ?? []).flatMap((r) => r.outcomes ?? []);
151 return yield* HttpServerResponse.json({
152 outcomes,
153 ruleResults: result.ruleResults ?? [],
154 });
155 }
156
157 if (request.method === "POST" && pathname === "/event") {
158 const body = (yield* request.json) as {
159 eventId: string;
160 email: string;
161 ip?: string;
162 entityId?: string;
163 };
164 const emailVarName = yield* emailVar;
165 const ipVarName = yield* ipVar;
166 yield* sendEvent({
167 eventId: body.eventId,
168 eventTimestamp: new Date().toISOString(),
169 entities: [
170 {
171 entityType: yield* entityTypeName,
172 entityId: body.entityId ?? "cust-1",
173 },
174 ],
175 eventVariables: {
176 [emailVarName]: body.email,
177 [ipVarName]: body.ip ?? "1.2.3.4",
178 },
179 });
180 return yield* HttpServerResponse.json({ ok: true });
181 }
182
183 if (request.method === "GET" && pathname === "/event") {
184 const eventId = url.searchParams.get("id")!;
185 // A deleted / not-yet-consistent event surfaces as a typed
186 // ResourceNotFoundException — report it as absent, not a 500.
187 const { event } = yield* getEvent({ eventId }).pipe(
188 Effect.catchTag("ResourceNotFoundException", () =>
189 Effect.succeed({ event: undefined }),
190 ),
191 );
192 return yield* HttpServerResponse.json({
193 found: event !== undefined,
194 currentLabel: event?.currentLabel,
195 });
196 }
197
198 if (request.method === "POST" && pathname === "/event/label") {
199 const body = (yield* request.json) as { eventId: string };
200 yield* updateEventLabel({
201 eventId: body.eventId,
202 assignedLabel: yield* fraudLabelName,
203 labelTimestamp: new Date().toISOString(),
204 });
205 return yield* HttpServerResponse.json({ ok: true });
206 }
207
208 if (request.method === "DELETE" && pathname === "/event") {
209 const eventId = url.searchParams.get("id")!;
210 yield* deleteEvent({ eventId, deleteAuditHistory: true });
211 return yield* HttpServerResponse.json({ ok: true });
212 }
213
214 if (request.method === "GET" && pathname === "/list") {
215 const { elements } = yield* getListElements({});
216 return yield* HttpServerResponse.json({
217 elements: (elements ?? []).map((e) => (typeof e === "string" ? e : Redacted.value(e))),
218 });
219 }
220
221 if (request.method === "POST" && pathname === "/list/append") {
222 const body = (yield* request.json) as { element: string };
223 yield* updateList({
224 elements: [body.element],
225 updateMode: "APPEND",
226 });
227 return yield* HttpServerResponse.json({ ok: true });
228 }
229
230 if (request.method === "GET" && pathname === "/predictions") {
231 const eventId = url.searchParams.get("eventId")!;
232 const { eventPredictionSummaries } = yield* listEventPredictions({
233 eventId: { value: eventId },
234 });
235 return yield* HttpServerResponse.json({
236 summaries: eventPredictionSummaries ?? [],
237 });
238 }
239
240 if (request.method === "GET" && pathname === "/prediction-metadata") {
241 const eventId = url.searchParams.get("eventId")!;
242 // Find the prediction summary first, then audit its full metadata.
243 const { eventPredictionSummaries } = yield* listEventPredictions({
244 eventId: { value: eventId },
245 });
246 const summary = eventPredictionSummaries?.[0];
247 if (summary === undefined) {
248 return yield* HttpServerResponse.json({ found: false });
249 }
250 const metadata = yield* getEventPredictionMetadata({
251 eventId,
252 eventTypeName: summary.eventTypeName!,
253 detectorVersionId: summary.detectorVersionId!,
254 predictionTimestamp: summary.predictionTimestamp!,
255 });
256 return yield* HttpServerResponse.json({
257 found: true,
258 outcomes: metadata.outcomes ?? [],
259 ruleCount: (metadata.rules ?? []).length,
260 });
261 }
262
263 if (request.method === "POST" && pathname === "/events/purge") {
264 const { eventsDeletionStatus } = yield* deleteEventsByEventType({});
265 return yield* HttpServerResponse.json({
266 status: eventsDeletionStatus,
267 });
268 }
269
270 if (request.method === "GET" && pathname === "/events/purge-status") {
271 const { eventsDeletionStatus } = yield* getDeleteEventsByEventTypeStatus({});
272 return yield* HttpServerResponse.json({
273 status: eventsDeletionStatus,
274 });
275 }
276
277 return yield* HttpServerResponse.json(
278 { error: "Not found", method: request.method, pathname },
279 { status: 404 },
280 );
281 }).pipe(Effect.orDie),
282 };
283 }).pipe(
284 Effect.provide(
285 Layer.mergeAll(
286 FraudDetector.GetEventPredictionHttp,
287 FraudDetector.SendEventHttp,
288 FraudDetector.GetEventHttp,
289 FraudDetector.UpdateEventLabelHttp,
290 FraudDetector.DeleteEventHttp,
291 FraudDetector.GetListElementsHttp,
292 FraudDetector.UpdateListHttp,
293 FraudDetector.ListEventPredictionsHttp,
294 FraudDetector.GetEventPredictionMetadataHttp,
295 FraudDetector.DeleteEventsByEventTypeHttp,
296 FraudDetector.GetDeleteEventsByEventTypeStatusHttp,
297 ),
298 ),
299 ),
300 );