Your First Workflow

import { task } from "@aikirun/workflow";

const notifyRestaurant = task({
	name: "notify-restaurant",
	async handler(input: { orderId: string; items: string[] }) {
		console.log(`Notifying restaurant about order ${input.orderId}`);
		console.log(`Items: ${input.items.join(", ")}`);
	},
	retry: {
		type: "exponential",
		maxAttempts: 3,
		baseDelayMs: 1000,
	},
});

const notifyCustomer = task({
	name: "notify-customer",
	async handler(input: { customerId: string; message: string }) {
		console.log(`To customer ${input.customerId}: ${input.message}`);
	},
});

const sendFeedbackEmail = task({
	name: "send-feedback-email",
	async handler(input: { orderId: string; customerId: string }) {
		console.log(`Sending feedback request for order ${input.orderId}`);
	},
});

import { event, workflow } from "@aikirun/workflow";

const courierDelivery = workflow({ name: "courier-delivery" });

const courierDeliveryV1 = courierDelivery.v("1.0.0", {
	async handler(run, input: { orderId: string; restaurantId: string }) {
		run.logger.info("Finding available courier...");

		// Simulate courier search
		await run.sleep("find-courier", { seconds: 2 });

		run.logger.info("Courier assigned, waiting for food to be ready...");

		// Wait for restaurant to signal food is ready
		await run.events.foodReady.wait();

		run.logger.info("Food ready! Courier picking up...");
		await run.sleep("delivery", { seconds: 2 });

		run.logger.info("Order delivered!");
		return { courierName: "Oluwafemi" };
	},
	events: {
		foodReady: event(),
	},
});

const restaurantOrder = workflow({ name: "restaurant-order" });

const restaurantOrderV1 = restaurantOrder.v("1.0.0", {
	async handler(run, input: { orderId: string; customerId: string; items: string[] }) {
		// Step 1: Notify restaurant
		await notifyRestaurant.start(run, {
			orderId: input.orderId,
			items: input.items,
		});

		// Step 2: Wait for restaurant to accept (with 5 minute timeout)
		const response = await run.events.restaurantAccepted.wait({
			timeout: { minutes: 5 },
		});

		if (response.timeout) {
			await notifyCustomer.start(run, {
				customerId: input.customerId,
				message: "Restaurant didn't respond. Order cancelled.",
			});
			return { status: "cancelled", reason: "timeout" };
		}

		// Step 3: Notify customer of acceptance
		await notifyCustomer.start(run, {
			customerId: input.customerId,
			message: `Order confirmed! Estimated time: ${response.data.estimatedTime} mins`,
		});

		// Step 4: Start courier delivery as child workflow
		// (with reference ID for external access)
		const deliveryHandle = await courierDeliveryV1
			.with()
			.opt("reference.id", input.orderId)
			.startAsChild(run, {
				orderId: input.orderId,
				restaurantId: "restaurant-1",
			});

		// Step 5: Wait for delivery to complete
		const deliveryResult = await deliveryHandle.waitForStatus("completed");
		if (!deliveryResult.success) {
			return { status: "failed", reason: "delivery_failed" };
		}

		// Step 6: Notify customer of delivery (using child workflow output)
		const { courierName } = deliveryResult.state.output;
		await notifyCustomer.start(run, {
			customerId: input.customerId,
			message: `Your order was delivered by ${courierName}. Enjoy!`,
		});

		// Step 7: Sleep briefly, then request feedback
		await run.sleep("feedback-delay", { seconds: 30 });
		await sendFeedbackEmail.start(run, {
			orderId: input.orderId,
			customerId: input.customerId,
		});

		return { status: "completed", orderId: input.orderId };
	},
	events: {
		restaurantAccepted: event<{ estimatedTime: number }>(),
	},
});

import { client } from "@aikirun/client";
import { database, server } from "@aikirun/server";
import { worker } from "@aikirun/worker";

const databaseUrl = process.env.DATABASE_URL ?? "postgresql://user:password@localhost:5432/aiki";

const aikiServer = server({ db: database({ provider: "pg", url: databaseUrl }) });
const runtimeHandle = aikiServer.runtime.start();

const aikiClient = client({ handler: aikiServer.handler });

const aikiWorker = worker({
	workflows: [restaurantOrderV1, courierDeliveryV1],
});
const workerHandle = aikiWorker.spawn(aikiClient);

// Graceful shutdown
process.on("SIGINT", async () => {
	await workerHandle.stop();
	await runtimeHandle.stop();
	process.exit(0);
});

// Start the order workflow
const orderId = crypto.randomUUID();
const customerId = crypto.randomUUID();

const handle = await restaurantOrderV1.start(aikiClient, {
	orderId,
	customerId,
	items: ["Burger", "Fries", "Drink"],
});

console.log("Workflow started:", handle.run.id);

// Simulate restaurant accepting the order after 3 seconds
setTimeout(async () => {
	await handle.events.restaurantAccepted.send({ estimatedTime: 30 });
	console.log("Restaurant accepted the order!");
}, 3000);

// In a real app, the restaurant would send the foodReady event via API
// when the food is prepared. For this demo, we'll simulate it:
setTimeout(async () => {
	// Get the courier delivery workflow handle using the order ID as reference
	const courierHandle = await courierDeliveryV1.getHandleByReferenceId(aikiClient, orderId);
	await courierHandle.events.foodReady.send();
	console.log("Food is ready for pickup!");
}, 10000);

// Wait for completion (the 30-second feedback sleep happens here)
const result = await handle.waitForStatus("completed");
if (result.success) {
	console.log("Order completed:", result.state.output);
}