CRUD from Record Variable

The Avonni Dynamic Components provide a set of interactions that allow you to perform CRUD (Create, Read, Update, Delete) operations on Salesforce records directly. These interactions operate on Record Variables that you define within your Dynamic Component.

Overview

These interactions are not typically used with components that have built-in data binding and automatic updates (like Data Table, List, Kanban, Map). Those components handle data updates through their data source configurations. Instead, the CRUD interactions are most valuable when:

• Working with Individual Records: You need to create, update, or delete a single record based on user actions or other logic outside the context of a repeating list.

• Custom Forms: You're building a custom form (using individual Input components, not a Data Table) to create or update a record.

• Combining with "On Load": You want to retrieve a record's data when a component loads, modify it, and then save the changes.

• Complex Scenarios: More complex scenarios require fine-grained control over record manipulation.

Available Interactions

• Create from Record Variable: Creates a new Salesforce record using the data in a Record Variable.

• Update from Record Variable: Modifies an existing Salesforce record, updating it with the data in a Record Variable.

• Upsert from Record Variable: Creates or updates a new record.

• Delete from Record Variable: Deletes a Salesforce record. Use this with extreme caution!

How it Works: Record Variables are Key

These interactions always work in conjunction with a Record Variable. Here's the process:

1. Create a Record Variable: You define a Record Variable resource in your Dynamic Component, specifying the Salesforce object type (e.g., Account, Contact, My_Custom_Object__c).

2. Populate the Record Variable: You need to get data into the Record Variable. This can happen in several ways:

   • "On Load" + "Get Records" (for Updates/Deletes): Use an "On Load" interaction on your component. Within the "On Load" interaction, add a "Get Records" action. Configure "Get Records" to retrieve the specific record you want to work with (usually based on an ID from a URL parameter, like @recordId on a record page) and store the result in your Record Variable.

   • User Input (for Creates/Updates): Place individual input components (Text Input, Number Input, etc.) on your canvas and bind their Value properties to the fields of your Record Variable (e.g., {!MyAccountVariable.Name}, {!MyAccountVariable.Industry}). As the user enters data, the Record Variable is automatically updated.

   • Set Variable Value interaction: To change the value of the record variable.

3. Trigger the Interaction: Add an interactive component (usually a Button) and configure an "On Click" (or other relevant event) interaction.

4. Choose the Action: Select the appropriate CRUD interaction ("Create from...", "Update from...", "Delete from...", "Upsert from...").

5. Select the Record Variable: In the interaction's configuration, choose the Record Variable you populated in step 2.

6. Select Fields (Create/Update/Upsert) Select fields to be used.

Example: Updating Related Account Information from a Contact Page

Let's say you're on a Contact record page and want to display and allow editing of some fields from the related Account.

1. Set Target Object API Name: In your Dynamic Component's settings, set the Target Object API Name to Contact. This gives you access to the current Contact record via $Component.record.

2. Create an Account Record Variable: Create a Variable resource:

   • API Name: relatedAccount

   • Data Type: Record

   • Object API Name: Select Account.

   • Availability Outside...: Leave these unchecked for this example.

3. Add an "On Load" Interaction:

   • Select your Dynamic Component itself (not a specific component within it).

   • Add an "On Load" interaction.

   • Action Type: Choose Get Records.

   • Object API Name: Select Account.

   • Record ID: Use direct attribute referencing to get the Account ID from the current Contact: @recordId.

   • Record Variable: Select your relatedAccount variable. This is where the retrieved Account data will be stored.

   • Fields: Select the fields you want to retrieve from the Account.

4. Display Account Fields: Add Text components (or other display components) to your canvas. Bind their Value properties to the fields of the relatedAccount variable (e.g., {!relatedAccount.Name}, {!relatedAccount.Industry}).

5. Add Input Components (for Editing): Add Input components (Text Input, etc.) for the Account fields you want to allow the user to edit. Bind the Value property of each Input component to the corresponding field of the relatedAccount variable (e.g., bind a Text Input's Value to {!relatedAccount.Name}).

6. Add a "Save" Button: Add a Button component, labeled "Save Account Changes".

7. Add an "On Click" Interaction to the Button:

   • Select the Button.

   • Add an "On Click" interaction.

   • Action Type: Choose Update from Record Variable.

   • Record Variable: Select your relatedAccount variable.

   • Fields: Select your fields.

8. Add Show Toast action:

   • Add an On Finish interaction, choose Show Toast

   • Set a message.

Now, when the component loads on a Contact page:

• The "On Load" interaction fetches the related Account record and stores it in relatedAccount.

• The display components show the Account data.

• The user can edit the Account fields via the Input components (which are bound to relatedAccount).

• Clicking "Save" triggers the "Update from Record Variable" interaction, updating the Account in Salesforce with the data from relatedAccount.

• The Toast message confirms.

Important Considerations

• Record Variables are Essential: These CRUD interactions require Record Variables.

• "On Load" for Retrieval: Use "On Load" with "Get Records" to fetch existing record data.

• Data Binding for Input: Use data binding to connect Input components to the fields of your Record Variable.

• Error Handling: Consider adding error handling (e.g., using the "On Error" event of the "Execute Flow" interaction, if you're using a Flow for more complex logic).

• Permissions: Users need the appropriate Salesforce permissions (Create, Edit, Delete) on the relevant objects.

• Use with caution the Delete Action: Use carefully the delete action.

In Summary

Avonni Dynamic Components provides a powerful way to interact with Salesforce data using Record Variables and CRUD interactions. These features allow you to build sophisticated data management capabilities without writing code, making it ideal for creating custom forms and updating related records.