Using BackendKit

import { onCall } from "firebase-functions/v2/https";
 
export const helloWorldFunction = onCall(async (request) => {
  return "Hello World!";
});

import FirebaseFunctions
 
struct ContentView: View {
    var body: some View {
        Button("Call Hello World") {
            Task {
                let data = try await Functions.functions().httpsCallable("helloWorldFunction").call()
                print(data.data)
            }
        }
    }
}

import { onCall } from "firebase-functions/v2/https";
 
type HelloWorldResponse = {
  message: string;
  count: number;
  someBooleanValue: boolean;
};
 
export const helloWorldFunction = onCall(async (request) => {
  const response: HelloWorldResponse = {
    message: "Hey There"!,
    count: 3,
    someBooleanValue: true,
  };
  return response;
});

struct HelloWorldReceivedDataType: Codable {
	let message: String
	let count: Int
	let someBooleanValue: Bool
 
    init(from rawData: [String: Any]) throws {
		guard JSONSerialization.isValidJSONObject(rawData),
			let data = try? JSONSerialization.data(withJSONObject: rawData),
			let decodedResults = try? JSONDecoder().decode(Self.self, from: data)
		else {
			throw NSError(domain: "Invalid Init Object", code: 0, userInfo: nil)
		}
		self = decodedResults
	}
}

import FirebaseFunctions
 
struct HelloWorldReceivedDataType: Codable { /* see above */ }
 
struct ContentView: View {
    var body: some View {
        Button("Call Hello World") {
            Task {
                do {
                    let receivedDataRaw = try await Functions.functions().httpsCallable("helloWorldFunction").call()
 
                    guard let receivedDataDict = receivedDataRaw.data as? [String: Any] else {
                        // ... error handling
                        return
                    }
 
                    let receivedDataConverted = try HelloWorldReceivedDataType(from: receivedDataDict)
                    print(receivedDataConverted)
                } catch {
                    // ... error handling
                    return
                }
            }
        }
    }
}

// ...
let contentDict: [String: Any] = ["name": "John"]
let data = try await Functions.functions().httpsCallable("functionWithParams").call(contentDict)
print(data.data)
// ...

export const functionWithParams = onCall(async (request) => {
  const name = request.data?.name as string | null;
  if (!name) {
    throw new Error("No Name Provided");
  }
  return name;
});

export const functionWithParams = onCall(async (request) => {
  const name = request.data?.name as string | null;
  if (!name) {
    throw new HttpsError("invalid-argument", "No Name Provided");
  }
  return name;
});

do {
    let contentDict: [String: Any] = ["lastname": "Doe"]
    let data = try await Functions.functions().httpsCallable("functionWithParams").call(contentDict)
    print(data.data)
} catch {
    if let error = error as NSError? {
        if error.domain == FunctionsErrorDomain {
            let code = FunctionsErrorCode(rawValue: error.code)!
            switch code {
                case .invalidArgument: print("Invalid argument")
                default: print("Server error")
            }
            let message = error.localizedDescription
            print(message)
        }
        // ...
    }
    // ...
}

import * as AI from "./AIKit/AI";
 
// Send a new chat message to AI
// Will return the provided text message + the AI's response
export const sendANewAIChatMessageForCurrentUser = onCall(async (request) => {
  // ... fetch previous chat history
 
  const response = await AI.accessGPTChat({
    text,
    previousChatMessages: chatHistoryInGPTFormat,
  });
 
  // ... append the response to the chat history
 
  // return the new chat history
  return resultingChatHistoryAdditions;
});

export type GPTChatMessage = {};
 
export async function accessGPTChat({
  text,
  previousChatMessages = [],
}: {
  text: string;
  previousChatMessages?: GPTChatMessage[];
}): Promise<string | null> {
  const response = await openai.chat.completions.create({
    // ...
  });
  return response.choices[0].message.content;
}

extension DB {
    	/// Will return new chat messages to append to current chat history
	public func sendNewAIChatMessage(text: String) async -> [AIChatMessage] {
		// ...
		do {
			let contentDict: [String: Any] = ["text": text]
			let data = try await functions.httpsCallable("sendANewAIChatMessageForCurrentUser").call(contentDict)
 
            // we return an array of objects, so cast it to an array of dictionaries
			guard let messagesRaw = data.data as? [[String: Any]] else {
                // ... error handling
			}
 
            // map the dictionaries to AIChatMessage objects
			return try messagesRaw.map({ try AIChatMessage(from: $0) })
		} catch {
			// ... error handling
		}
	}
}

import FirebaseKit
import SwiftUI
 
struct YourView: View {
    @EnvironmentObject var db: DB
 
    var body: some View {
        Button("Send Message") {
            Task {
                let messages = await db.sendNewAIChatMessage(text: "Hello")
                print(messages)
            }
        }
        // .requireLogin is an AuthKit modifier that will show a login screen if the user is not logged in
        .requireLogin(db: db, onCancel: {})
    }
}

firebase deploy --only functions