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

main
ts 180 lines 7.81 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { Dataset, DatasetGroup, EventTracker, Schema } from "@alchemy.run/aws/Personalize";
3 import { toTagRecord } from "@alchemy.run/aws/Personalize/internal";
4 import { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as personalize from "@distilled.cloud/aws/personalize";
7 import * as Data from "effect/Data";
8 import * as Effect from "effect/Effect";
9 import * as Schedule from "effect/Schedule";
10
11 const { test } = Test.make({ providers: AWS.providers() });
12
13 const INTERACTIONS_SCHEMA = JSON.stringify({
14 type: "record",
15 name: "Interactions",
16 namespace: "com.amazonaws.personalize.schema",
17 fields: [
18 { name: "USER_ID", type: "string" },
19 { name: "ITEM_ID", type: "string" },
20 { name: "TIMESTAMP", type: "long" },
21 ],
22 version: "1.0",
23 });
24
25 class DatasetGroupStillExists extends Data.TaggedError("DatasetGroupStillExists")<{
26 readonly arn: string;
27 }> {}
28
29 const assertDatasetGroupDeleted = (arn: string) =>
30 personalize.describeDatasetGroup({ datasetGroupArn: arn }).pipe(
31 Effect.flatMap(() => Effect.fail(new DatasetGroupStillExists({ arn }))),
32 Effect.catchTag("ResourceNotFoundException", () => Effect.succeed(undefined)),
33 Effect.retry({
34 while: (e) => e._tag === "DatasetGroupStillExists",
35 schedule: Schedule.max([Schedule.spaced("3 seconds"), Schedule.recurs(20)]),
36 }),
37 );
38
39 // Typed-error probe: proves the SDK decodes Personalize errors as typed tags.
40 // A missing dataset group surfaces as ResourceNotFoundException. Training
41 // resources (solutions, campaigns) take ~an hour of paid training — they are
42 // intentionally NOT implemented; only the cheap definition resources below
43 // have a live lifecycle.
44 test.provider(
45 "describeDatasetGroup on a nonexistent ARN fails with a typed error",
46 () =>
47 Effect.gen(function* () {
48 const region = yield* yield* AWS.Region;
49 const error = yield* Effect.flip(
50 personalize.describeDatasetGroup({
51 datasetGroupArn: `arn:aws:personalize:${region}:000000000000:dataset-group/does-not-exist`,
52 }),
53 );
54 expect(["ResourceNotFoundException", "AccessDeniedException"].includes(error._tag)).toBe(
55 true,
56 );
57 }),
58 { tags: ["provider:aws", "provider:aws:personalize", "live"] },
59 );
60
61 // Personalize schemas, dataset groups, datasets, and event trackers are
62 // cheap, fast metadata objects — the live lifecycle runs ungated with
63 // out-of-band verification. The expensive training work (solutions,
64 // campaigns, import jobs) runs at runtime through the MLOps bindings instead
65 // of IaC resources.
66 test.provider(
67 "create and destroy a schema, dataset group, dataset, and event tracker",
68 (stack) =>
69 Effect.gen(function* () {
70 yield* stack.destroy();
71
72 const created = yield* stack.deploy(
73 Effect.gen(function* () {
74 const schema = yield* Schema("Interactions", { schema: INTERACTIONS_SCHEMA });
75 const group = yield* DatasetGroup("Group", { tags: { Environment: "test" } });
76 const dataset = yield* Dataset("Dataset", {
77 schemaArn: schema.schemaArn,
78 datasetGroupArn: group.datasetGroupArn,
79 datasetType: "Interactions",
80 tags: { Environment: "test" },
81 });
82 // Depend on the DATASET's group ARN (not the group's): Personalize
83 // rejects creating an event tracker until the group has an
84 // Interactions dataset, so the tracker must be sequenced after it.
85 const tracker = yield* EventTracker("Tracker", {
86 datasetGroupArn: dataset.datasetGroupArn,
87 tags: { Environment: "test" },
88 });
89 return { schema, group, dataset, tracker };
90 }),
91 );
92
93 expect(created.schema.schemaArn).toContain(":schema/");
94 expect(created.group.datasetGroupArn).toContain(":dataset-group/");
95 expect(created.group.status).toBe("ACTIVE");
96 expect(created.dataset.datasetArn).toContain(":dataset/");
97 expect(created.dataset.status).toBe("ACTIVE");
98 // Personalize canonicalizes the dataset type to uppercase on describe.
99 expect(created.dataset.datasetType).toBe("INTERACTIONS");
100
101 // Out-of-band verification via distilled.
102 const describedSchema = yield* personalize.describeSchema({
103 schemaArn: created.schema.schemaArn,
104 });
105 expect(JSON.parse(describedSchema.schema!.schema!)).toEqual(JSON.parse(INTERACTIONS_SCHEMA));
106
107 const describedGroup = yield* personalize.describeDatasetGroup({
108 datasetGroupArn: created.group.datasetGroupArn,
109 });
110 expect(describedGroup.datasetGroup?.status).toBe("ACTIVE");
111
112 const groupTags = yield* personalize.listTagsForResource({
113 resourceArn: created.group.datasetGroupArn,
114 });
115 expect(toTagRecord(groupTags.tags)["alchemy::id"]).toBe("Group");
116
117 const describedDataset = yield* personalize.describeDataset({
118 datasetArn: created.dataset.datasetArn,
119 });
120 expect(describedDataset.dataset?.datasetType).toBe("INTERACTIONS");
121 expect(describedDataset.dataset?.schemaArn).toBe(created.schema.schemaArn);
122
123 expect(created.tracker.eventTrackerArn).toContain(":event-tracker/");
124 expect(created.tracker.status).toBe("ACTIVE");
125 expect(created.tracker.trackingId).toBeTruthy();
126 const describedTracker = yield* personalize.describeEventTracker({
127 eventTrackerArn: created.tracker.eventTrackerArn,
128 });
129 expect(describedTracker.eventTracker?.trackingId).toBe(created.tracker.trackingId);
130 expect(describedTracker.eventTracker?.datasetGroupArn).toBe(created.group.datasetGroupArn);
131
132 // Update: change the dataset group's tags in place.
133 const updated = yield* stack.deploy(
134 Effect.gen(function* () {
135 const schema = yield* Schema("Interactions", { schema: INTERACTIONS_SCHEMA });
136 const group = yield* DatasetGroup("Group", {
137 tags: { Environment: "test", Extra: "yes" },
138 });
139 const dataset = yield* Dataset("Dataset", {
140 schemaArn: schema.schemaArn,
141 datasetGroupArn: group.datasetGroupArn,
142 datasetType: "Interactions",
143 tags: { Environment: "test" },
144 });
145 const tracker = yield* EventTracker("Tracker", {
146 datasetGroupArn: dataset.datasetGroupArn,
147 tags: { Environment: "test", Extra: "yes" },
148 });
149 return { schema, group, dataset, tracker };
150 }),
151 );
152 // Stable identifiers are preserved across the update.
153 expect(updated.group.datasetGroupArn).toBe(created.group.datasetGroupArn);
154 expect(updated.dataset.datasetArn).toBe(created.dataset.datasetArn);
155 expect(updated.tracker.eventTrackerArn).toBe(created.tracker.eventTrackerArn);
156 expect(updated.tracker.trackingId).toBe(created.tracker.trackingId);
157
158 const updatedTags = yield* personalize.listTagsForResource({
159 resourceArn: created.group.datasetGroupArn,
160 });
161 expect(toTagRecord(updatedTags.tags).Extra).toBe("yes");
162 const updatedTrackerTags = yield* personalize.listTagsForResource({
163 resourceArn: created.tracker.eventTrackerArn,
164 });
165 expect(toTagRecord(updatedTrackerTags.tags).Extra).toBe("yes");
166
167 // Destroy and verify deletion out-of-band.
168 yield* stack.destroy();
169 yield* assertDatasetGroupDeleted(created.group.datasetGroupArn);
170 const datasetError = yield* Effect.flip(
171 personalize.describeDataset({ datasetArn: created.dataset.datasetArn }),
172 );
173 expect(datasetError._tag).toBe("ResourceNotFoundException");
174 const trackerError = yield* Effect.flip(
175 personalize.describeEventTracker({ eventTrackerArn: created.tracker.eventTrackerArn }),
176 );
177 expect(trackerError._tag).toBe("ResourceNotFoundException");
178 }),
179 { tags: ["provider:aws", "provider:aws:personalize", "live"], timeout: 480_000 },
180 );