Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Transformieren von Daten mit JSONata in Step Functions

Mit JSonata erhalten Sie eine leistungsstarke Open-Source-Abfrage- und Ausdruckssprache, mit der Sie Daten in Ihren Workflows auswählen und transformieren können. Eine kurze Einführung und eine vollständige JSonata-Referenz finden Sie in der Dokumentation. JSONata.org

Das folgende Video beschreibt Variablen und JSONata in Step Functions anhand eines DynamoDB-Beispiels:

Sie müssen sich anmelden, um die Abfrage- und Transformationssprache JSonata für bestehende Workflows zu verwenden. Wenn Sie einen Workflow in der Konsole erstellen, empfehlen wir, JSONata für die Zustandsmaschine der obersten Ebene zu wählen. QueryLanguage Für bestehende oder neue Workflows, die JSONPath verwenden, bietet die Konsole eine Option zum Konvertieren einzelner Status in JSONata.

Nachdem Sie JSONata ausgewählt haben, werden Ihre Workflow-Felder von fünf JSONPath-Feldern (InputPath, Parameters ResultSelectorResultPath, und) auf nur zwei Felder reduziert: undOutputPath. Arguments Output Außerdem werden Sie keine Schlüsselnamen für .$ JSON-Objekte verwenden.

Wenn Sie mit Step Functions noch nicht vertraut sind, müssen Sie nur wissen, dass JSONata-Ausdrücke die folgende Syntax verwenden:

JSONata-Syntax: "{% <JSONata expression> %}"

Die folgenden Codebeispiele zeigen eine Konvertierung von JSONPath zu JSONata:

# Original sample using JSONPath
{
  "QueryLanguage": "JSONPath", // Set explicitly; could be set and inherited from top-level
  "Type": "Task",
  ...
  "Parameters": {
    "static": "Hello",
    "title.$": "$.title",
    "name.$": "$customerName",  // With $customerName declared as a variable
    "not-evaluated": "$customerName"
  }
}
  

# Sample after conversion to JSONata
{
  "QueryLanguage": "JSONata", // Set explicitly; could be set and inherited from top-level
  "Type": "Task",
  ...
  "Arguments": { // JSONata states do not have Parameters
    "static": "Hello",
    "title": "{% $states.input.title %}", 
    "name": "{% $customerName %}",   // With $customerName declared as a variable
    "not-evaluated": "$customerName"
  }
}
  

Bei gegebener Eingabe { "title" : "Doctor" } und customerName zugewiesener Variablen erzeugen beide Zustandsmaschinen das folgende JSON-Ergebnis: "María"

{
  "static": "Hello",
  "title": "Doctor",
  "name": "María",
  "not-evaluated": "$customerName"
 }
  

Im nächsten Diagramm sehen Sie eine grafische Darstellung, die zeigt, wie die Konvertierung von JsonPath (links) in JSONata (rechts) die Komplexität der Schritte in Ihren Zustandsmaschinen reduziert:

Sie können (optional) Daten aus der Statuseingabe auswählen und in Argumente umwandeln, um sie an Ihre integrierte Aktion zu senden. Mit JSONata können Sie dann (optional) die Ergebnisse der Aktion für die Zuweisung zu Variablen und für die Statusausgabe auswählen und transformieren.

Hinweis: Die Schritte Zuweisen und Ausgeben erfolgen parallel. Wenn Sie sich dafür entscheiden, Daten während der Variablenzuweisung zu transformieren, sind diese transformierten Daten im Ausgabeschritt nicht verfügbar. Sie müssen die JSONata-Transformation im Ausgabeschritt erneut anwenden.

QueryLanguage Feld

In Ihren Workflow-ASL-Definitionen gibt es ein QueryLanguage Feld auf der obersten Ebene einer Zustandsmaschinen-Definition und in einzelnen Status. Indem Sie die QueryLanguage Einstellungen für einzelne Status festlegen, können Sie JSONata schrittweise in eine bestehende Zustandsmaschine übernehmen, anstatt die Zustandsmaschine auf einmal zu aktualisieren.

