Triggers 

What is a trigger? 

Triggers in Gadget are events or conditions that initiate an action within an application. They parse external events, such as incoming webhooks or API calls, and then run your action with parameters. Default triggers are already established in many actions, such as the API endpoint trigger for integrating the action into your app's API or the Shopify data trigger that executes actions in response to Shopify webhooks.

How triggers work 

Each trigger in Gadget does two things:

1. Activates on a certain event: Each trigger is designed to execute at a specific point, determined by various conditions or events. For instance, an API endpoint trigger executes when its corresponding mutation in the GraphQL API is invoked, while a Scheduler trigger activates at pre-set time intervals like a cron job might.

2. Sends the params and trigger to the action: Upon activating, the trigger tests authorization. If successful, the action is run with the params and trigger variables parsed out by the trigger. The contents of the params object depend on the trigger, and the contents of the trigger object describe which trigger ran and why.

Types of triggers 

API endpoint trigger 

The API endpoint trigger invokes your action when an incoming API call is made to your application's API. For more on your application's API and how to make API calls, see the API Reference.

By default, most actions have an api trigger already registered. If you want to explicitly register an api trigger, you can do so by adding an api property to the triggers object in the action's options.

How the API actions are run 

The API trigger runs your actions when the corresponding mutation is run in your application's generated API. When this mutation is called, the trigger assesses if the caller has permission to run the action using your application's access control.

If permitted, the action's run function is executed, passing any incoming parameters. For model actions, the resulting record is sent back to the API caller, and for global actions the return value of the run function is sent back. If any errors are thrown during processing, those errors are instead sent back to the caller.

The generated API endpoints for your API triggers can be called using the api object within your application, or using the React hooks from @gadgetinc/react hooks library, or any other GraphQL client.

API endpoint trigger params 

The API endpoint trigger validates that incoming parameters match the expected types for the action, and then passes the params to the action.

For model actions, API triggers add automatic params for each field on the model. For global actions, there are no params by default.

For more on adding parameters to actions, see the action guide.

API endpoint trigger trigger object 

When an action is invoked via an API call, the passed trigger object will look like this:

an example API trigger object
json
Copy
{
  "type": "api",
  "mutationName": "updateWidget",
  "rootAction": "update",
  "rawParams": {
    "id": "123",
    "widget": {
      "title": "New Widget Title",
      "inventoryCount": 10
    }
  }
}

• type: will always be set to api.
• mutationName: the string name of the mutation called in the API.
• rootAction: the API identifier of the action triggered by the mutation.
• rawParams: the params passed to this API call.

Scheduler trigger 

The Scheduler trigger invokes your action at a regular interval. For example, scheduled actions can be used to send out periodic emails, build database aggregates, or sync data from external systems.

The Scheduler trigger has a scheduler property which describes how often the action should be run, and at what specific times. For example, you can create a Schedule that runs every day at 10:00 AM UTC:

Schedule triggers also support multiple individual schedules, and will invoke your action at each time specified by any included schedule. For example, we can set up a scheduler to run an action every day at midnight UTC, as well as every Wednesday at noon:

Schedule triggers can also be expressed using cron syntax, which is a more powerful way to define schedules. For example, the following scheduler options will run an action every day at midnight UTC:

The minimum interval supported by the scheduler trigger is once a minute.

How scheduled actions are run 

When you add a Scheduler trigger, Gadget's internal scheduler starts a ticking clock. When the time arrives for a scheduled action to run, Gadget invokes the global action. Unlike api triggers, no params will be passed to the action.

Overlapping executions 

If a scheduled action is still running when the next scheduled invocation arrives, that next invocation will be skipped. For example, if an action is scheduled to run every minute and it takes 3.5 minutes to complete, the executions that were scheduled during that 3.5-minute window will be skipped.

Schedule trigger params 

The Scheduler trigger passes an empty params object when it invokes an action.

If you need to know the current time for executing your action, you can use new Date().

Schedule trigger trigger object 

The Scheduler trigger passes a simple trigger object describing the trigger type:

json
Copy
{
  "type": "scheduler"
}

Shopify data trigger 

The Shopify data trigger executes model actions when:

• Shopify sends a webhook to your Gadget application
• when a missed webhook is detected by Gadget during reconciliation
• or when a sync is run and data differences are detected

When this trigger runs, it:

