/** * Cloud Event Function triggered by a change to a Firestore document. */constfunctions=require('@google-cloud/functions-framework');constprotobuf=require('protobufjs');functions.cloudEvent('helloFirestore',asynccloudEvent=>{console.log(`Function triggered by event on:${cloudEvent.source}`);console.log(`Event type:${cloudEvent.type}`);console.log('Loading protos...');constroot=awaitprotobuf.load('data.proto');constDocumentEventData=root.lookupType('google.events.cloud.firestore.v1.DocumentEventData');console.log('Decoding data...');constfirestoreReceived=DocumentEventData.decode(cloudEvent.data);console.log('\nOld value:');console.log(JSON.stringify(firestoreReceived.oldValue,null,2));console.log('\nNew value:');console.log(JSON.stringify(firestoreReceived.value,null,2));});

fromcloudevents.httpimportCloudEventimportfunctions_frameworkfromgoogle.events.cloudimportfirestore@functions_framework.cloud_eventdefhello_firestore(cloud_event:CloudEvent)->None:"""Triggers by a change to a Firestore document.    Args:        cloud_event: cloud event with information on the firestore event trigger    """firestore_payload=firestore.DocumentEventData()firestore_payload._pb.ParseFromString(cloud_event.data)print(f"Function triggered by change to:{cloud_event['source']}")print("\nOld value:")print(firestore_payload.old_value)print("\nNew value:")print(firestore_payload.value)

// Package hellofirestore contains a Cloud Event Function triggered by a Cloud Firestore event.packagehellofirestoreimport("context""fmt""github.com/GoogleCloudPlatform/functions-framework-go/functions""github.com/cloudevents/sdk-go/v2/event""github.com/googleapis/google-cloudevents-go/cloud/firestoredata""google.golang.org/protobuf/proto")funcinit(){functions.CloudEvent("helloFirestore",HelloFirestore)}// HelloFirestore is triggered by a change to a Firestore document.funcHelloFirestore(ctxcontext.Context,eventevent.Event)error{vardatafirestoredata.DocumentEventData// If you omit `DiscardUnknown`, protojson.Unmarshal returns an error// when encountering a new or unknown field.options:=proto.UnmarshalOptions{DiscardUnknown:true,}err:=options.Unmarshal(event.Data(),&data)iferr!=nil{returnfmt.Errorf("proto.Unmarshal: %w",err)}fmt.Printf("Function triggered by change to: %v\n",event.Source())fmt.Printf("Old value: %+v\n",data.GetOldValue())fmt.Printf("New value: %+v\n",data.GetValue())returnnil}

importcom.google.cloud.functions.CloudEventsFunction;importcom.google.events.cloud.firestore.v1.DocumentEventData;importcom.google.protobuf.InvalidProtocolBufferException;importio.cloudevents.CloudEvent;importjava.util.logging.Logger;publicclassFirebaseFirestoreimplementsCloudEventsFunction{privatestaticfinalLoggerlogger=Logger.getLogger(FirebaseFirestore.class.getName());@Overridepublicvoidaccept(CloudEventevent)throwsInvalidProtocolBufferException{DocumentEventDatafirestoreEventData=DocumentEventData.parseFrom(event.getData().toBytes());logger.info("Function triggered by event on: "+event.getSource());logger.info("Event type: "+event.getType());logger.info("Old value:");logger.info(firestoreEventData.getOldValue().toString());logger.info("New value:");logger.info(firestoreEventData.getValue().toString());}}

