effect-cf 0.23.1 → 0.25.0

package/dist/Vitest.mjs

@@ -0,0 +1,184 @@
+import { d as WorkerConfig, f as WorkerEnvironment, r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-B5RCFnRy.mjs";
+import { ConfigProvider, Effect, Exit, Layer } from "effect";
+import { env } from "cloudflare:workers";
+import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";
+//#region src/Vitest.ts
+/**
+* Effect-native helpers for tests running in Cloudflare's Vitest Workers pool.
+*
+* Import this module through the `effect-cf/vitest` subpath. It is intended to
+* run inside the Workers test runtime, where `cloudflare:test` is available.
+*/
+const currentEnv = env;
+/**
+* Provides the Workers pool environment as both {@link WorkerEnvironment} and
+* the active Effect `ConfigProvider`.
+*/
+const layer = Layer.mergeAll(Layer.succeed(WorkerEnvironment, currentEnv), ConfigProvider.layer(WorkerConfig.providerFromEnv(currentEnv)));
+/**
+* Creates an `ExecutionContext` and drains all `waitUntil` work before the
+* returned effect completes, including when `use` fails or is interrupted.
+*/
+const withExecutionContext = Effect.fn("effect-cf/vitest/withExecutionContext")(function* (use) {
+	return yield* Effect.acquireUseRelease(Effect.sync(createExecutionContext), use, (context) => Effect.promise(() => waitOnExecutionContext(context)));
+});
+/**
+* Invokes an Effect-backed Worker fetch handler and drains its `waitUntil`
+* work before returning the response.
+*/
+const fetch = Effect.fn("effect-cf/vitest/fetch")(function* (Worker, request, workerEnv = currentEnv) {
+	return yield* withExecutionContext(Effect.fnUntraced(function* (context) {
+		const worker = new Worker(context, workerEnv);
+		return yield* Effect.promise(() => worker.fetch(request));
+	}));
+});
+/**
+* Invokes a modules-format scheduled handler and drains its `waitUntil` work.
+*/
+const scheduled = Effect.fn("effect-cf/vitest/scheduled")(function* (handler, options, workerEnv = currentEnv) {
+	const controller = createScheduledController(options);
+	yield* withExecutionContext((context) => Effect.promise(async () => handler(controller, workerEnv, context)));
+	return controller;
+});
+/**
+* Invokes a Pages Function with a typed event context and drains its
+* `waitUntil` work, including when the function fails.
+*/
+const pages = Effect.fn("effect-cf/vitest/pages")(function* (handler, init) {
+	return yield* Effect.acquireUseRelease(Effect.sync(() => createPagesEventContext(init)), (context) => Effect.promise(async () => handler(context)), (context) => Effect.promise(() => waitOnExecutionContext(context)));
+});
+/**
+* Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
+* returns Pool Workers' acknowledgement and retry result.
+*/
+const queue = Effect.fn("effect-cf/vitest/queue")(function* (Worker, queueName, messages, workerEnv = currentEnv) {
+	return yield* withExecutionContext(Effect.fnUntraced(function* (context) {
+		const batch = createMessageBatch(queueName, [...messages]);
+		const worker = new Worker(context, workerEnv);
+		yield* Effect.promise(() => worker.queue(batch));
+		return {
+			batch,
+			result: yield* Effect.promise(() => getQueueResult(batch, context))
+		};
+	}));
+});
+/**
+* Runs an Effect inside the I/O context of a Durable Object instance.
+*
+* The caller's Effect context is preserved, and the instance's native state is
+* provided as {@link DurableObjectState}. A wrapped state service is also
+* passed to `use` for direct access.
+*/
+const runInDurableObject = Effect.fn("effect-cf/vitest/runInDurableObject")(function* (stub, use) {
+	const context = yield* Effect.context();
+	return yield* yield* Effect.promise(() => runInDurableObject$1(stub, (instance, nativeState) => {
+		const state = fromDurableObjectState(nativeState);
+		const effect = Effect.provideService(use(instance, state), DurableObjectState, state);
+		return Effect.runPromiseExitWith(context)(effect);
+	}));
+});
+/** Immediately runs and removes a scheduled Durable Object alarm. */
+const runDurableObjectAlarm = Effect.fn("effect-cf/vitest/runDurableObjectAlarm")(function* (stub) {
+	return yield* Effect.promise(() => runDurableObjectAlarm$1(stub));
+});
+/** Gracefully evicts one running Durable Object while preserving durable storage. */
+const evictDurableObject = Effect.fn("effect-cf/vitest/evictDurableObject")(function* (stub, options) {
+	yield* Effect.promise(() => evictDurableObject$1(stub, options));
+});
+/** Lists all IDs created in a Durable Object namespace. */
+const listDurableObjectIds = Effect.fn("effect-cf/vitest/listDurableObjectIds")(function* (namespace) {
+	return yield* Effect.promise(() => listDurableObjectIds$1(namespace));
+});
+/** Deletes data from all bindings attached to the current test Worker. */
+const reset = Effect.fn("effect-cf/vitest/reset")(function* () {
+	yield* Effect.promise(reset$1);
+});
+/** Aborts all Durable Object instances without deleting their persisted data. */
+const abortAllDurableObjects = Effect.fn("effect-cf/vitest/abortAllDurableObjects")(function* () {
+	yield* Effect.promise(abortAllDurableObjects$1);
+});
+/** Gracefully evicts all running Durable Objects while preserving durable storage. */
+const evictAllDurableObjects = Effect.fn("effect-cf/vitest/evictAllDurableObjects")(function* (options) {
+	yield* Effect.promise(() => evictAllDurableObjects$1(options));
+});
+/** Applies all D1 migrations that have not already been recorded. */
+const applyD1Migrations = Effect.fn("effect-cf/vitest/applyD1Migrations")(function* (database, migrations, migrationsTableName) {
+	yield* Effect.promise(() => applyD1Migrations$1(database, migrations.map(({ name, queries }) => ({
+		name,
+		queries: [...queries]
+	})), migrationsTableName));
+});
+/** Acquires an Effect-native admin client for a Secrets Store binding. */
+const adminSecretsStore = Effect.fn("effect-cf/vitest/adminSecretsStore")(function* (binding) {
+	const admin = yield* Effect.sync(() => adminSecretsStore$1(binding));
+	return {
+		raw: admin,
+		create: (value) => Effect.promise(() => admin.create(value)),
+		update: (value, id) => Effect.promise(() => admin.update(value, id)),
+		duplicate: (id, newName) => Effect.promise(() => admin.duplicate(id, newName)),
+		delete: (id) => Effect.promise(() => admin.delete(id)),
+		list: Effect.promise(() => admin.list()),
+		get: (id) => Effect.promise(() => admin.get(id))
+	};
+});
+const wrapWorkflowModifier = (modifier) => ({
+	disableSleeps: (steps) => Effect.promise(() => modifier.disableSleeps(steps === void 0 ? void 0 : [...steps])),
+	disableRetryDelays: (steps) => Effect.promise(() => modifier.disableRetryDelays(steps === void 0 ? void 0 : [...steps])),
+	mockStepResult: (step, result) => Effect.promise(() => modifier.mockStepResult(step, result)),
+	mockStepError: (step, error, times) => Effect.promise(() => modifier.mockStepError(step, error, times)),
+	forceStepTimeout: (step, times) => Effect.promise(async () => {
+		await modifier.forceStepTimeout(step, times);
+	}),
+	mockEvent: (event) => Effect.promise(() => modifier.mockEvent(event)),
+	forceEventTimeout: (step) => Effect.promise(() => modifier.forceEventTimeout(step))
+});
+const runWorkflowModifier = Effect.fnUntraced(function* (register, use) {
+	const context = yield* Effect.context();
+	return yield* yield* Effect.promise(async () => {
+		let callbackExit;
+		try {
+			await register(async (modifier) => {
+				callbackExit = await Effect.runPromiseExitWith(context)(use(wrapWorkflowModifier(modifier)));
+				if (Exit.isFailure(callbackExit)) throw callbackExit;
+			});
+		} catch (cause) {
+			if (callbackExit !== void 0 && Exit.isFailure(callbackExit)) return callbackExit;
+			throw cause;
+		}
+		if (callbackExit === void 0) throw new Error("Pool Workers did not invoke the Workflow modifier callback");
+		return callbackExit;
+	});
+});
+const wrapWorkflowInstanceIntrospector = (introspector) => ({
+	raw: introspector,
+	modify: (use) => runWorkflowModifier((callback) => introspector.modify(callback), use),
+	waitForStepResult: (step) => Effect.promise(() => introspector.waitForStepResult(step)),
+	waitForStatus: (status) => Effect.promise(() => introspector.waitForStatus(status)),
+	getOutput: Effect.promise(() => introspector.getOutput()),
+	getError: Effect.promise(() => introspector.getError())
+});
+const wrapWorkflowIntrospector = (introspector) => ({
+	raw: introspector,
+	modifyAll: (use) => runWorkflowModifier((callback) => introspector.modifyAll(callback), use),
+	get: Effect.promise(async () => {
+		return (await introspector.get()).map(wrapWorkflowInstanceIntrospector);
+	})
+});
+/**
+* Acquires an Effect-native Workflow introspector that is disposed when the
+* surrounding Effect scope closes.
+*/
+const introspectWorkflow = Effect.fn("effect-cf/vitest/introspectWorkflow")(function* (workflow) {
+	const introspector = yield* Effect.acquireDisposable(Effect.promise(() => introspectWorkflow$1(workflow)));
+	return wrapWorkflowIntrospector(introspector);
+});
+/**
+* Acquires an Effect-native Workflow instance introspector that is disposed
+* when the surrounding Effect scope closes.
+*/
+const introspectWorkflowInstance = Effect.fn("effect-cf/vitest/introspectWorkflowInstance")(function* (workflow, instanceId) {
+	const introspector = yield* Effect.acquireDisposable(Effect.promise(() => introspectWorkflowInstance$1(workflow, instanceId)));
+	return wrapWorkflowInstanceIntrospector(introspector);
+});
+//#endregion
+export { abortAllDurableObjects, adminSecretsStore, applyD1Migrations, evictAllDurableObjects, evictDurableObject, fetch, introspectWorkflow, introspectWorkflowInstance, layer, listDurableObjectIds, pages, queue, reset, runDurableObjectAlarm, runInDurableObject, scheduled, withExecutionContext };