1. parses the payload from Shopify, performing HMAC validation on webhooks to ensure authenticity
2. transforms the payload into appropriate params for each record described in the payload
3. executes the action for each record in the payload, including nested records

Shopify data triggers can also be added to global actions to process webhooks there. For more information on how to use Shopify data triggers in global actions check out the guide here. You can include a shopify trigger in Shopify models, but not other models.

Shopify data triggers look like this within your action's options:

Shopify data trigger params 

For model actions, the Shopify data trigger pulls out the right parameters for the current record from the payload and adjusts the keys to have consistent JavaScript style-casing. For example, when a webhook for a product/create webhook arrives, Gadget chops up the payload into the chunk to create params for the root-level product, and then another set of params for each shopifyProductVariant record described in the payload. For this example webhook on the shopifyProduct model, the params object will look like this:

example model action Shopify Webhook trigger params
json
Copy
{
  "id": "12345",
  "shopifyProduct": {
    "title": "Example T-Shirt",
    "tags": ["example", "t-shirt"],
    "publishedAt": "2024-01-01T00:00:00Z",
    "productCategory": {
      "id": "12345",
      "name": "Shirts"
    }
    // ... etc
  }
}

and for the shopifyProductVariant model, the params object will look like this:

example model action Shopify Webhook trigger params
json
Copy
{
  "id": "5678",
  "shopifyProductVariant": {
    "title": "Example T-Shirt",
    "sku": 10,
    "price": 10.99,
    "inventoryPolicy": "continue",
    "fulfillmentService": "manual"
    // ... etc
  }
}

For global actions, the incoming Shopify webhook payload is delivered as the params unchanged. For a product/create webhook, the params object will look like this:

example global action Shopify Webhook trigger params
json
Copy
{
  "topic": "products/create",
  "payload": {
    "admin_graphql_api_id": "gid://shopify/Product/788032119674292922",
    "body_html": "An example T-Shirt",
    "created_at": null,
    "handle": "example-t-shirt",
    "id": 788032119674292922
    // ... etc
  }
}

Shopify data trigger trigger object 

When a Shopify data trigger invokes an action, it will pass a trigger describing the event that caused the action to run. For the Shopify data trigger, this can be one of two events:

• a webhook was received
• a sync detected differences

You can detect which type of event occurred by checking the type property of the trigger object:

Example webhook trigger object 

When a Shopify webhook is received by your Gadget application, the trigger object passed to your action will look like this:

json
Copy
// An example Shopify Webhook trigger
{
  "type": "shopify_webhook",
  "topic": "products/update",
  "payload": {
    "id": 788032119674292900,
    "title": "Example T-Shirt",
    "body_html": "An example T-Shirt",
    "vendor": "Acme",
    "product_type": "Shirts",
    "created_at": null,
    "handle": "example-t-shirt"
    // ... etc matching Shopify's format exactly
  },
  "shopId": "shop123",
  "retries": 0
}

• type: will always be set to shopify_webhook
• topic: the string representing the topic of the incoming webhook from Shopify, like products/update or orders/create
• payload: the raw incoming payload from Shopify, which includes all the data sent by the webhook unchanged
• shopId: the identifier for the Shopify store that received the webhook
• retries: the number of times this webhook has been retried

Example sync trigger object 

When a sync of a particular Shopify shop is run and detects differences, the trigger object passed to your action will look like this:

An example Shopify Sync trigger
json
Copy
{
  "type": "shopify_sync",
  "shopId": "123456",
  "apiVersion": "2023-01",
  "shopifyScopes": ["read_products", "write_products"],
  "syncId": "1",
  "syncSince": null,
  "models": ["shopifyShop", "shopifyProduct"],
  "force": false,
  "startReason": undefined // will be "scheduled" if Action ran via daily sync
}

• type: Will always be set to shopify_sync
• shopId: The identifier of the Shopify shop being synced
• apiVersion: The version of the Shopify API being used for the sync
• shopifyScopes: The available OAuth scopes of the Shopify shop being synced
• syncId: The identifier of the sync record tracking the state of this sync (optional, only available if set)
• syncSince: The specified date range of this sync (optional, only set if specified when the sync was started)
• models: The list of model API identifiers that this sync will work on
• force: Indicates if this sync is being run in 'force' mode, which will always run actions even if the 'updated_at' timestamps match between Gadget and Shopify
• startReason: The string describing the reason why this sync was started (optional, only set if specified when the sync began)