Das QueryLanguage Feld kann auf oder gesetzt werden. "JSONPath" "JSONata" Wenn das QueryLanguage Feld der obersten Ebene weggelassen wird, ist es standardmäßig auf. "JSONPath" Wenn ein Bundesstaat ein QueryLanguage Feld auf Bundesstaatsebene enthält, verwendet Step Functions die angegebene Abfragesprache für diesen Status. Wenn der Bundesstaat kein Feld enthält, wird die QueryLanguage im Feld der obersten Ebene QueryLanguage angegebene Abfragesprache verwendet.

Schreiben von JSONata-Ausdrücken in JSON-Zeichenketten

Wenn eine Zeichenfolge im Wert eines ASL-Felds, eines JSON-Objektfeldes oder eines JSON-Array-Elements von {% %} Zeichen umgeben ist, wird diese Zeichenfolge als JSONata ausgewertet. Beachten Sie, dass die Zeichenfolge {% ohne führende Leerzeichen beginnen und ohne abschließende Leerzeichen %} enden muss. Ein unsachgemäßes Öffnen oder Schließen des Ausdrucks führt zu einem Validierungsfehler.

Hier einige Beispiele:

Nicht alle ASL-Felder akzeptieren JSONata. Beispielsweise muss das Type Feld jedes Bundesstaates auf eine konstante Zeichenfolge gesetzt werden. In ähnlicher Weise muss das Resource Feld des Task Bundesstaates eine konstante Zeichenfolge sein. Das Map Items Statusfeld akzeptiert ein JSON-Array, ein JSON-Objekt oder einen JSONata-Ausdruck, der zu einem Array oder Objekt ausgewertet werden muss.

Reservierte Variable: $states

Step Functions definiert eine einzelne reservierte Variable namens $states. In JSonata-Zuständen werden die folgenden Strukturen $states zur Verwendung in JSonata-Ausdrücken zugewiesen:

# Reserved $states variable in JSONata states
$states = {
  "input":       // Original input to the state
  "result":      // API or sub-workflow's result (if successful)
  "errorOutput": // Error Output (only available in a Catch)
  "context":     // Context object
}
  

Bei der Zustandseingabe weist Step Functions die Statuseingabe zu $states.input. Der Wert von $states.input kann in allen Feldern verwendet werden, die JSONata-Ausdrücke akzeptieren. $states.inputbezieht sich immer auf die ursprüngliche Statuseingabe.

Für TaskParallel, und gibt Map an:

Der Versuch, auf Felder und Zustände zuzugreifen$states.result, auf die nicht zugegriffen werden kann, wird bei der Erstellung, Aktualisierung oder Überprüfung der Zustandsmaschine abgefangen. $states.errorOutput

Das $states.context Objekt stellt Ihren Workflows Informationen über deren spezifische Ausführung zur Verfügung, z. B. StartTime Aufgabentoken und erste Workflow-Eingaben. Weitere Informationen finden Sie unterZugreifen auf Ausführungsdaten aus dem Context-Objekt in Step Functions.

Behandlung von Ausdrucksfehlern

Zur Laufzeit kann die Auswertung von JSONata-Ausdrücken aus verschiedenen Gründen fehlschlagen, z. B.:

In jedem Fall gibt der Interpreter den Fehler aus:. States.QueryEvaluationError Ihre Status „Task“, „Map“ und „Parallel“ können ein Catch Feld catch Erfassung des Fehlers und ein Retry Feld zur Wiederholung des Fehlers bereitstellen.

Konvertierung von JSONPath nach JSONata

In den folgenden Abschnitten werden die Unterschiede zwischen Code, der mit JSONPath und JSONata geschrieben wurde, verglichen und erklärt.

Keine Pfadfelder mehr

ASL verlangt von Entwicklern, bei der Verwendung von JSONPath beispielsweise Path Feldversionen zu verwendenTimeoutSecondsPath, um einen Wert aus den Statusdaten auszuwählen. Wenn Sie JSONata verwenden, verwenden Sie keine Felder mehr, da ASL JSONata-Ausdrücke in Path Feldern, die nicht im {% %} Pfad enthalten sind, automatisch für Sie interpretiert, z. B. TimeoutSeconds

Ebenso ItemsPath wurde der Map Status durch das Items Feld ersetzt, das ein JSON-Array, ein JSON-Objekt oder einen JSONata-Ausdruck akzeptiert, der zu einem Array oder Objekt ausgewertet werden muss.

JSON-Objekte

