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

main
ts 249 lines 8.3 KB
Raw
1 import { describe, expect } from "@alchemy.run/test";
2 import * as Test from "@alchemy.run/test/Alchemy";
3 import * as Effect from "effect/Effect";
4 import * as Exit from "effect/Exit";
5 import * as Layer from "effect/Layer";
6 /**
7 * A tagged platform resource declared as a bare tag — no props, no inline
8 * impl — gets both from its `.make(props, impl)` Layer. Yielding it without
9 * that Layer used to register the resource with `undefined` props, so the
10 * failure surfaced much later as an opaque `TypeError` inside whichever
11 * provider first read a prop (`news.name` in the Cloudflare Worker
12 * pre-create). It must fail fast instead, naming the class and its Layer.
13 *
14 * The three neighbouring branches of `Platform.ts`'s tag handling must keep
15 * working: tag + Layer provided, tag + props (external), plain non-tagged.
16 */
17 import * as Alchemy from "@/index.ts";
18 import { Platform } from "@/Platform.ts";
19 import * as Provider from "@/Provider.ts";
20 import type { Resource } from "@/Resource.ts";
21 import { InMemoryService, State } from "@/State/index.ts";
22
23 interface Widget extends Resource<
24 "Test.PlatformWidget",
25 { name?: string; env?: Record<string, any>; exports?: string[] },
26 { name: string },
27 { env?: Record<string, any> }
28 > {}
29
30 const Widget: any = Platform<Widget>("Test.PlatformWidget", {
31 createRuntimeContext: () => ({}) as any,
32 });
33
34 /** `Widget` is untyped (`Platform` returns `any`), so yields need a cast. */
35 const yieldWidget = (cls: unknown) => cls as Effect.Effect<{ name: string }>;
36
37 /** What the provider received as `news`, if it ran at all. */
38 let observed: { ran: boolean; news: unknown } = { ran: false, news: undefined };
39
40 const providers = Provider.succeed(Widget, {
41 list: () => Effect.succeed([]),
42 diff: Effect.fn(function* () {
43 return undefined;
44 }),
45 reconcile: Effect.fn(function* ({ id, news }: any) {
46 observed = { ran: true, news };
47 return { name: news?.name ?? id };
48 }),
49 delete: Effect.fn(function* () {}),
50 });
51
52 const state = Layer.effect(
53 State,
54 Effect.sync(() => InMemoryService({})),
55 );
56
57 const { test, deploy } = Test.make({ providers, state });
58
59 const runDeploy = (stack: any) =>
60 Effect.gen(function* () {
61 observed = { ran: false, news: undefined };
62 return yield* Effect.exit(deploy(stack) as Effect.Effect<any>);
63 });
64
65 // A bare tag whose `.make(...)` Layer is deliberately never provided.
66 class BareWidget extends Widget()("BareWidget") {}
67
68 const MissingImplStack = Alchemy.Stack(
69 "PlatformMissingImplStack",
70 { providers, state },
71 Effect.gen(function* () {
72 const widget = yield* yieldWidget(BareWidget);
73 return { name: widget.name };
74 }),
75 );
76
77 class ProvidedWidget extends Widget()("ProvidedWidget") {}
78 const ProvidedWidgetLive = ProvidedWidget.make({ name: "provided" }, Effect.succeed({}));
79
80 const ProvidedStack = Alchemy.Stack(
81 "PlatformProvidedStack",
82 { providers, state },
83 Effect.gen(function* () {
84 const widget = yield* yieldWidget(ProvidedWidget);
85 return { name: widget.name };
86 }).pipe(Effect.provide([ProvidedWidgetLive as Layer.Layer<never>])),
87 );
88
89 /** Tag WITH props and no impl — the "external" (non-Effect-native) form. */
90 class ExternalWidget extends Widget()("ExternalWidget", {
91 name: "external",
92 }) {}
93
94 const ExternalStack = Alchemy.Stack(
95 "PlatformExternalStack",
96 { providers, state },
97 Effect.gen(function* () {
98 const widget = yield* yieldWidget(ExternalWidget);
99 return { name: widget.name };
100 }),
101 );
102
103 const PlainStack = Alchemy.Stack(
104 "PlatformPlainStack",
105 { providers, state },
106 Effect.gen(function* () {
107 const widget = yield* yieldWidget(Widget("PlainWidget", { name: "plain" }));
108 return { name: widget.name };
109 }),
110 );
111
112 /**
113 * Forward reference: the tag is yielded OUTSIDE the Layer's region — before
114 * the Layer has built — and again inside it. This is the #874 shape (a
115 * worker tag in another worker's `env` resolves during that worker's
116 * async-binding pass) reduced to the minimal harness: the first yield
117 * registers with `undefined` props, the Layer's build repairs them, and the
118 * plan must see the repaired registration.
119 */
120 class FwdWidget extends Widget()("FwdWidget") {}
121 const FwdWidgetLive = FwdWidget.make({ name: "forward" }, Effect.succeed({}));
122
123 const ForwardRefStack = Alchemy.Stack(
124 "PlatformForwardRefStack",
125 { providers, state },
126 Effect.gen(function* () {
127 yield* yieldWidget(FwdWidget);
128 const real = yield* yieldWidget(FwdWidget).pipe(
129 Effect.provide([FwdWidgetLive as Layer.Layer<never>]),
130 );
131 return { name: real.name };
132 }),
133 );
134
135 /** The bare tag yielded twice — registration must stay idempotent. */
136 class DoubleBareWidget extends Widget()("DoubleBareWidget") {}
137
138 const DoubleBareStack = Alchemy.Stack(
139 "PlatformDoubleBareStack",
140 { providers, state },
141 Effect.gen(function* () {
142 yield* yieldWidget(DoubleBareWidget);
143 yield* yieldWidget(DoubleBareWidget);
144 return {};
145 }),
146 );
147
148 /** The same bare tag on a platform that installs a `transformProps` hook. */
149 const TransformedWidget: any = Platform<Widget>("Test.PlatformWidget", {
150 createRuntimeContext: () => ({}) as any,
151 transformProps: (_id, props) => Effect.succeed(props),
152 });
153
154 class BareTransformedWidget extends TransformedWidget()("BareTransformedWidget") {}
155
156 const TransformedMissingImplStack = Alchemy.Stack(
157 "PlatformTransformedMissingImplStack",
158 { providers, state },
159 Effect.gen(function* () {
160 const widget = yield* yieldWidget(BareTransformedWidget);
161 return { name: widget.name };
162 }),
163 );
164
165 describe("tagged platform resource yielded without its impl layer", { tags: ["local"] }, () => {
166 test(
167 "fails fast, naming the class and its layer",
168 Effect.gen(function* () {
169 const exit = yield* runDeploy(MissingImplStack);
170
171 expect(Exit.isFailure(exit)).toBe(true);
172 const message = String(Exit.isFailure(exit) ? exit.cause : "");
173 expect(message).toContain("Test.PlatformWidget<BareWidget>");
174 expect(message).toContain("BareWidget.make(");
175 expect(message).toContain("Provide it to the Stack's program");
176 expect(message).toContain("Effect.provide([BareWidgetLive])");
177 // The provider must never be reached with undefined props.
178 expect(observed.ran).toBe(false);
179 }),
180 { timeout: 60_000 },
181 );
182
183 test(
184 "still deploys when the .make(...) layer IS provided",
185 Effect.gen(function* () {
186 const exit = yield* runDeploy(ProvidedStack);
187 expect(Exit.isSuccess(exit)).toBe(true);
188 expect((observed.news as any)?.name).toBe("provided");
189 }),
190 { timeout: 60_000 },
191 );
192
193 test(
194 "still deploys a tag declared WITH props and no impl",
195 Effect.gen(function* () {
196 const exit = yield* runDeploy(ExternalStack);
197 expect(Exit.isSuccess(exit)).toBe(true);
198 expect((observed.news as any)?.name).toBe("external");
199 expect((observed.news as any)?.isExternal).toBe(true);
200 }),
201 { timeout: 60_000 },
202 );
203
204 test(
205 "still deploys a plain (non-tagged) instance",
206 Effect.gen(function* () {
207 const exit = yield* runDeploy(PlainStack);
208 expect(Exit.isSuccess(exit)).toBe(true);
209 expect((observed.news as any)?.name).toBe("plain");
210 }),
211 { timeout: 60_000 },
212 );
213
214 test(
215 "a forward reference yielded before the layer builds still deploys",
216 Effect.gen(function* () {
217 const exit = yield* runDeploy(ForwardRefStack);
218 expect(Exit.isSuccess(exit)).toBe(true);
219 // The provider must see the Layer's props, not the forward
220 // reference's `undefined`.
221 expect((observed.news as any)?.name).toBe("forward");
222 }),
223 { timeout: 60_000 },
224 );
225
226 test(
227 "yielding the bare tag twice registers once and still fails fast",
228 Effect.gen(function* () {
229 const exit = yield* runDeploy(DoubleBareStack);
230 expect(Exit.isFailure(exit)).toBe(true);
231 const message = String(Exit.isFailure(exit) ? exit.cause : "");
232 expect(message).toContain("Test.PlatformWidget<DoubleBareWidget>");
233 expect(observed.ran).toBe(false);
234 }),
235 { timeout: 60_000 },
236 );
237
238 test(
239 "fails fast when the platform transforms props",
240 Effect.gen(function* () {
241 const exit = yield* runDeploy(TransformedMissingImplStack);
242 expect(Exit.isFailure(exit)).toBe(true);
243 const message = String(Exit.isFailure(exit) ? exit.cause : "");
244 expect(message).toContain("Test.PlatformWidget<BareTransformedWidget>");
245 expect(observed.ran).toBe(false);
246 }),
247 { timeout: 60_000 },
248 );
249 });