Workshop: Build serverless edge applications with Cloudflare Workers and Fauna

npm install fauna
npm install uuid

import { Client, fql, FaunaError, FeedClientConfiguration, ServiceError } from 'fauna';
import { v4 as uuidv4 } from 'uuid';

export interface Env {
  FAUNA_SECRET: string;
}

export default {
    async scheduled(
        request: ScheduledEvent,
        env: Env,
        ctx: ExecutionContext
    ): Promise<void> {

        // Extract the method from the request.
        const { method } = request;

        // Instatiate a Fauna client instance.
        const client = new Client({ secret: env.FAUNA_SECRET });

        try {
            // There are two cursors used in the code. The first is for where in the Fauna feed to pick up from.
            // the second is for the document stored in Fauna that is used for locking the feed so it's only processed
            // one at a time by a single Worker.
            const myIdentifer = uuidv4().toString(); //generate a unique identifier for this function run.

            // Call the lockAcquire user-defined function in Fauna to get the cursor information,
            // lock information, and if you can lock it, append the identity.
            const lockDataResponse = await client.query(
                fql`lockAcquire("orderFulfillment", ${myIdentifer})`
            );

            // The response from the UDF is a JSON object with a data field containing the cursor
            //information and stats. We need the data part only for this example.
            const lockData = lockDataResponse.data;

            // If locked is true and the identity field doesn't match, return 409.
            if ((lockData.locked) && ('identity' in lockData) && !(lockData.identity == myIdentifer)) {
                return new Response('Another Worker is processing the feed', { status: 409 });

            } else if (lockData.locked == true && lockData.identity == myIdentifer) {
                // Got the lock. Process the Fauna Event Feed.
                    const cursorValue = await client.query(
                        fql`Cursor.byId(${lockData.cursor.id}) { cursorValue }`
                    );

                    // Get the value of the cursor.
                    let cursorVal: string | null = cursorValue.data?.cursorValue;

                    const options = cursorVal ? { cursor: cursorVal } : undefined
                try {
                    // Get an Event Feed for the `Order` collection.
                    const feed = client.feed(fql`Order.all().eventSource()`, options);

                    for await (const page of feed) {
                        console.log("Page: ", page);
                        // You need to make a decision here if you want to
                        // flatten the events. This example does not.
                        cursorVal = page.cursor;
                        for (const event of page.events) {
                            console.log("Event: ", event);
                            cursorVal = event.cursor;
                            console.log("event cursor: " + cursorVal);
                            switch (event.type) {
                                case "add":
                                // Webhook to add a new order in the fulfillment system
                                //console.log("Add event: ", event);
                                break;
                                case "update":
                                // Webhook to update an order in the fulfillment system
                                console.log("Update event: ", event);
                                break;
                                case "remove":
                                // Webhook to attempt to cancel an order in the fulfillment system
                                console.log("Remove event: ", event);
                                break;
                            }
                        }
                        // Update the cursor in Fauna.
                        const updateCursor = await client.query(
                            fql`Cursor.byId(${lockData.cursor.id})!.update({ cursorValue: ${page.cursor} })`
                        );

                    }
                    console.log(cursorVal);
                    // Release the lock.
                    await client.query(
                        fql`lockUpdate("orderFulfillment", ${cursorVal})`
                    );

                    return new Response('I got the lock and then did some stuff!', { status: 200 });
                } catch (cursorError) {
                    if (cursorError instanceof FaunaError && cursorError.message.includes("is too far in the past")) {
                        console.warn("Cursor is too old, deleting and retrying...");

                        // Delete the outdated cursor document.
                        await client.query(
                            fql`Cursor.byId(${lockData.cursor.id})!.update({cursorValue: null})`
                        );

                        // Unlock the lock document.
                        await client.query(
                            fql`lockUpdate("orderFulfillment", ${cursorVal})`
                        );
                    } else {
                        throw cursorError;
                    }
                }
            } else {
                return new Response('There is nothing to do, something went wrong.', { status: 500 });
            }
        } catch (error) {
            if (error instanceof FaunaError) {
                if (error instanceof ServiceError) {
                    console.error(error.queryInfo?.summary);
                } else {
                    return new Response("Error " + error, { status: 500 });
                }
            }
            return new Response('An error occurred, ' + error.message, { status: 500 });
        }
    },
};

// Create a new order document in the Order collection, but save the order ID.
let order = Order.create({ customer: Customer.byId(111), status: "processing", createdAt: Time.now() })

// Create a new order item document in the OrderItem collection and relate it to the order with the ID
// from the previous step.
OrderItem.create({order: order, product: Product.byName("pizza").first(), quantity: 1})

wrangler deploy

// Create a new order document in the Order collection, but save the order ID.
let order = Order.create({ customer: Customer.byId(111), status: "processing", createdAt: Time.now() })

// Create a new order item document in the OrderItem collection and relate it to the order with the ID
// from the previous step.
OrderItem.create({order: order, product: Product.byName("cups").first(), quantity: 1})