ASL verwendet den Begriff Payload-Vorlage, um ein JSON-Objekt zu beschreiben, das JSONPath-Ausdrücke für Parameters und Feldwerte enthalten kann. ResultSelector ASL verwendet den Begriff Payload-Vorlage nicht für JSONata, da die JSONata-Auswertung für alle Zeichenketten erfolgt, unabhängig davon, ob sie eigenständig oder innerhalb eines JSON-Objekts oder eines JSON-Arrays vorkommen.

Nicht mehr. $

ASL verlangt, dass Sie '.$' an Feldnamen in Payload-Vorlagen anhängen, um JSONPath und systeminterne Funktionen verwenden zu können. Wenn Sie angeben"QueryLanguage":"JSONata", verwenden Sie nicht mehr die Konvention '.$' für Feldnamen von JSON-Objekten. Stattdessen schließen Sie JSONata-Ausdrücke in Zeichen ein. {% %} Sie verwenden dieselbe Konvention für alle Felder mit Zeichenkettenwerten, unabhängig davon, wie tief das Objekt in anderen Arrays oder Objekten verschachtelt ist.

Argumente und Ausgabefelder

Wenn das auf gesetzt QueryLanguage istJSONata, werden die alten I/O Verarbeitungsfelder deaktiviert (InputPath, ParametersResultSelector, ResultPath undOutputPath) und die meisten Staaten erhalten zwei neue Felder: Arguments undOutput.

JSONata bietet im Vergleich zu den Feldern, die mit JsonPath verwendet werden, eine einfachere Methode zur Durchführung von I/O Transformationen. Die Funktionen von JSONata machen es Output leistungsfähiger als die Arguments vorherigen fünf Felder mit JSONPath. Diese neuen Feldnamen helfen auch dabei, Ihre ASL zu vereinfachen und das Modell für die Übergabe und Rückgabe von Werten zu verdeutlichen.

Die Output Felder Arguments und (und andere ähnliche Felder wie die des Map BundesstaatesItemSelector) akzeptieren entweder ein JSON-Objekt wie:

"Arguments": {
    "field1": 42, 
    "field2": "{% jsonata expression %}"
}
  

Oder Sie können einen JSONata-Ausdruck direkt verwenden, zum Beispiel:

"Output": "{% jsonata expression %}"
  

Die Ausgabe kann auch jede Art von JSON-Wert akzeptieren, zum Beispiel:"Output":true,. "Output":42

Die Output Felder Arguments und unterstützen nur JSONata, daher ist es ungültig, sie mit Workflows zu verwenden, die JSONPath verwenden. Umgekehrt werden,InputPath, Parameters ResultSelector ResultPathOutputPath, und andere JSONPath-Felder nur in JSONPath unterstützt. Daher ist es nicht zulässig, pfadbasierte Felder zu verwenden, wenn Sie JSONata als oberste Workflow-Sprache oder Statusabfragesprache verwenden.

Übergabezustand

Der optionale Status Result in a Pass wurde bisher als Ausgabe einer virtuellen Aufgabe behandelt. Wenn JSONata als Workflow- oder Statusabfragesprache ausgewählt ist, können Sie jetzt das neue Ausgabefeld verwenden.

Status „Auswahl“

Bei der Verwendung von JSONPath haben Auswahlstatus eine Eingabe Variable und zahlreiche Vergleichspfade, wie z. B. die folgenden: NumericLessThanEqualsPath

# JSONPath choice state sample, with Variable and comparison path
"Check Price": {
  "Type": "Choice",
  "Default": "Pause",
  "Choices": [
  {
    "Variable": "$.current_price.current_price",
    "NumericLessThanEqualsPath": "$.desired_price",
    "Next": "Send Notification"
  } ],
}
  

Bei JSonata gibt es im Auswahlstatus eine Option, Condition in der Sie einen JSONata-Ausdruck verwenden können:

