All library modules are provided a context
variable when they are executed. The structure of the context
variable is the following:
The arc
property represents an object that provides information about the event triggering the rule. It contains the following properties:
context.arc.event: Object<string, *>
logger.log(context.arc.event);
The event that triggered the rule. The object will contain the following values:
rule.xdm: string
The XDM object of the event.
rule.data: string
The custom data layer.
context.arc.request: Object<string, *>
logger.log(context.arc.request);
The request that travels through the Adobe Edge Network that will finnaly be processed by the edge server. This object is not intended for public consumption and will not be detailed inside the documentation.
context.arc.ruleStash: Object<string, *>
logger.log(context.arc.ruleStash);
ruleStash
is an object that will collect every result from action modules.
Each extension has its own namespace. For example, if your extension has the name send-beacon
, all the results from the send-beacon
actions will be stored on the ruleStash['send-beacon']
namespace.
The namespace is unique for each extension and it has the value undefined
at the beginning.
The namespace will be overridden with the returned result from each action. There is no namespace magic happening. Let’s say we have a transform
extension containing two actions: generate-fullname
and generate-fulladdress
. Let’s say we add the two actions to a rule.
If the result of generate-fullname
action is Firstname Lastname
, then the rule stash will appear as follows after the action is completed:
{
transform: 'Firstname Lastname`
}
If the result of the generate-address
action is 3900 Adobe Way
, then the rule stash will appears as follows after the action is completed:
{
transform: '3900 Adobe Way`
}
Notice that “Firstname Lastname” no longer exists within the rule stash, because the generate-address action overrode it with the address.
If you want to store the results from both actions inside the transform
namespace in the ruleStash
you can write your action module similar to the following example:
module.exports = (context) => {
let transformRuleStash = context.arc.ruleStash.transform;
if (!transformRuleStash) {
transformRuleStash = {};
}
transformRuleStash.fullName = 'Firstname Lastname';
return transformRuleStash;
}
The first time this action is executed, the ruleStash
will be undefined
and we initialize it with an empty object. The next time when the action is executed, we will get the ruleStash
returned by our action when it was previously called. Using an object as ruleStash
, allows us to add new data without losing data previously set by other actions from our extension.
You need to be careful to always return the full extension rule stash in this case. If you were to return only a value (eg: 5), then the rule stash would look like:
{
transform: 5
}
The utils
property represents an object that provides utilities specific to the Launch runtime.
context.utils.logger: Object<string, Function>
context.utils.logger.error('Error!');
Logging utility used to log messages that will be shown during debugging session when using the Adobe Experience Cloud Debugger Chrome extension. The logger has the following methods:
logger.log(message:string)
Logs a message to the console.
logger.info(message: string)
Logs an informational message to the console.
logger.warn(message: string)
Logs a warning message to the console.
logger.error(message: string)
Logs an error message to the console.
logger.debug(message: string)
Logs a debug message to the console. (Visible only when verbose
logging is enabled within your browser console.)
context.utils.fetch: Function
context.utils.fetch('http://example.com/movies.json')
.then(response => response.json())
Fetch utility that implements Fetch API. You can use the function to make requests to third-party endpoints.
context.utils.getBuildInfo: Function
logger.log(context.utils.getBuildInfo().turbineBuildDate);
A function that returns an object containing information about the build of the current Launch runtime library. The object will contain the following values:
buildInfo.turbineVersion: string
The Turbine version used inside the current library.
buildInfo.turbineBuildDate: string
The ISO 8601 date when the version of Turbine used inside the container was built.
buildInfo.buildDate: string
The ISO 8601 date when the current library was built.
buildInfo.environment: string
The environment for which this library was built. The possible values are: ‘development’, ‘staging’, ‘production.’
This is an example demonstrating the object values that are returned by the getBuildInfo
function:
{
turbineVersion: "1.0.0",
turbineBuildDate: "2016-07-01T18:10:34Z",
buildDate: "2016-03-30T16:27:10Z",
environment: "development"
}
context.utils.getExtensionSettings => Function
logger.log(context.utils.getExtensionSettings());
Returns the settings object that was last saved from the extension configuration view.
context.utils.getSettings => Function
logger.log(context.utils.getSettings());
Returns the settings object that was last saved from the library module corresponding view.
context.utils.getRule: Function
logger.log(context.utils.getRule());
Returns an object containing information about the rule that is triggering the module. The object will contain the following values:
rule.id: string
The rule ID.
rule.name: string
The rule name.