effect-cf 0.23.0 → 0.24.0

package/dist/Vitest.d.mts

@@ -0,0 +1,192 @@
+import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-Bq_FPzlt.mjs";
+import { c as DurableObjectState, l as DurableObjectStateService, o as WorkflowInstanceStatusName } from "./WorkflowBinding-BECGNTzu.mjs";
+import { Effect, Layer } from "effect";
+import { DurableObject } from "cloudflare:workers";
+import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";
+//#region src/Vitest.d.ts
+/**
+ * Provides the Workers pool environment as both {@link WorkerEnvironment} and
+ * the active Effect `ConfigProvider`.
+ */
+declare const layer: Layer.Layer<WorkerEnvironment>;
+/** Constructor shape shared by Effect-backed Worker entrypoints. */
+interface WorkerConstructor<Instance> {
+  new (context: globalThis.ExecutionContext, env: WorkerEnv): Instance;
+}
+/**
+ * Creates an `ExecutionContext` and drains all `waitUntil` work before the
+ * returned effect completes, including when `use` fails or is interrupted.
+ */
+declare const withExecutionContext: <A, E, R>(use: (context: globalThis.ExecutionContext) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+interface FetchWorker {
+  fetch(request: Request): Promise<Response>;
+}
+/**
+ * Invokes an Effect-backed Worker fetch handler and drains its `waitUntil`
+ * work before returning the response.
+ */
+declare const fetch: <Instance extends FetchWorker>(Worker: WorkerConstructor<Instance>, request: Request<unknown, CfProperties<unknown>>, workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<Response, never, never>;
+/** Modules-format scheduled handler accepted by {@link scheduled}. */
+type ScheduledHandler = NonNullable<globalThis.ExportedHandler<WorkerEnv>["scheduled"]>;
+/** Options used to construct a scheduled event controller. */
+interface ScheduledOptions {
+  readonly scheduledTime?: number | Date;
+  readonly cron?: string;
+}
+/**
+ * Invokes a modules-format scheduled handler and drains its `waitUntil` work.
+ */
+declare const scheduled: (handler: ExportedHandlerScheduledHandler<Cloudflare.Env, unknown>, options?: ScheduledOptions | undefined, workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<ScheduledController, never, never>;
+type AnyPagesFunction = globalThis.PagesFunction<WorkerEnv, string, any>;
+interface PagesEventContextInitBase {
+  readonly request: Request<unknown, IncomingRequestCfProperties>;
+  readonly functionPath?: string;
+  readonly next?: (request: Request) => Response | Promise<Response>;
+}
+type PagesEventContextInitParams<Context> = Context extends globalThis.EventContext<unknown, infer Params, unknown> ? [Params] extends [never] ? {
+  readonly params?: Record<string, never>;
+} : {
+  readonly params: Record<Params, string | Array<string>>;
+} : never;
+type PagesEventContextInitData<Context> = Context extends globalThis.EventContext<unknown, string, infer Data> ? Data extends Record<string, never> ? {
+  readonly data?: Data;
+} : {
+  readonly data: Data;
+} : never;
+/** Initialization accepted by Pool Workers for a Pages Function. */
+type PagesEventContextInit<Function extends AnyPagesFunction> = PagesEventContextInitBase & PagesEventContextInitParams<Parameters<Function>[0]> & PagesEventContextInitData<Parameters<Function>[0]>;
+/**
+ * Invokes a Pages Function with a typed event context and drains its
+ * `waitUntil` work, including when the function fails.
+ */
+declare const pages: <Function extends AnyPagesFunction>(handler: Function, init: PagesEventContextInit<Function>) => Effect.Effect<Response, never, never>;
+interface QueueWorker {
+  queue(batch: globalThis.MessageBatch): Promise<void>;
+}
+/** Input message accepted by Pool Workers' `createMessageBatch` helper. */
+type QueueMessage<Body> = {
+  readonly id: string;
+  readonly timestamp: Date;
+  readonly attempts: number;
+} & ({
+  readonly body: Body;
+} | {
+  readonly serializedBody: ArrayBuffer | ArrayBufferView;
+});
+/** Acknowledgement and retry result returned by Pool Workers. */
+type QueueResult = Awaited<ReturnType<typeof getQueueResult>>;
+/** Result of invoking a queue consumer through {@link queue}. */
+interface QueueRunResult<Body> {
+  readonly batch: globalThis.MessageBatch<Body>;
+  readonly result: QueueResult;
+}
+/**
+ * Invokes an Effect-backed queue consumer, drains its `waitUntil` work, and
+ * returns Pool Workers' acknowledgement and retry result.
+ */
+declare const queue: <Body, Instance extends QueueWorker>(Worker: WorkerConstructor<Instance>, queueName: string, messages: readonly QueueMessage<Body>[], workerEnv?: Cloudflare.Env | undefined) => Effect.Effect<QueueRunResult<Body>, never, never>;
+/**
+ * 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.
+ */
+declare const runInDurableObject: <Object extends DurableObject, A, E, R>(stub: DurableObjectStub<Object>, use: (instance: Object, state: DurableObjectStateService) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, DurableObjectState>>;
+/** Immediately runs and removes a scheduled Durable Object alarm. */
+declare const runDurableObjectAlarm: (stub: DurableObjectStub<DurableObject<Cloudflare.Env, {}>>) => Effect.Effect<boolean, never, never>;
+/** Options controlling how Durable Object eviction handles WebSockets. */
+interface DurableObjectEvictionOptions {
+  readonly webSockets?: "close" | "hibernate";
+}
+/** Gracefully evicts one running Durable Object while preserving durable storage. */
+declare const evictDurableObject: (stub: DurableObjectStub<DurableObject<Cloudflare.Env, {}>>, options?: DurableObjectEvictionOptions | undefined) => Effect.Effect<void, never, never>;
+/** Lists all IDs created in a Durable Object namespace. */
+declare const listDurableObjectIds: <Object extends DurableObject | undefined>(namespace: DurableObjectNamespace<Object>) => Effect.Effect<DurableObjectId[], never, never>;
+/** Deletes data from all bindings attached to the current test Worker. */
+declare const reset: () => Effect.Effect<void, never, never>;
+/** Aborts all Durable Object instances without deleting their persisted data. */
+declare const abortAllDurableObjects: () => Effect.Effect<void, never, never>;
+/** Gracefully evicts all running Durable Objects while preserving durable storage. */
+declare const evictAllDurableObjects: (options?: DurableObjectEvictionOptions | undefined) => Effect.Effect<void, never, never>;
+/** A D1 migration accepted by Pool Workers. */
+interface D1Migration {
+  readonly name: string;
+  readonly queries: ReadonlyArray<string>;
+}
+/** Applies all D1 migrations that have not already been recorded. */
+declare const applyD1Migrations: (database: D1Database, migrations: readonly D1Migration[], migrationsTableName?: string | undefined) => Effect.Effect<void, never, never>;
+type NativeSecretsStoreAdmin = ReturnType<typeof adminSecretsStore$1>;
+/** Secret metadata returned by {@link SecretsStoreAdmin.list}. */
+interface SecretsStoreSecret {
+  readonly name: string;
+  readonly metadata?: {
+    readonly uuid: string;
+  };
+}
+/** Effect-native wrapper around Pool Workers' Secrets Store admin API. */
+interface SecretsStoreAdmin {
+  readonly raw: NativeSecretsStoreAdmin;
+  readonly create: (value: string) => Effect.Effect<string>;
+  readonly update: (value: string, id: string) => Effect.Effect<string>;
+  readonly duplicate: (id: string, newName: string) => Effect.Effect<string>;
+  readonly delete: (id: string) => Effect.Effect<void>;
+  readonly list: Effect.Effect<Array<SecretsStoreSecret>>;
+  readonly get: (id: string) => Effect.Effect<string>;
+}
+/** Acquires an Effect-native admin client for a Secrets Store binding. */
+declare const adminSecretsStore: (binding: {
+  get(): Promise<string>;
+}) => Effect.Effect<SecretsStoreAdmin, never, never>;
+type NativeWorkflowIntrospector = Awaited<ReturnType<typeof introspectWorkflow$1>>;
+type NativeWorkflowInstanceIntrospector = Awaited<ReturnType<typeof introspectWorkflowInstance$1>>;
+/** Identifies one occurrence of a Workflow step or sleep. */
+interface WorkflowStepTarget {
+  readonly name: string;
+  readonly index?: number;
+}
+/** Event delivered to a mocked Workflow `waitForEvent` operation. */
+interface WorkflowMockEvent {
+  readonly type: string;
+  readonly payload: unknown;
+}
+/** Effect-native Workflow behavior modifier. */
+interface WorkflowInstanceModifier {
+  readonly disableSleeps: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
+  readonly disableRetryDelays: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
+  readonly mockStepResult: (step: WorkflowStepTarget, result: unknown) => Effect.Effect<void>;
+  readonly mockStepError: (step: WorkflowStepTarget, error: Error, times?: number) => Effect.Effect<void>;
+  readonly forceStepTimeout: (step: WorkflowStepTarget, times?: number) => Effect.Effect<void>;
+  readonly mockEvent: (event: WorkflowMockEvent) => Effect.Effect<void>;
+  readonly forceEventTimeout: (step: WorkflowStepTarget) => Effect.Effect<void>;
+}
+/** Effect-native introspector for one Workflow instance. */
+interface WorkflowInstanceIntrospector {
+  readonly raw: NativeWorkflowInstanceIntrospector;
+  readonly modify: <A, E, R>(use: (modifier: WorkflowInstanceModifier) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  readonly waitForStepResult: (step: WorkflowStepTarget) => Effect.Effect<unknown>;
+  readonly waitForStatus: (status: WorkflowInstanceStatusName) => Effect.Effect<void>;
+  readonly getOutput: Effect.Effect<unknown>;
+  readonly getError: Effect.Effect<{
+    readonly name: string;
+    readonly message: string;
+  }>;
+}
+/** Effect-native introspector for subsequently created Workflow instances. */
+interface WorkflowIntrospector {
+  readonly raw: NativeWorkflowIntrospector;
+  readonly modifyAll: <A, E, R>(use: (modifier: WorkflowInstanceModifier) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  readonly get: Effect.Effect<ReadonlyArray<WorkflowInstanceIntrospector>>;
+}
+/**
+ * Acquires an Effect-native Workflow introspector that is disposed when the
+ * surrounding Effect scope closes.
+ */
+declare const introspectWorkflow: (workflow: Workflow<unknown>) => Effect.Effect<WorkflowIntrospector, never, import("effect/Scope").Scope>;
+/**
+ * Acquires an Effect-native Workflow instance introspector that is disposed
+ * when the surrounding Effect scope closes.
+ */
+declare const introspectWorkflowInstance: (workflow: Workflow<unknown>, instanceId: string) => Effect.Effect<WorkflowInstanceIntrospector, never, import("effect/Scope").Scope>;
+//#endregion
+export { D1Migration, DurableObjectEvictionOptions, PagesEventContextInit, QueueMessage, QueueResult, QueueRunResult, ScheduledHandler, ScheduledOptions, SecretsStoreAdmin, SecretsStoreSecret, WorkerConstructor, WorkflowInstanceIntrospector, WorkflowInstanceModifier, WorkflowIntrospector, WorkflowMockEvent, WorkflowStepTarget, abortAllDurableObjects, adminSecretsStore, applyD1Migrations, evictAllDurableObjects, evictDurableObject, fetch, introspectWorkflow, introspectWorkflowInstance, layer, listDurableObjectIds, pages, queue, reset, runDurableObjectAlarm, runInDurableObject, scheduled, withExecutionContext };

package/dist/Vitest.mjs

@@ -0,0 +1,184 @@
+import { d as WorkerConfig, f as WorkerEnvironment, r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-8sgBJB0s.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 };