usingCloudNative.CloudEvents;usingGoogle.Cloud.Functions.Framework;usingGoogle.Events.Protobuf.Cloud.Firestore.V1;usingMicrosoft.Extensions.Logging;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Threading;usingSystem.Threading.Tasks;namespaceFirebaseFirestore;publicclassFunction:ICloudEventFunction<DocumentEventData>{privatereadonlyILogger_logger;publicFunction(ILogger<Function>logger)=>_logger=logger;publicTaskHandleAsync(CloudEventcloudEvent,DocumentEventDatadata,CancellationTokencancellationToken){_logger.LogInformation("Function triggered by event on {subject}",cloudEvent.Subject);_logger.LogInformation("Event type: {type}",cloudEvent.Type);MaybeLogDocument("Old value",data.OldValue);MaybeLogDocument("New value",data.Value);// In this example, we don't need to perform any asynchronous operations, so the// method doesn't need to be declared async.returnTask.CompletedTask;}/// <summary>/// Logs the names and values of the fields in a document in a very simplistic way./// </summary>privatevoidMaybeLogDocument(stringmessage,Documentdocument){if(documentisnull){return;}// ConvertFields converts the Firestore representation into a .NET-friendly// representation.IReadOnlyDictionary<string,object>fields=document.ConvertFields();varfieldNamesAndTypes=fields.OrderBy(pair=>pair.Key).Select(pair=>$"{pair.Key}: {pair.Value}");_logger.LogInformation(message+": {fields}",string.Join(", ",fieldNamesAndTypes));}}

constfunctions=require('@google-cloud/functions-framework');constFirestore=require('@google-cloud/firestore');constprotobuf=require('protobufjs');constfirestore=newFirestore({projectId:process.env.GOOGLE_CLOUD_PROJECT,});// Converts strings added to /messages/{pushId}/original to uppercasefunctions.cloudEvent('makeUpperCase',asynccloudEvent=>{console.log('Loading protos...');constroot=awaitprotobuf.load('data.proto');constDocumentEventData=root.lookupType('google.events.cloud.firestore.v1.DocumentEventData');console.log('Decoding data...');constfirestoreReceived=DocumentEventData.decode(cloudEvent.data);constresource=firestoreReceived.value.name;constaffectedDoc=firestore.doc(resource.split('/documents/')[1]);constcurValue=firestoreReceived.value.fields.original.stringValue;constnewValue=curValue.toUpperCase();if(curValue===newValue){// Value is already upper-case// Don't perform a(nother) write to avoid infinite loopsconsole.log('Value is already upper-case.');return;}console.log(`Replacing value:${curValue} -->${newValue}`);affectedDoc.set({original:newValue,});});

fromcloudevents.httpimportCloudEventimportfunctions_frameworkfromgoogle.cloudimportfirestorefromgoogle.events.cloudimportfirestoreasfirestoredataclient=firestore.Client()# Converts strings added to /messages/{pushId}/original to uppercase@functions_framework.cloud_eventdefmake_upper_case(cloud_event:CloudEvent)->None:firestore_payload=firestoredata.DocumentEventData()firestore_payload._pb.ParseFromString(cloud_event.data)path_parts=firestore_payload.value.name.split("/")separator_idx=path_parts.index("documents")collection_path=path_parts[separator_idx+1]document_path="/".join(path_parts[(separator_idx+2):])print(f"Collection path:{collection_path}")print(f"Document path:{document_path}")affected_doc=client.collection(collection_path).document(document_path)cur_value=firestore_payload.value.fields["original"].string_valuenew_value=cur_value.upper()ifcur_value!=new_value:print(f"Replacing value:{cur_value} -->{new_value}")affected_doc.set({"original":new_value})else:# Value is already upper-case# Don't perform a second write (which can trigger an infinite loop)print("Value is already upper-case.")

// Package upper contains a Firestore Cloud Function.packageupperimport("context""errors""fmt""log""os""strings""cloud.google.com/go/firestore"firebase"firebase.google.com/go/v4""github.com/GoogleCloudPlatform/functions-framework-go/functions""github.com/cloudevents/sdk-go/v2/event""github.com/googleapis/google-cloudevents-go/cloud/firestoredata""google.golang.org/protobuf/proto")// set the GOOGLE_CLOUD_PROJECT environment variable when deploying.varprojectID=os.Getenv("GOOGLE_CLOUD_PROJECT")// client is a Firestore client, reused between function invocations.varclient*firestore.Clientfuncinit(){// Use the application default credentials.conf:=&firebase.Config{ProjectID:projectID}// Use context.Background() because the app/client should persist across// invocations.ctx:=context.Background()app,err:=firebase.NewApp(ctx,conf)iferr!=nil{log.Fatalf("firebase.NewApp: %v",err)}client,err=app.Firestore(ctx)iferr!=nil{log.Fatalf("app.Firestore: %v",err)}// Register cloud event functionfunctions.CloudEvent("MakeUpperCase",MakeUpperCase)}// MakeUpperCase is triggered by a change to a Firestore document. It updates// the `original` value of the document to upper case.funcMakeUpperCase(ctxcontext.Context,eevent.Event)error{vardatafirestoredata.DocumentEventData// If you omit `DiscardUnknown`, protojson.Unmarshal returns an error// when encountering a new or unknown field.options:=proto.UnmarshalOptions{DiscardUnknown:true,}err:=options.Unmarshal(e.Data(),&data)iferr!=nil{returnfmt.Errorf("proto.Unmarshal: %w",err)}ifdata.GetValue()==nil{returnerrors.New("Invalid message: 'Value' not present")}fullPath:=strings.Split(data.GetValue().GetName(),"/documents/")[1]pathParts:=strings.Split(fullPath,"/")collection:=pathParts[0]doc:=strings.Join(pathParts[1:],"/")varoriginalStringValuestringifv,ok:=data.GetValue().GetFields()["original"];ok{originalStringValue=v.GetStringValue()}else{returnerrors.New("Document did not contain field \"original\"")}newValue:=strings.ToUpper(originalStringValue)iforiginalStringValue==newValue{log.Printf("%q is already upper case: skipping",originalStringValue)returnnil}log.Printf("Replacing value: %q -> %q",originalStringValue,newValue)newDocumentEntry:=map[string]string{"original":newValue}_,err=client.Collection(collection).Doc(doc).Set(ctx,newDocumentEntry)iferr!=nil{returnfmt.Errorf("Set: %w",err)}returnnil}

importcom.google.cloud.firestore.Firestore;importcom.google.cloud.firestore.FirestoreOptions;importcom.google.cloud.firestore.SetOptions;importcom.google.cloud.functions.CloudEventsFunction;importcom.google.events.cloud.firestore.v1.DocumentEventData;importcom.google.events.cloud.firestore.v1.Value;importcom.google.protobuf.InvalidProtocolBufferException;importio.cloudevents.CloudEvent;importjava.util.Map;importjava.util.concurrent.ExecutionException;importjava.util.logging.Logger;publicclassFirebaseFirestoreReactiveimplementsCloudEventsFunction{privatestaticfinalLoggerlogger=Logger.getLogger(FirebaseFirestoreReactive.class.getName());privatefinalFirestorefirestore;privatestaticfinalStringFIELD_KEY="original";privatestaticfinalStringAPPLICATION_PROTOBUF="application/protobuf";publicFirebaseFirestoreReactive(){this(FirestoreOptions.getDefaultInstance().getService());}publicFirebaseFirestoreReactive(Firestorefirestore){this.firestore=firestore;}@Overridepublicvoidaccept(CloudEventevent)throwsInvalidProtocolBufferException,InterruptedException,ExecutionException{if(event.getData()==null){logger.warning("No data found in event!");return;}if(!event.getDataContentType().equals(APPLICATION_PROTOBUF)){logger.warning(String.format("Found unexpected content type %s, expected %s",event.getDataContentType(),APPLICATION_PROTOBUF));return;}DocumentEventDatafirestoreEventData=DocumentEventData.parseFrom(event.getData().toBytes());// Get the fields from the post-operation document snapshot// https://firebase.google.com/docs/firestore/reference/rest/v1/projects.databases.documents#DocumentMap<String,Value>fields=firestoreEventData.getValue().getFieldsMap();if(!fields.containsKey(FIELD_KEY)){logger.warning("Document does not contain original field");return;}StringcurrValue=fields.get(FIELD_KEY).getStringValue();StringnewValue=currValue.toUpperCase();if(currValue.equals(newValue)){logger.info("Value is already upper-case");return;}// Retrieve the document name from the resource path:// projects/{project_id}/databases/{database_id}/documents/{document_path}StringaffectedDoc=firestoreEventData.getValue().getName().split("/documents/")[1].replace("\"","");logger.info(String.format("Replacing values: %s --> %s",currValue,newValue));// Wait for the async call to completethis.firestore.document(affectedDoc).set(Map.of(FIELD_KEY,newValue),SetOptions.merge()).get();}}

usingCloudNative.CloudEvents;usingGoogle.Cloud.Firestore;usingGoogle.Cloud.Functions.Framework;usingGoogle.Cloud.Functions.Hosting;usingGoogle.Events.Protobuf.Cloud.Firestore.V1;usingMicrosoft.AspNetCore.Hosting;usingMicrosoft.Extensions.DependencyInjection;usingMicrosoft.Extensions.Logging;usingSystem.Collections.Generic;usingSystem.Threading;usingSystem.Threading.Tasks;namespaceFirestoreReactive;publicclassStartup:FunctionsStartup{publicoverridevoidConfigureServices(WebHostBuilderContextcontext,IServiceCollectionservices)=>services.AddSingleton(FirestoreDb.Create());}// Register the startup class to provide the Firestore dependency.[FunctionsStartup(typeof(Startup))]publicclassFunction:ICloudEventFunction<DocumentEventData>{privatereadonlyILogger_logger;privatereadonlyFirestoreDb_firestoreDb;publicFunction(ILogger<Function>logger,FirestoreDbfirestoreDb)=>(_logger,_firestoreDb)=(logger,firestoreDb);publicasyncTaskHandleAsync(CloudEventcloudEvent,DocumentEventDatadata,CancellationTokencancellationToken){// Get the recently-written value. This expression will result in a null value// if any of the following is true:// - The event doesn't contain a "new" document// - The value doesn't contain a field called "original"// - The "original" field isn't a stringstringcurrentValue=data.Value?.ConvertFields().GetValueOrDefault("original")asstring;if(currentValueisnull){_logger.LogWarning($"Event did not contain a suitable document");return;}stringnewValue=currentValue.ToUpperInvariant();if(newValue==currentValue){_logger.LogInformation("Value is already upper-cased; no replacement necessary");return;}// The CloudEvent subject is "documents/x/y/...".// The Firestore SDK FirestoreDb.Document method expects a reference relative to// "documents" (so just the "x/y/..." part). This may be simplified over time.if(cloudEvent.Subjectisnull||!cloudEvent.Subject.StartsWith("documents/")){_logger.LogWarning("CloudEvent subject is not a document reference.");return;}stringdocumentPath=cloudEvent.Subject.Substring("documents/".Length);_logger.LogInformation("Replacing '{current}' with '{new}' in '{path}'",currentValue,newValue,documentPath);await_firestoreDb.Document(documentPath).UpdateAsync("original",newValue,cancellationToken:cancellationToken);}}