effect-cf 0.40.0 → 0.40.1

package/dist/WorkflowDefinition.mjs

@@ -0,0 +1,69 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer } from "./WorkflowBinding.mjs";
+import { WorkflowEvent, make as make$1 } from "./Workflow.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+//#region src/WorkflowDefinition.ts
+var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	Workflow: () => Workflow,
+	implement: () => implement,
+	make: () => make
+});
+const makeDefinition = (id, definition) => {
+	const workflowDefinition = {
+		id,
+		payload: definition.payload,
+		result: definition.result
+	};
+	return Object.assign(workflowDefinition, { make: (layer, options) => make$1(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
+};
+const make = (id, definition) => Tag()(id, definition);
+const Tag = () => (id, definition) => {
+	const workflowDefinition = makeDefinition(id, definition);
+	const tag = Context.Service()(`effect-cf/Workflow/${id}`);
+	const layer$1 = (binding) => layer(tag, {
+		...binding,
+		payload: definition.payload,
+		result: definition.result
+	});
+	const create = Effect.fnUntraced(function* (payload, options) {
+		return yield* (yield* tag).create(payload, options);
+	});
+	const createBatch = Effect.fnUntraced(function* (batch) {
+		return yield* (yield* tag).createBatch(batch);
+	});
+	const get = Effect.fnUntraced(function* (instanceId) {
+		return yield* (yield* tag).get(instanceId);
+	});
+	const rawUnsafe = Effect.flatMap(tag, (workflow) => workflow.rawUnsafe);
+	return Object.assign(tag, {
+		id: workflowDefinition.id,
+		payload: workflowDefinition.payload,
+		result: workflowDefinition.result,
+		make: workflowDefinition.make,
+		layer: layer$1,
+		create,
+		createBatch,
+		get,
+		rawUnsafe
+	});
+};
+const Workflow = Tag;
+const wrapHandler = (definition, handler) => {
+	const decodePayload = S.decodeUnknownEffect(definition.payload);
+	const encodeResult = S.encodeEffect(definition.result);
+	return Effect.fnUntraced(function* (payload) {
+		const decodedPayload = yield* decodePayload(payload);
+		const decodedEvent = {
+			...yield* WorkflowEvent,
+			payload: decodedPayload
+		};
+		const result = yield* handler(decodedPayload).pipe(Effect.provideService(WorkflowEvent, decodedEvent));
+		return yield* encodeResult(result);
+	});
+};
+const implement = (_definition, handler) => handler;
+//#endregion
+export { Tag, Workflow, WorkflowDefinition_exports, implement, make };

package/dist/{rolldown-runtime-D7D4PA-g.mjs → _virtual/_rolldown/runtime.mjs}

@@ -10,4 +10,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll as t };
+export { __exportAll };