Ballerina for AI as a Service

service / on new http:Listener(9090) {
    resource function post products() returns int|error {
        // Get the product details from the last inserted row of the Google Sheet.
        sheets:Range range = check gsheets->getRange(googleSheetId, "Sheet1", "A2:F");
        var [name, benefits, features, productType] = getProduct(range);

        // Generate a product description from OpenAI for a given product name.
        text:CreateCompletionRequest textPrompt = {
            prompt: string `generate a product descirption in 250 words about ${name}`,
            model: "text-davinci-003",
            max_tokens: 100
        };

        text:CreateCompletionResponse completionRes = 
            check openAIText->/completions.post(textPrompt);

        // Generate a product image from OpenAI for the given product.
        images:CreateImageRequest imagePrmt = {
            prompt: string `${name}, 
            ${benefits}, 
            ${features}`
        };
        images:ImagesResponse imageRes = 
            check openAIImages->/images/generations.post(imagePrmt);

        // Create a product in Shopify.
        shopify:CreateProduct product = {
            product: {
                title: name,
                body_html: completionRes.choices[0].text,
                tags: features,
                product_type: productType,
                images: [{src: imageRes.data[0].url}]
            }
        };
        shopify:ProductObject prodObj = check shopify->createProduct(product);
        int? pid = prodObj?.product?.id;
        if pid is () {
            return error("Error in creating product in Shopify");
        }
        return pid;
    }
}

type GreetingDetails record {|
    string occasion;
    string recipientEmail;
    string emailSubject;
    string specialNotes?;
|};

service / on new http:Listener(8080) {
    resource function post greetingCard(@http:Payload GreetingDetails req) returns error? {
        string occasion = req.occasion;
        string specialNotes = req.specialNotes ?: "";

        fork {
            // Generate greeting text and design in parallel
            worker greetingWorker returns string|error? {
                text:CreateCompletionRequest textPrompt = {
                    prompt: string `Generate a greeting for a/an ${
                                    occasion}.${"\n"}Special notes: ${specialNotes}`,
                    model: "text-davinci-003",
                    max_tokens: 100
                };
                text:CreateCompletionResponse completionRes = 
                    check openAIText->/completions.post(textPrompt);
                return completionRes.choices[0].text;
            }
            worker imageWorker returns string|error? {
                images:CreateImageRequest imagePrompt = {
                    prompt: string `Greeting card design for ${occasion}, ${
                                    specialNotes}`
                };
                images:ImagesResponse imageRes = 
                    check openAIImages->/images/generations.post(imagePrompt);
                return imageRes.data[0].url;
            }
        }

        record {|
            string|error? greetingWorker;
            string|error? imageWorker;
        |} resutls = wait {greetingWorker, imageWorker};

        string? greeting = check resutls.greetingWorker;
        string? imageURL = check resutls.imageWorker;
        if greeting !is string || imageURL !is string {
            return error("Error while generating greeting card");
        }

        // Send an email with the greeting and the image using the email connector
        gmail:MessageRequest messageRequest = {
            recipient: req.recipientEmail,
            subject: req.emailSubject,
            messageBody: string `<p>${greeting}</p> <br/> <img src="${imageURL}">`,
            contentType: gmail:TEXT_HTML
        };
        _ = check gmail->sendMessage(messageRequest, userId = "me");
    }
}

public function main(*EmailDetails emailDetails) returns error? {
    fork {
        worker poemWorker returns string|error? {
            text:CreateCompletionRequest textPrompt = {
                prompt: string `Generate a creative poem on the topic ${emailDetails.topic}.`,
                model: "text-davinci-003",
                max_tokens: 1000
            };
            text:CreateCompletionResponse completionRes = 
                check openAIText->/completions.post(textPrompt);
            return completionRes.choices[0].text;
        }

        worker imageWorker returns byte[]|error {
            stabilityai:TextToImageRequestBody payload = 
                {text_prompts: [{"text": emailDetails.topic, "weight": 1}]};
            stabilityai:ImageRes listResult = 
                check stabilityAI->/v1/generation/stable\-diffusion\-v1/
                text\-to\-image.post(payload);
            string? imageBytesString = listResult.artifacts[0].'base64;
            if imageBytesString is () {
                return error("Image byte string is empty.");
            }
            byte[] imageBytes = imageBytesString.toBytes();
            var decodedImage = check mime:base64Decode(imageBytes);
            if decodedImage !is byte[] {
                return error("Error in decoding the image byte string.");
            }
            return decodedImage;
        }
    }

    record {|
        string|error? poemWorker;
        byte[]|error imageWorker;
    |} results = wait {poemWorker, imageWorker};

    string? poem = check results.poemWorker;
    byte[]? image = check results.imageWorker;
    if poem !is string || image !is byte[] {
        return error("Error while generating the poem and the image.");
    }

    io:Error? fileWrite = io:fileWriteBytes("./image.png", image);
    if fileWrite is io:Error {
        return error("Error while writing the image to a file.");
    }

    string messageBody = poem.trim();
    string:RegExp r = re `\n`;
    messageBody = r.replaceAll(messageBody, "<br>");

    gmail:MessageRequest messageRequest = {
        recipient: emailDetails.recipientEmail,
        subject: emailDetails.topic,
        messageBody,
        contentType: gmail:TEXT_HTML,
        inlineImagePaths: [{imagePath: "./image.png", mimeType: "image/png"}]
    };
    _ = check gmail->sendMessage(messageRequest, userId = "me");
}