import { Images } from "@alchemy.run/cloudflare/Images/Images";
import { Browser } from "@alchemy.run/cloudflare/Workers/Browser";
import { RateLimit } from "@alchemy.run/cloudflare/Workers/RateLimit";
import { VersionMetadata } from "@alchemy.run/cloudflare/Workers/VersionMetadata";
import { Worker } from "@alchemy.run/cloudflare/Workers/Worker";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import { Resource } from "alchemy/Resource";
import { effectClass } from "alchemy/Util/effect";
import * as Effect from "effect/Effect";
import { TestLayers, TestResource } from "./test.resources.ts";
const { test } = Test.make({ providers: TestLayers() });
// A throwaway resource type used to exercise the `({ methods })` overload
// without mutating the shared `TestResource`.
interface MethodsResource extends Resource<"Test.EffectableMethods", {}, { value: string }> {}
describe("Effectable: migrated constructs are real Effects", { tags: ["unit", "local"] }, () => {
test(
"Resource constructor class is an Effect",
Effect.gen(function* () {
expect(Effect.isEffect(TestResource)).toBe(true);
// still iterable (yield*-able)
expect(typeof (TestResource as any)[Symbol.iterator]).toBe("function");
}),
);
test(
"Resource.ref(...) returns an Effect",
Effect.gen(function* () {
expect(Effect.isEffect(TestResource.ref("X"))).toBe(true);
}),
);
test(
"a resource instance call is an Effect",
Effect.gen(function* () {
expect(Effect.isEffect(TestResource("A", { string: "x" }))).toBe(true);
}),
);
test(
"effectClass(...) and its subclasses are Effects",
Effect.gen(function* () {
const Klass = effectClass(Effect.succeed(1));
expect(Effect.isEffect(Klass)).toBe(true);
class Sub extends effectClass<{ x: number }>()(Effect.succeed({ x: 1 })) {}
// static Effect protocol is inherited through the constructor chain
expect(Effect.isEffect(Sub)).toBe(true);
}),
);
test(
"Platform/Worker construct is an Effect",
Effect.gen(function* () {
const w = Worker("EffectableProbeWorker", { main: "./unused.ts" });
expect(Effect.isEffect(w)).toBe(true);
expect(typeof (w as any)[Symbol.iterator]).toBe("function");
}),
{ tags: ["provider:cloudflare", "provider:cloudflare:worker"] },
);
});
describe(
"Effectable: deliberate non-Effect binding markers",
{
tags: [
"unit",
"provider:cloudflare",
"provider:cloudflare:images",
"provider:cloudflare:worker",
"local",
],
},
() => {
// These markers MUST stay non-Effects (InferEnv + the Worker `env`-value
// resolver both branch on `Effect.isEffect`). They remain yield*-able via
// `[Symbol.iterator]`. See the marker JSDoc for the rationale.
const markers: Array<[name: string, marker: any]> = [
["Images", Images("IMAGES")],
["RateLimit", RateLimit("THROTTLE", { namespaceId: 1, simple: { limit: 1, period: 60 } })],
["Browser", Browser("BROWSER")],
["VersionMetadata", VersionMetadata("CF_VERSION_METADATA")],
];
for (const [name, marker] of markers) {
test(
`${name} marker is NOT an Effect but stays yield*-able`,
Effect.gen(function* () {
expect(Effect.isEffect(marker)).toBe(false);
expect(typeof marker[Symbol.iterator]).toBe("function");
}),
);
}
},
);
describe(
"Effectable: Effect.all / Effect.forEach over constructs",
{ tags: ["unit", "local"] },
() => {
test(
"Effect.all over effectClass instances executes each",
Effect.gen(function* () {
const [a, b] = yield* Effect.all([
effectClass(Effect.succeed(1)),
effectClass(Effect.succeed(2)),
]);
expect([a, b]).toEqual([1, 2]);
}),
);
test(
"Effect.forEach over effectClass instances executes each",
Effect.gen(function* () {
const result = yield* Effect.forEach(
[effectClass(Effect.succeed("a")), effectClass(Effect.succeed("b"))],
(eff) => eff,
);
expect(result).toEqual(["a", "b"]);
}),
);
test.provider("Effect.all over resource constructor calls deploys all of them", (stack) =>
Effect.gen(function* () {
const strings = yield* Effect.gen(function* () {
const resources = yield* Effect.all([
TestResource("A", { string: "a" }),
TestResource("B", { string: "b" }),
]);
return resources.map((r) => r.string);
}).pipe(stack.deploy);
expect(strings).toEqual(["a", "b"]);
}),
);
test.provider("Effect.forEach over resource constructor calls deploys all of them", (stack) =>
Effect.gen(function* () {
const strings = yield* Effect.gen(function* () {
const resources = yield* Effect.forEach(["A", "B", "C"], (id) =>
TestResource(id, { string: id.toLowerCase() }),
);
return resources.map((r) => r.string);
}).pipe(stack.deploy);
expect(strings).toEqual(["a", "b", "c"]);
}),
);
},
);
describe("Effectable: overloads", { tags: ["unit", "local"] }, () => {
test(
"yield* a bare Resource class resolves to its constructor",
Effect.gen(function* () {
const ctor = yield* TestResource;
expect(typeof ctor).toBe("function");
}),
);
test(
"Resource class .pipe behaves as piping an Effect",
Effect.gen(function* () {
const piped = TestResource.pipe(Effect.map((ctor) => typeof ctor));
expect(Effect.isEffect(piped)).toBe(true);
expect(yield* piped).toBe("function");
}),
);
test(
"Resource({ methods }) augments the class and keeps it an Effect",
Effect.gen(function* () {
const R = Resource<MethodsResource>("Test.EffectableMethods");
const augmented = R({ greet: () => "hi" });
// the `({ methods })` overload mutates + returns the same class
expect(augmented).toBe(R);
expect((R as any).greet()).toBe("hi");
expect(Effect.isEffect(R)).toBe(true);
}),
);
test.provider("Resource accepts props-as-Effect (Effect<Props> overload)", (stack) =>
Effect.gen(function* () {
const value = yield* Effect.gen(function* () {
const A = yield* TestResource("A", Effect.succeed({ string: "fromEffect" }));
return A.string;
}).pipe(stack.deploy);
expect(value).toEqual("fromEffect");
}),
);
test(
"Worker.of(shape) returns the shape and the tagged class is an Effect",
Effect.gen(function* () {
const W = (Worker as any)()("EffectableTaggedWorker", { main: "./unused.ts" });
expect(Effect.isEffect(W)).toBe(true);
expect(typeof W.of).toBe("function");
expect(W.of({ foo: 1 })).toEqual({ foo: 1 });
}),
{ tags: ["provider:cloudflare", "provider:cloudflare:worker"] },
);
});