For example, in the JavaScript template, the body of the loop is per the following:

// Read the next document, wrap it in a map and write out the wrapper
var doc = this.input.next();
var wrapper = {
    "original" : doc
}
this.output.write(doc, wrapper);

For JavaScript, objects written to the output view should be composed of serializable Java types. Some downstream Snaps, such as the Copy Snap, require this. To write out a map to the output view in a JavaScript, use a Java Map implementation, such as HashMap or LinkedHashMap, per the following:

importClass(java.util.LinkedHashMap);
...
var inDoc = this.input.next();
var outDoc = new LinkedHashMap();
outDoc.put("original", inDoc);
this.output.write(inDoc, outDoc);

To implement Python in the Script Snap, we use Jython. We have upgraded the Jython engine from version 2.7-b3 (a beta version from 2014) to version 2.7.2(March 2020). The following are the resultant issues and workarounds:

• An open bug in 2.7 introduced a backward-incompatible change in the SnapLogic platform wherein the Jython engine automatically converts BigInteger values to primitive long values. This impacts all your scripts that perform numeric manipulation of integer values from documents (SnapLogic uses the BigInteger type to represent integers in documents). Your pipelines and Snaps with the Script (or the deprecated Execute Script) that use numeric manipulation scripts with integer or BigInteger data type may fail during execution. We recommend you prospectively replace integer or BigInteger values with long values.

The known fix is to rewrite the above calculation as sum = a + b by removing occurrences of .intValue() or .longValue() from your Python scripts.

• Before the 4.22 release (August 2020), when using the Script Snap with the Scripting language option selected as Python, requesting a key that did not exist in a dictionary (for example, my_dict['missing_key']) would return None. Starting from the 4.22 release, the same request returns a KeyError exception. If you need to continue returning None, use the .get(key) method instead (for example, my_dict.get['missing_key']).

• - zlib.compress():
 The zlib library compresses the JSON files retrieved from the SnapLogic APIs and backs-up Pipelines and accounts to a database. The following Python code, when trying to compress displays an ascii … ordinal not in range(128) error.

  Original code: in_doc["json"] = zlib.compress(in_doc["json"])

  Fix: in_doc["json"]

  =
      zlib.compress(in_doc["json"].encode("utf-8"))

• {dictionary}.values().toArray()[i]:
Before the 4.22 release (August 2020), to subscript a {dictionary}.values() method, you had to append the toArray() method to values(); else, you would see the

  Failure: ‘java.util.LinkedHashMap$LinkedValues’ object is
            unsubscriptable

  error. After the 4.22 release, toArray() returns Failure: ‘list’ object has no attribute ‘toArray’. However, the requirement for toArray() is no longer necessary for the subscript.

  Original code: sLine = data.values().toArray()[0]

  Fix: sLine = data.values()[0]

package com.snaplogic.scripting.language;

import java.util.Iterator;

/**
 * ScriptHook is the interface that should be implemented as a callback mechanism for
 * ExecuteScript snap to call into the script.
*/

public interface ScriptHook {

    /**
     * Scripts should implement this method to provide application logic.
     */
    void execute();

    /**
     * Scripts should implement this method to cleanup any resources allocated in execute().
     */
    void cleanup();

    /**
     * Input is interface that is used by the script to read input from the snap's input view.
     */
    interface Input extends Iterator<Object> {
    }

    /**
     * Output is interface that is used by the script to send output data to the snap output view.
     */
    interface Output {

        /**
         * Write the data to the snap output.
         *
         * @param data
         */
        void write(Object data);

        /**
         * Write the data that was generated for the given incoming data to the snap output.
         * This method carries the lineage data forward.
         *
         * @param incomingData
         * @param data
         */
        void write(Object incomingData, Object data);
    }

    /**
     * Error is interface that is used by the script to send error data to snap error view.
     */
    interface Error extends Output {
    }
}

While SnapLogic does not support importing third-party libraries directly using the Script Snap, you can add their package/JAR files in a directory in your Groundplex nodes and then import them using this Snap. For example, consider that you have added the JAR file, mongo-java-driver-3.12.7.jar, in the directory /opt/snaplogic/ext_jar/. For your Python scripts to be able to use this library, create a file named .jython in the home directory of the user running the JCC process. The .jython file should specify a value for the python.path, as follows:

python.path=/opt/snaplogic/ext_jar/mongo-java-driver-3.12.7.jar

Here’s an example of Python script that imports and uses code from this library. Use the cleanup method to ensure that the mongoClient object is appropriately closed.

from com.snaplogic.scripting.language import ScriptHook
from com.mongodb.client import MongoClients
class TransformScript(ScriptHook):
    def __init__(self, input, output, error, log):
        self.input = input
        self.output = output
        self.error = error
        self.log = log
    def execute(self):
        try:
            self.mongoClient = MongoClients.create("mongodb://localhost:27017/?readPreference=primary&ssl=false")
            for d in self.mongoClient.listDatabases():
                self.output.write(d)
        except Exception as e:
            errDoc = {
                'error' : str(e.args)
            }
            self.error.write(errDoc)
    def cleanup(self):
        self.mongoClient.close()
hook = TransformScript(input, output, error, log)

The script author should declare a global variable named 'hook' (note that this variable name is case-sensitive). The Script engine makes the following four global variables available to the script as defined in the Script#ScriptHook Interface section:

• The variable input is of type ScriptHook.Input

• The variable output is of type ScriptHook.Output

• The variable error is of type ScriptHook.Error

• The variable log is of type org.slf4j.Logger

Data Type	Java Class
NUMBER	java.math.BigDecimal
INTEGER	java.math.BigInteger
STRING	java.lang.String
DATETIME	org.joda.time. DateTime
LOCALDATETIME	org.joda.time. LocalDateTime
BOOLEAN	java.lang.Boolean
DATE	org.joda.time.LocalDate
TIME	org.joda.time.LocalTime
BINARY	java.lang.Byte
TABLE	java.util.List
ANY	java.lang.Object
COMPOSITE	java.util.Map