pure-effect 0.7.0 → 0.9.0

package/test/types.test-d.ts

@@ -1,13 +1,18 @@
 import { expectType, expectError } from 'tsd';
-import { Success, Failure, Command, Ask, Retry, effectPipe, runEffect } from '../index.js';
+import { Success, Failure, Command, Ask, Retry, Parallel, effectPipe, runEffect, configureEffect } from '../index.js';
 import type {
     SuccessState,
     FailureState,
     CommandState,
     AskState,
     RetryState,
+    ParallelState,
     RetryExhaustedError,
-    Effect
+    Effect,
+    EffectConfiguration,
+    StepRunner,
+    RunWrapper,
+    CommandInterceptor
 } from '../index.js';
 
 interface User {
@@ -32,6 +37,17 @@ expectType<FailureState<string>>(f);
 
 // --- Command ---
 
+// next is optional, defaulting to Success
+expectType<CommandState<number, number>>(Command(() => 42));
+expectType<CommandState<number, string>>(
+    Command(
+        () => 42,
+        (n: number) => Success(String(n))
+    )
+);
+Command(() => 42, undefined, { name: 'readRow' });
+expectError(Command());
+
 const cmd = Command(
     async () => ({ id: 1, email: 'a@b.com' }) as SavedUser,
     (saved) => {
@@ -131,3 +147,85 @@ expectType<Effect<SavedUser, ValidationError | DbError>>(typedFlow({ email: 'a@b
 
 const typedResult = await runEffect(typedFlow({ email: 'a@b.com', password: 'secret123' }));
 expectType<SuccessState<SavedUser> | FailureState<ValidationError | DbError>>(typedResult);
+
+// --- Parallel ---
+
+// Values tuple is correctly typed
+const par = Parallel([Success(42), Success('hello')], ([n, s]) => {
+    expectType<number>(n);
+    expectType<string>(s);
+    return Success({ n, s });
+});
+expectType<ParallelState<[number, string], { n: number; s: string }>>(par);
+
+// Parallel in effectPipe preserves type flow
+const parallelFlow = effectPipe((input: User) =>
+    Parallel([Success(input.email), Success(input.password)], ([email, password]) => Success({ email, password }))
+);
+expectType<Effect<{ email: string; password: string }>>(parallelFlow({ email: 'a@b.com', password: 'secret123' }));
+
+// runEffect return type flows through Parallel
+const parallelResult = await runEffect(Parallel([Success(1), Success('x')], ([n, s]) => Success({ n, s })));
+expectType<SuccessState<{ n: number; s: string }> | FailureState<unknown>>(parallelResult);
+
+// --- Ctx (context type) ---
+
+interface AppCtx {
+    db: string;
+}
+
+// Ask infers Ctx from callback parameter type
+const askWithCtx = Ask((ctx: AppCtx) => Success(ctx.db));
+expectType<AskState<string, unknown, AppCtx>>(askWithCtx);
+
+// effectPipe propagates Ctx through steps
+const ctxFlow = effectPipe((input: User) => Ask((ctx: AppCtx) => Success({ ...input, conn: ctx.db })));
+expectType<Effect<{ email: string; password: string; conn: string }, unknown, AppCtx>>(
+    ctxFlow({ email: 'a@b.com', password: 'secret123' })
+);
+
+// runEffect enforces context argument matches Ctx
+const ctxResult = await runEffect(ctxFlow({ email: 'a@b.com', password: 'secret123' }), { db: 'conn' });
+expectType<SuccessState<{ email: string; password: string; conn: string }> | FailureState<unknown>>(ctxResult);
+
+// wrong context shape should error
+expectError(runEffect(ctxFlow({ email: 'a@b.com', password: 'secret123' }), { wrong: 'thing' }));
+
+// --- configureEffect / EffectConfiguration ---
+
+// accepts full configuration
+configureEffect({
+    onStep: async (_name, _type, op) => op(),
+    onRun: async (_effect, op, _flowName) => op(),
+    onBeforeCommand: async (_cmd, _ctx) => {},
+    retry: { attempts: 3, delay: 100, backoff: 2 }
+});
+
+// accepts partial configuration
+configureEffect({ retry: { attempts: 5 } });
+configureEffect({});
+
+// rejects invalid shapes
+expectError(configureEffect({ onStep: 'not-a-function' }));
+expectError(configureEffect({ retry: { attempts: 'three' } }));
+
+// hook types are correctly shaped
+const myStep: StepRunner = async (name, type, op) => {
+    expectType<string>(name);
+    expectType<string>(type);
+    return op();
+};
+
+const myRun: RunWrapper = async (effect, op, flowName) => {
+    expectType<Effect<unknown>>(effect);
+    expectType<string | undefined>(flowName);
+    return op();
+};
+
+const myInterceptor: CommandInterceptor = async (cmd, _ctx) => {
+    expectType<CommandState<unknown, unknown>>(cmd);
+};
+
+// EffectConfiguration is a usable type
+const config: EffectConfiguration = { onStep: myStep, onRun: myRun, onBeforeCommand: myInterceptor };
+expectType<EffectConfiguration>(config);

package/opentelemetry-example.js

@@ -1,91 +0,0 @@
-// @ts-check
-
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
-import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { trace, SpanStatusCode } from '@opentelemetry/api';
-import { configureEffect } from './index.js';
-
-/** @import { RunWrapper, StepRunner } from "./index.js" */
-
-const traceExporter = new OTLPTraceExporter({
-    url: 'http://localhost:4318/v1/traces'
-});
-
-const sdk = new NodeSDK({
-    serviceName: 'pure-effect-test',
-    traceExporter,
-    spanProcessor: new SimpleSpanProcessor(traceExporter),
-    instrumentations: []
-});
-
-sdk.start();
-
-process.on('SIGTERM', () => {
-    sdk.shutdown()
-        .then(() => console.log('Tracing terminated'))
-        .catch((error) => console.log('Error terminating tracing', error))
-        .finally(() => process.exit(0));
-});
-
-export function enableTelemetry() {
-    const tracer = trace.getTracer('pure-effect-test');
-    configureEffect({
-        /** @type RunWrapper */
-        onRun: (effect, pipeline, flowName) => {
-            return tracer.startActiveSpan('Effect Pipeline', async (rootSpan) => {
-                try {
-                    rootSpan.setAttribute('effect.initialInput', JSON.stringify(effect.initialInput));
-                    rootSpan.setAttribute('effect.flow', flowName || '');
-
-                    const result = await pipeline();
-
-                    if (result.type === 'Failure') {
-                        rootSpan.setStatus({
-                            code: SpanStatusCode.ERROR,
-                            message: String(result.error)
-                        });
-                    } else {
-                        rootSpan.setStatus({ code: SpanStatusCode.OK });
-                    }
-
-                    return result;
-                } catch (/** @type any */ err) {
-                    rootSpan.recordException(err);
-                    rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
-                    throw err;
-                } finally {
-                    rootSpan.end();
-                }
-            });
-        },
-        /** @type StepRunner */
-        onStep: (name, type, op) => {
-            return tracer.startActiveSpan(name, async (span) => {
-                span.setAttribute('effect.type', type);
-                try {
-                    const result = await op();
-                    try {
-                        if (result !== undefined) {
-                            const outputString = typeof result === 'object' ? JSON.stringify(result) : String(result);
-                            span.setAttribute('effect.output', outputString);
-                        }
-                    } catch (serializationError) {
-                        span.setAttribute('effect.output', '[Circular or Non-Serializable Data]');
-                    }
-                    span.setStatus({ code: SpanStatusCode.OK });
-                    return result;
-                } catch (/** @type any */ err) {
-                    span.recordException(err);
-                    span.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: err.message
-                    });
-                    throw err;
-                } finally {
-                    span.end();
-                }
-            });
-        }
-    });
-}