Dynomate

Multi-Operation Requests

A multi-operation request contains two or more DynamoDB operations. The current editor supports Query, Put Item, Update Item, and Delete Item.

Use a multi-operation request when later operations need a value from an earlier Query result. The operations are separate DynamoDB calls. Dynomate does not combine the complete request into one DynamoDB transaction.

Multi-operation request tabs are available during a trial and with Professional or Enterprise access. They are not available with Community or Indie access.

Add Operations

  1. Open a request.
  2. Select Add Operation.
  3. Enter a unique operation name.
  4. Select the operation type.
  5. Select an AWS profile.
  6. Select a table ARN.
  7. Configure the operation values.
  8. Repeat these steps for each additional operation.
Operation Current editor inputs
Query Key values, optional index, optional sort-key condition, optional limit, consistent read, and sort order.
Put Item Item attributes and optional equality conditions.
Update Item Item key, fields to set, and fields to remove.
Delete Item Item key and optional equality conditions.

Scan, GetItem, BatchGetItem, and BatchWriteItem are not available in the request editor. The editor also has no batchWrite, #each, conditional skip, or JavaScript-expression syntax.

AWS API permissions

Query uses the DynamoDB Query API. Update Item uses UpdateItem. Put Item and Delete Item each use a single-item TransactWriteItems call, so their AWS profile needs dynamodb:TransactWriteItems permission.

Execution Order

Select Execute to run the current editor state. You do not need to save first.

The current desktop editor sends operations in their displayed order. Dynomate runs one operation at a time. A successful result becomes available to operations that run later.

If one operation fails, Dynomate records a failed outcome. Later operations still run unless the execution request contains a dependency on the failed operation. The current editor limitation described in Dependency Support means an editor run normally continues with the next operation.

Reference Query Results

Dynomate adds each successful operation result to the runtime context. It converts the operation name to lowercase and replaces spaces with underscores. For example, Find order becomes find_order.

Use this placeholder syntax:

${operation_name.path.to.value}

Use dot notation for object fields. Use a numeric index in brackets for an array item. For example: 

${find_order.items[0].orderId}

You can also place a reference inside a larger string: 

audit#${find_order.items[0].orderId}

Result references and variables use the same placeholder grammar. Dynomate performs one substitution pass. It does not evaluate JavaScript, comparisons, array length, or functions inside a placeholder.

Supported template fields include the AWS profile, table ARN, key values, item values, update values, and condition values. Query limit, consistent read, sort order, index name, operation name, and expression text are not template fields in the current editor.

Unresolved references

A reference can use only a value that is available before the operation runs. If a root or path is missing, that operation fails before Dynomate sends its DynamoDB call.

Operation Results

The response panel shows one outcome for each operation. An outcome has the operation name, a status, a result when available, and an error when the operation fails.

  • success means that the operation completed.
  • failed means that validation, substitution, credentials, or DynamoDB returned an error.
  • skipped means that a declared dependency failed.

Query produces the useful data result for chaining. Its result has this shape: 

{
  "items": [
    {
      "accountId": "account#42",
      "orderId": "order#1049",
      "status": "PENDING"
    }
  ],
  "count": 1,
  "scanned_count": 1,
  "last_evaluated_key": null,
  "consumed_capacity": { "capacity_units": 1 },
  "request_id": "example-request-id"
}

Put Item and Delete Item return null after a successful write. Update Item currently returns an empty object because the request does not ask DynamoDB to return updated attributes. Do not use these mutation results as item data for a later operation.

Dependency Support

The saved request format supports one optional direct dependency for each operation. The execution engine can move a dependency before its dependent operation. If the dependency fails, the engine marks the dependent operation as skipped. A missing dependency stops the request before execution.

Current desktop editor limitation

The editor does not provide a dependency control. It can load a saved dependency, but the current Execute action does not send that dependency to the execution engine. Use the displayed operation order for current desktop workflows. Do not rely on a saved dependency to change order or skip a later operation from the editor.

Practical Example

This example queries an order and then updates that order. It uses only fields that the current editor supports.

Operation 1: Find order

  1. Add a Query operation.
  2. Name it Find order.
  3. Select the orders table.
  4. Set the partition key to account#42.
  5. Set a sort-key condition that returns the required order.
  6. Set the limit to 1.

Operation 2: Mark order reviewed

  1. Add an Update Item operation after Find order.
  2. Name it Mark order reviewed.
  3. Select the same table.
  4. Set the partition key to account#42.
  5. Set the sort key to ${find_order.items[0].orderId}.
  6. Add the field status.
  7. Set the field value to REVIEWED.
  8. Select Execute.

If the Query returns no item, the sort-key reference is unresolved. The Update Item outcome then fails before an update call is sent.

Save and Rename

Select Save to write the complete request to its collection. The same save includes every operation and all request variables.

Select the request name in the editor header to rename it. The editor does not provide request descriptions or tags.

See Request Collections for local file behavior and sharing instructions.

Previous Request collections Next Variables