The script tag may be provided the optional style attribute "--detail: once" to specify that the script should execute before content personalization for each recipient begins.

This also works for the iTL expression, using iTL parameter syntax:

Content generated with message.write() in this context is inserted literally into the message, without link tracking or other automatic interpretation. Lookup(), Query(), and Webscrape() operations are allowed, but no per-recipient identifiers are available in SSJS during the interpretation of a run-once script.

You can use script.outerHTML to create content whose interpretation is deferred until send time:

<script type="itl/javascript" style="--detail: once">
script.outerHMTL += "<a href='https://www.ipost.com'>iPost</a>";
</script>

Although it refers to HTML, this also works for {\javascript ...} expressions in plain text.

This object provides access to the data describing the recipient of the message. Unless specified below, assignments to the properties of this object do not have an effect outside of the Javascript scope. The contact object has no defined fields during run-once scripts.

This object provides access to the data describing the client.

An object representing the <script> element that contains the executing script. It currently has four properties:

When processing content for email sending, this represents the current message body part in which the script appears. In other contexts this property is undefined.

There are also four attributes that may be available when the message is sent by injection of a contact into a journey. Whether they are defined depends on the journey configuration.

message.formdata.submitterIP

message.formdata.submitTime

Information about the form submission that injected this contact.

message.formdata.newEmailAddress

message.formdata.oldEmailAddress

The new and previous email addresses in the event of an address change.

None of these are defined in run-once scripts. 

These attributes may become read-only in the future.

An object providing low-level interfaces to the iTL engine. It currently has six function properties, get, set, call, ref, literal, and log.

For example:

Note that the following iTL forms may not be called this way.  As a workaround to these restrictions, see script.outerHTML above.

Output a timestamped string (or list of strings) to the log, with the source line number appended.

Return a string that is the JSON representation of the object.

Converts a JSON string back into an object. This is a convenience function; the following two examples should be equivalent: 

 var jsonString = '{ "one": "1", "two": "2" }';
 var obj = JSON.parse(jsonString); // Example 1
 eval("var obj = "+jsonString);    // Example 2

Returns an object representing a tracked URL. The type is a string, typically one of "a" (for anchor), or "img", indicating the context of the URL. The link() method of that object returns the encoded and tracked representation of url, or throws an Error if the URL schema prevents tracking. Usage is for example:

This is usually better done with message.a(), but there may be cases in which a tracked URL is wanted without the HTML markup. 

In run-once scripts the link() method returns an iTL expression representing the link, suitable for use in script.outerHTML. However, note that the content of script.outerHTML is subject to automatic link rewriting, so Link() is not usually needed.

Returns an object defining a simple search of a single Custom Data Table. The searchFields are required and are represented by an Object with property names corresponding to column names from the table and values to be matched against the table rows. All matches are exact, but are case-insensitive unless otherwise determined by the column definition for the table.

The tableName must be a String and may be of the form "db.table" where "db" names an alternate database. Currently only two database names are valid: The system tables database (ID_imm), and the client's customizable database (ID_cdt), which is selected by default.

The optional orderBy is an Object with properties corresponding to columns and values "asc" or "desc" for the direction of the ordering. The optional limit determines the maximum number of rows to return.

The returned object has a single function property:

execute(trackUrls) 

Performs the table search and returns an Array. Each element of that Array is an Object corresponding to one matched row from the table. If no rows match, the returned Array is empty. The properties of each object are the column names from the table.

If the optional Boolean trackUrls is true, any text-typed values in the returned rows are scanned for URL references, and those references are converted as described for the Link().link() method.

Example: 

 var rIndexArray = Array("ASU", "DEL", "JMU", "NYU", "OCM");
 for (var i in rIndexArray) {
   var look = Lookup("school_branding", {school_code: rIndexArray[i]});
   var result = look.execute();
   if (result.length) {
     var school = result[0];
     message.write(rIndexArray[i]+" is code for "+school.school_name);
   }
 }

Lookup() throws errors for incorrect parameter usage, such as tableName not a String or limit not a number. It's an error to use trackURLs = true in run-once scripts in the execute(), get(), and post() functions.

Alternately: Query({id:queryId,key:keyField,bind:bindings,limit:limit})

Returns an object representing a query defined in the Enterprise SQL Queries user interface. All arguments except the queryId are optional. The arguments may be passed either as properties of an object, or as positional arguments as shown. In the positional form, if you wish to provide bindings without using a keyField, you must explicity use undefined as the second argument.