Shopify customer account login trigger 

This trigger fetches customer data from Shopify when customer account authentication is enabled in Gadget and a Shopify customer makes a request to a Gadget app from a customer account UI extension.

When the request is made from a customer account UI extension, the customer is assigned a unique session record that is linked to their shopifyCustomer model record. If this shopifyCustomer record does not exist in Gadget, this trigger will be activated to fetch the customer data from Shopify so the customer can be linked to their current session.

This trigger is automatically added to the shopifyCustomer model's create action when customer account authentication is enabled in Gadget. If customer account authentication is disabled, this trigger will be automatically removed.

BigCommerce webhook trigger 

The BigCommerce webhook trigger allows you to run global actions in response to BigCommerce webhooks.

When this trigger runs, it:

1. Parses the payload from BigCommerce, following the BigCommerce best practices for webhook security
2. Adds the raw webhook payload to params
3. Executes the action

When you add a BigCommerce webhook trigger to a global action, Gadget will automatically register the webhook. You can specify which BigCommerce webhooks should trigger your action by adding a bigcommerce property to the triggers object in the action's options, or by using the Gadget editor to add the trigger and select the webhook topics.

This is what a BigCommerce webhook trigger looks like in your action's options:

BigCommerce webhook trigger params 

BigCommerce webhook payloads contain minimal information about the store and event. Gadget will pull out the important information from the payload and pass it to the action as params. You can then use the included BigCommerce API client to fetch the full resource data in the action.

For example, this is what the params object might look like for a store/product/created webhook:

example of a params payload for a store/product/created webhook
json
Copy
{
  "id": 1,
  "storeHash": "<your-store-hash>",
  "type": "product"
}

BigCommerce webhook trigger trigger object 

The trigger object passed to your action contains the entire webhook payload, as well as additional information about the trigger itself.

This is what the trigger object might look like for a store/product/created webhook:

example of a trigger object for a store/product/created webhook
json
Copy
{
  "createdAt": 1723578525,
  "data": {
    "id": 1,
    "type": "product"
  },
  "hash": "<your-hash-value>",
  "retries": 0,
  "scope": "store/product/created",
  "storeHash": "<your-store-hash>",
  "type": "bigcommerce_webhook"
}

For BigCommerce webhook triggers, the trigger object will always contain the following properties:

• type: will always be set to bigcommerce_webhook
• scope: the string representing the topic of the incoming webhook from BigCommerce, like store/product/created or store/order/updated
• storeHash: the hash of the BigCommerce store that received the webhook
• hash: the hash value of the webhook payload
• retries: the number of times this webhook has been retried
• createdAt: the timestamp of when the webhook was created
• data: the raw incoming payload from BigCommerce, which includes all the data sent by the webhook unchanged

Google OAuth sign up trigger 

This trigger is part of the authentication process that integrates Google as an OAuth provider in your application. The entire profile payload from Google plus the additional data from the user model to the action to receive the necessary information from the user's Google profile.

Google OAuth sign up trigger params 

When a new user signs up using Google OAuth, the trigger will run your action with params describing the new user, like this:

example Google OAuth Sign Up params
json
Copy
{
  "user": {
    "email": "[email protected]",
    "emailVerified": true,
    "firstName": "Giz",
    "googleImageUrl": "https://gmail.com/some/image.png",
    "googleProfileId": "113836975668244786030",
    "lastName": "Mo",
    "roles": ["signed-in"]
  }
}

These params are derived from the Google OAuth callback data passed by Google and adjusted by the trigger to match the fields of the user model. The raw data returned by Google is available in the trigger object.

Google OAuth sign up trigger trigger 

The trigger object contains the raw data returned by Google at user object.

example Google OAuth Sign Up trigger
json
Copy
{
  "type": "google_oauth_signup",
  "user": {
    "email": "[email protected]",
    "email_verified": true,
    "family_name": "Mo",
    "given_name": "Giz",
    "hd": "gadget.dev",
    "name": "Giz Mo",
    "picture": "https://gmail.com/some/image.png",
    "sub": "113836975668244786030"
  }
}

Default email/password authentication triggers 

Every Gadget web app template by default comes with several out-of-the-box authentication triggers associated with the corresponding authentication actions.

The following authentication triggers although named differently all have the same behavior of the API endpoint trigger.

• Sign up
• Sign in
• Verify email
• Reset password
• Send reset password
• Send verify email
• Change password