# Choice state after JSONata conversion
"Check Price": {
  "Type": "Choice",
  "Default": "Pause"
  "Choices": [
    {
      "Condition": "{% $current_price <= $states.input.desired_priced %}",
      "Next": "Send Notification"
    } ]
    
  

Hinweis: Variablen und Vergleichsfelder sind nur für JSONPath verfügbar. Condition ist nur für JSONata verfügbar.

JSonata-Beispiele

Die folgenden Beispiele können in Workflow Studio erstellt werden, um mit JSonata zu experimentieren. Sie können die Zustandsmaschinen erstellen und ausführen oder den Teststatus verwenden, um Daten zu übergeben und sogar die Zustandsmaschinen-Definition zu ändern.

Beispiel: Eingabe und Ausgabe

Dieses Beispiel zeigt, wie Sie $states.input die Statuseingabe und das Output Feld verwenden, um die Statusausgabe anzugeben, wenn Sie sich für JSONata entscheiden.

{
  "Comment": "Input and Output example using JSONata",
  "QueryLanguage": "JSONata",
  "StartAt": "Basic Input and Output",
  "States": {
    "Basic Input and Output": {
      "QueryLanguage": "JSONata",
      "Type": "Succeed",
      "Output": {
        "lastName": "{% 'Last=>' & $states.input.customer.lastName %}",
        "orderValue": "{% $states.input.order.total %}"
      }
    }
  }
}
  

Wenn der Workflow mit dem Folgenden als Eingabe ausgeführt wird:

{
  "customer": {
    "firstName": "Martha",
    "lastName": "Rivera"
  },
  "order": {
    "items": 7,
    "total": 27.91
  }
}
  

Bei der Ausführung des Teststatus oder der Zustandsmaschine wird die folgende JSON-Ausgabe zurückgegeben:

{
  "lastName": "Last=>Rivera",
  "orderValue": 27.91
}
  

Beispiel: Filterung mit JSonata

Sie können Ihre Daten mit JSONata Path-Operatoren filtern. Stellen Sie sich beispielsweise vor, Sie haben eine Liste von Produkten zur Eingabe und möchten nur Produkte verarbeiten, die keine Kalorien enthalten. Sie können eine Zustandsmaschinen-Definition mit der folgenden ASL erstellen und den FilterDietProducts Status mit der folgenden Beispieleingabe testen.

State-Machine-Definition für die Filterung mit JSonata

{
  "Comment": "Filter products using JSONata",
  "QueryLanguage": "JSONata",
  "StartAt": "FilterDietProducts",
  "States": {
    "FilterDietProducts": {
      "Type": "Pass",
      "Output": {
        "dietProducts": "{% $states.input.products[calories=0] %}"
      },
      "End": true
    }
  }
}
  

Beispieleingabe für den Test

{
  "products": [
    {
      "calories": 140,
      "flavour": "Cola",
      "name": "Product-1"
    },
    {
      "calories": 0,
      "flavour": "Cola",
      "name": "Product-2"
    },
    {
      "calories": 160,
      "flavour": "Orange",
      "name": "Product-3"
    },
    {
      "calories": 100,
      "flavour": "Orange",
      "name": "Product-4"
    },
    {
      "calories": 0,
      "flavour": "Lime",
      "name": "Product-5"
    }
  ]
}
  

Ergebnis des Testens des Schritts in Ihrer Zustandsmaschine

{
    "dietProducts": [
        {
            "calories": 0,
            "flavour": "Cola",
            "name": "Product-2"
        },
        {
            "calories": 0,
            "flavour": "Lime",
            "name": "Product-5"
        }
    ]
}

Beispiel: Verwendung der vorherigen Statusausgabe in einem Map-Status

Dieses Beispiel zeigt, wie die Ausgabe eines vorherigen Status als Eingabe für einen Map-Status mit JSONata verwendet wird. Der folgende Workflow verwendet den Status Pass, um eine Aufgabe zu simulieren, die eine Bestellung mit einer Liste von Elementen zurückgibt. Anschließend wählt ein Map-Status das Artikel-Array aus dieser Ausgabe aus und iteriert darüber.

Zustandsmaschine (Definition)

{
  "Comment": "Example: Using previous state output in a Map state with JSONata",
  "QueryLanguage": "JSONata",
  "StartAt": "GetOrder",
  "States": {
    "GetOrder": {
      "Type": "Pass",
      "Output": {
        "orderId": "{% $states.input.orderId %}",
        "items": "{% $states.input.items %}"
      },
      "Next": "ProcessItems"
    },
    "ProcessItems": {
      "Type": "Map",
      "Items": "{% $states.input.items %}",
      "ItemProcessor": {
        "ProcessorConfig": {
          "Mode": "INLINE"
        },
        "StartAt": "CalculateItemTotal",
        "States": {
          "CalculateItemTotal": {
            "Type": "Pass",
            "Output": {
              "name": "{% $states.input.name %}",
              "total": "{% $states.input.price * $states.input.quantity %}"
            },
            "End": true
          }
        }
      },
      "End": true
    }
  }
}
  

In dieser Definition gibt der GetOrder Staat die Auftragsdaten unverändert aus. Der ProcessItems Map-Status wird verwendet"Items": "{% $states.input.items %}", um das items Array aus der Ausgabe von auszuwählenGetOrder. Jede Iteration erhält einen Artikel aus dem Array und berechnet den Gesamtwert des Artikels, indem der Preis mit der Menge multipliziert wird.

Beispieleingabe

{
  "orderId": "ORD-1234",
  "items": [
    {
      "name": "Widget",
      "price": 4.99,
      "quantity": 3
    },
    {
      "name": "Gadget",
      "price": 12.50,
      "quantity": 2
    },
    {
      "name": "Bolt",
      "price": 0.75,
      "quantity": 10
    }
  ]
}
  

Erwartete Ausgabe

[
  {
    "name": "Widget",
    "total": 14.97
  },
  {
    "name": "Gadget",
    "total": 25
  },
  {
    "name": "Bolt",
    "total": 7.5
  }
]
  

Beispiel: Reduzieren der Ausgabe im parallelen Zustand

Wenn Sie den Status Parallel verwenden, wird ein Array zurückgegeben, in dem jedes Element die Ausgabe eines Zweigs ist. Mit JSONata können Sie das Output Feld im Parallel-Status verwenden, um diese Ergebnisse zu reduzieren oder zu einem einzigen Objekt zusammenzuführen. Dieser Ansatz ersetzt das Feld JSONPath. ResultSelector

Im folgenden Beispiel wird ein Parallelstatus mit zwei Verzweigungen verwendet. Jeder Zweig simuliert einen GetItem DynamoDB-Aufruf mithilfe eines Pass-Zustands. Der Parallel-Status verwendet $merge($states.result) in seinem Output Feld, um die Verzweigungsergebnisse zu einem einzigen Objekt zusammenzuführen.

Zustandsmaschine (Definition)

{
  "Comment": "Example: Flattening Parallel state output with JSONata",
  "QueryLanguage": "JSONata",
  "StartAt": "GetOrderAndCustomer",
  "States": {
    "GetOrderAndCustomer": {
      "Type": "Parallel",
      "Output": "{% $merge($states.result) %}",
      "Branches": [
        {
          "StartAt": "Get Order",
          "States": {
            "Get Order": {
              "Type": "Pass",
              "Output": {
                "orderId": "{% $states.input.orderId %}",
                "orderDate": "2024-11-20",
                "total": 35.99
              },
              "End": true
            }
          }
        },
        {
          "StartAt": "Get Customer",
          "States": {
            "Get Customer": {
              "Type": "Pass",
              "Output": {
                "customerId": "{% $states.input.customerId %}",
                "customerName": "Martha Rivera",
                "email": "martha@example.com"
              },
              "End": true
            }
          }
        }
      ],
      "Next": "Done"
    },
    "Done": {
      "Type": "Succeed"
    }
  }
}
  

Beispieleingabe

{
  "orderId": "12345",
  "customerId": "C-100"
}
  

Erwartete Ausgabe

{
  "orderId": "12345",
  "orderDate": "2024-11-20",
  "total": 35.99,
  "customerId": "C-100",
  "customerName": "Martha Rivera",
  "email": "martha@example.com"
}
  

Die $merge() Funktion kombiniert eine Reihe von Objekten zu einem einzigen Objekt. Wenn Verzweigungen Objekte mit überlappenden Schlüsseln zurückgeben, haben spätere Array-Elemente Vorrang. Die Verzweigungsergebnisse sind konsistent angeordnet — sie entsprechen der Reihenfolge des Branches Arrays in der State-Machine-Definition.

Von Step Functions bereitgestellte JSONata-Funktionen

JSONata enthält Funktionsbibliotheken für Funktionen vom Typ String, Numeric, Aggregation, Boolean, Array, Object und High Order. Date/Time Step Functions bietet zusätzliche JSonata-Funktionen, die Sie in Ihren JSonata-Ausdrücken verwenden können. Diese integrierten Funktionen dienen als Ersatz für die intrinsischen Funktionen von Step Functions. Systeminterne Funktionen sind nur in Staaten verfügbar, die die JSONPath-Abfragesprache verwenden.

Hinweis: Built-in JSONata-Funktionen, die Ganzzahlwerte als Parameter benötigen, runden automatisch alle angegebenen Zahlen ab, die keine Ganzzahlen sind.

$partition — JSONata-Äquivalent einer States.ArrayPartition systemeigenen Funktion zur Partitionierung eines großen Arrays.

Der erste Parameter ist das zu partitionierende Array, der zweite Parameter ist eine Ganzzahl, die die Chunk-Größe darstellt. Der Rückgabewert wird ein zweidimensionales Array sein. Der Interpreter teilt das Eingabearray in mehrere Arrays der durch die Chunk-Größe angegebenen Größe auf. Die Länge des letzten Array-Chunks kann geringer sein als die Länge der vorherigen Array-Chunks, wenn die Anzahl der verbleibenden Elemente im Array kleiner als die Chunk-Größe ist.

"Assign": {
  "arrayPartition": "{% $partition([1,2,3,4], $states.input.chunkSize) %}"
}

$range — JSONata-Äquivalent zur systemeigenen Funktion zur Generierung eines States.ArrayRange Wertearrays.

Diese Funktion benötigt drei Argumente. Das erste Argument ist eine Ganzzahl, die das erste Element des neuen Arrays darstellt, das zweite Argument ist eine Ganzzahl, die das letzte Element des neuen Arrays darstellt, und das dritte Argument ist die Ganzzahl mit Deltawert für die Elemente im neuen Array. Der Rückgabewert ist ein neu generiertes Array von Werten, das vom ersten Argument der Funktion bis zum zweiten Argument der Funktion reicht, wobei die dazwischen liegenden Elemente durch das Delta angepasst werden. Der Deltawert kann positiv oder negativ sein, wodurch jedes Element vom letzten Element bis zum Erreichen oder Überschreiten des Endwerts erhöht oder verringert wird.

"Assign": {
  "arrayRange": "{% $range(0, 10, 2) %}"
}

$hash — JSONata-Äquivalent der States.Hash systemeigenen Funktion zur Berechnung des Hashwerts einer bestimmten Eingabe.

Diese Funktion benötigt zwei Argumente. Das erste Argument ist die Quellzeichenfolge, die gehasht werden soll. Das zweite Argument ist eine Zeichenfolge, die den Hash-Algorithmus für die Hash-Berechnung darstellt. Der Hash-Algorithmus muss einen der folgenden Werte haben:"MD5",,, "SHA-1""SHA-256","SHA-384". "SHA-512" Der Rückgabewert ist eine Zeichenfolge mit dem berechneten Hash der Daten.

Diese Funktion wurde erstellt, weil JSONata die Fähigkeit zur Berechnung von Hashes nicht nativ unterstützt.

"Assign": {
  "myHash": "{% $hash($states.input.content, $hashAlgorithmName) %}"
}

$random — JSONata-Äquivalent der systemeigenen Funktion zur Rückgabe einer States.MathRandom Zufallszahl n where. 0 ≤ n < 1

Die Funktion verwendet ein optionales Integer-Argument, das den Startwert der Zufallsfunktion darstellt. Wenn Sie diese Funktion mit demselben Ausgangswert verwenden, gibt sie eine identische Zahl zurück.

Diese überladene Funktion wurde erstellt, weil die integrierte JSONata-Funktion $randomkeinen Startwert akzeptiert.

"Assign": {
   "randNoSeed": "{% $random() %}",
   "randSeeded": "{% $random($states.input.seed) %}"
}

$uuid — JSONata-Version der systemeigenen Funktion. States.UUID

Die Funktion akzeptiert keine Argumente. Diese Funktion gibt eine v4-UUID zurück.

Diese Funktion wurde erstellt, weil JSONata die Fähigkeit, UUIDs zu generieren, nicht nativ unterstützt.

"Assign": {
  "uniqueId": "{% $uuid() %}"
}

$parse - JSONata-Funktion zum Deserialisieren von JSON-Strings.

Die Funktion verwendet ein stringifiziertes JSON als einziges Argument.

JSonata unterstützt diese Funktionalität über$eval; $eval wird jedoch in Step Functions Functions-Workflows nicht unterstützt.

"Assign": {
  "deserializedPayload": "{% $parse($states.input.json_string) %}"
}