The positional form is a convenience most useful when the only argument is the queryId, thus:

var query = Query(74);

The keyField is used by the execute() method (see below) to structure the query results. If a keyField is defined, rows are unordered, otherwise they are ordered as defined in the query.

The bindings are contained in an object whose property names are the names of variables declared in the query definition, and the limit declares the maximum number of rows to return, which defaults to, and may never exceed, 100 rows. The bindings property names must include the "@" prefix used for variable naming in SQL, so they should be quoted as strings (see example below).

execute(trackUrls,newBindings) 

Runs the query specified by queryId. If the optional Boolean trackUrls is true, any text-typed values in the returned rows are scanned for URL references, and those references are converted as described for the Link().link() method. Optional newBindings may be provided to replace the bindings, in the same format. 

The return value is determined by the keyField: 

• If the query results in no rows, the result is the undefined value. This differs from iTL {\query} which returns an empty list, but maintains the semantic that a query of no result is Boolean false.
• If the keyField is undefined, or does not refer to a name that is present in the SELECT list of the query, the result is an Array. Each element of that Array is itself an Array corresponding to one matched row from the table, following the ORDER BY of the query (if any). The order of the fields is as defined in the SELECT list.
• Otherwise the result is an Object whose properties are the values of the keyField from each row. The value of each property is an Object representing one row from the query, as described above for Lookup().execute(). Note that the keyField results are not required to be syntactically valid as unquoted property names, so the object.property syntax is not always usable to reference these rows. Use object["property"] format when necessary. 

Example:

// In this example, queryID = 74 has "SET @qEmail = ..."
// and "SELECT email, first_name, last_name FROM ..."
// ITL: {\query \id=74 \bind={{@qEmail {\recipient_addr}}} \limit=1}

var query = Query({id:74,bind:{"@qEmail": contact.emailAddress},limit:1});
var result = query.execute();
if (result) {
   // keyField was undefined, so result is an Array, and limit == 1
   var row = result[0];
   // Output: email last,first
   message.write(row[0]+" "+row[2]+","+row[1]);
}

// Same query, alternate format, using keyField = "email" and no limit
// ITL: {\query \id=74 \key=email \bind={{@qEmail {\recipient_addr}}}}

var query = Query(74,"email",{"@qEmail": contact.emailAddress});
var result = query.execute();
if (result) {
   var row = result[contact.emailAddress];
   message.write(row.email+" "+row.first_name+","+row.last_name);
}

Query() throws errors for incorrect parameter usage, such as keyField not a String or limit not a number. It's an error to use trackURLs = true in run-once scripts in the execute(), get(), and post() functions.

Returns an object defining a remote content source. The only valid URI schema for url are http, https, and ftp, other URLs throw an error. This is based on the iTL {\webscrape} macro, see the iTL documentation for additional details.

The optional params object defines form data for POST requests.

The returned object has two function properties, each of which returns a String containing the answer from the remote server:

get(trackUrls) 

Issues a GET request. If url does not have a search string (aka query parameters) and params were provided, that form data is converted into a search string. The optional Boolean trackUrls (default false) determines whether the retrieved content is searched for URL references, which if found are encoded as described above for Link().link(). 

post(trackUrls, headers) 

Issues a POST request. If url has a search string and no params were provided, the search string is converted into form data. Boolean trackUrls is as for get(). The optional headers object defines additional headers for the request, such as authentication tokens, etc.

Behavior when both a search string and form data are present is determined by the remote server.

Note headers are not supported for GET requests, because the iTL {\webscrape} supports them only for POST.

Both of these functions will throw an error if there is any problem either retrieving the content, or converting it for inclusion in the message source. Note that unlike raw iTL {\webscrape}, this interface does not provide for "fallback content" to suppress these errors, so use try/catch() if a fallback is desired.

It's an error to use trackURLs = true in run-once scripts in the execute(), get(), and post() functions.

Return a string that is a simple XML representation of the object. Throws SyntaxError if object does not represent a node tree.

Converts an XML string into an object. This may be used to parse HTML content, but the resulting object tree may be ambiguous, so may not reproduce the original if converted back into HTML.

The parse is forgiving of unmatched < and of unstructured text preceding or following balanced XML tags, but throws SyntaxError for more serious errors such as a closing tag with no corresponding open.