ff-effect 0.0.10 → 0.0.11

package/src/for/inngest/cron.ts

@@ -0,0 +1,21 @@
+import type { Cron } from 'effect';
+import { Option } from 'effect';
+
+function fieldToString(field: ReadonlySet<number>, max: number) {
+	if (field.size === 0 || field.size === max) return '*';
+	return Array.from(field)
+		.sort((a, b) => a - b)
+		.join(',');
+}
+
+export function cronToString(cron: Cron.Cron) {
+	const minutes = fieldToString(cron.minutes, 60);
+	const hours = fieldToString(cron.hours, 24);
+	const days = fieldToString(cron.days, 31);
+	const months = fieldToString(cron.months, 12);
+	const weekdays = fieldToString(cron.weekdays, 7);
+
+	const expr = `${minutes} ${hours} ${days} ${months} ${weekdays}`;
+	if (Option.isSome(cron.tz)) return `TZ=${cron.tz.value} ${expr}`;
+	return expr;
+}

package/src/for/inngest/index.test.ts

@@ -0,0 +1,177 @@
+import { Cron, Duration, Effect } from 'effect';
+import { EventSchemas, Inngest as InngestSdk } from 'inngest';
+import { describe, expect, expectTypeOf, test, vi } from 'vitest';
+import { cronToString } from './cron';
+import { createInngest } from './index';
+import { wrapStep } from './step';
+
+describe('cronToString', () => {
+	test('converts simple cron', () => {
+		const cron = Cron.unsafeParse('5 4 * * *');
+		expect(cronToString(cron)).toBe('5 4 * * *');
+	});
+
+	test('converts cron with all fields', () => {
+		const cron = Cron.unsafeParse('0 12 1 6 3');
+		expect(cronToString(cron)).toBe('0 12 1 6 3');
+	});
+
+	test('converts every-minute cron', () => {
+		const cron = Cron.unsafeParse('* * * * *');
+		expect(cronToString(cron)).toBe('* * * * *');
+	});
+
+	test('converts cron with multiple values', () => {
+		const cron = Cron.unsafeParse('0,30 * * * *');
+		expect(cronToString(cron)).toBe('0,30 * * * *');
+	});
+});
+
+describe('wrapStep', () => {
+	const mockStep = {
+		run: vi.fn(),
+		sleep: vi.fn(),
+		sleepUntil: vi.fn(),
+		invoke: vi.fn(),
+		waitForEvent: vi.fn(),
+		sendEvent: vi.fn(),
+	};
+
+	test('step.run executes Effect callback', async () => {
+		mockStep.run.mockImplementation((_id: string, fn: () => Promise<unknown>) =>
+			fn(),
+		);
+
+		const wrapped = wrapStep(mockStep);
+		const result = await Effect.runPromise(
+			wrapped.run('test', () => Effect.succeed(42)),
+		);
+		expect(result).toBe(42);
+		expect(mockStep.run).toHaveBeenCalledWith('test', expect.any(Function));
+	});
+
+	test('step.run wraps errors in InngestError', async () => {
+		mockStep.run.mockRejectedValue(new Error('boom'));
+
+		const wrapped = wrapStep(mockStep);
+		const exit = await Effect.runPromiseExit(
+			wrapped.run('fail', () => Effect.succeed(1)),
+		);
+		expect(exit._tag).toBe('Failure');
+	});
+
+	test('step.sleep converts Duration to ms', async () => {
+		mockStep.sleep.mockResolvedValue(undefined);
+
+		const wrapped = wrapStep(mockStep);
+		await Effect.runPromise(wrapped.sleep('wait', Duration.hours(1)));
+		expect(mockStep.sleep).toHaveBeenCalledWith('wait', 3600000);
+	});
+
+	test('step.sleepUntil passes through', async () => {
+		mockStep.sleepUntil.mockResolvedValue(undefined);
+
+		const wrapped = wrapStep(mockStep);
+		const date = new Date('2024-01-01');
+		await Effect.runPromise(wrapped.sleepUntil('until', date));
+		expect(mockStep.sleepUntil).toHaveBeenCalledWith('until', date);
+	});
+
+	test('step.sendEvent returns ids', async () => {
+		mockStep.sendEvent.mockResolvedValue({ ids: ['id1'] });
+
+		const wrapped = wrapStep(mockStep);
+		const result = await Effect.runPromise(
+			wrapped.sendEvent('send', { name: 'test', data: {} }),
+		);
+		expect(result).toEqual({ ids: ['id1'] });
+	});
+});
+
+describe('createInngest', () => {
+	test('creates builder with Tag and layer', () => {
+		const client = new InngestSdk({ id: 'test' });
+		const Inngest = createInngest(Effect.succeed(client));
+
+		expect(Inngest.Tag).toBeDefined();
+		expect(Inngest.layer).toBeDefined();
+	});
+
+	test('custom tagId', () => {
+		const client = new InngestSdk({ id: 'test' });
+		const Inngest = createInngest(Effect.succeed(client), {
+			tagId: 'MyInngest',
+		});
+
+		expect(Inngest.Tag).toBeDefined();
+	});
+
+	test('createFunction returns an Effect', async () => {
+		const client = new InngestSdk({ id: 'test' });
+		const Inngest = createInngest(Effect.succeed(client));
+
+		const fnEffect = Inngest.createFunction(
+			{ id: 'my-fn' },
+			{ event: 'test/event' },
+			() => Effect.succeed('done'),
+		);
+
+		const fn = await Effect.runPromise(
+			fnEffect.pipe(Effect.provide(Inngest.layer), Effect.scoped),
+		);
+		expect(fn).toBeDefined();
+	});
+
+	test('fetchHandler returns a fetch handler', async () => {
+		const client = new InngestSdk({ id: 'test' });
+		const Inngest = createInngest(Effect.succeed(client));
+
+		const handler = await Effect.runPromise(
+			Inngest.fetchHandler({ functions: [] }).pipe(
+				Effect.provide(Inngest.layer),
+			),
+		);
+		expect(typeof handler).toBe('function');
+	});
+
+	test('httpHandler returns an Effect HttpApp', async () => {
+		const client = new InngestSdk({ id: 'test' });
+		const Inngest = createInngest(Effect.succeed(client));
+
+		const app = await Effect.runPromise(
+			Inngest.httpHandler({ functions: [] }).pipe(
+				Effect.provide(Inngest.layer),
+			),
+		);
+		expect(Effect.isEffect(app)).toBe(true);
+	});
+
+	test('event schema types flow through', async () => {
+		type Data = { email: string };
+
+		const client = new InngestSdk({
+			id: 'typed',
+			schemas: new EventSchemas().fromRecord<{
+				'user.signup': { data: Data };
+			}>(),
+		});
+		const Inngest = createInngest(Effect.succeed(client));
+
+		const fnEffect = Inngest.createFunction(
+			{ id: 'on-signup' },
+			{ event: 'user.signup' },
+			({ event }) => {
+				expectTypeOf(event).toHaveProperty('name');
+				expectTypeOf(event).toHaveProperty('data');
+				expectTypeOf(event.data).toEqualTypeOf<Data>();
+				const email: string = event.data.email;
+				return Effect.succeed(email);
+			},
+		);
+
+		const fn = await Effect.runPromise(
+			fnEffect.pipe(Effect.provide(Inngest.layer), Effect.scoped),
+		);
+		expect(fn).toBeDefined();
+	});
+});

package/src/for/inngest/index.ts

@@ -0,0 +1,187 @@
+import { HttpApp } from '@effect/platform';
+import { type Cron, Data, Effect, FiberSet, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Inspectable from 'effect/Inspectable';
+import type { GetEvents, GetFunctionInput, Inngest } from 'inngest';
+import { serve } from 'inngest/bun';
+import { extract } from '../../extract';
+import { cronToString } from './cron';
+import { wrapStep } from './step';
+
+export const TagTypeId = Context.TagTypeId;
+export const NodeInspectSymbol = Inspectable.NodeInspectSymbol;
+
+export class InngestError extends Data.TaggedError('ff-effect/InngestError')<{
+	message: string;
+	cause?: unknown;
+}> {}
+
+declare const InngestFunctionBrand: unique symbol;
+
+/** Opaque wrapper around inngest's InngestFunction to avoid leaking internal types */
+export type InngestFunction = { readonly [InngestFunctionBrand]: true };
+
+// biome-ignore lint/suspicious/noExplicitAny: matches Inngest.Any
+type AnyInngest = Inngest<any>;
+
+type CreateFunctionParams<TClient extends AnyInngest> = Parameters<
+	TClient['createFunction']
+>;
+
+type FunctionConfig<TClient extends AnyInngest> =
+	CreateFunctionParams<TClient>[0];
+
+type FunctionTrigger<TClient extends AnyInngest> =
+	CreateFunctionParams<TClient>[1];
+
+type TriggerInput<TClient extends AnyInngest> =
+	| FunctionTrigger<TClient>
+	| CronTrigger;
+
+type ExtractTriggerName<TClient extends AnyInngest, T> = T extends {
+	event: infer E extends keyof GetEvents<TClient, true> & string;
+}
+	? E
+	: keyof GetEvents<TClient, true> & string;
+
+type CronTrigger = { cron: Cron.Cron };
+
+function isCronTrigger(trigger: unknown): trigger is CronTrigger {
+	return (
+		typeof trigger === 'object' &&
+		trigger !== null &&
+		'cron' in trigger &&
+		typeof (trigger as CronTrigger).cron === 'object' &&
+		(trigger as CronTrigger).cron !== null &&
+		'minutes' in (trigger as CronTrigger).cron
+	);
+}
+
+function resolveTrigger<TClient extends AnyInngest>(
+	trigger: TriggerInput<TClient>,
+): FunctionTrigger<TClient> {
+	if (Array.isArray(trigger)) {
+		return trigger.map((t) =>
+			resolveTrigger<TClient>(t),
+		) as FunctionTrigger<TClient>;
+	}
+	if (isCronTrigger(trigger)) {
+		return { cron: cronToString(trigger.cron) } as FunctionTrigger<TClient>;
+	}
+	return trigger as FunctionTrigger<TClient>;
+}
+
+type EffectHandlerCtx<
+	TClient extends AnyInngest,
+	TTriggerName extends keyof GetEvents<TClient, true> &
+		string = keyof GetEvents<TClient, true> & string,
+> = Omit<GetFunctionInput<TClient, TTriggerName>, 'step'> & {
+	step: ReturnType<typeof wrapStep<unknown>>;
+};
+
+const defaultPrefix = '@ff-effect/Inngest' as const;
+
+export function createInngest<
+	TClient extends AnyInngest,
+	E,
+	R,
+	T extends string = typeof defaultPrefix,
+>(createClient: Effect.Effect<TClient, E, R>, opts?: { tagId?: T }) {
+	const tagId = (opts?.tagId ?? defaultPrefix) as T;
+
+	type Tag = typeof tagId;
+	const Tag = Context.Tag(tagId)<Tag, TClient>();
+
+	const send = (
+		payload: Parameters<TClient['send']>[0],
+	): Effect.Effect<{ ids: string[] }, InngestError, Tag> =>
+		Effect.gen(function* () {
+			const c = yield* Tag;
+			return yield* Effect.tryPromise({
+				// @ts-expect-error inngest generic variance issue between constrained and inferred client types
+				try: () => c.send(payload) as Promise<{ ids: string[] }>,
+				catch: (cause) =>
+					new InngestError({ message: 'Failed to send event', cause }),
+			});
+		});
+
+	const createFunction = <TTrigger extends TriggerInput<TClient>, A, EH, RH>(
+		config: FunctionConfig<TClient>,
+		trigger: TTrigger,
+		handler: (
+			ctx: EffectHandlerCtx<TClient, ExtractTriggerName<TClient, TTrigger>>,
+		) => Effect.Effect<A, EH, RH>,
+	) =>
+		Effect.gen(function* () {
+			const c = yield* Tag;
+			const ext_handler = yield* extract(handler);
+			const resolvedTrigger = resolveTrigger<TClient>(trigger);
+			const runPromise = yield* FiberSet.makeRuntimePromise();
+
+			return c.createFunction(
+				config,
+				resolvedTrigger,
+				// biome-ignore lint/suspicious/noExplicitAny: inngest middleware produces unresolvable context type
+				async (ctx: any) => {
+					const effectStep = wrapStep(ctx.step);
+					return runPromise(
+						ext_handler({
+							...ctx,
+							step: effectStep,
+						} as unknown as EffectHandlerCtx<
+							TClient,
+							ExtractTriggerName<TClient, TTrigger>
+						>),
+					);
+				},
+			) as unknown as InngestFunction;
+		});
+
+	type ServeOpts = {
+		functions: InngestFunction[];
+		servePath?: string;
+		signingKey?: string;
+		signingKeyFallback?: string;
+		logLevel?: 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'silent';
+		streaming?: 'allow' | 'force' | false;
+	};
+
+	function buildServe(client: TClient, httpOpts: ServeOpts) {
+		return serve({
+			client,
+			functions: httpOpts.functions as unknown as Parameters<
+				typeof serve
+			>[0]['functions'],
+			...(httpOpts.servePath != null && { servePath: httpOpts.servePath }),
+			...(httpOpts.signingKey != null && {
+				signingKey: httpOpts.signingKey,
+			}),
+			...(httpOpts.signingKeyFallback != null && {
+				signingKeyFallback: httpOpts.signingKeyFallback,
+			}),
+			...(httpOpts.logLevel != null && { logLevel: httpOpts.logLevel }),
+			...(httpOpts.streaming != null && { streaming: httpOpts.streaming }),
+		});
+	}
+
+	const fetchHandler = (httpOpts: ServeOpts) =>
+		Effect.gen(function* () {
+			const c = yield* Tag;
+			return buildServe(c, httpOpts);
+		});
+
+	const httpHandler = (httpOpts: ServeOpts) =>
+		Effect.gen(function* () {
+			const c = yield* Tag;
+			return HttpApp.fromWebHandler(buildServe(c, httpOpts));
+		});
+
+	return {
+		Tag,
+		layer: Layer.effect(Tag, createClient),
+		createFunction,
+		send,
+		fetchHandler,
+		httpHandler,
+	};
+}

package/src/for/inngest/step.ts

@@ -0,0 +1,77 @@
+import { Duration, Effect } from 'effect';
+import { runPromiseUnwrapped } from '../../run-promise-unwrapped';
+import { InngestError } from './index';
+
+type OriginalStep = {
+	run: (id: string, fn: () => Promise<unknown>) => Promise<unknown>;
+	sleep: (id: string, time: number | string) => Promise<void>;
+	sleepUntil: (id: string, time: Date | string) => Promise<void>;
+	invoke: (id: string, opts: unknown) => Promise<unknown>;
+	waitForEvent: (id: string, opts: unknown) => Promise<unknown>;
+	sendEvent: (id: string, payload: unknown) => Promise<unknown>;
+};
+
+export type WrappedStep<TStep> = ReturnType<typeof wrapStep<TStep>>;
+
+export function wrapStep<TStep>(step: TStep) {
+	const s = step as unknown as OriginalStep;
+
+	return {
+		run: <A, E>(id: string, fn: () => Effect.Effect<A, E, never>) =>
+			Effect.tryPromise({
+				try: () => s.run(id, () => runPromiseUnwrapped(fn())),
+				catch: (cause) =>
+					new InngestError({ message: `Step "${id}" failed`, cause }),
+			}) as Effect.Effect<A, InngestError>,
+
+		sleep: (id: string, duration: Duration.DurationInput) =>
+			Effect.tryPromise({
+				try: () => s.sleep(id, Duration.toMillis(Duration.decode(duration))),
+				catch: (cause) =>
+					new InngestError({
+						message: `Step sleep "${id}" failed`,
+						cause,
+					}),
+			}),
+
+		sleepUntil: (id: string, time: Date | string) =>
+			Effect.tryPromise({
+				try: () => s.sleepUntil(id, time),
+				catch: (cause) =>
+					new InngestError({
+						message: `Step sleepUntil "${id}" failed`,
+						cause,
+					}),
+			}),
+
+		invoke: <TResult = unknown>(id: string, opts: unknown) =>
+			Effect.tryPromise({
+				try: () => s.invoke(id, opts),
+				catch: (cause) =>
+					new InngestError({
+						message: `Step invoke "${id}" failed`,
+						cause,
+					}),
+			}) as Effect.Effect<TResult, InngestError>,
+
+		waitForEvent: <TEvent = unknown>(id: string, opts: unknown) =>
+			Effect.tryPromise({
+				try: () => s.waitForEvent(id, opts),
+				catch: (cause) =>
+					new InngestError({
+						message: `Step waitForEvent "${id}" failed`,
+						cause,
+					}),
+			}) as Effect.Effect<TEvent | null, InngestError>,
+
+		sendEvent: (id: string, payload: unknown) =>
+			Effect.tryPromise({
+				try: () => s.sendEvent(id, payload),
+				catch: (cause) =>
+					new InngestError({
+						message: `Step sendEvent "${id}" failed`,
+						cause,
+					}),
+			}) as Effect.Effect<{ ids: string[] }, InngestError>,
+	};
+}

package/src/run-promise-unwrapped.ts

@@ -1,10 +1,10 @@
-import { Cause, Effect, Exit } from "effect";
+import { Cause, Effect, Exit } from 'effect';
 
 /**
  * A simple wrapper around Effect.runPromiseExit that throws the error if it's a failure
  **/
 export async function runPromiseUnwrapped<A, E>(
-	effect: Effect.Effect<A, E, never>
+	effect: Effect.Effect<A, E, never>,
 ) {
 	const exit = await Effect.runPromiseExit(effect);
 	return Exit.match(exit, {

package/src/wrap-client.ts

@@ -39,4 +39,4 @@ export function wrapClient<CLIENT, ERROR extends Error>(opts: {
 			OUTPUT,
 			unknown extends OVERRIDEN_ERROR ? ERROR : OVERRIDEN_ERROR
 		>;
-}
+}